Techdebt: Replace sure with regular assertions in Timestreamwrite (#6655)

tests/test_timestreamwrite/test_server.py

@@ -1,5 +1,4 @@
 import json
-import sure  # noqa # pylint: disable=unused-import
 
 import moto.server as server
 from moto import mock_timestreamwrite
@@ -12,5 +11,5 @@ def test_timestreamwrite_list():
 
     headers = {"X-Amz-Target": "Timestream_20181101.ListDatabases"}
     resp = test_client.post("/", headers=headers, json={})
-    resp.status_code.should.equal(200)
+    assert resp.status_code == 200
-    json.loads(resp.data).should.equal({"Databases": []})
+    assert json.loads(resp.data) == {"Databases": []}

tests/test_timestreamwrite/test_timestreamwrite_database.py

@@ -1,8 +1,7 @@
 import boto3
-import pytest
-import sure  # noqa # pylint: disable=unused-import
-
 from botocore.exceptions import ClientError
+import pytest
+
 from moto import mock_timestreamwrite
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
 
@@ -13,14 +12,12 @@ def test_create_database_simple():
     resp = ts.create_database(DatabaseName="mydatabase")
     database = resp["Database"]
 
-    database.should.have.key("Arn").equals(
+    assert database["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase"
     )
-    database.should.have.key("DatabaseName").equals("mydatabase")
+    assert database["DatabaseName"] == "mydatabase"
-    database.should.have.key("TableCount").equals(0)
+    assert database["TableCount"] == 0
-    database.should.have.key("KmsKeyId").equals(
+    assert database["KmsKeyId"] == f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key"
-        f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key"
-    )
 
 
 @mock_timestreamwrite
@@ -33,12 +30,12 @@ def test_create_database_advanced():
     )
     database = resp["Database"]
 
-    database.should.have.key("Arn").equals(
+    assert database["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase"
     )
-    database.should.have.key("DatabaseName").equals("mydatabase")
+    assert database["DatabaseName"] == "mydatabase"
-    database.should.have.key("TableCount").equals(0)
+    assert database["TableCount"] == 0
-    database.should.have.key("KmsKeyId").equal("mykey")
+    assert database["KmsKeyId"] == "mykey"
 
 
 @mock_timestreamwrite
@@ -48,12 +45,12 @@ def test_describe_database():
 
     database = ts.describe_database(DatabaseName="mydatabase")["Database"]
 
-    database.should.have.key("Arn").equals(
+    assert database["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase"
     )
-    database.should.have.key("DatabaseName").equals("mydatabase")
+    assert database["DatabaseName"] == "mydatabase"
-    database.should.have.key("TableCount").equals(0)
+    assert database["TableCount"] == 0
-    database.should.have.key("KmsKeyId").equal("mykey")
+    assert database["KmsKeyId"] == "mykey"
 
 
 @mock_timestreamwrite
@@ -62,8 +59,8 @@ def test_describe_unknown_database():
     with pytest.raises(ClientError) as exc:
         ts.describe_database(DatabaseName="unknown")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
+    assert err["Code"] == "ResourceNotFoundException"
-    err["Message"].should.equal("The database unknown does not exist.")
+    assert err["Message"] == "The database unknown does not exist."
 
 
 @mock_timestreamwrite
@@ -74,23 +71,19 @@ def test_list_databases():
 
     resp = ts.list_databases()
     databases = resp["Databases"]
-    databases.should.have.length_of(2)
+    assert len(databases) == 2
-    databases.should.contain(
+    assert {
-        {
+        "Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_with",
-            "Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_with",
+        "DatabaseName": "db_with",
-            "DatabaseName": "db_with",
+        "TableCount": 0,
-            "TableCount": 0,
+        "KmsKeyId": "mykey",
-            "KmsKeyId": "mykey",
+    } in databases
-        }
+    assert {
-    )
+        "Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_without",
-    databases.should.contain(
+        "DatabaseName": "db_without",
-        {
+        "TableCount": 0,
-            "Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_without",
+        "KmsKeyId": f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key",
-            "DatabaseName": "db_without",
+    } in databases
-            "TableCount": 0,
-            "KmsKeyId": f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key",
-        }
-    )
 
 
 @mock_timestreamwrite
@@ -100,13 +93,13 @@ def test_delete_database():
     ts.create_database(DatabaseName="db_2")
     ts.create_database(DatabaseName="db_3", KmsKeyId="mysecondkey")
 
-    ts.list_databases()["Databases"].should.have.length_of(3)
+    assert len(ts.list_databases()["Databases"]) == 3
 
     ts.delete_database(DatabaseName="db_2")
 
     databases = ts.list_databases()["Databases"]
-    databases.should.have.length_of(2)
+    assert len(databases) == 2
-    [db["DatabaseName"] for db in databases].should.equal(["db_1", "db_3"])
+    assert [db["DatabaseName"] for db in databases] == ["db_1", "db_3"]
 
 
 @mock_timestreamwrite
@@ -114,10 +107,10 @@ def test_update_database():
     ts = boto3.client("timestream-write", region_name="us-east-1")
     ts.create_database(DatabaseName="mydatabase", KmsKeyId="mykey")
     resp = ts.update_database(DatabaseName="mydatabase", KmsKeyId="updatedkey")
-    resp.should.have.key("Database")
+    assert "Database" in resp
     database = resp["Database"]
-    database.should.have.key("Arn")
+    assert "Arn" in database
-    database.should.have.key("KmsKeyId").equal("updatedkey")
+    assert database["KmsKeyId"] == "updatedkey"
 
     database = ts.describe_database(DatabaseName="mydatabase")["Database"]
-    database.should.have.key("KmsKeyId").equal("updatedkey")
+    assert database["KmsKeyId"] == "updatedkey"

tests/test_timestreamwrite/test_timestreamwrite_table.py

@@ -1,9 +1,9 @@
 import time
-import boto3
-import pytest
-import sure  # noqa # pylint: disable=unused-import
 
+import boto3
 from botocore.exceptions import ClientError
+import pytest
+
 from moto import mock_timestreamwrite, settings
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
 
@@ -22,18 +22,16 @@ def test_create_table():
         },
     )
     table = resp["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
+    assert table["TableName"] == "mytable"
-    table.should.have.key("DatabaseName").equal("mydatabase")
+    assert table["DatabaseName"] == "mydatabase"
-    table.should.have.key("TableStatus").equal("ACTIVE")
+    assert table["TableStatus"] == "ACTIVE"
-    table.should.have.key("RetentionProperties").should.equal(
+    assert table["RetentionProperties"] == {
-        {
+        "MemoryStoreRetentionPeriodInHours": 7,
-            "MemoryStoreRetentionPeriodInHours": 7,
+        "MagneticStoreRetentionPeriodInDays": 42,
-            "MagneticStoreRetentionPeriodInDays": 42,
+    }
-        }
-    )
 
 
 @mock_timestreamwrite
@@ -52,20 +50,18 @@ def test_create_table__with_magnetic_store_write_properties():
         },
     )
     table = resp["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
+    assert table["TableName"] == "mytable"
-    table.should.have.key("DatabaseName").equal("mydatabase")
+    assert table["DatabaseName"] == "mydatabase"
-    table.should.have.key("TableStatus").equal("ACTIVE")
+    assert table["TableStatus"] == "ACTIVE"
-    table.should.have.key("MagneticStoreWriteProperties").should.equal(
+    assert table["MagneticStoreWriteProperties"] == {
-        {
+        "EnableMagneticStoreWrites": True,
-            "EnableMagneticStoreWrites": True,
+        "MagneticStoreRejectedDataLocation": {
-            "MagneticStoreRejectedDataLocation": {
+            "S3Configuration": {"BucketName": "hithere"}
-                "S3Configuration": {"BucketName": "hithere"}
+        },
-            },
+    }
-        }
-    )
 
 
 @mock_timestreamwrite
@@ -75,18 +71,16 @@ def test_create_table_without_retention_properties():
 
     resp = ts.create_table(DatabaseName="mydatabase", TableName="mytable")
     table = resp["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
+    assert table["TableName"] == "mytable"
-    table.should.have.key("DatabaseName").equal("mydatabase")
+    assert table["DatabaseName"] == "mydatabase"
-    table.should.have.key("TableStatus").equal("ACTIVE")
+    assert table["TableStatus"] == "ACTIVE"
-    table.should.have.key("RetentionProperties").equals(
+    assert table["RetentionProperties"] == {
-        {
+        "MemoryStoreRetentionPeriodInHours": 123,
-            "MemoryStoreRetentionPeriodInHours": 123,
+        "MagneticStoreRetentionPeriodInDays": 123,
-            "MagneticStoreRetentionPeriodInDays": 123,
+    }
-        }
-    )
 
 
 @mock_timestreamwrite
@@ -104,18 +98,16 @@ def test_describe_table():
     )
 
     table = ts.describe_table(DatabaseName="mydatabase", TableName="mytable")["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
+    assert table["TableName"] == "mytable"
-    table.should.have.key("DatabaseName").equal("mydatabase")
+    assert table["DatabaseName"] == "mydatabase"
-    table.should.have.key("TableStatus").equal("ACTIVE")
+    assert table["TableStatus"] == "ACTIVE"
-    table.should.have.key("RetentionProperties").should.equal(
+    assert table["RetentionProperties"] == {
-        {
+        "MemoryStoreRetentionPeriodInHours": 10,
-            "MemoryStoreRetentionPeriodInHours": 10,
+        "MagneticStoreRetentionPeriodInDays": 12,
-            "MagneticStoreRetentionPeriodInDays": 12,
+    }
-        }
-    )
 
 
 @mock_timestreamwrite
@@ -126,8 +118,8 @@ def test_describe_unknown_database():
     with pytest.raises(ClientError) as exc:
         ts.describe_table(DatabaseName="mydatabase", TableName="unknown")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
+    assert err["Code"] == "ResourceNotFoundException"
-    err["Message"].should.equal("The table unknown does not exist.")
+    assert err["Message"] == "The table unknown does not exist."
 
 
 @mock_timestreamwrite
@@ -147,15 +139,19 @@ def test_create_multiple_tables():
 
     database = ts.describe_database(DatabaseName="mydatabase")["Database"]
 
-    database.should.have.key("TableCount").equals(5)
+    assert database["TableCount"] == 5
 
     tables = ts.list_tables(DatabaseName="mydatabase")["Tables"]
-    tables.should.have.length_of(5)
+    assert len(tables) == 5
-    set([t["DatabaseName"] for t in tables]).should.equal({"mydatabase"})
+    assert {t["DatabaseName"] for t in tables} == {"mydatabase"}
-    set([t["TableName"] for t in tables]).should.equal(
+    assert {t["TableName"] for t in tables} == {
-        {"mytable_0", "mytable_1", "mytable_2", "mytable_3", "mytable_4"}
+        "mytable_0",
-    )
+        "mytable_1",
-    set([t["TableStatus"] for t in tables]).should.equal({"ACTIVE"})
+        "mytable_2",
+        "mytable_3",
+        "mytable_4",
+    }
+    assert {t["TableStatus"] for t in tables} == {"ACTIVE"}
 
 
 @mock_timestreamwrite
@@ -174,13 +170,13 @@ def test_delete_table():
         )
 
     tables = ts.list_tables(DatabaseName="mydatabase")["Tables"]
-    tables.should.have.length_of(3)
+    assert len(tables) == 3
 
     ts.delete_table(DatabaseName="mydatabase", TableName="mytable_1")
 
     tables = ts.list_tables(DatabaseName="mydatabase")["Tables"]
-    tables.should.have.length_of(2)
+    assert len(tables) == 2
-    set([t["TableName"] for t in tables]).should.equal({"mytable_0", "mytable_2"})
+    assert {t["TableName"] for t in tables} == {"mytable_0", "mytable_2"}
 
 
 @mock_timestreamwrite
@@ -198,26 +194,22 @@ def test_update_table():
         },
     )
     table = resp["Table"]
