Yasuke/moto
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
kbalk 2023-08-14 05:53:02 -04:00 committed by GitHub
parent 76a743c56e
commit 3c4f4b5b0a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 129 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
tests/test_timestreamwrite/test_server.py
View File

@ -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)
json.loads(resp.data).should.equal({"Databases": []})
assert resp.status_code == 200
assert json.loads(resp.data) == {"Databases": []}

79
tests/test_timestreamwrite/test_timestreamwrite_database.py
View File

@ -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")
database.should.have.key("TableCount").equals(0)
database.should.have.key("KmsKeyId").equals(
f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key"
)
assert database["DatabaseName"] == "mydatabase"
assert database["TableCount"] == 0
assert database["KmsKeyId"] == 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")
database.should.have.key("TableCount").equals(0)
database.should.have.key("KmsKeyId").equal("mykey")
assert database["DatabaseName"] == "mydatabase"
assert database["TableCount"] == 0
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")
database.should.have.key("TableCount").equals(0)
database.should.have.key("KmsKeyId").equal("mykey")
assert database["DatabaseName"] == "mydatabase"
assert database["TableCount"] == 0
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")
err["Message"].should.equal("The database unknown does not exist.")
assert err["Code"] == "ResourceNotFoundException"
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)
databases.should.contain(
{
"Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_with",
"DatabaseName": "db_with",
"TableCount": 0,
"KmsKeyId": "mykey",
}
)
databases.should.contain(
{
"Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_without",
"DatabaseName": "db_without",
"TableCount": 0,
"KmsKeyId": f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key",
}
)
assert len(databases) == 2
assert {
"Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_with",
"DatabaseName": "db_with",
"TableCount": 0,
"KmsKeyId": "mykey",
} in databases
assert {
"Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_without",
"DatabaseName": "db_without",
"TableCount": 0,
"KmsKeyId": f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key",
} in databases
@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)
[db["DatabaseName"] for db in databases].should.equal(["db_1", "db_3"])
assert len(databases) == 2
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")
database.should.have.key("KmsKeyId").equal("updatedkey")
assert "Arn" in database
assert database["KmsKeyId"] == "updatedkey"
database = ts.describe_database(DatabaseName="mydatabase")["Database"]
database.should.have.key("KmsKeyId").equal("updatedkey")
assert database["KmsKeyId"] == "updatedkey"

171
tests/test_timestreamwrite/test_timestreamwrite_table.py
View File