-    table.should.have.key("RetentionProperties").equals(
+    assert table["RetentionProperties"] == {
-        {
+        "MagneticStoreRetentionPeriodInDays": 2,
-            "MagneticStoreRetentionPeriodInDays": 2,
+        "MemoryStoreRetentionPeriodInHours": 1,
-            "MemoryStoreRetentionPeriodInHours": 1,
+    }
-        }
-    )
 
     table = ts.describe_table(DatabaseName="mydatabase", TableName="mytable")["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
+    assert table["TableName"] == "mytable"
-    table.should.have.key("DatabaseName").equal("mydatabase")
+    assert table["DatabaseName"] == "mydatabase"
-    table.should.have.key("TableStatus").equal("ACTIVE")
+    assert table["TableStatus"] == "ACTIVE"
-    table.should.have.key("RetentionProperties").equals(
+    assert table["RetentionProperties"] == {
-        {
+        "MagneticStoreRetentionPeriodInDays": 2,
-            "MagneticStoreRetentionPeriodInDays": 2,
+        "MemoryStoreRetentionPeriodInHours": 1,
-            "MemoryStoreRetentionPeriodInHours": 1,
+    }
-        }
-    )
 
 
 @mock_timestreamwrite
@@ -238,20 +230,18 @@ def test_update_table__with_magnetic_store_write_properties():
         },
     )
     table = resp["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
+    assert table["TableName"] == "mytable"
-    table.should.have.key("DatabaseName").equal("mydatabase")
+    assert table["DatabaseName"] == "mydatabase"
-    table.should.have.key("TableStatus").equal("ACTIVE")
+    assert table["TableStatus"] == "ACTIVE"
-    table.should.have.key("MagneticStoreWriteProperties").should.equal(
+    assert table["MagneticStoreWriteProperties"] == {
-        {
+        "EnableMagneticStoreWrites": True,
-            "EnableMagneticStoreWrites": True,
+        "MagneticStoreRejectedDataLocation": {
-            "MagneticStoreRejectedDataLocation": {
+            "S3Configuration": {"BucketName": "hithere"}
-                "S3Configuration": {"BucketName": "hithere"}
+        },
-            },
+    }
-        }
-    )
 
 
 @mock_timestreamwrite
@@ -263,7 +253,8 @@ def test_write_records():
     ts.create_database(DatabaseName="mydatabase")
     ts.create_table(DatabaseName="mydatabase", TableName="mytable")
 
-    # Sample records from https://docs.aws.amazon.com/timestream/latest/developerguide/code-samples.write.html
+    # Sample records from:
+    # https://docs.aws.amazon.com/timestream/latest/developerguide/code-samples.write.html
     dimensions = [
         {"Name": "region", "Value": "us-east-1"},
         {"Name": "az", "Value": "az1"},
@@ -293,15 +284,15 @@ def test_write_records():
         TableName="mytable",
         Records=sample_records,
     ).get("RecordsIngested", {})
-    resp["Total"].should.equal(len(sample_records))
+    assert resp["Total"] == len(sample_records)
-    (resp["MemoryStore"] + resp["MagneticStore"]).should.equal(resp["Total"])
+    assert (resp["MemoryStore"] + resp["MagneticStore"]) == resp["Total"]
 
     if not settings.TEST_SERVER_MODE:
         from moto.timestreamwrite.models import timestreamwrite_backends
 
         backend = timestreamwrite_backends[ACCOUNT_ID]["us-east-1"]
         records = backend.databases["mydatabase"].tables["mytable"].records
-        records.should.equal(sample_records)
+        assert records == sample_records
 
         disk_utilization = {
             "Dimensions": dimensions,
@@ -317,4 +308,4 @@ def test_write_records():
             TableName="mytable",
             Records=[disk_utilization],
         )
-        records.should.equal(sample_records)
+        assert records == sample_records

tests/test_timestreamwrite/test_timestreamwrite_tagging.py

@@ -19,7 +19,7 @@ def test_list_tagging_for_table_without_tags():
     table_arn = resp["Table"]["Arn"]
 
     resp = ts.list_tags_for_resource(ResourceARN=table_arn)
-    resp.should.have.key("Tags").equals([])
+    assert resp["Tags"] == []
 
 
 @mock_timestreamwrite
@@ -39,7 +39,7 @@ def test_list_tagging_for_table_with_tags():
     table_arn = resp["Table"]["Arn"]
 
     resp = ts.list_tags_for_resource(ResourceARN=table_arn)
-    resp.should.have.key("Tags").equals([{"Key": "k1", "Value": "v1"}])
+    assert resp["Tags"] == [{"Key": "k1", "Value": "v1"}]
 
 
 @mock_timestreamwrite
@@ -48,7 +48,7 @@ def test_list_tagging_for_database_without_tags():
     db_arn = ts.create_database(DatabaseName="mydatabase")["Database"]["Arn"]
 
     resp = ts.list_tags_for_resource(ResourceARN=db_arn)
-    resp.should.have.key("Tags").equals([])
+    assert resp["Tags"] == []
 
 
 @mock_timestreamwrite
@@ -59,7 +59,7 @@ def test_list_tagging_for_database_with_tags():
     )["Database"]["Arn"]
 
     resp = ts.list_tags_for_resource(ResourceARN=db_arn)