@ -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")
table.should.have.key("DatabaseName").equal("mydatabase")
table.should.have.key("TableStatus").equal("ACTIVE")
table.should.have.key("RetentionProperties").should.equal(
{
"MemoryStoreRetentionPeriodInHours": 7,
"MagneticStoreRetentionPeriodInDays": 42,
}
)
assert table["TableName"] == "mytable"
assert table["DatabaseName"] == "mydatabase"
assert table["TableStatus"] == "ACTIVE"
assert table["RetentionProperties"] == {
"MemoryStoreRetentionPeriodInHours": 7,
"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")
table.should.have.key("DatabaseName").equal("mydatabase")
table.should.have.key("TableStatus").equal("ACTIVE")
table.should.have.key("MagneticStoreWriteProperties").should.equal(
{
"EnableMagneticStoreWrites": True,
"MagneticStoreRejectedDataLocation": {
"S3Configuration": {"BucketName": "hithere"}
},
}
)
assert table["TableName"] == "mytable"
assert table["DatabaseName"] == "mydatabase"
assert table["TableStatus"] == "ACTIVE"
assert table["MagneticStoreWriteProperties"] == {
"EnableMagneticStoreWrites": True,
"MagneticStoreRejectedDataLocation": {
"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")
table.should.have.key("DatabaseName").equal("mydatabase")
table.should.have.key("TableStatus").equal("ACTIVE")
table.should.have.key("RetentionProperties").equals(
{
"MemoryStoreRetentionPeriodInHours": 123,
"MagneticStoreRetentionPeriodInDays": 123,
}
)
assert table["TableName"] == "mytable"
assert table["DatabaseName"] == "mydatabase"
assert table["TableStatus"] == "ACTIVE"
assert table["RetentionProperties"] == {
"MemoryStoreRetentionPeriodInHours": 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")
table.should.have.key("DatabaseName").equal("mydatabase")
table.should.have.key("TableStatus").equal("ACTIVE")
table.should.have.key("RetentionProperties").should.equal(
{
"MemoryStoreRetentionPeriodInHours": 10,
"MagneticStoreRetentionPeriodInDays": 12,
}
)
assert table["TableName"] == "mytable"
assert table["DatabaseName"] == "mydatabase"
assert table["TableStatus"] == "ACTIVE"
assert table["RetentionProperties"] == {
"MemoryStoreRetentionPeriodInHours": 10,
"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")
err["Message"].should.equal("The table unknown does not exist.")
assert err["Code"] == "ResourceNotFoundException"
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)
set([t["DatabaseName"] for t in tables]).should.equal({"mydatabase"})
set([t["TableName"] for t in tables]).should.equal(
{"mytable_0", "mytable_1", "mytable_2", "mytable_3", "mytable_4"}
)
set([t["TableStatus"] for t in tables]).should.equal({"ACTIVE"})
assert len(tables) == 5
assert {t["DatabaseName"] for t in tables} == {"mydatabase"}
assert {t["TableName"] for t in tables} == {
"mytable_0",
"mytable_1",
"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)
set([t["TableName"] for t in tables]).should.equal({"mytable_0", "mytable_2"})
assert len(tables) == 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(
{
"MagneticStoreRetentionPeriodInDays": 2,
"MemoryStoreRetentionPeriodInHours": 1,
}
)
assert table["RetentionProperties"] == {
"MagneticStoreRetentionPeriodInDays": 2,
"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")
table.should.have.key("DatabaseName").equal("mydatabase")
table.should.have.key("TableStatus").equal("ACTIVE")
table.should.have.key("RetentionProperties").equals(
{
"MagneticStoreRetentionPeriodInDays": 2,
"MemoryStoreRetentionPeriodInHours": 1,
}
)
assert table["TableName"] == "mytable"
assert table["DatabaseName"] == "mydatabase"
assert table["TableStatus"] == "ACTIVE"
assert table["RetentionProperties"] == {
"MagneticStoreRetentionPeriodInDays": 2,
"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")
table.should.have.key("DatabaseName").equal("mydatabase")
table.should.have.key("TableStatus").equal("ACTIVE")
table.should.have.key("MagneticStoreWriteProperties").should.equal(
{
"EnableMagneticStoreWrites": True,
"MagneticStoreRejectedDataLocation": {
"S3Configuration": {"BucketName": "hithere"}
},
}
)
assert table["TableName"] == "mytable"
assert table["DatabaseName"] == "mydatabase"
assert table["TableStatus"] == "ACTIVE"
assert table["MagneticStoreWriteProperties"] == {
"EnableMagneticStoreWrites": True,
"MagneticStoreRejectedDataLocation": {
"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))
(resp["MemoryStore"] + resp["MagneticStore"]).should.equal(resp["Total"])
assert resp["Total"] == len(sample_records)
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

24
tests/test_timestreamwrite/test_timestreamwrite_tagging.py
View File

@ -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(
[
{"Key": "k1", "Value": "v1"},
{"Key": "k2", "Value": "v2"},
{"Key": "k3", "Value": "v3"},
]
)
assert resp["Tags"] == [
{"Key": "k1", "Value": "v1"},
{"Key": "k2", "Value": "v2"},
{"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(
[{"Key": "k1", "Value": "v1"}, {"Key": "k3", "Value": "v3"}]
)
assert resp["Tags"] == [{"Key": "k1", "Value": "v1"}, {"Key": "k3", "Value": "v3"}]