-    resp.should.have.key("Tags").equals([{"Key": "k1", "Value": "v1"}])
+    assert resp["Tags"] == [{"Key": "k1", "Value": "v1"}]
 
 
 @mock_timestreamwrite
@@ -75,17 +75,13 @@ def test_tag_and_untag_database():
     )
 
     resp = ts.list_tags_for_resource(ResourceARN=db_arn)
-    resp.should.have.key("Tags").equals(
+    assert resp["Tags"] == [
-        [
+        {"Key": "k1", "Value": "v1"},
-            {"Key": "k1", "Value": "v1"},
+        {"Key": "k2", "Value": "v2"},
-            {"Key": "k2", "Value": "v2"},
+        {"Key": "k3", "Value": "v3"},
-            {"Key": "k3", "Value": "v3"},
+    ]
-        ]
-    )
 
     ts.untag_resource(ResourceARN=db_arn, TagKeys=["k2"])
 
     resp = ts.list_tags_for_resource(ResourceARN=db_arn)
-    resp.should.have.key("Tags").equals(
+    assert resp["Tags"] == [{"Key": "k1", "Value": "v1"}, {"Key": "k3", "Value": "v3"}]
-        [{"Key": "k1", "Value": "v1"}, {"Key": "k3", "Value": "v3"}]
-    )