Repository: getmoto/moto
Pull request #6579 (2023-07-31 21:19:59)

Techdebt: Replace sure with regular assertions in Kinesis
See #6035


Patch:
diff --git a/moto/ec2/models/vpc_service_configuration.py b/moto/ec2/models/vpc_service_configuration.py
index cccad8d4d..27350b8d6 100644
--- a/moto/ec2/models/vpc_service_configuration.py
+++ b/moto/ec2/models/vpc_service_configuration.py
@@ -41,6 +41,21 @@ class VPCServiceConfiguration(TaggedEC2Resource, CloudFormationModel):
         self.principals: List[str] = []
         self.ec2_backend = ec2_backend
 
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "AcceptanceRequired": self.acceptance_required,
+            "AvailabilityZones": self.availability_zones,
+            "BaseEndpointDnsNames": [self.endpoint_dns_name],
+            "ManagesVpcEndpoints": self.manages_vpc_endpoints,
+            "Owner": self.ec2_backend.account_id,
+            "PrivateDnsName": self.private_dns_name,
+            "PrivateDnsNames": [{"PrivateDnsName": self.private_dns_name}],
+            "ServiceId": self.id,
+            "ServiceName": self.service_name,
+            "ServiceType": [{"ServiceType": self.service_type}],
+            "VpcEndpointPolicySupported": True,
+        }
+
 
 class VPCServiceConfigurationBackend:
     def __init__(self) -> None:
diff --git a/moto/ec2/models/vpcs.py b/moto/ec2/models/vpcs.py
index 43407744a..badb85b19 100644
--- a/moto/ec2/models/vpcs.py
+++ b/moto/ec2/models/vpcs.py
@@ -845,13 +845,16 @@ class VPCBackend:
         default_services = self._collect_default_endpoint_services(
             self.account_id, region  # type: ignore[attr-defined]
         )
+        custom_services = [x.to_dict() for x in self.configurations.values()]  # type: ignore
+        all_services = default_services + custom_services
+
         for service_name in service_names:
-            if service_name not in [x["ServiceName"] for x in default_services]:
+            if service_name not in [x["ServiceName"] for x in all_services]:
                 raise InvalidServiceName(service_name)
 
         # Apply filters specified in the service_names and filters arguments.
         filtered_services = sorted(
-            self._filter_endpoint_services(service_names, filters, default_services),
+            self._filter_endpoint_services(service_names, filters, all_services),
             key=itemgetter("ServiceName"),
         )
 


Test patch:
diff --git a/tests/test_ec2/test_vpc_service_configuration.py b/tests/test_ec2/test_vpc_service_configuration.py
index 2881ffff0..80dd07650 100644
--- a/tests/test_ec2/test_vpc_service_configuration.py
+++ b/tests/test_ec2/test_vpc_service_configuration.py
@@ -3,6 +3,7 @@ import pytest
 
 from botocore.exceptions import ClientError
 from moto import mock_ec2, mock_elbv2
+from moto.core import DEFAULT_ACCOUNT_ID
 from moto.moto_api._internal import mock_random
 
 # See our Development Tips on writing tests for hints on how to write good tests:
@@ -101,13 +102,11 @@ def test_create_vpc_endpoint_service_configuration_with_options():
         region_name="us-east-2", lb_type="gateway", zone="us-east-1c"
     )
 
-    resp = client.create_vpc_endpoint_service_configuration(
+    config = client.create_vpc_endpoint_service_configuration(
         GatewayLoadBalancerArns=[lb_arn],
         AcceptanceRequired=False,
         PrivateDnsName="example.com",
-    )
-    assert "ServiceConfiguration" in resp
-    config = resp["ServiceConfiguration"]
+    )["ServiceConfiguration"]
 
     assert config["AcceptanceRequired"] is False
     assert config["PrivateDnsName"] == "example.com"
@@ -118,6 +117,13 @@ def test_create_vpc_endpoint_service_configuration_with_options():
         "Value": "val",
     }
 
+    service_name = config["ServiceName"]
+    detail = client.describe_vpc_endpoint_services(ServiceNames=[service_name])[
+        "ServiceDetails"
+    ][0]
+    assert detail["ServiceName"] == service_name
+    assert detail["Owner"] == DEFAULT_ACCOUNT_ID
+
 
 @mock_ec2
 @mock_elbv2
diff --git a/tests/test_iot/test_iot.py b/tests/test_iot/test_iot.py
index 2c88fe214..7ee9fab68 100644
--- a/tests/test_iot/test_iot.py
+++ b/tests/test_iot/test_iot.py
@@ -1,4 +1,3 @@
-import sure  # noqa # pylint: disable=unused-import
 import boto3
 
 from moto import mock_iot
@@ -14,37 +13,26 @@ def test_endpoints():
 
     # iot:Data
     endpoint = client.describe_endpoint(endpointType="iot:Data")
-    endpoint.should.have.key("endpointAddress").which.should_not.contain("ats")
-    endpoint.should.have.key("endpointAddress").which.should.contain(
-        f"iot.{region_name}.amazonaws.com"
-    )
+    assert "ats" not in endpoint["endpointAddress"]
+    assert f"iot.{region_name}.amazonaws.com" in endpoint["endpointAddress"]
 
     # iot:Data-ATS
     endpoint = client.describe_endpoint(endpointType="iot:Data-ATS")
-    endpoint.should.have.key("endpointAddress").which.should.contain(
-        f"ats.iot.{region_name}.amazonaws.com"
-    )
+    assert f"ats.iot.{region_name}.amazonaws.com" in endpoint["endpointAddress"]
 
     # iot:Data-ATS
     endpoint = client.describe_endpoint(endpointType="iot:CredentialProvider")
-    endpoint.should.have.key("endpointAddress").which.should.contain(
-        f"credentials.iot.{region_name}.amazonaws.com"
-    )
+    assert f"credentials.iot.{region_name}.amazonaws.com" in endpoint["endpointAddress"]
 
     # iot:Data-ATS
     endpoint = client.describe_endpoint(endpointType="iot:Jobs")
-    endpoint.should.have.key("endpointAddress").which.should.contain(
-        f"jobs.iot.{region_name}.amazonaws.com"
-    )
+    assert f"jobs.iot.{region_name}.amazonaws.com" in endpoint["endpointAddress"]
 
     # raise InvalidRequestException
-    try:
+    with pytest.raises(ClientError) as exc:
         client.describe_endpoint(endpointType="iot:Abc")
-    except client.exceptions.InvalidRequestException as exc:
-        error_code = exc.response["Error"]["Code"]
-        error_code.should.equal("InvalidRequestException")
-    else:
-        raise Exception("Should have raised error")
+    err = exc.value.response["Error"]
+    assert err["Code"] == "InvalidRequestException"
 
 
 @mock_iot
@@ -59,32 +47,34 @@ def test_principal_policy():
     client.attach_policy(policyName=policy_name, target=cert_arn)
 
     res = client.list_principal_policies(principal=cert_arn)
-    res.should.have.key("policies").which.should.have.length_of(1)
+    assert len(res["policies"]) == 1
     for policy in res["policies"]:
-        policy.should.have.key("policyName").which.should_not.be.none
-        policy.should.have.key("policyArn").which.should_not.be.none
+        assert policy["policyName"] is not None
+        assert policy["policyArn"] is not None
 
     # do nothing if policy have already attached to certificate
     client.attach_policy(policyName=policy_name, target=cert_arn)
 
     res = client.list_principal_policies(principal=cert_arn)
-    res.should.have.key("policies").which.should.have.length_of(1)
+    assert len(res["policies"]) == 1
     for policy in res["policies"]:
-        policy.should.have.key("policyName").which.should_not.be.none
-        policy.should.have.key("policyArn").which.should_not.be.none
+        assert policy["policyName"] is not None
+        assert policy["policyArn"] is not None
 
     res = client.list_policy_principals(policyName=policy_name)
-    res.should.have.key("principals").length_of(1)
-    res["principals"][0].should.match(f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:cert/")
+    assert len(res["principals"]) == 1
+    assert res["principals"][0].startswith(
+        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:cert/"
+    )
 
     client.detach_policy(policyName=policy_name, target=cert_arn)
     res = client.list_principal_policies(principal=cert_arn)
-    res.should.have.key("policies").which.should.have.length_of(0)
+    assert len(res["policies"]) == 0
     res = client.list_policy_principals(policyName=policy_name)
-    res.should.have.key("principals").which.should.have.length_of(0)
+    assert len(res["principals"]) == 0
     with pytest.raises(ClientError) as e:
         client.detach_policy(policyName=policy_name, target=cert_arn)
-    e.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
+    assert e.value.response["Error"]["Code"] == "ResourceNotFoundException"
 
 
 @mock_iot
@@ -99,21 +89,24 @@ def test_principal_policy_deprecated():
     client.attach_principal_policy(policyName=policy_name, principal=cert_arn)
 
     res = client.list_principal_policies(principal=cert_arn)
-    res.should.have.key("policies").length_of(1)
-    res["policies"][0].should.have.key("policyName").equal("my-policy")
-    res["policies"][0].should.have.key("policyArn").equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:policy/my-policy"
+    assert len(res["policies"]) == 1
+    assert res["policies"][0]["policyName"] == "my-policy"
+    assert (
+        res["policies"][0]["policyArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:policy/my-policy"
     )
 
     res = client.list_policy_principals(policyName=policy_name)
-    res.should.have.key("principals").length_of(1)
-    res["principals"][0].should.match(f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:cert/")
+    assert len(res["principals"]) == 1
+    assert res["principals"][0].startswith(
+        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:cert/"
+    )
 
     client.detach_principal_policy(policyName=policy_name, principal=cert_arn)
     res = client.list_principal_policies(principal=cert_arn)
-    res.should.have.key("policies").which.should.have.length_of(0)
+    assert len(res["policies"]) == 0
     res = client.list_policy_principals(policyName=policy_name)
-    res.should.have.key("principals").which.should.have.length_of(0)
+    assert len(res["principals"]) == 0
 
 
 @mock_iot
@@ -127,22 +120,25 @@ def test_principal_thing():
     client.attach_thing_principal(thingName=thing_name, principal=cert_arn)
 
     res = client.list_principal_things(principal=cert_arn)
-    res.should.have.key("things").which.should.have.length_of(1)
-    res["things"][0].should.equal(thing_name)
+    assert len(res["things"]) == 1
+    assert res["things"][0] == thing_name
     res = client.list_thing_principals(thingName=thing_name)
-    res.should.have.key("principals").length_of(1)
-    res["principals"][0].should.match(f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:cert/")
+    assert len(res["principals"]) == 1
+    assert res["principals"][0].startswith(
+        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:cert/"
+    )
 
     client.detach_thing_principal(thingName=thing_name, principal=cert_arn)
     res = client.list_principal_things(principal=cert_arn)
-    res.should.have.key("things").which.should.have.length_of(0)
+    assert len(res["things"]) == 0
     res = client.list_thing_principals(thingName=thing_name)
-    res.should.have.key("principals").which.should.have.length_of(0)
+    assert len(res["principals"]) == 0
 
     with pytest.raises(ClientError) as e:
         client.list_thing_principals(thingName="xxx")
 
-    e.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
-    e.value.response["Error"]["Message"].should.equal(
-        "Failed to list principals for thing xxx because the thing does not exist in your account"
+    assert e.value.response["Error"]["Code"] == "ResourceNotFoundException"
+    assert (
+        e.value.response["Error"]["Message"]
+        == "Failed to list principals for thing xxx because the thing does not exist in your account"
     )
diff --git a/tests/test_iot/test_iot_ca_certificates.py b/tests/test_iot/test_iot_ca_certificates.py
index 4050714fd..88d98dbcf 100644
--- a/tests/test_iot/test_iot_ca_certificates.py
+++ b/tests/test_iot/test_iot_ca_certificates.py
@@ -14,8 +14,8 @@ def test_register_ca_certificate_simple():
         verificationCertificate="verification_certificate",
     )
 
-    resp.should.have.key("certificateArn")
-    resp.should.have.key("certificateId")
+    assert "certificateArn" in resp
+    assert "certificateId" in resp
 
 
 @mock_iot
@@ -25,7 +25,7 @@ def test_describe_ca_certificate_unknown():
     with pytest.raises(ClientError) as exc:
         client.describe_ca_certificate(certificateId="a" * 70)
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
+    assert err["Code"] == "ResourceNotFoundException"
 
 
 @mock_iot
@@ -39,12 +39,12 @@ def test_describe_ca_certificate_simple():
 
     describe = client.describe_ca_certificate(certificateId=resp["certificateId"])
 
-    describe.should.have.key("certificateDescription")
+    assert "certificateDescription" in describe
     description = describe["certificateDescription"]
-    description.should.have.key("certificateArn").equals(resp["certificateArn"])
-    description.should.have.key("certificateId").equals(resp["certificateId"])
-    description.should.have.key("status").equals("INACTIVE")
-    description.should.have.key("certificatePem").equals("ca_certificate")
+    assert description["certificateArn"] == resp["certificateArn"]
+    assert description["certificateId"] == resp["certificateId"]
+    assert description["status"] == "INACTIVE"
+    assert description["certificatePem"] == "ca_certificate"
 
 
 @mock_iot
@@ -63,17 +63,15 @@ def test_describe_ca_certificate_advanced():
 
     describe = client.describe_ca_certificate(certificateId=resp["certificateId"])
 
-    describe.should.have.key("certificateDescription")
     description = describe["certificateDescription"]
-    description.should.have.key("certificateArn").equals(resp["certificateArn"])
-    description.should.have.key("certificateId").equals(resp["certificateId"])
-    description.should.have.key("status").equals("ACTIVE")
-    description.should.have.key("certificatePem").equals("ca_certificate")
+    assert description["certificateArn"] == resp["certificateArn"]
+    assert description["certificateId"] == resp["certificateId"]
+    assert description["status"] == "ACTIVE"
+    assert description["certificatePem"] == "ca_certificate"
 
-    describe.should.have.key("registrationConfig")
     config = describe["registrationConfig"]
-    config.should.have.key("templateBody").equals("template_b0dy")
-    config.should.have.key("roleArn").equals("aws:iot:arn:role/asdfqwerwe")
+    assert config["templateBody"] == "template_b0dy"
+    assert config["roleArn"] == "aws:iot:arn:role/asdfqwerwe"
 
 
 @mock_iot
@@ -89,7 +87,7 @@ def test_list_certificates_by_ca():
 
     # list certificates should be empty at first
     certs = client.list_certificates_by_ca(caCertificateId=ca_cert_id)
-    certs.should.have.key("certificates").equals([])
+    assert certs["certificates"] == []
 
     # create one certificate
     cert1 = client.register_certificate(
@@ -98,8 +96,8 @@ def test_list_certificates_by_ca():
 
     # list certificates should return this
     certs = client.list_certificates_by_ca(caCertificateId=ca_cert_id)
-    certs.should.have.key("certificates").length_of(1)
-    certs["certificates"][0]["certificateId"].should.equal(cert1["certificateId"])
+    assert len(certs["certificates"]) == 1
+    assert certs["certificates"][0]["certificateId"] == cert1["certificateId"]
 
     # create another certificate, without ca
     client.register_certificate(
@@ -110,7 +108,7 @@ def test_list_certificates_by_ca():
 
     # list certificate should still only return the first certificate
     certs = client.list_certificates_by_ca(caCertificateId=ca_cert_id)
-    certs.should.have.key("certificates").length_of(1)
+    assert len(certs["certificates"]) == 1
 
 
 @mock_iot
@@ -127,7 +125,7 @@ def test_delete_ca_certificate():
     with pytest.raises(ClientError) as exc:
         client.describe_ca_certificate(certificateId=cert_id)
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
+    assert err["Code"] == "ResourceNotFoundException"
 
 
 @mock_iot
@@ -142,10 +140,11 @@ def test_update_ca_certificate__status():
     client.update_ca_certificate(certificateId=cert_id, newStatus="DISABLE")
     cert = client.describe_ca_certificate(certificateId=cert_id)
     cert_desc = cert["certificateDescription"]
-    cert_desc.should.have.key("status").which.should.equal("DISABLE")
-    cert.should.have.key("registrationConfig").equals(
-        {"roleArn": "my:old_and_busted:arn", "templateBody": "tb"}
-    )
+    assert cert_desc["status"] == "DISABLE"
+    assert cert["registrationConfig"] == {
+        "roleArn": "my:old_and_busted:arn",
+        "templateBody": "tb",
+    }
 
 
 @mock_iot
@@ -162,10 +161,11 @@ def test_update_ca_certificate__config():
     )
     cert = client.describe_ca_certificate(certificateId=cert_id)
     cert_desc = cert["certificateDescription"]
-    cert_desc.should.have.key("status").which.should.equal("INACTIVE")
-    cert.should.have.key("registrationConfig").equals(
-        {"roleArn": "my:new_and_fancy:arn", "templateBody": "tb"}
-    )
+    assert cert_desc["status"] == "INACTIVE"
+    assert cert["registrationConfig"] == {
+        "roleArn": "my:new_and_fancy:arn",
+        "templateBody": "tb",
+    }
 
 
 @mock_iot
@@ -173,4 +173,4 @@ def test_get_registration_code():
     client = boto3.client("iot", region_name="us-west-1")
 
     resp = client.get_registration_code()
-    resp.should.have.key("registrationCode")
+    assert "registrationCode" in resp
diff --git a/tests/test_iot/test_iot_certificates.py b/tests/test_iot/test_iot_certificates.py
index aafc40bfe..b7293c1f1 100644
--- a/tests/test_iot/test_iot_certificates.py
+++ b/tests/test_iot/test_iot_certificates.py
@@ -15,7 +15,7 @@ def test_certificate_id_generation_deterministic():
     cert2 = client.register_certificate(
         certificatePem=cert1["certificatePem"], setAsActive=False
     )
-    cert2.should.have.key("certificateId").which.should.equal(cert1["certificateId"])
+    assert cert2["certificateId"] == cert1["certificateId"]
     client.delete_certificate(certificateId=cert2["certificateId"])
 
 
@@ -25,32 +25,25 @@ def test_create_certificate_from_csr():
     client = boto3.client("iot", region_name="us-east-2")
 
     resp = client.create_certificate_from_csr(certificateSigningRequest=csr)
-    resp.should.have.key("certificateArn")
-    resp.should.have.key("certificateId")
-    resp.should.have.key("certificatePem")
+    assert "certificateArn" in resp
+    assert "certificateId" in resp
+    assert "certificatePem" in resp
 
     # Can create certificate a second time
     client.create_certificate_from_csr(certificateSigningRequest=csr)
 
-    client.list_certificates().should.have.key("certificates").length_of(2)
+    assert len(client.list_certificates()["certificates"]) == 2
 
 
 @mock_iot
 def test_create_key_and_certificate():
     client = boto3.client("iot", region_name="us-east-1")
     cert = client.create_keys_and_certificate(setAsActive=True)
-    cert.should.have.key("certificateArn").which.should_not.be.none
-    cert.should.have.key("certificateId").which.should_not.be.none
-    cert.should.have.key("certificatePem").which.should.match(
-        r"^-----BEGIN CERTIFICATE-----"
-    )
-    cert.should.have.key("keyPair")
-    cert["keyPair"].should.have.key("PublicKey").which.should.match(
-        r"^-----BEGIN PUBLIC KEY-----"
-    )
-    cert["keyPair"].should.have.key("PrivateKey").which.should.match(
-        r"^-----BEGIN RSA PRIVATE KEY-----"
-    )
+    assert cert["certificateArn"] is not None
+    assert cert["certificateId"] is not None
+    assert cert["certificatePem"].startswith("-----BEGIN CERTIFICATE-----")
+    assert cert["keyPair"]["PublicKey"].startswith("-----BEGIN PUBLIC KEY-----")
+    assert cert["keyPair"]["PrivateKey"].startswith("-----BEGIN RSA PRIVATE KEY-----")
 
 
 @mock_iot
@@ -60,16 +53,15 @@ def test_describe_certificate_by_id():
     cert_id = cert["certificateId"]
 
     cert = client.describe_certificate(certificateId=cert_id)
-    cert.should.have.key("certificateDescription")
     cert_desc = cert["certificateDescription"]
-    cert_desc.should.have.key("certificateArn").which.should_not.be.none
-    cert_desc.should.have.key("certificateId").which.should_not.be.none
-    cert_desc.should.have.key("certificatePem").which.should_not.be.none
-    cert_desc.should.have.key("validity").which.should_not.be.none
+    assert cert_desc["certificateArn"] is not None
+    assert cert_desc["certificateId"] is not None
+    assert cert_desc["certificatePem"] is not None
+    assert cert_desc["validity"] is not None
     validity = cert_desc["validity"]
-    validity.should.have.key("notBefore").which.should_not.be.none
-    validity.should.have.key("notAfter").which.should_not.be.none
-    cert_desc.should.have.key("status").which.should.equal("ACTIVE")
+    assert validity["notBefore"] is not None
+    assert validity["notAfter"] is not None
+    assert cert_desc["status"] == "ACTIVE"
 
 
 @mock_iot
@@ -80,15 +72,15 @@ def test_list_certificates():
 
     res = client.list_certificates()
     for cert in res["certificates"]:
-        cert.should.have.key("certificateArn").which.should_not.be.none
-        cert.should.have.key("certificateId").which.should_not.be.none
-        cert.should.have.key("status").which.should_not.be.none
-        cert.should.have.key("creationDate").which.should_not.be.none
+        assert cert["certificateArn"] is not None
+        assert cert["certificateId"] is not None
+        assert cert["status"] is not None
+        assert cert["creationDate"] is not None
 
     client.update_certificate(certificateId=cert_id, newStatus="REVOKED")
     cert = client.describe_certificate(certificateId=cert_id)
     cert_desc = cert["certificateDescription"]
-    cert_desc.should.have.key("status").which.should.equal("REVOKED")
+    assert cert_desc["status"] == "REVOKED"
 
 
 @mock_iot
@@ -100,7 +92,7 @@ def test_update_certificate():
     client.update_certificate(certificateId=cert_id, newStatus="REVOKED")
     cert = client.describe_certificate(certificateId=cert_id)
     cert_desc = cert["certificateDescription"]
-    cert_desc.should.have.key("status").which.should.equal("REVOKED")
+    assert cert_desc["status"] == "REVOKED"
 
 
 @pytest.mark.parametrize("status", ["REVOKED", "INACTIVE"])
@@ -115,7 +107,7 @@ def test_delete_certificate_with_status(status):
 
     client.delete_certificate(certificateId=cert_id)
     res = client.list_certificates()
-    res.should.have.key("certificates").equals([])
+    assert res["certificates"] == []
 
 
 @mock_iot
@@ -132,21 +124,21 @@ def test_register_certificate_without_ca():
     cert = client.register_certificate_without_ca(
         certificatePem=cert_pem, status="INACTIVE"
     )
-    cert.should.have.key("certificateId").which.should_not.be.none
-    cert.should.have.key("certificateArn").which.should_not.be.none
+    assert cert["certificateId"] is not None
+    assert cert["certificateArn"] is not None
     cert_id = cert["certificateId"]
 
     res = client.list_certificates()
-    res.should.have.key("certificates").which.should.have.length_of(1)
+    assert len(res["certificates"]) == 1
     for cert in res["certificates"]:
-        cert.should.have.key("certificateArn").which.should_not.be.none
-        cert.should.have.key("certificateId").which.should_not.be.none
-        cert.should.have.key("status").which.should_not.be.none
-        cert.should.have.key("creationDate").which.should_not.be.none
+        assert cert["certificateArn"] is not None
+        assert cert["certificateId"] is not None
+        assert cert["status"] is not None
+        assert cert["creationDate"] is not None
 
     client.delete_certificate(certificateId=cert_id)
     res = client.list_certificates()
-    res.should.have.key("certificates")
+    assert "certificates" in res
 
 
 @mock_iot
@@ -159,18 +151,20 @@ def test_create_certificate_validation():
         client.register_certificate(
             certificatePem=cert["certificatePem"], setAsActive=False
         )
-    e.value.response["Error"]["Message"].should.contain(
+    assert (
         "The certificate is already provisioned or registered"
+        in e.value.response["Error"]["Message"]
     )
 
     with pytest.raises(ClientError) as e:
         client.register_certificate_without_ca(
             certificatePem=cert["certificatePem"], status="ACTIVE"
         )
-    e.value.response.should.have.key("resourceArn").equals(cert["certificateArn"])
-    e.value.response.should.have.key("resourceId").equals(cert["certificateId"])
-    e.value.response["Error"]["Message"].should.contain(
+    assert e.value.response["resourceArn"] == cert["certificateArn"]
+    assert e.value.response["resourceId"] == cert["certificateId"]
+    assert (
         "The certificate is already provisioned or registered"
+        in e.value.response["Error"]["Message"]
     )
 
 
@@ -202,34 +196,37 @@ def test_delete_certificate_validation():
 
     with pytest.raises(ClientError) as e:
         client.delete_certificate(certificateId=cert_id)
-    e.value.response["Error"]["Message"].should.contain(
+    assert (
         "Certificate must be deactivated (not ACTIVE) before deletion."
+        in e.value.response["Error"]["Message"]
     )
     res = client.list_certificates()
-    res.should.have.key("certificates").which.should.have.length_of(1)
+    assert len(res["certificates"]) == 1
 
     client.update_certificate(certificateId=cert_id, newStatus="REVOKED")
     with pytest.raises(ClientError) as e:
         client.delete_certificate(certificateId=cert_id)
-    e.value.response["Error"]["Message"].should.contain(
+    assert (
         f"Things must be detached before deletion (arn: {cert_arn})"
+        in e.value.response["Error"]["Message"]
     )
     res = client.list_certificates()
-    res.should.have.key("certificates").which.should.have.length_of(1)
+    assert len(res["certificates"]) == 1
 
     client.detach_thing_principal(thingName=thing_name, principal=cert_arn)
     with pytest.raises(ClientError) as e:
         client.delete_certificate(certificateId=cert_id)
-    e.value.response["Error"]["Message"].should.contain(
+    assert (
         f"Certificate policies must be detached before deletion (arn: {cert_arn})"
+        in e.value.response["Error"]["Message"]
     )
     res = client.list_certificates()
-    res.should.have.key("certificates").which.should.have.length_of(1)
+    assert len(res["certificates"]) == 1
 
     client.detach_principal_policy(policyName=policy_name, principal=cert_arn)
     client.delete_certificate(certificateId=cert_id)
     res = client.list_certificates()
-    res.should.have.key("certificates").which.should.have.length_of(0)
+    assert len(res["certificates"]) == 0
 
 
 @mock_iot
@@ -247,14 +244,14 @@ def test_delete_certificate_force():
     with pytest.raises(ClientError) as e:
         client.delete_certificate(certificateId=cert_id, forceDelete=True)
     err = e.value.response["Error"]
-    err["Message"].should.contain("Certificate must be deactivated")
+    assert "Certificate must be deactivated" in err["Message"]
 
     client.update_certificate(certificateId=cert_id, newStatus="INACTIVE")
     # If does work if the status is INACTIVE, even though we still have policies attached
     client.delete_certificate(certificateId=cert_id, forceDelete=True)
 
     res = client.list_certificates()
-    res.should.have.key("certificates").which.should.have.length_of(0)
+    assert len(res["certificates"]) == 0
 
 
 @mock_iot
@@ -272,9 +269,10 @@ def test_delete_thing_with_certificate_validation():
     with pytest.raises(ClientError) as e:
         client.delete_thing(thingName=thing_name)
     err = e.value.response["Error"]
-    err["Code"].should.equal("InvalidRequestException")
-    err["Message"].should.equals(
-        f"Cannot delete. Thing {thing_name} is still attached to one or more principals"
+    assert err["Code"] == "InvalidRequestException"
+    assert (
+        err["Message"]
+        == f"Cannot delete. Thing {thing_name} is still attached to one or more principals"
     )
 
     client.detach_thing_principal(thingName=thing_name, principal=cert_arn)
@@ -283,9 +281,9 @@ def test_delete_thing_with_certificate_validation():
 
     # Certificate still exists
     res = client.list_certificates()
-    res.should.have.key("certificates").which.should.have.length_of(1)
-    res["certificates"][0]["certificateArn"].should.equal(cert_arn)
-    res["certificates"][0]["status"].should.equal("REVOKED")
+    assert len(res["certificates"]) == 1
+    assert res["certificates"][0]["certificateArn"] == cert_arn
+    assert res["certificates"][0]["status"] == "REVOKED"
 
 
 @mock_iot
@@ -295,12 +293,10 @@ def test_certs_create_inactive():
     cert_id = cert["certificateId"]
 
     cert = client.describe_certificate(certificateId=cert_id)
-    cert.should.have.key("certificateDescription")
     cert_desc = cert["certificateDescription"]
-    cert_desc.should.have.key("status").which.should.equal("INACTIVE")
+    assert cert_desc["status"] == "INACTIVE"
 
     client.update_certificate(certificateId=cert_id, newStatus="ACTIVE")
     cert = client.describe_certificate(certificateId=cert_id)
-    cert.should.have.key("certificateDescription")
     cert_desc = cert["certificateDescription"]
-    cert_desc.should.have.key("status").which.should.equal("ACTIVE")
+    assert cert_desc["status"] == "ACTIVE"
diff --git a/tests/test_iot/test_iot_deprecate_thing_type.py b/tests/test_iot/test_iot_deprecate_thing_type.py
index 6bee18d71..95b7dd3ab 100644
--- a/tests/test_iot/test_iot_deprecate_thing_type.py
+++ b/tests/test_iot/test_iot_deprecate_thing_type.py
@@ -14,16 +14,16 @@ def test_deprecate_undeprecate_thing_type():
     )
 
     res = client.describe_thing_type(thingTypeName=thing_type_name)
-    res["thingTypeMetadata"]["deprecated"].should.equal(False)
+    assert res["thingTypeMetadata"]["deprecated"] is False
     client.deprecate_thing_type(thingTypeName=thing_type_name, undoDeprecate=False)
 
     res = client.describe_thing_type(thingTypeName=thing_type_name)
-    res["thingTypeMetadata"]["deprecated"].should.equal(True)
+    assert res["thingTypeMetadata"]["deprecated"] is True
 
     client.deprecate_thing_type(thingTypeName=thing_type_name, undoDeprecate=True)
 
     res = client.describe_thing_type(thingTypeName=thing_type_name)
-    res["thingTypeMetadata"]["deprecated"].should.equal(False)
+    assert res["thingTypeMetadata"]["deprecated"] is False
 
 
 @mock_iot
diff --git a/tests/test_iot/test_iot_domain_configuration.py b/tests/test_iot/test_iot_domain_configuration.py
index 351f5a4d4..b2f93600c 100644
--- a/tests/test_iot/test_iot_domain_configuration.py
+++ b/tests/test_iot/test_iot_domain_configuration.py
@@ -10,10 +10,8 @@ def test_create_domain_configuration_only_name():
     domain_config = client.create_domain_configuration(
         domainConfigurationName="testConfig"
     )
-    domain_config.should.have.key("domainConfigurationName").which.should.equal(
-        "testConfig"
-    )
-    domain_config.should.have.key("domainConfigurationArn").which.should_not.be.none
+    assert domain_config["domainConfigurationName"] == "testConfig"
+    assert domain_config["domainConfigurationArn"] is not None
 
 
 @mock_iot
@@ -22,15 +20,13 @@ def test_create_duplicate_domain_configuration_fails():
     domain_config = client.create_domain_configuration(
         domainConfigurationName="testConfig"
     )
-    domain_config.should.have.key("domainConfigurationName").which.should.equal(
-        "testConfig"
-    )
-    domain_config.should.have.key("domainConfigurationArn").which.should_not.be.none
+    assert domain_config["domainConfigurationName"] == "testConfig"
+    assert domain_config["domainConfigurationArn"] is not None
     with pytest.raises(client.exceptions.ResourceAlreadyExistsException) as exc:
         client.create_domain_configuration(domainConfigurationName="testConfig")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceAlreadyExistsException")
-    err["Message"].should.equal("Domain configuration with given name already exists.")
+    assert err["Code"] == "ResourceAlreadyExistsException"
+    assert err["Message"] == "Domain configuration with given name already exists."
 
 
 @mock_iot
@@ -47,10 +43,8 @@ def test_create_domain_configuration_full_params():
         },
         serviceType="DATA",
     )
-    domain_config.should.have.key("domainConfigurationName").which.should.equal(
-        "testConfig"
-    )
-    domain_config.should.have.key("domainConfigurationArn").which.should_not.be.none
+    assert domain_config["domainConfigurationName"] == "testConfig"
+    assert domain_config["domainConfigurationArn"] is not None
 
 
 @mock_iot
@@ -61,9 +55,10 @@ def test_create_domain_configuration_invalid_service_type():
             domainConfigurationName="testConfig", serviceType="INVALIDTYPE"
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("InvalidRequestException")
-    err["Message"].should.equal(
-        "An error occurred (InvalidRequestException) when calling the DescribeDomainConfiguration operation: Service type INVALIDTYPE not recognized."
+    assert err["Code"] == "InvalidRequestException"
+    assert (
+        err["Message"]
+        == "An error occurred (InvalidRequestException) when calling the DescribeDomainConfiguration operation: Service type INVALIDTYPE not recognized."
     )
 
 
@@ -73,8 +68,8 @@ def test_describe_nonexistent_domain_configuration():
     with pytest.raises(client.exceptions.ResourceNotFoundException) as exc:
         client.describe_domain_configuration(domainConfigurationName="doesntExist")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
-    err["Message"].should.equal("The specified resource does not exist.")
+    assert err["Code"] == "ResourceNotFoundException"
+    assert err["Message"] == "The specified resource does not exist."
 
 
 @mock_iot
@@ -95,18 +90,14 @@ def test_describe_domain_configuration():
     described_config = client.describe_domain_configuration(
         domainConfigurationName="testConfig"
     )
-    described_config.should.have.key("domainConfigurationName").which.should.equal(
-        "testConfig"
-    )
-    described_config.should.have.key("domainConfigurationArn")
-    described_config.should.have.key("serverCertificates")
-    described_config.should.have.key("authorizerConfig")
-    described_config.should.have.key("domainConfigurationStatus").which.should.equal(
-        "ENABLED"
-    )
-    described_config.should.have.key("serviceType").which.should.equal("DATA")
-    described_config.should.have.key("domainType")
-    described_config.should.have.key("lastStatusChangeDate")
+    assert described_config["domainConfigurationName"] == "testConfig"
+    assert described_config["domainConfigurationArn"]
+    assert described_config["serverCertificates"]
+    assert described_config["authorizerConfig"]
+    assert described_config["domainConfigurationStatus"] == "ENABLED"
+    assert described_config["serviceType"] == "DATA"
+    assert described_config["domainType"]
+    assert described_config["lastStatusChangeDate"]
 
 
 @mock_iot
@@ -131,18 +122,10 @@ def test_update_domain_configuration():
         },
         domainConfigurationStatus="DISABLED",
     )
-    described_updated_config = client.describe_domain_configuration(
-        domainConfigurationName="testConfig"
-    )
-    described_updated_config.should.have.key("authorizerConfig").which.should.have.key(
-        "defaultAuthorizerName"
-    ).which.should.equal("updatedName")
-    described_updated_config.should.have.key("authorizerConfig").which.should.have.key(
-        "allowAuthorizerOverride"
-    ).which.should.equal(False)
-    described_updated_config.should.have.key(
-        "domainConfigurationStatus"
-    ).which.should.equal("DISABLED")
+    updated = client.describe_domain_configuration(domainConfigurationName="testConfig")
+    assert updated["authorizerConfig"]["defaultAuthorizerName"] == "updatedName"
+    assert updated["authorizerConfig"]["allowAuthorizerOverride"] is False
+    assert updated["domainConfigurationStatus"] == "DISABLED"
 
 
 @mock_iot
@@ -162,10 +145,8 @@ def test_update_domain_configuration_remove_authorizer_type():
     client.update_domain_configuration(
         domainConfigurationName="testConfig", removeAuthorizerConfig=True
     )
-    described_updated_config = client.describe_domain_configuration(
-        domainConfigurationName="testConfig"
-    )
-    described_updated_config.should_not.have.key("authorizerConfig")
+    config = client.describe_domain_configuration(domainConfigurationName="testConfig")
+    assert "authorizerConfig" not in config
 
 
 @mock_iot
@@ -174,8 +155,8 @@ def test_update_nonexistent_domain_configuration():
     with pytest.raises(client.exceptions.ResourceNotFoundException) as exc:
         client.update_domain_configuration(domainConfigurationName="doesntExist")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
-    err["Message"].should.equal("The specified resource does not exist.")
+    assert err["Code"] == "ResourceNotFoundException"
+    assert err["Message"] == "The specified resource does not exist."
 
 
 @mock_iot
@@ -183,16 +164,10 @@ def test_list_domain_configuration():
     client = boto3.client("iot", region_name="us-east-1")
     client.create_domain_configuration(domainConfigurationName="testConfig1")
     client.create_domain_configuration(domainConfigurationName="testConfig2")
-    domain_configs = client.list_domain_configurations()
-    domain_configs.should.have.key("domainConfigurations").which.should.have.length_of(
-        2
-    )
-    domain_configs["domainConfigurations"][0].should.have.key(
-        "domainConfigurationName"
-    ).which.should.equal("testConfig1")
-    domain_configs["domainConfigurations"][1].should.have.key(
-        "domainConfigurationName"
-    ).which.should.equal("testConfig2")
+    domain_configs = client.list_domain_configurations()["domainConfigurations"]
+    assert len(domain_configs) == 2
+    assert domain_configs[0]["domainConfigurationName"] == "testConfig1"
+    assert domain_configs[1]["domainConfigurationName"] == "testConfig2"
 
 
 @mock_iot
@@ -200,14 +175,10 @@ def test_delete_domain_configuration():
     client = boto3.client("iot", region_name="us-east-1")
     client.create_domain_configuration(domainConfigurationName="testConfig")
     domain_configs = client.list_domain_configurations()
-    domain_configs.should.have.key("domainConfigurations").which.should.have.length_of(
-        1
-    )
+    assert len(domain_configs["domainConfigurations"]) == 1
     client.delete_domain_configuration(domainConfigurationName="testConfig")
     domain_configs = client.list_domain_configurations()
-    domain_configs.should.have.key("domainConfigurations").which.should.have.length_of(
-        0
-    )
+    assert len(domain_configs["domainConfigurations"]) == 0
 
 
 @mock_iot
@@ -216,5 +187,5 @@ def test_delete_nonexistent_domain_configuration():
     with pytest.raises(client.exceptions.ResourceNotFoundException) as exc:
         client.delete_domain_configuration(domainConfigurationName="doesntExist")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
-    err["Message"].should.equal("The specified resource does not exist.")
+    assert err["Code"] == "ResourceNotFoundException"
+    assert err["Message"] == "The specified resource does not exist."
diff --git a/tests/test_iot/test_iot_job_executions.py b/tests/test_iot/test_iot_job_executions.py
index 980f8021c..e84f19ff8 100644
--- a/tests/test_iot/test_iot_job_executions.py
+++ b/tests/test_iot/test_iot_job_executions.py
@@ -13,8 +13,8 @@ def test_describe_job_execution():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     # job document
     job_document = {"field": "value"}
@@ -32,64 +32,43 @@ def test_describe_job_execution():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
-    job.should.have.key("description")
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
+    assert "description" in job
 
     job_execution = client.describe_job_execution(jobId=job_id, thingName=name)
-    job_execution.should.have.key("execution")
-    job_execution["execution"].should.have.key("jobId").which.should.equal(job_id)
-    job_execution["execution"].should.have.key("status").which.should.equal("QUEUED")
-    job_execution["execution"].should.have.key("forceCanceled").which.should.equal(
-        False
-    )
-    job_execution["execution"].should.have.key("statusDetails").which.should.equal(
-        {"detailsMap": {}}
-    )
-    job_execution["execution"].should.have.key("thingArn").which.should.equal(
-        thing["thingArn"]
-    )
-    job_execution["execution"].should.have.key("queuedAt")
-    job_execution["execution"].should.have.key("startedAt")
-    job_execution["execution"].should.have.key("lastUpdatedAt")
-    job_execution["execution"].should.have.key("executionNumber").which.should.equal(
-        123
-    )
-    job_execution["execution"].should.have.key("versionNumber").which.should.equal(123)
-    job_execution["execution"].should.have.key(
-        "approximateSecondsBeforeTimedOut"
-    ).which.should.equal(123)
+    assert job_execution["execution"]["jobId"] == job_id
+    assert job_execution["execution"]["status"] == "QUEUED"
+    assert job_execution["execution"]["forceCanceled"] is False
+    assert job_execution["execution"]["statusDetails"] == {"detailsMap": {}}
+    assert job_execution["execution"]["thingArn"] == thing["thingArn"]
+    assert "queuedAt" in job_execution["execution"]
+    assert "startedAt" in job_execution["execution"]
+    assert "lastUpdatedAt" in job_execution["execution"]
+    assert job_execution["execution"]["executionNumber"] == 123
+    assert job_execution["execution"]["versionNumber"] == 123
+    assert job_execution["execution"]["approximateSecondsBeforeTimedOut"] == 123
 
     job_execution = client.describe_job_execution(
         jobId=job_id, thingName=name, executionNumber=123
     )
-    job_execution.should.have.key("execution")
-    job_execution["execution"].should.have.key("jobId").which.should.equal(job_id)
-    job_execution["execution"].should.have.key("status").which.should.equal("QUEUED")
-    job_execution["execution"].should.have.key("forceCanceled").which.should.equal(
-        False
-    )
-    job_execution["execution"].should.have.key("statusDetails").which.should.equal(
-        {"detailsMap": {}}
-    )
-    job_execution["execution"].should.have.key("thingArn").which.should.equal(
-        thing["thingArn"]
-    )
-    job_execution["execution"].should.have.key("queuedAt")
-    job_execution["execution"].should.have.key("startedAt")
-    job_execution["execution"].should.have.key("lastUpdatedAt")
-    job_execution["execution"].should.have.key("executionNumber").which.should.equal(
-        123
-    )
-    job_execution["execution"].should.have.key("versionNumber").which.should.equal(123)
-    job_execution["execution"].should.have.key(
-        "approximateSecondsBeforeTimedOut"
-    ).which.should.equal(123)
+    assert "execution" in job_execution
+    assert job_execution["execution"]["jobId"] == job_id
+    assert job_execution["execution"]["status"] == "QUEUED"
+    assert job_execution["execution"]["forceCanceled"] is False
+    assert job_execution["execution"]["statusDetails"] == {"detailsMap": {}}
+    assert job_execution["execution"]["thingArn"] == thing["thingArn"]
+    assert "queuedAt" in job_execution["execution"]
+    assert "startedAt" in job_execution["execution"]
+    assert "lastUpdatedAt" in job_execution["execution"]
+    assert job_execution["execution"]["executionNumber"] == 123
+    assert job_execution["execution"]["versionNumber"] == 123
+    assert job_execution["execution"]["approximateSecondsBeforeTimedOut"] == 123
 
     with pytest.raises(ClientError) as exc:
         client.describe_job_execution(jobId=job_id, thingName=name, executionNumber=456)
     error_code = exc.value.response["Error"]["Code"]
-    error_code.should.equal("ResourceNotFoundException")
+    assert error_code == "ResourceNotFoundException"
 
 
 @mock_iot
@@ -99,8 +78,8 @@ def test_cancel_job_execution():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     # job document
     job_document = {"field": "value"}
@@ -118,14 +97,14 @@ def test_cancel_job_execution():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
-    job.should.have.key("description")
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
+    assert "description" in job
 
     client.cancel_job_execution(jobId=job_id, thingName=name)
     job_execution = client.describe_job_execution(jobId=job_id, thingName=name)
-    job_execution.should.have.key("execution")
-    job_execution["execution"].should.have.key("status").which.should.equal("CANCELED")
+    assert "execution" in job_execution
+    assert job_execution["execution"]["status"] == "CANCELED"
 
 
 @mock_iot
@@ -135,8 +114,8 @@ def test_delete_job_execution():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     # job document
     job_document = {"field": "value"}
@@ -154,16 +133,16 @@ def test_delete_job_execution():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
-    job.should.have.key("description")
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
+    assert "description" in job
 
     client.delete_job_execution(jobId=job_id, thingName=name, executionNumber=123)
 
     with pytest.raises(ClientError) as exc:
         client.describe_job_execution(jobId=job_id, thingName=name, executionNumber=123)
     error_code = exc.value.response["Error"]["Code"]
-    error_code.should.equal("ResourceNotFoundException")
+    assert error_code == "ResourceNotFoundException"
 
 
 @mock_iot
@@ -173,8 +152,8 @@ def test_list_job_executions_for_job():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     # job document
     job_document = {"field": "value"}
@@ -192,21 +171,15 @@ def test_list_job_executions_for_job():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
-    job.should.have.key("description")
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
+    assert "description" in job
 
     job_execution = client.list_job_executions_for_job(jobId=job_id)
-    job_execution.should.have.key("executionSummaries")
-    job_execution["executionSummaries"][0].should.have.key(
-        "thingArn"
-    ).which.should.equal(thing["thingArn"])
+    assert job_execution["executionSummaries"][0]["thingArn"] == thing["thingArn"]
 
     job_execution = client.list_job_executions_for_job(jobId=job_id, status="QUEUED")
-    job_execution.should.have.key("executionSummaries")
-    job_execution["executionSummaries"][0].should.have.key(
-        "thingArn"
-    ).which.should.equal(thing["thingArn"])
+    assert job_execution["executionSummaries"][0]["thingArn"] == thing["thingArn"]
 
 
 @mock_iot
@@ -216,8 +189,8 @@ def test_list_job_executions_for_thing():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     # job document
     job_document = {"field": "value"}
@@ -235,23 +208,17 @@ def test_list_job_executions_for_thing():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
-    job.should.have.key("description")
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
+    assert "description" in job
 
     job_execution = client.list_job_executions_for_thing(thingName=name)
-    job_execution.should.have.key("executionSummaries")
-    job_execution["executionSummaries"][0].should.have.key("jobId").which.should.equal(
-        job_id
-    )
+    assert job_execution["executionSummaries"][0]["jobId"] == job_id
 
     job_execution = client.list_job_executions_for_thing(
         thingName=name, status="QUEUED"
     )
-    job_execution.should.have.key("executionSummaries")
-    job_execution["executionSummaries"][0].should.have.key("jobId").which.should.equal(
-        job_id
-    )
+    assert job_execution["executionSummaries"][0]["jobId"] == job_id
 
 
 @mock_iot
@@ -269,19 +236,17 @@ def test_list_job_executions_for_thing_paginated():
 
     res = client.list_job_executions_for_thing(thingName=name, maxResults=2)
     executions = res["executionSummaries"]
-    executions.should.have.length_of(2)
-    res.should.have.key("nextToken")
+    assert len(executions) == 2
 
     res = client.list_job_executions_for_thing(
         thingName=name, maxResults=1, nextToken=res["nextToken"]
     )
     executions = res["executionSummaries"]
-    executions.should.have.length_of(1)
-    res.should.have.key("nextToken")
+    assert len(executions) == 1
 
     res = client.list_job_executions_for_thing(
         thingName=name, nextToken=res["nextToken"]
     )
     executions = res["executionSummaries"]
-    executions.should.have.length_of(7)
-    res.shouldnt.have.key("nextToken")
+    assert len(executions) == 7
+    assert "nextToken" not in res
diff --git a/tests/test_iot/test_iot_jobs.py b/tests/test_iot/test_iot_jobs.py
index 48c43989c..6295f4ff6 100644
--- a/tests/test_iot/test_iot_jobs.py
+++ b/tests/test_iot/test_iot_jobs.py
@@ -14,8 +14,8 @@ def test_create_job():
     #         "field": "value"
     #     }
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     # job document
     job_document = {"field": "value"}
@@ -33,9 +33,9 @@ def test_create_job():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
-    job.should.have.key("description")
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
+    assert "description" in job
 
 
 @mock_iot
@@ -48,8 +48,8 @@ def test_list_jobs():
     #         "field": "value"
     #     }
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     # job document
     job_document = {"field": "value"}
@@ -67,9 +67,9 @@ def test_list_jobs():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job1.should.have.key("jobId").which.should.equal(job_id)
-    job1.should.have.key("jobArn")
-    job1.should.have.key("description")
+    assert job1["jobId"] == job_id
+    assert "jobArn" in job1
+    assert "description" in job1
 
     job2 = client.create_job(
         jobId=job_id + "1",
@@ -84,15 +84,15 @@ def test_list_jobs():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job2.should.have.key("jobId").which.should.equal(job_id + "1")
-    job2.should.have.key("jobArn")
-    job2.should.have.key("description")
+    assert job2["jobId"] == job_id + "1"
+    assert "jobArn" in job2
+    assert "description" in job2
 
     jobs = client.list_jobs()
-    jobs.should.have.key("jobs")
-    jobs.should_not.have.key("nextToken")
-    jobs["jobs"][0].should.have.key("jobId").which.should.equal(job_id)
-    jobs["jobs"][1].should.have.key("jobId").which.should.equal(job_id + "1")
+    assert "jobs" in jobs
+    assert "nextToken" not in jobs
+    assert jobs["jobs"][0]["jobId"] == job_id
+    assert jobs["jobs"][1]["jobId"] == job_id + "1"
 
 
 @mock_iot
@@ -102,8 +102,8 @@ def test_describe_job():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     job = client.create_job(
         jobId=job_id,
@@ -117,34 +117,28 @@ def test_describe_job():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
-
-    job = client.describe_job(jobId=job_id)
-    job.should.have.key("documentSource")
-    job.should.have.key("job")
-    job.should.have.key("job").which.should.have.key("jobArn")
-    job.should.have.key("job").which.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("job").which.should.have.key("targets")
-    job.should.have.key("job").which.should.have.key("jobProcessDetails")
-    job.should.have.key("job").which.should.have.key("lastUpdatedAt")
-    job.should.have.key("job").which.should.have.key("createdAt")
-    job.should.have.key("job").which.should.have.key("jobExecutionsRolloutConfig")
-    job.should.have.key("job").which.should.have.key(
-        "targetSelection"
-    ).which.should.equal("CONTINUOUS")
-    job.should.have.key("job").which.should.have.key("presignedUrlConfig")
-    job.should.have.key("job").which.should.have.key(
-        "presignedUrlConfig"
-    ).which.should.have.key("roleArn").which.should.equal(
-        "arn:aws:iam::1:role/service-role/iot_job_role"
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
+
+    resp = client.describe_job(jobId=job_id)
+    assert "documentSource" in resp
+
+    job = resp["job"]
+    assert "jobArn" in job
+    assert job["jobId"] == job_id
+    assert "targets" in job
+    assert "jobProcessDetails" in job
+    assert "lastUpdatedAt" in job
+    assert "createdAt" in job
+    assert "jobExecutionsRolloutConfig" in job
+    assert job["targetSelection"] == "CONTINUOUS"
+    assert "presignedUrlConfig" in job
+    assert (
+        job["presignedUrlConfig"]["roleArn"]
+        == "arn:aws:iam::1:role/service-role/iot_job_role"
     )
-    job.should.have.key("job").which.should.have.key(
-        "presignedUrlConfig"
-    ).which.should.have.key("expiresInSec").which.should.equal(123)
-    job.should.have.key("job").which.should.have.key(
-        "jobExecutionsRolloutConfig"
-    ).which.should.have.key("maximumPerMinute").which.should.equal(10)
+    assert job["presignedUrlConfig"]["expiresInSec"] == 123
+    assert job["jobExecutionsRolloutConfig"]["maximumPerMinute"] == 10
 
 
 @mock_iot
@@ -154,8 +148,8 @@ def test_describe_job_1():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     # job document
     job_document = {"field": "value"}
@@ -172,33 +166,23 @@ def test_describe_job_1():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
-
-    job = client.describe_job(jobId=job_id)
-    job.should.have.key("job")
-    job.should.have.key("job").which.should.have.key("jobArn")
-    job.should.have.key("job").which.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("job").which.should.have.key("targets")
-    job.should.have.key("job").which.should.have.key("jobProcessDetails")
-    job.should.have.key("job").which.should.have.key("lastUpdatedAt")
-    job.should.have.key("job").which.should.have.key("createdAt")
-    job.should.have.key("job").which.should.have.key("jobExecutionsRolloutConfig")
-    job.should.have.key("job").which.should.have.key(
-        "targetSelection"
-    ).which.should.equal("CONTINUOUS")
-    job.should.have.key("job").which.should.have.key("presignedUrlConfig")
-    job.should.have.key("job").which.should.have.key(
-        "presignedUrlConfig"
-    ).which.should.have.key("roleArn").which.should.equal(
-        "arn:aws:iam::1:role/service-role/iot_job_role"
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
+
+    job = client.describe_job(jobId=job_id)["job"]
+    assert "jobArn" in job
+    assert job["jobId"] == job_id
+    assert "targets" in job
+    assert "jobProcessDetails" in job
+    assert "lastUpdatedAt" in job
+    assert "createdAt" in job
+    assert job["targetSelection"] == "CONTINUOUS"
+    assert (
+        job["presignedUrlConfig"]["roleArn"]
+        == "arn:aws:iam::1:role/service-role/iot_job_role"
     )
-    job.should.have.key("job").which.should.have.key(
-        "presignedUrlConfig"
-    ).which.should.have.key("expiresInSec").which.should.equal(123)
-    job.should.have.key("job").which.should.have.key(
-        "jobExecutionsRolloutConfig"
-    ).which.should.have.key("maximumPerMinute").which.should.equal(10)
+    assert job["presignedUrlConfig"]["expiresInSec"] == 123
+    assert job["jobExecutionsRolloutConfig"]["maximumPerMinute"] == 10
 
 
 @mock_iot
@@ -208,8 +192,8 @@ def test_delete_job():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     job = client.create_job(
         jobId=job_id,
@@ -223,16 +207,15 @@ def test_delete_job():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
 
-    job = client.describe_job(jobId=job_id)
-    job.should.have.key("job")
-    job.should.have.key("job").which.should.have.key("jobId").which.should.equal(job_id)
+    job = client.describe_job(jobId=job_id)["job"]
+    assert job["jobId"] == job_id
 
     client.delete_job(jobId=job_id)
 
-    client.list_jobs()["jobs"].should.have.length_of(0)
+    assert client.list_jobs()["jobs"] == []
 
 
 @mock_iot
@@ -242,8 +225,8 @@ def test_cancel_job():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     job = client.create_job(
         jobId=job_id,
@@ -257,32 +240,22 @@ def test_cancel_job():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
 
-    job = client.describe_job(jobId=job_id)
-    job.should.have.key("job")
-    job.should.have.key("job").which.should.have.key("jobId").which.should.equal(job_id)
+    job = client.describe_job(jobId=job_id)["job"]
+    assert job["jobId"] == job_id
 
     job = client.cancel_job(jobId=job_id, reasonCode="Because", comment="You are")
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
-
-    job = client.describe_job(jobId=job_id)
-    job.should.have.key("job")
-    job.should.have.key("job").which.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("job").which.should.have.key("status").which.should.equal(
-        "CANCELED"
-    )
-    job.should.have.key("job").which.should.have.key(
-        "forceCanceled"
-    ).which.should.equal(False)
-    job.should.have.key("job").which.should.have.key("reasonCode").which.should.equal(
-        "Because"
-    )
-    job.should.have.key("job").which.should.have.key("comment").which.should.equal(
-        "You are"
-    )
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
+
+    job = client.describe_job(jobId=job_id)["job"]
+    assert job["jobId"] == job_id
+    assert job["status"] == "CANCELED"
+    assert job["forceCanceled"] is False
+    assert job["reasonCode"] == "Because"
+    assert job["comment"] == "You are"
 
 
 @mock_iot
@@ -292,8 +265,8 @@ def test_get_job_document_with_document_source():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     job = client.create_job(
         jobId=job_id,
@@ -307,11 +280,11 @@ def test_get_job_document_with_document_source():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
 
     job_document = client.get_job_document(jobId=job_id)
-    job_document.should.have.key("document").which.should.equal("")
+    assert job_document["document"] == ""
 
 
 @mock_iot
@@ -321,8 +294,8 @@ def test_get_job_document_with_document():
     job_id = "TestJob"
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     # job document
     job_document = {"field": "value"}
@@ -339,8 +312,8 @@ def test_get_job_document_with_document():
         jobExecutionsRolloutConfig={"maximumPerMinute": 10},
     )
 
-    job.should.have.key("jobId").which.should.equal(job_id)
-    job.should.have.key("jobArn")
+    assert job["jobId"] == job_id
+    assert "jobArn" in job
 
     job_document = client.get_job_document(jobId=job_id)
-    job_document.should.have.key("document").which.should.equal('{"field": "value"}')
+    assert job_document["document"] == '{"field": "value"}'
diff --git a/tests/test_iot/test_iot_policies.py b/tests/test_iot/test_iot_policies.py
index bc514540f..076a92c22 100644
--- a/tests/test_iot/test_iot_policies.py
+++ b/tests/test_iot/test_iot_policies.py
@@ -30,12 +30,12 @@ def test_attach_policy(iot_client, policy):
     iot_client.attach_policy(policyName=policy_name, target=cert_arn)
 
     res = iot_client.list_attached_policies(target=cert_arn)
-    res.should.have.key("policies").which.should.have.length_of(1)
-    res["policies"][0]["policyName"].should.equal("my-policy")
+    assert len(res["policies"]) == 1
+    assert res["policies"][0]["policyName"] == "my-policy"
 
     res = iot_client.list_attached_policies(target=cert_arn)
-    res.should.have.key("policies").which.should.have.length_of(1)
-    res["policies"][0]["policyName"].should.equal("my-policy")
+    assert len(res["policies"]) == 1
+    assert res["policies"][0]["policyName"] == "my-policy"
 
 
 @mock_cognitoidentity
@@ -54,8 +54,8 @@ def test_attach_policy_to_identity(region_name, iot_client, policy):
     client.attach_policy(policyName=policy_name, target=identity["IdentityId"])
 
     res = client.list_attached_policies(target=identity["IdentityId"])
-    res.should.have.key("policies").which.should.have.length_of(1)
-    res["policies"][0]["policyName"].should.equal(policy_name)
+    assert len(res["policies"]) == 1
+    assert res["policies"][0]["policyName"] == policy_name
 
 
 def test_detach_policy(iot_client, policy):
@@ -67,18 +67,18 @@ def test_detach_policy(iot_client, policy):
     iot_client.attach_policy(policyName=policy_name, target=cert_arn)
 
     res = iot_client.list_attached_policies(target=cert_arn)
-    res.should.have.key("policies").which.should.have.length_of(1)
-    res["policies"][0]["policyName"].should.equal(policy_name)
+    assert len(res["policies"]) == 1
+    assert res["policies"][0]["policyName"] == policy_name
 
     iot_client.detach_policy(policyName=policy_name, target=cert_arn)
     res = iot_client.list_attached_policies(target=cert_arn)
-    res.should.have.key("policies").which.should.be.empty
+    assert res["policies"] == []
 
 
 def test_list_attached_policies(iot_client):
     cert = iot_client.create_keys_and_certificate(setAsActive=True)
     policies = iot_client.list_attached_policies(target=cert["certificateArn"])
-    policies["policies"].should.equal([])
+    assert policies["policies"] == []
 
 
 def test_policy_versions(iot_client):
@@ -86,123 +86,103 @@ def test_policy_versions(iot_client):
     doc = "{}"
 
     policy = iot_client.create_policy(policyName=policy_name, policyDocument=doc)
-    policy.should.have.key("policyName").which.should.equal(policy_name)
-    policy.should.have.key("policyArn").which.should_not.be.none
-    policy.should.have.key("policyDocument").which.should.equal(json.dumps({}))
-    policy.should.have.key("policyVersionId").which.should.equal("1")
+    assert policy["policyName"] == policy_name
+    assert policy["policyArn"] is not None
+    assert policy["policyDocument"] == json.dumps({})
+    assert policy["policyVersionId"] == "1"
 
     policy = iot_client.get_policy(policyName=policy_name)
-    policy.should.have.key("policyName").which.should.equal(policy_name)
-    policy.should.have.key("policyArn").which.should_not.be.none
-    policy.should.have.key("policyDocument").which.should.equal(json.dumps({}))
-    policy.should.have.key("defaultVersionId").which.should.equal(
-        policy["defaultVersionId"]
-    )
+    assert policy["policyName"] == policy_name
+    assert policy["policyArn"] is not None
+    assert policy["policyDocument"] == json.dumps({})
+    assert policy["defaultVersionId"] == policy["defaultVersionId"]
 
     policy1 = iot_client.create_policy_version(
         policyName=policy_name,
         policyDocument=json.dumps({"version": "version_1"}),
         setAsDefault=True,
     )
-    policy1.should.have.key("policyArn").which.should_not.be.none
-    policy1.should.have.key("policyDocument").which.should.equal(
-        json.dumps({"version": "version_1"})
-    )
-    policy1.should.have.key("policyVersionId").which.should.equal("2")
-    policy1.should.have.key("isDefaultVersion").which.should.equal(True)
+    assert policy1["policyArn"] is not None
+    assert policy1["policyDocument"] == json.dumps({"version": "version_1"})
+    assert policy1["policyVersionId"] == "2"
+    assert policy1["isDefaultVersion"] is True
 
     policy2 = iot_client.create_policy_version(
         policyName=policy_name,
         policyDocument=json.dumps({"version": "version_2"}),
         setAsDefault=False,
     )
-    policy2.should.have.key("policyArn").which.should_not.be.none
-    policy2.should.have.key("policyDocument").which.should.equal(
-        json.dumps({"version": "version_2"})
-    )
-    policy2.should.have.key("policyVersionId").which.should.equal("3")
-    policy2.should.have.key("isDefaultVersion").which.should.equal(False)
+    assert policy2["policyArn"] is not None
+    assert policy2["policyDocument"] == json.dumps({"version": "version_2"})
+    assert policy2["policyVersionId"] == "3"
+    assert policy2["isDefaultVersion"] is False
 
     policy = iot_client.get_policy(policyName=policy_name)
-    policy.should.have.key("policyName").which.should.equal(policy_name)
-    policy.should.have.key("policyArn").which.should_not.be.none
-    policy.should.have.key("policyDocument").which.should.equal(
-        json.dumps({"version": "version_1"})
-    )
-    policy.should.have.key("defaultVersionId").which.should.equal(
-        policy1["policyVersionId"]
-    )
+    assert policy["policyName"] == policy_name
+    assert policy["policyArn"] is not None
+    assert policy["policyDocument"] == json.dumps({"version": "version_1"})
+    assert policy["defaultVersionId"] == policy1["policyVersionId"]
 
     policy3 = iot_client.create_policy_version(
         policyName=policy_name,
         policyDocument=json.dumps({"version": "version_3"}),
         setAsDefault=False,
     )
-    policy3.should.have.key("policyArn").which.should_not.be.none
-    policy3.should.have.key("policyDocument").which.should.equal(
-        json.dumps({"version": "version_3"})
-    )
-    policy3.should.have.key("policyVersionId").which.should.equal("4")
-    policy3.should.have.key("isDefaultVersion").which.should.equal(False)
+    assert policy3["policyArn"] is not None
+    assert policy3["policyDocument"] == json.dumps({"version": "version_3"})
+    assert policy3["policyVersionId"] == "4"
+    assert policy3["isDefaultVersion"] is False
 
     policy4 = iot_client.create_policy_version(
         policyName=policy_name,
         policyDocument=json.dumps({"version": "version_4"}),
         setAsDefault=False,
     )
-    policy4.should.have.key("policyArn").which.should_not.be.none
-    policy4.should.have.key("policyDocument").which.should.equal(
-        json.dumps({"version": "version_4"})
-    )
-    policy4.should.have.key("policyVersionId").which.should.equal("5")
-    policy4.should.have.key("isDefaultVersion").which.should.equal(False)
+    assert policy4["policyArn"] is not None
+    assert policy4["policyDocument"] == json.dumps({"version": "version_4"})
+    assert policy4["policyVersionId"] == "5"
+    assert policy4["isDefaultVersion"] is False
 
-    policy_versions = iot_client.list_policy_versions(policyName=policy_name)
-    policy_versions.should.have.key("policyVersions").which.should.have.length_of(5)
-    list(
-        map(lambda item: item["isDefaultVersion"], policy_versions["policyVersions"])
-    ).count(True).should.equal(1)
-    default_policy = list(
-        filter(lambda item: item["isDefaultVersion"], policy_versions["policyVersions"])
+    policy_versions = iot_client.list_policy_versions(policyName=policy_name)[
+        "policyVersions"
+    ]
+    assert len(policy_versions) == 5
+    assert (
+        list(map(lambda item: item["isDefaultVersion"], policy_versions)).count(True)
+        == 1
     )
-    default_policy[0].should.have.key("versionId").should.equal(
-        policy1["policyVersionId"]
+    default_policy = list(
+        filter(lambda item: item["isDefaultVersion"], policy_versions)
     )
+    assert default_policy[0]["versionId"] == policy1["policyVersionId"]
 
     policy = iot_client.get_policy(policyName=policy_name)
-    policy.should.have.key("policyName").which.should.equal(policy_name)
-    policy.should.have.key("policyArn").which.should_not.be.none
-    policy.should.have.key("policyDocument").which.should.equal(
-        json.dumps({"version": "version_1"})
-    )
-    policy.should.have.key("defaultVersionId").which.should.equal(
-        policy1["policyVersionId"]
-    )
+    assert policy["policyName"] == policy_name
+    assert policy["policyArn"] is not None
+    assert policy["policyDocument"] == json.dumps({"version": "version_1"})
+    assert policy["defaultVersionId"] == policy1["policyVersionId"]
 
     iot_client.set_default_policy_version(
         policyName=policy_name, policyVersionId=policy4["policyVersionId"]
     )
-    policy_versions = iot_client.list_policy_versions(policyName=policy_name)
-    policy_versions.should.have.key("policyVersions").which.should.have.length_of(5)
-    list(
-        map(lambda item: item["isDefaultVersion"], policy_versions["policyVersions"])
-    ).count(True).should.equal(1)
-    default_policy = list(
-        filter(lambda item: item["isDefaultVersion"], policy_versions["policyVersions"])
+    policy_versions = iot_client.list_policy_versions(policyName=policy_name)[
+        "policyVersions"
+    ]
+    assert len(policy_versions) == 5
+    assert (
+        list(map(lambda item: item["isDefaultVersion"], policy_versions)).count(True)
+        == 1
     )
-    default_policy[0].should.have.key("versionId").should.equal(
-        policy4["policyVersionId"]
+    default_policy = list(
+        filter(lambda item: item["isDefaultVersion"], policy_versions)
     )
+    assert default_policy[0]["versionId"] == policy4["policyVersionId"]
 
     policy = iot_client.get_policy(policyName=policy_name)
-    policy.should.have.key("policyName").which.should.equal(policy_name)
-    policy.should.have.key("policyArn").which.should_not.be.none
-    policy.should.have.key("policyDocument").which.should.equal(
-        json.dumps({"version": "version_4"})
-    )
-    policy.should.have.key("defaultVersionId").which.should.equal(
-        policy4["policyVersionId"]
-    )
+    assert policy["policyName"] == policy_name
+    assert policy["policyArn"] is not None
+    assert policy["policyDocument"] == json.dumps({"version": "version_4"})
+    assert policy["defaultVersionId"] == policy4["policyVersionId"]
 
     with pytest.raises(ClientError) as exc:
         iot_client.create_policy_version(
@@ -211,30 +191,31 @@ def test_policy_versions(iot_client):
             setAsDefault=False,
         )
     err = exc.value.response["Error"]
-    err["Message"].should.equal(
-        f"The policy {policy_name} already has the maximum number of versions (5)"
+    assert (
+        err["Message"]
+        == f"The policy {policy_name} already has the maximum number of versions (5)"
     )
 
     iot_client.delete_policy_version(policyName=policy_name, policyVersionId="1")
     policy_versions = iot_client.list_policy_versions(policyName=policy_name)
-    policy_versions.should.have.key("policyVersions").which.should.have.length_of(4)
+    assert len(policy_versions["policyVersions"]) == 4
 
     iot_client.delete_policy_version(
         policyName=policy_name, policyVersionId=policy1["policyVersionId"]
     )
     policy_versions = iot_client.list_policy_versions(policyName=policy_name)
-    policy_versions.should.have.key("policyVersions").which.should.have.length_of(3)
+    assert len(policy_versions["policyVersions"]) == 3
     iot_client.delete_policy_version(
         policyName=policy_name, policyVersionId=policy2["policyVersionId"]
     )
     policy_versions = iot_client.list_policy_versions(policyName=policy_name)
-    policy_versions.should.have.key("policyVersions").which.should.have.length_of(2)
+    assert len(policy_versions["policyVersions"]) == 2
 
     iot_client.delete_policy_version(
         policyName=policy_name, policyVersionId=policy3["policyVersionId"]
     )
     policy_versions = iot_client.list_policy_versions(policyName=policy_name)
-    policy_versions.should.have.key("policyVersions").which.should.have.length_of(1)
+    assert len(policy_versions["policyVersions"]) == 1
 
     # should fail as it"s the default policy. Should use delete_policy instead
     with pytest.raises(ClientError) as exc:
@@ -242,7 +223,7 @@ def test_policy_versions(iot_client):
             policyName=policy_name, policyVersionId=policy4["policyVersionId"]
         )
     err = exc.value.response["Error"]
-    err["Message"].should.equal("Cannot delete the default version of a policy")
+    assert err["Message"] == "Cannot delete the default version of a policy"
 
 
 def test_policy_versions_increment_beyond_5(iot_client, policy):
@@ -260,7 +241,7 @@ def test_policy_versions_increment_beyond_5(iot_client, policy):
             policyDocument=json.dumps({"version": f"version_{v}"}),
             setAsDefault=True,
         )
-        new_version.should.have.key("policyVersionId").which.should.equal(str(v))
+        assert new_version["policyVersionId"] == str(v)
         iot_client.delete_policy_version(
             policyName=policy_name, policyVersionId=str(v - 1)
         )
@@ -275,13 +256,13 @@ def test_policy_versions_increment_even_after_version_delete(iot_client, policy)
         policyName=policy_name,
         policyDocument=json.dumps({"version": "version_2"}),
     )
-    new_version.should.have.key("policyVersionId").which.should.equal("2")
+    assert new_version["policyVersionId"] == "2"
     iot_client.delete_policy_version(policyName=policy_name, policyVersionId="2")
     third_version = iot_client.create_policy_version(
         policyName=policy_name,
         policyDocument=json.dumps({"version": "version_3"}),
     )
-    third_version.should.have.key("policyVersionId").which.should.equal("3")
+    assert third_version["policyVersionId"] == "3"
 
 
 def test_delete_policy_validation(iot_client):
@@ -306,43 +287,43 @@ def test_delete_policy_validation(iot_client):
 
     with pytest.raises(ClientError) as e:
         iot_client.delete_policy(policyName=policy_name)
-    e.value.response["Error"]["Message"].should.contain(
-        "The policy cannot be deleted as the policy is attached to one or more principals (name=%s)"
-        % policy_name
+    assert (
+        f"The policy cannot be deleted as the policy is attached to one or more principals (name={policy_name})"
+        in e.value.response["Error"]["Message"]
     )
     res = iot_client.list_policies()
-    res.should.have.key("policies").which.should.have.length_of(1)
+    assert len(res["policies"]) == 1
 
     iot_client.detach_principal_policy(policyName=policy_name, principal=cert_arn)
     iot_client.delete_policy(policyName=policy_name)
     res = iot_client.list_policies()
-    res.should.have.key("policies").which.should.have.length_of(0)
+    assert len(res["policies"]) == 0
 
 
 def test_policy(iot_client):
     name = "my-policy"
     doc = "{}"
     policy = iot_client.create_policy(policyName=name, policyDocument=doc)
-    policy.should.have.key("policyName").which.should.equal(name)
-    policy.should.have.key("policyArn").which.should_not.be.none
-    policy.should.have.key("policyDocument").which.should.equal(doc)
-    policy.should.have.key("policyVersionId").which.should.equal("1")
+    assert policy["policyName"] == name
+    assert policy["policyArn"] is not None
+    assert policy["policyDocument"] == doc
+    assert policy["policyVersionId"] == "1"
 
     policy = iot_client.get_policy(policyName=name)
-    policy.should.have.key("policyName").which.should.equal(name)
-    policy.should.have.key("policyArn").which.should_not.be.none
-    policy.should.have.key("policyDocument").which.should.equal(doc)
-    policy.should.have.key("defaultVersionId").which.should.equal("1")
+    assert policy["policyName"] == name
+    assert policy["policyArn"] is not None
+    assert policy["policyDocument"] == doc
+    assert policy["defaultVersionId"] == "1"
 
     res = iot_client.list_policies()
-    res.should.have.key("policies").which.should.have.length_of(1)
+    assert len(res["policies"]) == 1
     for policy in res["policies"]:
-        policy.should.have.key("policyName").which.should_not.be.none
-        policy.should.have.key("policyArn").which.should_not.be.none
+        assert policy["policyName"] is not None
+        assert policy["policyArn"] is not None
 
     iot_client.delete_policy(policyName=name)
     res = iot_client.list_policies()
-    res.should.have.key("policies").which.should.have.length_of(0)
+    assert len(res["policies"]) == 0
 
 
 def test_attach_policy_to_thing_group(iot_client, policy):
@@ -353,8 +334,8 @@ def test_attach_policy_to_thing_group(iot_client, policy):
     iot_client.attach_policy(policyName=policy_name, target=thing_group_arn)
 
     res = iot_client.list_attached_policies(target=thing_group_arn)
-    res.should.have.key("policies").which.should.have.length_of(1)
-    res["policies"][0]["policyName"].should.equal(policy_name)
+    assert len(res["policies"]) == 1
+    assert res["policies"][0]["policyName"] == policy_name
 
 
 def test_attach_policy_to_non_existant_thing_group_raises_ResourceNotFoundException(
@@ -378,14 +359,15 @@ def test_policy_delete_fails_when_versions_exist(iot_client, policy):
     )
     with pytest.raises(ClientError) as e:
         iot_client.delete_policy(policyName=policy_name)
-    e.value.response["Error"]["Message"].should.contain(
+    assert (
         "Cannot delete the policy because it has one or more policy versions attached to it"
+        in e.value.response["Error"]["Message"]
     )
 
 
 def test_list_targets_for_policy_empty(iot_client, policy):
     res = iot_client.list_targets_for_policy(policyName=policy["policyName"])
-    res.should.have.key("targets").which.should.have.length_of(0)
+    assert len(res["targets"]) == 0
 
 
 def test_list_targets_for_policy_one_attached_thing_group(iot_client, policy):
@@ -396,8 +378,8 @@ def test_list_targets_for_policy_one_attached_thing_group(iot_client, policy):
     iot_client.attach_policy(policyName=policy_name, target=thing_group_arn)
 
     res = iot_client.list_targets_for_policy(policyName=policy["policyName"])
-    res.should.have.key("targets").which.should.have.length_of(1)
-    res["targets"][0].should.equal(thing_group_arn)
+    assert len(res["targets"]) == 1
+    assert res["targets"][0] == thing_group_arn
 
 
 def test_list_targets_for_policy_one_attached_certificate(iot_client, policy):
@@ -408,16 +390,16 @@ def test_list_targets_for_policy_one_attached_certificate(iot_client, policy):
     iot_client.attach_policy(policyName=policy_name, target=cert_arn)
 
     res = iot_client.list_targets_for_policy(policyName=policy["policyName"])
-    res.should.have.key("targets").which.should.have.length_of(1)
-    res["targets"][0].should.equal(cert_arn)
+    assert len(res["targets"]) == 1
+    assert res["targets"][0] == cert_arn
 
 
 def test_list_targets_for_policy_resource_not_found(iot_client):
     with pytest.raises(ClientError) as e:
         iot_client.list_targets_for_policy(policyName="NON_EXISTENT_POLICY_NAME")
 
-    e.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
-    e.value.response["Error"]["Message"].should.contain("Policy not found")
+    assert e.value.response["Error"]["Code"] == "ResourceNotFoundException"
+    assert "Policy not found" in e.value.response["Error"]["Message"]
 
 
 def test_create_policy_fails_when_name_taken(iot_client, policy):
@@ -430,12 +412,11 @@ def test_create_policy_fails_when_name_taken(iot_client, policy):
         )
 
     current_policy = iot_client.get_policy(policyName=policy_name)
-    e.value.response["Error"]["Code"].should.equal("ResourceAlreadyExistsException")
-    e.value.response["Error"]["Message"].should.equal(
-        f"Policy cannot be created - name already exists (name={policy_name})"
+    assert e.value.response["Error"]["Code"] == "ResourceAlreadyExistsException"
+    assert (
+        e.value.response["Error"]["Message"]
+        == f"Policy cannot be created - name already exists (name={policy_name})"
     )
 
     # the policy should not have been overwritten
-    current_policy.should.have.key("policyDocument").which.should.equal(
-        policy["policyDocument"]
-    )
+    assert current_policy["policyDocument"] == policy["policyDocument"]
diff --git a/tests/test_iot/test_iot_search.py b/tests/test_iot/test_iot_search.py
index 48f7ea165..6422ad34d 100644
--- a/tests/test_iot/test_iot_search.py
+++ b/tests/test_iot/test_iot_search.py
@@ -47,8 +47,8 @@ def test_search_attribute_specific_value(query_string, results):
         )
 
     resp = client.search_index(queryString=query_string)
-    resp.should.have.key("thingGroups").equals([])
-    resp.should.have.key("things").length_of(len(results))
+    assert resp["thingGroups"] == []
+    assert len(resp["things"]) == len(results)
 
     thing_names = [t["thingName"] for t in resp["things"]]
-    set(thing_names).should.equal(results)
+    assert set(thing_names) == results
diff --git a/tests/test_iot/test_iot_thing_groups.py b/tests/test_iot/test_iot_thing_groups.py
index e456f5c25..d69a5b218 100644
--- a/tests/test_iot/test_iot_thing_groups.py
+++ b/tests/test_iot/test_iot_thing_groups.py
@@ -61,8 +61,8 @@ class TestListThingGroup:
         generate_thing_group_tree(client, self.tree_dict)
         # test
         resp = client.list_thing_groups()
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(8)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 8
 
     @mock_iot
     def test_should_list_all_groups_non_recursively(self):
@@ -71,8 +71,8 @@ class TestListThingGroup:
         generate_thing_group_tree(client, self.tree_dict)
         # test
         resp = client.list_thing_groups(recursive=False)
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(2)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 2
 
     @mock_iot
     def test_should_list_all_groups_filtered_by_parent(self):
@@ -81,17 +81,17 @@ class TestListThingGroup:
         generate_thing_group_tree(client, self.tree_dict)
         # test
         resp = client.list_thing_groups(parentGroup=self.group_name_1a)
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(6)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 6
         resp = client.list_thing_groups(parentGroup=self.group_name_2a)
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(2)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 2
         resp = client.list_thing_groups(parentGroup=self.group_name_1b)
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(0)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 0
         with pytest.raises(ClientError) as e:
             client.list_thing_groups(parentGroup="inexistant-group-name")
-            e.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
+            assert e.value.response["Error"]["Code"] == "ResourceNotFoundException"
 
     @mock_iot
     def test_should_list_all_groups_filtered_by_parent_non_recursively(self):
@@ -100,11 +100,11 @@ class TestListThingGroup:
         generate_thing_group_tree(client, self.tree_dict)
         # test
         resp = client.list_thing_groups(parentGroup=self.group_name_1a, recursive=False)
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(2)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 2
         resp = client.list_thing_groups(parentGroup=self.group_name_2a, recursive=False)
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(2)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 2
 
     @mock_iot
     def test_should_list_all_groups_filtered_by_name_prefix(self):
@@ -113,14 +113,14 @@ class TestListThingGroup:
         generate_thing_group_tree(client, self.tree_dict)
         # test
         resp = client.list_thing_groups(namePrefixFilter="my-group-name-1")
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(2)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 2
         resp = client.list_thing_groups(namePrefixFilter="my-group-name-3")
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(4)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 4
         resp = client.list_thing_groups(namePrefixFilter="prefix-which-doesn-not-match")
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(0)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 0
 
     @mock_iot
     def test_should_list_all_groups_filtered_by_name_prefix_non_recursively(self):
@@ -131,13 +131,13 @@ class TestListThingGroup:
         resp = client.list_thing_groups(
             namePrefixFilter="my-group-name-1", recursive=False
         )
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(2)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 2
         resp = client.list_thing_groups(
             namePrefixFilter="my-group-name-3", recursive=False
         )
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(0)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 0
 
     @mock_iot
     def test_should_list_all_groups_filtered_by_name_prefix_and_parent(self):
@@ -148,19 +148,19 @@ class TestListThingGroup:
         resp = client.list_thing_groups(
             namePrefixFilter="my-group-name-2", parentGroup=self.group_name_1a
         )
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(2)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 2
         resp = client.list_thing_groups(
             namePrefixFilter="my-group-name-3", parentGroup=self.group_name_1a
         )
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(4)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 4
         resp = client.list_thing_groups(
             namePrefixFilter="prefix-which-doesn-not-match",
             parentGroup=self.group_name_1a,
         )
-        resp.should.have.key("thingGroups")
-        resp["thingGroups"].should.have.length_of(0)
+        assert "thingGroups" in resp
+        assert len(resp["thingGroups"]) == 0
 
 
 @mock_iot
@@ -176,24 +176,24 @@ def test_delete_thing_group():
         client.delete_thing_group(thingGroupName=group_name_1a)
     except client.exceptions.InvalidRequestException as exc:
         error_code = exc.response["Error"]["Code"]
-        error_code.should.equal("InvalidRequestException")
+        assert error_code == "InvalidRequestException"
     else:
         raise Exception("Should have raised error")
 
     # delete child group
     client.delete_thing_group(thingGroupName=group_name_2a)
     res = client.list_thing_groups()
-    res.should.have.key("thingGroups").which.should.have.length_of(1)
-    res["thingGroups"].should_not.have.key(group_name_2a)
+    assert len(res["thingGroups"]) == 1
+    assert group_name_2a not in res["thingGroups"]
 
     # now that there is no child group, we can delete the previous group safely
     client.delete_thing_group(thingGroupName=group_name_1a)
     res = client.list_thing_groups()
-    res.should.have.key("thingGroups").which.should.have.length_of(0)
+    assert len(res["thingGroups"]) == 0
 
     # Deleting an invalid thing group does not raise an error.
     res = client.delete_thing_group(thingGroupName="non-existent-group-name")
-    res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert res["ResponseMetadata"]["HTTPStatusCode"] == 200
 
 
 @mock_iot
@@ -220,210 +220,94 @@ def test_describe_thing_group_metadata_hierarchy():
     # describe groups
     # groups level 1
     # 1a
-    thing_group_description1a = client.describe_thing_group(
-        thingGroupName=group_name_1a
-    )
-    thing_group_description1a.should.have.key("thingGroupName").which.should.equal(
-        group_name_1a
-    )
-    thing_group_description1a.should.have.key("thingGroupProperties")
-    thing_group_description1a.should.have.key("thingGroupMetadata")
-    thing_group_description1a["thingGroupMetadata"].should.have.key("creationDate")
-    thing_group_description1a.should.have.key("version")
+    desc1a = client.describe_thing_group(thingGroupName=group_name_1a)
+    assert desc1a["thingGroupName"] == group_name_1a
+    assert "thingGroupProperties" in desc1a
+    assert "creationDate" in desc1a["thingGroupMetadata"]
+    assert "version" in desc1a
     # 1b
-    thing_group_description1b = client.describe_thing_group(
-        thingGroupName=group_name_1b
-    )
-    thing_group_description1b.should.have.key("thingGroupName").which.should.equal(
-        group_name_1b
-    )
-    thing_group_description1b.should.have.key("thingGroupProperties")
-    thing_group_description1b.should.have.key("thingGroupMetadata")
-    thing_group_description1b["thingGroupMetadata"].should.have.length_of(1)
-    thing_group_description1b["thingGroupMetadata"].should.have.key("creationDate")
-    thing_group_description1b.should.have.key("version")
+    desc1b = client.describe_thing_group(thingGroupName=group_name_1b)
+    assert desc1b["thingGroupName"] == group_name_1b
+    assert "thingGroupProperties" in desc1b
+    assert len(desc1b["thingGroupMetadata"]) == 1
+    assert "creationDate" in desc1b["thingGroupMetadata"]
+    assert "version" in desc1b
     # groups level 2
     # 2a
-    thing_group_description2a = client.describe_thing_group(
-        thingGroupName=group_name_2a
-    )
-    thing_group_description2a.should.have.key("thingGroupName").which.should.equal(
-        group_name_2a
-    )
-    thing_group_description2a.should.have.key("thingGroupProperties")
-    thing_group_description2a.should.have.key("thingGroupMetadata")
-    thing_group_description2a["thingGroupMetadata"].should.have.length_of(3)
-    thing_group_description2a["thingGroupMetadata"].should.have.key(
-        "parentGroupName"
-    ).being.equal(group_name_1a)
-    thing_group_description2a["thingGroupMetadata"].should.have.key(
-        "rootToParentThingGroups"
-    )
-    thing_group_description2a["thingGroupMetadata"][
-        "rootToParentThingGroups"
-    ].should.have.length_of(1)
-    thing_group_description2a["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupName"
-    ].should.match(group_name_1a)
-    thing_group_description2a["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupArn"
-    ].should.match(group_catalog[group_name_1a]["thingGroupArn"])
-    thing_group_description2a.should.have.key("version")
+    desc2a = client.describe_thing_group(thingGroupName=group_name_2a)
+    assert desc2a["thingGroupName"] == group_name_2a
+    assert "thingGroupProperties" in desc2a
+    assert len(desc2a["thingGroupMetadata"]) == 3
+    assert desc2a["thingGroupMetadata"]["parentGroupName"] == group_name_1a
+    desc2a_groups = desc2a["thingGroupMetadata"]["rootToParentThingGroups"]
+    assert len(desc2a_groups) == 1
+    assert desc2a_groups[0]["groupName"] == group_name_1a
+    assert desc2a_groups[0]["groupArn"] == group_catalog[group_name_1a]["thingGroupArn"]
+    assert "version" in desc2a
     # 2b
-    thing_group_description2b = client.describe_thing_group(
-        thingGroupName=group_name_2b
-    )
-    thing_group_description2b.should.have.key("thingGroupName").which.should.equal(
-        group_name_2b
-    )
-    thing_group_description2b.should.have.key("thingGroupProperties")
-    thing_group_description2b.should.have.key("thingGroupMetadata")
-    thing_group_description2b["thingGroupMetadata"].should.have.length_of(3)
-    thing_group_description2b["thingGroupMetadata"].should.have.key(
-        "parentGroupName"
-    ).being.equal(group_name_1a)
-    thing_group_description2b["thingGroupMetadata"].should.have.key(
-        "rootToParentThingGroups"
-    )
-    thing_group_description2b["thingGroupMetadata"][
-        "rootToParentThingGroups"
-    ].should.have.length_of(1)
-    thing_group_description2b["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupName"
-    ].should.match(group_name_1a)
-    thing_group_description2b["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupArn"
-    ].should.match(group_catalog[group_name_1a]["thingGroupArn"])
-    thing_group_description2b.should.have.key("version")
+    desc2b = client.describe_thing_group(thingGroupName=group_name_2b)
+    assert desc2b["thingGroupName"] == group_name_2b
+    assert "thingGroupProperties" in desc2b
+    assert len(desc2b["thingGroupMetadata"]) == 3
+    assert desc2b["thingGroupMetadata"]["parentGroupName"] == group_name_1a
+    desc2b_groups = desc2b["thingGroupMetadata"]["rootToParentThingGroups"]
+    assert len(desc2b_groups) == 1
+    assert desc2b_groups[0]["groupName"] == group_name_1a
+    assert desc2b_groups[0]["groupArn"] == group_catalog[group_name_1a]["thingGroupArn"]
+    assert "version" in desc2b
     # groups level 3
     # 3a
-    thing_group_description3a = client.describe_thing_group(
-        thingGroupName=group_name_3a
-    )
-    thing_group_description3a.should.have.key("thingGroupName").which.should.equal(
-        group_name_3a
-    )
-    thing_group_description3a.should.have.key("thingGroupProperties")
-    thing_group_description3a.should.have.key("thingGroupMetadata")
-    thing_group_description3a["thingGroupMetadata"].should.have.length_of(3)
-    thing_group_description3a["thingGroupMetadata"].should.have.key(
-        "parentGroupName"
-    ).being.equal(group_name_2a)
-    thing_group_description3a["thingGroupMetadata"].should.have.key(
-        "rootToParentThingGroups"
-    )
-    thing_group_description3a["thingGroupMetadata"][
-        "rootToParentThingGroups"
-    ].should.have.length_of(2)
-    thing_group_description3a["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupName"
-    ].should.match(group_name_1a)
-    thing_group_description3a["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupArn"
-    ].should.match(group_catalog[group_name_1a]["thingGroupArn"])
-    thing_group_description3a["thingGroupMetadata"]["rootToParentThingGroups"][1][
-        "groupName"
-    ].should.match(group_name_2a)
-    thing_group_description3a["thingGroupMetadata"]["rootToParentThingGroups"][1][
-        "groupArn"
-    ].should.match(group_catalog[group_name_2a]["thingGroupArn"])
-    thing_group_description3a.should.have.key("version")
+    desc3a = client.describe_thing_group(thingGroupName=group_name_3a)
+    assert desc3a["thingGroupName"] == group_name_3a
+    assert "thingGroupProperties" in desc3a
+    assert len(desc3a["thingGroupMetadata"]) == 3
+    assert desc3a["thingGroupMetadata"]["parentGroupName"] == group_name_2a
+    desc3a_groups = desc3a["thingGroupMetadata"]["rootToParentThingGroups"]
+    assert len(desc3a_groups) == 2
+    assert desc3a_groups[0]["groupName"] == group_name_1a
+    assert desc3a_groups[0]["groupArn"] == group_catalog[group_name_1a]["thingGroupArn"]
+    assert desc3a_groups[1]["groupName"] == group_name_2a
+    assert desc3a_groups[1]["groupArn"] == group_catalog[group_name_2a]["thingGroupArn"]
+    assert "version" in desc3a
     # 3b
-    thing_group_description3b = client.describe_thing_group(
-        thingGroupName=group_name_3b
-    )
-    thing_group_description3b.should.have.key("thingGroupName").which.should.equal(
-        group_name_3b
-    )
-    thing_group_description3b.should.have.key("thingGroupProperties")
-    thing_group_description3b.should.have.key("thingGroupMetadata")
-    thing_group_description3b["thingGroupMetadata"].should.have.length_of(3)
-    thing_group_description3b["thingGroupMetadata"].should.have.key(
-        "parentGroupName"
-    ).being.equal(group_name_2a)
-    thing_group_description3b["thingGroupMetadata"].should.have.key(
-        "rootToParentThingGroups"
-    )
-    thing_group_description3b["thingGroupMetadata"][
-        "rootToParentThingGroups"
-    ].should.have.length_of(2)
-    thing_group_description3b["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupName"
-    ].should.match(group_name_1a)
-    thing_group_description3b["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupArn"
-    ].should.match(group_catalog[group_name_1a]["thingGroupArn"])
-    thing_group_description3b["thingGroupMetadata"]["rootToParentThingGroups"][1][
-        "groupName"
-    ].should.match(group_name_2a)
-    thing_group_description3b["thingGroupMetadata"]["rootToParentThingGroups"][1][
-        "groupArn"
-    ].should.match(group_catalog[group_name_2a]["thingGroupArn"])
-    thing_group_description3b.should.have.key("version")
+    desc3b = client.describe_thing_group(thingGroupName=group_name_3b)
+    assert desc3b["thingGroupName"] == group_name_3b
+    assert "thingGroupProperties" in desc3b
+    assert len(desc3b["thingGroupMetadata"]) == 3
+    assert desc3b["thingGroupMetadata"]["parentGroupName"] == group_name_2a
+    desc3b_groups = desc3b["thingGroupMetadata"]["rootToParentThingGroups"]
+    assert len(desc3b_groups) == 2
+    assert desc3b_groups[0]["groupName"] == group_name_1a
+    assert desc3b_groups[0]["groupArn"] == group_catalog[group_name_1a]["thingGroupArn"]
+    assert desc3b_groups[1]["groupName"] == group_name_2a
+    assert desc3b_groups[1]["groupArn"] == group_catalog[group_name_2a]["thingGroupArn"]
+    assert "version" in desc3b
     # 3c
-    thing_group_description3c = client.describe_thing_group(
-        thingGroupName=group_name_3c
-    )
-    thing_group_description3c.should.have.key("thingGroupName").which.should.equal(
-        group_name_3c
-    )
-    thing_group_description3c.should.have.key("thingGroupProperties")
-    thing_group_description3c.should.have.key("thingGroupMetadata")
-    thing_group_description3c["thingGroupMetadata"].should.have.length_of(3)
-    thing_group_description3c["thingGroupMetadata"].should.have.key(
-        "parentGroupName"
-    ).being.equal(group_name_2b)
-    thing_group_description3c["thingGroupMetadata"].should.have.key(
-        "rootToParentThingGroups"
-    )
-    thing_group_description3c["thingGroupMetadata"][
-        "rootToParentThingGroups"
-    ].should.have.length_of(2)
-    thing_group_description3c["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupName"
-    ].should.match(group_name_1a)
-    thing_group_description3c["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupArn"
-    ].should.match(group_catalog[group_name_1a]["thingGroupArn"])
-    thing_group_description3c["thingGroupMetadata"]["rootToParentThingGroups"][1][
-        "groupName"
-    ].should.match(group_name_2b)
-    thing_group_description3c["thingGroupMetadata"]["rootToParentThingGroups"][1][
-        "groupArn"
-    ].should.match(group_catalog[group_name_2b]["thingGroupArn"])
-    thing_group_description3c.should.have.key("version")
+    desc3c = client.describe_thing_group(thingGroupName=group_name_3c)
+    assert desc3c["thingGroupName"] == group_name_3c
+    assert "thingGroupProperties" in desc3c
+    assert len(desc3c["thingGroupMetadata"]) == 3
+    assert desc3c["thingGroupMetadata"]["parentGroupName"] == group_name_2b
+    desc3c_groups = desc3c["thingGroupMetadata"]["rootToParentThingGroups"]
+    assert len(desc3c_groups) == 2
+    assert desc3c_groups[0]["groupName"] == group_name_1a
+    assert desc3c_groups[0]["groupArn"] == group_catalog[group_name_1a]["thingGroupArn"]
+    assert desc3c_groups[1]["groupName"] == group_name_2b
+    assert desc3c_groups[1]["groupArn"] == group_catalog[group_name_2b]["thingGroupArn"]
+    assert "version" in desc3c
     # 3d
-    thing_group_description3d = client.describe_thing_group(
-        thingGroupName=group_name_3d
-    )
-    thing_group_description3d.should.have.key("thingGroupName").which.should.equal(
-        group_name_3d
-    )
-    thing_group_description3d.should.have.key("thingGroupProperties")
-    thing_group_description3d.should.have.key("thingGroupMetadata")
-    thing_group_description3d["thingGroupMetadata"].should.have.length_of(3)
-    thing_group_description3d["thingGroupMetadata"].should.have.key(
-        "parentGroupName"
-    ).being.equal(group_name_2b)
-    thing_group_description3d["thingGroupMetadata"].should.have.key(
-        "rootToParentThingGroups"
-    )
-    thing_group_description3d["thingGroupMetadata"][
-        "rootToParentThingGroups"
-    ].should.have.length_of(2)
-    thing_group_description3d["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupName"
-    ].should.match(group_name_1a)
-    thing_group_description3d["thingGroupMetadata"]["rootToParentThingGroups"][0][
-        "groupArn"
-    ].should.match(group_catalog[group_name_1a]["thingGroupArn"])
-    thing_group_description3d["thingGroupMetadata"]["rootToParentThingGroups"][1][
-        "groupName"
-    ].should.match(group_name_2b)
-    thing_group_description3d["thingGroupMetadata"]["rootToParentThingGroups"][1][
-        "groupArn"
-    ].should.match(group_catalog[group_name_2b]["thingGroupArn"])
-    thing_group_description3d.should.have.key("version")
+    desc3d = client.describe_thing_group(thingGroupName=group_name_3d)
+    assert desc3d["thingGroupName"] == group_name_3d
+    assert "thingGroupProperties" in desc3d
+    assert len(desc3d["thingGroupMetadata"]) == 3
+    assert desc3d["thingGroupMetadata"]["parentGroupName"] == group_name_2b
+    desc3d_groups = desc3d["thingGroupMetadata"]["rootToParentThingGroups"]
+    assert len(desc3d_groups) == 2
+    assert desc3d_groups[0]["groupName"] == group_name_1a
+    assert desc3d_groups[0]["groupArn"] == group_catalog[group_name_1a]["thingGroupArn"]
+    assert desc3d_groups[1]["groupName"] == group_name_2b
+    assert desc3d_groups[1]["groupArn"] == group_catalog[group_name_2b]["thingGroupArn"]
+    assert "version" in desc3d
 
 
 @mock_iot
@@ -433,28 +317,28 @@ def test_thing_groups():
 
     # thing group
     thing_group = client.create_thing_group(thingGroupName=group_name)
-    thing_group.should.have.key("thingGroupName").which.should.equal(group_name)
-    thing_group.should.have.key("thingGroupArn")
-    thing_group["thingGroupArn"].should.contain(group_name)
+    assert thing_group["thingGroupName"] == group_name
+    assert "thingGroupArn" in thing_group
+    assert group_name in thing_group["thingGroupArn"]
 
     res = client.list_thing_groups()
-    res.should.have.key("thingGroups").which.should.have.length_of(1)
+    assert len(res["thingGroups"]) == 1
     for thing_group in res["thingGroups"]:
-        thing_group.should.have.key("groupName").which.should_not.be.none
-        thing_group.should.have.key("groupArn").which.should_not.be.none
+        assert thing_group["groupName"] is not None
+        assert thing_group["groupArn"] is not None
 
     thing_group = client.describe_thing_group(thingGroupName=group_name)
-    thing_group.should.have.key("thingGroupName").which.should.equal(group_name)
-    thing_group.should.have.key("thingGroupProperties")
-    thing_group.should.have.key("thingGroupMetadata")
-    thing_group.should.have.key("version")
-    thing_group.should.have.key("thingGroupArn")
-    thing_group["thingGroupArn"].should.contain(group_name)
+    assert thing_group["thingGroupName"] == group_name
+    assert "thingGroupProperties" in thing_group
+    assert "thingGroupMetadata" in thing_group
+    assert "version" in thing_group
+    assert "thingGroupArn" in thing_group
+    assert group_name in thing_group["thingGroupArn"]
 
     # delete thing group
     client.delete_thing_group(thingGroupName=group_name)
     res = client.list_thing_groups()
-    res.should.have.key("thingGroups").which.should.have.length_of(0)
+    assert len(res["thingGroups"]) == 0
 
     # props create test
     props = {
@@ -464,40 +348,34 @@ def test_thing_groups():
     thing_group = client.create_thing_group(
         thingGroupName=group_name, thingGroupProperties=props
     )
-    thing_group.should.have.key("thingGroupName").which.should.equal(group_name)
-    thing_group.should.have.key("thingGroupArn")
+    assert thing_group["thingGroupName"] == group_name
+    assert "thingGroupArn" in thing_group
 
     thing_group = client.describe_thing_group(thingGroupName=group_name)
-    thing_group.should.have.key("thingGroupProperties").which.should.have.key(
-        "attributePayload"
-    ).which.should.have.key("attributes")
+    assert "attributes" in thing_group["thingGroupProperties"]["attributePayload"]
     res_props = thing_group["thingGroupProperties"]["attributePayload"]["attributes"]
-    res_props.should.have.key("key1").which.should.equal("val01")
-    res_props.should.have.key("Key02").which.should.equal("VAL2")
+    assert res_props["key1"] == "val01"
+    assert res_props["Key02"] == "VAL2"
 
     # props update test with merge
     new_props = {"attributePayload": {"attributes": {"k3": "v3"}, "merge": True}}
     client.update_thing_group(thingGroupName=group_name, thingGroupProperties=new_props)
     thing_group = client.describe_thing_group(thingGroupName=group_name)
-    thing_group.should.have.key("thingGroupProperties").which.should.have.key(
-        "attributePayload"
-    ).which.should.have.key("attributes")
+    assert "attributes" in thing_group["thingGroupProperties"]["attributePayload"]
     res_props = thing_group["thingGroupProperties"]["attributePayload"]["attributes"]
-    res_props.should.have.key("key1").which.should.equal("val01")
-    res_props.should.have.key("Key02").which.should.equal("VAL2")
+    assert res_props["key1"] == "val01"
+    assert res_props["Key02"] == "VAL2"
 
-    res_props.should.have.key("k3").which.should.equal("v3")
+    assert res_props["k3"] == "v3"
 
     # props update test
     new_props = {"attributePayload": {"attributes": {"k4": "v4"}}}
     client.update_thing_group(thingGroupName=group_name, thingGroupProperties=new_props)
     thing_group = client.describe_thing_group(thingGroupName=group_name)
-    thing_group.should.have.key("thingGroupProperties").which.should.have.key(
-        "attributePayload"
-    ).which.should.have.key("attributes")
+    assert "attributes" in thing_group["thingGroupProperties"]["attributePayload"]
     res_props = thing_group["thingGroupProperties"]["attributePayload"]["attributes"]
-    res_props.should.have.key("k4").which.should.equal("v4")
-    res_props.should_not.have.key("key1")
+    assert res_props["k4"] == "v4"
+    assert "key1" not in res_props
 
 
 @mock_iot
@@ -508,13 +386,13 @@ def test_thing_group_relations():
 
     # thing group
     thing_group = client.create_thing_group(thingGroupName=group_name)
-    thing_group.should.have.key("thingGroupName").which.should.equal(group_name)
-    thing_group.should.have.key("thingGroupArn")
+    assert thing_group["thingGroupName"] == group_name
+    assert "thingGroupArn" in thing_group
 
     # thing
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     # add in 4 way
     client.add_thing_to_thing_group(thingGroupName=group_name, thingName=name)
@@ -529,12 +407,12 @@ def test_thing_group_relations():
     )
 
     things = client.list_things_in_thing_group(thingGroupName=group_name)
-    things.should.have.key("things")
-    things["things"].should.have.length_of(1)
+    assert "things" in things
+    assert len(things["things"]) == 1
 
     thing_groups = client.list_thing_groups_for_thing(thingName=name)
-    thing_groups.should.have.key("thingGroups")
-    thing_groups["thingGroups"].should.have.length_of(1)
+    assert "thingGroups" in thing_groups
+    assert len(thing_groups["thingGroups"]) == 1
 
     # remove in 4 way
     client.remove_thing_from_thing_group(thingGroupName=group_name, thingName=name)
@@ -548,21 +426,21 @@ def test_thing_group_relations():
         thingGroupArn=thing_group["thingGroupArn"], thingName=name
     )
     things = client.list_things_in_thing_group(thingGroupName=group_name)
-    things.should.have.key("things")
-    things["things"].should.have.length_of(0)
+    assert "things" in things
+    assert len(things["things"]) == 0
 
     # update thing group for thing
     client.update_thing_groups_for_thing(thingName=name, thingGroupsToAdd=[group_name])
     things = client.list_things_in_thing_group(thingGroupName=group_name)
-    things.should.have.key("things")
-    things["things"].should.have.length_of(1)
+    assert "things" in things
+    assert len(things["things"]) == 1
 
     client.update_thing_groups_for_thing(
         thingName=name, thingGroupsToRemove=[group_name]
     )
     things = client.list_things_in_thing_group(thingGroupName=group_name)
-    things.should.have.key("things")
-    things["things"].should.have.length_of(0)
+    assert "things" in things
+    assert len(things["things"]) == 0
 
 
 @mock_iot
@@ -614,9 +492,9 @@ def test_thing_group_updates_description():
     )
 
     thing_group = client.describe_thing_group(thingGroupName=name)
-    thing_group.should.have.key("thingGroupProperties").which.should.have.key(
-        "thingGroupDescription"
-    ).which.should.equal(new_description)
+    assert (
+        thing_group["thingGroupProperties"]["thingGroupDescription"] == new_description
+    )
 
 
 @mock_iot
@@ -638,9 +516,9 @@ def test_thing_group_update_with_no_previous_attributes_no_merge():
     )
 
     updated_thing_group = client.describe_thing_group(thingGroupName=name)
-    updated_thing_group.should.have.key("thingGroupProperties").which.should.have.key(
-        "attributePayload"
-    ).which.should.have.key("attributes").which.should.equal({"key1": "val01"})
+    assert updated_thing_group["thingGroupProperties"]["attributePayload"][
+        "attributes"
+    ] == {"key1": "val01"}
 
 
 @mock_iot
@@ -662,9 +540,9 @@ def test_thing_group_update_with_no_previous_attributes_with_merge():
     )
 
     updated_thing_group = client.describe_thing_group(thingGroupName=name)
-    updated_thing_group.should.have.key("thingGroupProperties").which.should.have.key(
-        "attributePayload"
-    ).which.should.have.key("attributes").which.should.equal({"key1": "val01"})
+    assert updated_thing_group["thingGroupProperties"]["attributePayload"][
+        "attributes"
+    ] == {"key1": "val01"}
 
 
 @mock_iot
@@ -684,6 +562,4 @@ def test_thing_group_updated_with_empty_attributes_no_merge_no_attributes_added(
     )
 
     updated_thing_group = client.describe_thing_group(thingGroupName=name)
-    updated_thing_group.should.have.key(
-        "thingGroupProperties"
-    ).which.should_not.have.key("attributePayload")
+    assert "attributePayload" not in updated_thing_group["thingGroupProperties"]
diff --git a/tests/test_iot/test_iot_thing_types.py b/tests/test_iot/test_iot_thing_types.py
index 01181098a..83cede6fe 100644
--- a/tests/test_iot/test_iot_thing_types.py
+++ b/tests/test_iot/test_iot_thing_types.py
@@ -9,9 +9,8 @@ def test_create_thing_type():
     type_name = "my-type-name"
 
     thing_type = client.create_thing_type(thingTypeName=type_name)
-    thing_type.should.have.key("thingTypeName").which.should.equal(type_name)
-    thing_type.should.have.key("thingTypeArn")
-    thing_type["thingTypeArn"].should.contain(type_name)
+    assert thing_type["thingTypeName"] == type_name
+    assert type_name in thing_type["thingTypeArn"]
 
 
 @mock_iot
@@ -22,11 +21,10 @@ def test_describe_thing_type():
     client.create_thing_type(thingTypeName=type_name)
 
     thing_type = client.describe_thing_type(thingTypeName=type_name)
-    thing_type.should.have.key("thingTypeName").which.should.equal(type_name)
-    thing_type.should.have.key("thingTypeProperties")
-    thing_type.should.have.key("thingTypeMetadata")
-    thing_type.should.have.key("thingTypeArn")
-    thing_type["thingTypeArn"].should.contain(type_name)
+    assert thing_type["thingTypeName"] == type_name
+    assert "thingTypeProperties" in thing_type
+    assert "thingTypeMetadata" in thing_type
+    assert type_name in thing_type["thingTypeArn"]
 
 
 @mock_iot
@@ -37,16 +35,16 @@ def test_list_thing_types():
         client.create_thing_type(thingTypeName=str(i + 1))
 
     thing_types = client.list_thing_types()
-    thing_types.should.have.key("nextToken")
-    thing_types.should.have.key("thingTypes").which.should.have.length_of(50)
-    thing_types["thingTypes"][0]["thingTypeName"].should.equal("1")
-    thing_types["thingTypes"][-1]["thingTypeName"].should.equal("50")
+    assert "nextToken" in thing_types
+    assert len(thing_types["thingTypes"]) == 50
+    assert thing_types["thingTypes"][0]["thingTypeName"] == "1"
+    assert thing_types["thingTypes"][-1]["thingTypeName"] == "50"
 
     thing_types = client.list_thing_types(nextToken=thing_types["nextToken"])
-    thing_types.should.have.key("thingTypes").which.should.have.length_of(50)
-    thing_types.should_not.have.key("nextToken")
-    thing_types["thingTypes"][0]["thingTypeName"].should.equal("51")
-    thing_types["thingTypes"][-1]["thingTypeName"].should.equal("100")
+    assert len(thing_types["thingTypes"]) == 50
+    assert "nextToken" not in thing_types
+    assert thing_types["thingTypes"][0]["thingTypeName"] == "51"
+    assert thing_types["thingTypes"][-1]["thingTypeName"] == "100"
 
 
 @mock_iot
@@ -61,16 +59,16 @@ def test_list_thing_types_with_typename_filter():
     client.create_thing_type(thingTypeName="find me it shall not")
 
     thing_types = client.list_thing_types(thingTypeName="thing")
-    thing_types.should_not.have.key("nextToken")
-    thing_types.should.have.key("thingTypes").which.should.have.length_of(4)
-    thing_types["thingTypes"][0]["thingTypeName"].should.equal("thing")
-    thing_types["thingTypes"][-1]["thingTypeName"].should.equal("thingTypeNameGroup")
+    assert "nextToken" not in thing_types
+    assert len(thing_types["thingTypes"]) == 4
+    assert thing_types["thingTypes"][0]["thingTypeName"] == "thing"
+    assert thing_types["thingTypes"][-1]["thingTypeName"] == "thingTypeNameGroup"
 
     thing_types = client.list_thing_types(thingTypeName="thingTypeName")
-    thing_types.should_not.have.key("nextToken")
-    thing_types.should.have.key("thingTypes").which.should.have.length_of(2)
-    thing_types["thingTypes"][0]["thingTypeName"].should.equal("thingTypeName")
-    thing_types["thingTypes"][-1]["thingTypeName"].should.equal("thingTypeNameGroup")
+    assert "nextToken" not in thing_types
+    assert len(thing_types["thingTypes"]) == 2
+    assert thing_types["thingTypes"][0]["thingTypeName"] == "thingTypeName"
+    assert thing_types["thingTypes"][-1]["thingTypeName"] == "thingTypeNameGroup"
 
 
 @mock_iot
@@ -83,4 +81,4 @@ def test_delete_thing_type():
     # delete thing type
     client.delete_thing_type(thingTypeName=type_name)
     res = client.list_thing_types()
-    res.should.have.key("thingTypes").which.should.have.length_of(0)
+    assert len(res["thingTypes"]) == 0
diff --git a/tests/test_iot/test_iot_things.py b/tests/test_iot/test_iot_things.py
index ee1ca8b56..65f605ea5 100644
--- a/tests/test_iot/test_iot_things.py
+++ b/tests/test_iot/test_iot_things.py
@@ -10,13 +10,13 @@ def test_create_thing():
     name = "my-thing"
 
     thing = client.create_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     res = client.list_things()
-    res.should.have.key("things").which.should.have.length_of(1)
-    res["things"][0].should.have.key("thingName").which.should_not.be.none
-    res["things"][0].should.have.key("thingArn").which.should_not.be.none
+    assert len(res["things"]) == 1
+    assert res["things"][0]["thingName"] is not None
+    assert res["things"][0]["thingArn"] is not None
 
 
 @mock_iot
@@ -28,16 +28,16 @@ def test_create_thing_with_type():
     client.create_thing_type(thingTypeName=type_name)
 
     thing = client.create_thing(thingName=name, thingTypeName=type_name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("thingArn")
+    assert thing["thingName"] == name
+    assert "thingArn" in thing
 
     res = client.list_things()
-    res.should.have.key("things").which.should.have.length_of(1)
-    res["things"][0].should.have.key("thingName").which.should_not.be.none
-    res["things"][0].should.have.key("thingArn").which.should_not.be.none
+    assert len(res["things"]) == 1
+    assert res["things"][0]["thingName"] is not None
+    assert res["things"][0]["thingArn"] is not None
 
     thing = client.describe_thing(thingName=name)
-    thing.should.have.key("thingTypeName").equals(type_name)
+    assert thing["thingTypeName"] == type_name
 
 
 @mock_iot
@@ -49,10 +49,10 @@ def test_update_thing():
 
     client.update_thing(thingName=name, attributePayload={"attributes": {"k1": "v1"}})
     res = client.list_things()
-    res.should.have.key("things").which.should.have.length_of(1)
-    res["things"][0].should.have.key("thingName").which.should_not.be.none
-    res["things"][0].should.have.key("thingArn").which.should_not.be.none
-    res["things"][0]["attributes"].should.have.key("k1").which.should.equal("v1")
+    assert len(res["things"]) == 1
+    assert res["things"][0]["thingName"] is not None
+    assert res["things"][0]["thingArn"] is not None
+    assert res["things"][0]["attributes"]["k1"] == "v1"
 
 
 @mock_iot
@@ -64,10 +64,10 @@ def test_describe_thing():
     client.update_thing(thingName=name, attributePayload={"attributes": {"k1": "v1"}})
 
     thing = client.describe_thing(thingName=name)
-    thing.should.have.key("thingName").which.should.equal(name)
-    thing.should.have.key("defaultClientId")
-    thing.should.have.key("attributes").equals({"k1": "v1"})
-    thing.should.have.key("version").equals(1)
+    assert thing["thingName"] == name
+    assert "defaultClientId" in thing
+    assert thing["attributes"] == {"k1": "v1"}
+    assert thing["version"] == 1
 
 
 @mock_iot
@@ -81,7 +81,7 @@ def test_delete_thing():
     client.delete_thing(thingName=name)
 
     res = client.list_things()
-    res.should.have.key("things").which.should.have.length_of(0)
+    assert len(res["things"]) == 0
 
 
 @mock_iot
@@ -92,51 +92,56 @@ def test_list_things_with_next_token():
         client.create_thing(thingName=str(i + 1))
 
     things = client.list_things()
-    things.should.have.key("nextToken")
-    things.should.have.key("things").which.should.have.length_of(50)
-    things["things"][0]["thingName"].should.equal("1")
-    things["things"][0]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/1"
+    assert len(things["things"]) == 50
+    assert things["things"][0]["thingName"] == "1"
+    assert (
+        things["things"][0]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/1"
     )
-    things["things"][-1]["thingName"].should.equal("50")
-    things["things"][-1]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/50"
+    assert things["things"][-1]["thingName"] == "50"
+    assert (
+        things["things"][-1]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/50"
     )
 
     things = client.list_things(nextToken=things["nextToken"])
-    things.should.have.key("nextToken")
-    things.should.have.key("things").which.should.have.length_of(50)
-    things["things"][0]["thingName"].should.equal("51")
-    things["things"][0]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/51"
+    assert len(things["things"]) == 50
+    assert things["things"][0]["thingName"] == "51"
+    assert (
+        things["things"][0]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/51"
     )
-    things["things"][-1]["thingName"].should.equal("100")
-    things["things"][-1]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/100"
+    assert things["things"][-1]["thingName"] == "100"
+    assert (
+        things["things"][-1]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/100"
     )
 
     things = client.list_things(nextToken=things["nextToken"])
-    things.should.have.key("nextToken")
-    things.should.have.key("things").which.should.have.length_of(50)
-    things["things"][0]["thingName"].should.equal("101")
-    things["things"][0]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/101"
+    assert len(things["things"]) == 50
+    assert things["things"][0]["thingName"] == "101"
+    assert (
+        things["things"][0]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/101"
     )
-    things["things"][-1]["thingName"].should.equal("150")
-    things["things"][-1]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/150"
+    assert things["things"][-1]["thingName"] == "150"
+    assert (
+        things["things"][-1]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/150"
     )
 
     things = client.list_things(nextToken=things["nextToken"])
-    things.should_not.have.key("nextToken")
-    things.should.have.key("things").which.should.have.length_of(50)
-    things["things"][0]["thingName"].should.equal("151")
-    things["things"][0]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/151"
+    assert "nextToken" not in things
+    assert len(things["things"]) == 50
+    assert things["things"][0]["thingName"] == "151"
+    assert (
+        things["things"][0]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/151"
     )
-    things["things"][-1]["thingName"].should.equal("200")
-    things["things"][-1]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/200"
+    assert things["things"][-1]["thingName"] == "200"
+    assert (
+        things["things"][-1]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/200"
     )
 
 
@@ -167,77 +172,87 @@ def test_list_things_with_attribute_and_thing_type_filter_and_next_token():
 
     # Test filter for thingTypeName
     things = client.list_things(thingTypeName=thing_type_name)
-    things.should.have.key("nextToken")
-    things.should.have.key("things").which.should.have.length_of(50)
-    things["things"][0]["thingName"].should.equal("2")
-    things["things"][0]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/2"
+    assert "nextToken" in things
+    assert len(things["things"]) == 50
+    assert things["things"][0]["thingName"] == "2"
+    assert (
+        things["things"][0]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/2"
     )
-    things["things"][-1]["thingName"].should.equal("100")
-    things["things"][-1]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/100"
+    assert things["things"][-1]["thingName"] == "100"
+    assert (
+        things["things"][-1]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/100"
     )
-    all(item["thingTypeName"] == thing_type_name for item in things["things"])
+    assert all(item["thingTypeName"] == thing_type_name for item in things["things"])
 
     things = client.list_things(
         nextToken=things["nextToken"], thingTypeName=thing_type_name
     )
-    things.should_not.have.key("nextToken")
-    things.should.have.key("things").which.should.have.length_of(50)
-    things["things"][0]["thingName"].should.equal("102")
-    things["things"][0]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/102"
+    assert "nextToken" not in things
+    assert len(things["things"]) == 50
+    assert things["things"][0]["thingName"] == "102"
+    assert (
+        things["things"][0]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/102"
     )
-    things["things"][-1]["thingName"].should.equal("200")
-    things["things"][-1]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/200"
+    assert things["things"][-1]["thingName"] == "200"
+    assert (
+        things["things"][-1]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/200"
     )
-    all(item["thingTypeName"] == thing_type_name for item in things["things"])
+    assert all(item["thingTypeName"] == thing_type_name for item in things["things"])
 
     # Test filter for attributes
     things = client.list_things(attributeName="foo", attributeValue="bar")
-    things.should.have.key("nextToken")
-    things.should.have.key("things").which.should.have.length_of(50)
-    things["things"][0]["thingName"].should.equal("3")
-    things["things"][0]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/3"
+    assert "nextToken" in things
+    assert len(things["things"]) == 50
+    assert things["things"][0]["thingName"] == "3"
+    assert (
+        things["things"][0]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/3"
     )
-    things["things"][-1]["thingName"].should.equal("150")
-    things["things"][-1]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/150"
+    assert things["things"][-1]["thingName"] == "150"
+    assert (
+        things["things"][-1]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/150"
     )
-    all(item["attributes"] == {"foo": "bar"} for item in things["things"])
+    assert all(item["attributes"] == {"foo": "bar"} for item in things["things"])
 
     things = client.list_things(
         nextToken=things["nextToken"], attributeName="foo", attributeValue="bar"
     )
-    things.should_not.have.key("nextToken")
-    things.should.have.key("things").which.should.have.length_of(16)
-    things["things"][0]["thingName"].should.equal("153")
-    things["things"][0]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/153"
+    assert "nextToken" not in things
+    assert len(things["things"]) == 16
+    assert things["things"][0]["thingName"] == "153"
+    assert (
+        things["things"][0]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/153"
     )
-    things["things"][-1]["thingName"].should.equal("198")
-    things["things"][-1]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/198"
+    assert things["things"][-1]["thingName"] == "198"
+    assert (
+        things["things"][-1]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/198"
     )
-    all(item["attributes"] == {"foo": "bar"} for item in things["things"])
+    assert all(item["attributes"] == {"foo": "bar"} for item in things["things"])
 
     # Test filter for attributes and thingTypeName
     things = client.list_things(
         thingTypeName=thing_type_name, attributeName="foo", attributeValue="bar"
     )
-    things.should_not.have.key("nextToken")
-    things.should.have.key("things").which.should.have.length_of(33)
-    things["things"][0]["thingName"].should.equal("6")
-    things["things"][0]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/6"
+    assert "nextToken" not in things
+    assert len(things["things"]) == 33
+    assert things["things"][0]["thingName"] == "6"
+    assert (
+        things["things"][0]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/6"
     )
-    things["things"][-1]["thingName"].should.equal("198")
-    things["things"][-1]["thingArn"].should.equal(
-        f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/198"
+    assert things["things"][-1]["thingName"] == "198"
+    assert (
+        things["things"][-1]["thingArn"]
+        == f"arn:aws:iot:ap-northeast-1:{ACCOUNT_ID}:thing/198"
     )
-    all(
+    assert all(
         item["attributes"] == {"foo": "bar"}
         and item["thingTypeName"] == thing_type_name
         for item in things["things"]
diff --git a/tests/test_iot/test_iot_topic_rules.py b/tests/test_iot/test_iot_topic_rules.py
index 199610181..484266fd1 100644
--- a/tests/test_iot/test_iot_topic_rules.py
+++ b/tests/test_iot/test_iot_topic_rules.py
@@ -29,7 +29,7 @@ def test_topic_rule_create():
     with pytest.raises(ClientError) as ex:
         client.create_topic_rule(ruleName=name, topicRulePayload=payload)
     error_code = ex.value.response["Error"]["Code"]
-    error_code.should.equal("ResourceAlreadyExistsException")
+    assert error_code == "ResourceAlreadyExistsException"
 
 
 @mock_iot
@@ -38,19 +38,19 @@ def test_topic_rule_list():
 
     # empty response
     res = client.list_topic_rules()
-    res.should.have.key("rules").which.should.have.length_of(0)
+    assert len(res["rules"]) == 0
 
     client.create_topic_rule(ruleName=name, topicRulePayload=payload)
     client.create_topic_rule(ruleName="my-rule-2", topicRulePayload=payload)
 
     res = client.list_topic_rules()
-    res.should.have.key("rules").which.should.have.length_of(2)
+    assert len(res["rules"]) == 2
     for rule, rule_name in zip(res["rules"], [name, "my-rule-2"]):
-        rule.should.have.key("ruleName").which.should.equal(rule_name)
-        rule.should.have.key("createdAt").which.should_not.be.none
-        rule.should.have.key("ruleArn").which.should_not.be.none
-        rule.should.have.key("ruleDisabled").which.should.equal(payload["ruleDisabled"])
-        rule.should.have.key("topicPattern").which.should.equal("topic/*")
+        assert rule["ruleName"] == rule_name
+        assert rule["createdAt"] is not None
+        assert rule["ruleArn"] is not None
+        assert rule["ruleDisabled"] == payload["ruleDisabled"]
+        assert rule["topicPattern"] == "topic/*"
 
 
 @mock_iot
@@ -61,25 +61,22 @@ def test_topic_rule_get():
     with pytest.raises(ClientError) as ex:
         client.get_topic_rule(ruleName=name)
     error_code = ex.value.response["Error"]["Code"]
-    error_code.should.equal("ResourceNotFoundException")
+    assert error_code == "ResourceNotFoundException"
 
     client.create_topic_rule(ruleName=name, topicRulePayload=payload)
 
     rule = client.get_topic_rule(ruleName=name)
 
-    rule.should.have.key("ruleArn").which.should_not.be.none
-    rule.should.have.key("rule")
+    assert rule["ruleArn"] is not None
     rrule = rule["rule"]
-    rrule.should.have.key("actions").which.should.equal(payload["actions"])
-    rrule.should.have.key("awsIotSqlVersion").which.should.equal(
-        payload["awsIotSqlVersion"]
-    )
-    rrule.should.have.key("createdAt").which.should_not.be.none
-    rrule.should.have.key("description").which.should.equal(payload["description"])
-    rrule.should.have.key("errorAction").which.should.equal(payload["errorAction"])
-    rrule.should.have.key("ruleDisabled").which.should.equal(payload["ruleDisabled"])
-    rrule.should.have.key("ruleName").which.should.equal(name)
-    rrule.should.have.key("sql").which.should.equal(payload["sql"])
+    assert rrule["actions"] == payload["actions"]
+    assert rrule["awsIotSqlVersion"] == payload["awsIotSqlVersion"]
+    assert rrule["createdAt"] is not None
+    assert rrule["description"] == payload["description"]
+    assert rrule["errorAction"] == payload["errorAction"]
+    assert rrule["ruleDisabled"] == payload["ruleDisabled"]
+    assert rrule["ruleName"] == name
+    assert rrule["sql"] == payload["sql"]
 
 
 @mock_iot
@@ -90,7 +87,7 @@ def test_topic_rule_replace():
     with pytest.raises(ClientError) as ex:
         client.replace_topic_rule(ruleName=name, topicRulePayload=payload)
     error_code = ex.value.response["Error"]["Code"]
-    error_code.should.equal("ResourceNotFoundException")
+    assert error_code == "ResourceNotFoundException"
 
     client.create_topic_rule(ruleName=name, topicRulePayload=payload)
 
@@ -99,8 +96,8 @@ def test_topic_rule_replace():
     client.replace_topic_rule(ruleName=name, topicRulePayload=my_payload)
 
     rule = client.get_topic_rule(ruleName=name)
-    rule["rule"]["ruleName"].should.equal(name)
-    rule["rule"]["description"].should.equal(my_payload["description"])
+    assert rule["rule"]["ruleName"] == name
+    assert rule["rule"]["description"] == my_payload["description"]
 
 
 @mock_iot
@@ -111,15 +108,15 @@ def test_topic_rule_disable():
     with pytest.raises(ClientError) as ex:
         client.disable_topic_rule(ruleName=name)
     error_code = ex.value.response["Error"]["Code"]
-    error_code.should.equal("ResourceNotFoundException")
+    assert error_code == "ResourceNotFoundException"
 
     client.create_topic_rule(ruleName=name, topicRulePayload=payload)
 
     client.disable_topic_rule(ruleName=name)
 
     rule = client.get_topic_rule(ruleName=name)
-    rule["rule"]["ruleName"].should.equal(name)
-    rule["rule"]["ruleDisabled"].should.equal(True)
+    assert rule["rule"]["ruleName"] == name
+    assert rule["rule"]["ruleDisabled"] is True
 
 
 @mock_iot
@@ -130,7 +127,7 @@ def test_topic_rule_enable():
     with pytest.raises(ClientError) as ex:
         client.enable_topic_rule(ruleName=name)
     error_code = ex.value.response["Error"]["Code"]
-    error_code.should.equal("ResourceNotFoundException")
+    assert error_code == "ResourceNotFoundException"
 
     my_payload = payload.copy()
     my_payload["ruleDisabled"] = True
@@ -139,8 +136,8 @@ def test_topic_rule_enable():
     client.enable_topic_rule(ruleName=name)
 
     rule = client.get_topic_rule(ruleName=name)
-    rule["rule"]["ruleName"].should.equal(name)
-    rule["rule"]["ruleDisabled"].should.equal(False)
+    assert rule["rule"]["ruleName"] == name
+    assert rule["rule"]["ruleDisabled"] is False
 
 
 @mock_iot
@@ -151,7 +148,7 @@ def test_topic_rule_delete():
     with pytest.raises(ClientError) as ex:
         client.delete_topic_rule(ruleName=name)
     error_code = ex.value.response["Error"]["Code"]
-    error_code.should.equal("ResourceNotFoundException")
+    assert error_code == "ResourceNotFoundException"
 
     client.create_topic_rule(ruleName=name, topicRulePayload=payload)
 
@@ -160,4 +157,4 @@ def test_topic_rule_delete():
     client.delete_topic_rule(ruleName=name)
 
     res = client.list_topic_rules()
-    res.should.have.key("rules").which.should.have.length_of(0)
+    assert len(res["rules"]) == 0
diff --git a/tests/test_iot/test_server.py b/tests/test_iot/test_server.py
index 8c81be327..6c4d8df20 100644
--- a/tests/test_iot/test_server.py
+++ b/tests/test_iot/test_server.py
@@ -1,8 +1,7 @@
 import json
-from urllib.parse import quote
-
 import pytest
-import sure  # noqa # pylint: disable=unused-import
+
+from urllib.parse import quote
 
 import moto.server as server
 from moto import mock_iot
@@ -19,7 +18,7 @@ def test_iot_list():
 
     # just making sure that server is up
     res = test_client.get("/things")
-    res.status_code.should.equal(200)
+    assert res.status_code == 200
 
 
 @pytest.mark.parametrize(
@@ -45,6 +44,6 @@ def test_list_attached_policies(url_encode_arn):
         certificate_arn = quote(certificate_arn, safe="")
 
     result = test_client.post(f"/attached-policies/{certificate_arn}")
-    result.status_code.should.equal(200)
+    assert result.status_code == 200
     result_dict = json.loads(result.data.decode("utf-8"))
-    result_dict["policies"][0]["policyName"].should.equal("my-policy")
+    assert result_dict["policies"][0]["policyName"] == "my-policy"
diff --git a/tests/test_kinesis/test_kinesis.py b/tests/test_kinesis/test_kinesis.py
index 116e8d733..da6cdab45 100644
--- a/tests/test_kinesis/test_kinesis.py
+++ b/tests/test_kinesis/test_kinesis.py
@@ -10,8 +10,6 @@ from dateutil.tz import tzlocal
 from moto import mock_kinesis
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
 
-import sure  # noqa # pylint: disable=unused-import
-
 
 @mock_kinesis
 def test_stream_creation_on_demand():
@@ -24,7 +22,7 @@ def test_stream_creation_on_demand():
 
     # AWS starts with 4 shards by default
     shard_list = client.list_shards(StreamARN=stream_arn)["Shards"]
-    shard_list.should.have.length_of(4)
+    assert len(shard_list) == 4
 
     # Cannot update-shard-count when we're in on-demand mode
     with pytest.raises(ClientError) as exc:
@@ -32,9 +30,10 @@ def test_stream_creation_on_demand():
             StreamARN=stream_arn, TargetShardCount=3, ScalingType="UNIFORM_SCALING"
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.equal(
-        f"Request is invalid. Stream my_stream under account {ACCOUNT_ID} is in On-Demand mode."
+    assert err["Code"] == "ValidationException"
+    assert (
+        err["Message"]
+        == f"Request is invalid. Stream my_stream under account {ACCOUNT_ID} is in On-Demand mode."
     )
 
 
@@ -54,7 +53,7 @@ def test_update_stream_mode():
 
     resp = client.describe_stream_summary(StreamName="my_stream")
     stream = resp["StreamDescriptionSummary"]
-    stream.should.have.key("StreamModeDetails").equals({"StreamMode": "PROVISIONED"})
+    assert stream["StreamModeDetails"] == {"StreamMode": "PROVISIONED"}
 
 
 @mock_kinesis
@@ -63,27 +62,25 @@ def test_describe_non_existent_stream():
     with pytest.raises(ClientError) as exc:
         client.describe_stream_summary(StreamName="not-a-stream")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
-    err["Message"].should.equal(
-        "Stream not-a-stream under account 123456789012 not found."
-    )
+    assert err["Code"] == "ResourceNotFoundException"
+    assert err["Message"] == "Stream not-a-stream under account 123456789012 not found."
 
 
 @mock_kinesis
 def test_list_and_delete_stream():
     client = boto3.client("kinesis", region_name="us-west-2")
-    client.list_streams()["StreamNames"].should.have.length_of(0)
+    assert len(client.list_streams()["StreamNames"]) == 0
 
     client.create_stream(StreamName="stream1", ShardCount=1)
     client.create_stream(StreamName="stream2", ShardCount=1)
-    client.list_streams()["StreamNames"].should.have.length_of(2)
+    assert len(client.list_streams()["StreamNames"]) == 2
 
     client.delete_stream(StreamName="stream1")
-    client.list_streams()["StreamNames"].should.have.length_of(1)
+    assert len(client.list_streams()["StreamNames"]) == 1
 
     stream_arn = get_stream_arn(client, "stream2")
     client.delete_stream(StreamARN=stream_arn)
-    client.list_streams()["StreamNames"].should.have.length_of(0)
+    assert len(client.list_streams()["StreamNames"]) == 0
 
 
 @mock_kinesis
@@ -92,10 +89,8 @@ def test_delete_unknown_stream():
     with pytest.raises(ClientError) as exc:
         client.delete_stream(StreamName="not-a-stream")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
-    err["Message"].should.equal(
-        "Stream not-a-stream under account 123456789012 not found."
-    )
+    assert err["Code"] == "ResourceNotFoundException"
+    assert err["Message"] == "Stream not-a-stream under account 123456789012 not found."
 
 
 @mock_kinesis
@@ -108,13 +103,13 @@ def test_list_many_streams():
     resp = conn.list_streams()
     stream_names = resp["StreamNames"]
     has_more_streams = resp["HasMoreStreams"]
-    stream_names.should.have.length_of(10)
-    has_more_streams.should.be(True)
+    assert len(stream_names) == 10
+    assert has_more_streams is True
     resp2 = conn.list_streams(ExclusiveStartStreamName=stream_names[-1])
     stream_names = resp2["StreamNames"]
     has_more_streams = resp2["HasMoreStreams"]
-    stream_names.should.have.length_of(1)
-    has_more_streams.should.equal(False)
+    assert len(stream_names) == 1
+    assert has_more_streams is False
 
 
 @mock_kinesis
@@ -127,18 +122,19 @@ def test_describe_stream_summary():
     resp = conn.describe_stream_summary(StreamName=stream_name)
     stream = resp["StreamDescriptionSummary"]
 
-    stream["StreamName"].should.equal(stream_name)
-    stream["OpenShardCount"].should.equal(shard_count)
-    stream["StreamARN"].should.equal(
-        f"arn:aws:kinesis:us-west-2:{ACCOUNT_ID}:stream/{stream_name}"
+    assert stream["StreamName"] == stream_name
+    assert stream["OpenShardCount"] == shard_count
+    assert (
+        stream["StreamARN"]
+        == f"arn:aws:kinesis:us-west-2:{ACCOUNT_ID}:stream/{stream_name}"
     )
-    stream["StreamStatus"].should.equal("ACTIVE")
+    assert stream["StreamStatus"] == "ACTIVE"
 
     stream_arn = get_stream_arn(conn, stream_name)
     resp = conn.describe_stream_summary(StreamARN=stream_arn)
     stream = resp["StreamDescriptionSummary"]
 
-    stream["StreamName"].should.equal(stream_name)
+    assert stream["StreamName"] == stream_name
 
 
 @mock_kinesis
@@ -156,8 +152,8 @@ def test_basic_shard_iterator():
     shard_iterator = resp["ShardIterator"]
 
     resp = client.get_records(ShardIterator=shard_iterator)
-    resp.should.have.key("Records").length_of(0)
-    resp.should.have.key("MillisBehindLatest").equal(0)
+    assert len(resp["Records"]) == 0
+    assert resp["MillisBehindLatest"] == 0
 
 
 @mock_kinesis
@@ -179,8 +175,8 @@ def test_basic_shard_iterator_by_stream_arn():
     resp = client.get_records(
         StreamARN=stream["StreamARN"], ShardIterator=shard_iterator
     )
-    resp.should.have.key("Records").length_of(0)
-    resp.should.have.key("MillisBehindLatest").equal(0)
+    assert len(resp["Records"]) == 0
+    assert resp["MillisBehindLatest"] == 0
 
 
 @mock_kinesis
@@ -195,11 +191,12 @@ def test_get_invalid_shard_iterator():
             StreamName=stream_name, ShardId="123", ShardIteratorType="TRIM_HORIZON"
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
+    assert err["Code"] == "ResourceNotFoundException"
     # There is some magic in AWS, that '123' is automatically converted into 'shardId-000000000123'
     # AWS itself returns this normalized ID in the error message, not the given id
-    err["Message"].should.equal(
-        f"Shard 123 in stream {stream_name} under account {ACCOUNT_ID} does not exist"
+    assert (
+        err["Message"]
+        == f"Shard 123 in stream {stream_name} under account {ACCOUNT_ID} does not exist"
     )
 
 
@@ -227,12 +224,12 @@ def test_put_records():
     shard_iterator = resp["ShardIterator"]
 
     resp = client.get_records(ShardIterator=shard_iterator)
-    resp["Records"].should.have.length_of(5)
+    assert len(resp["Records"]) == 5
     record = resp["Records"][0]
 
-    record["Data"].should.equal(data)
-    record["PartitionKey"].should.equal(partition_key)
-    record["SequenceNumber"].should.equal("1")
+    assert record["Data"] == data
+    assert record["PartitionKey"] == partition_key
+    assert record["SequenceNumber"] == "1"
 
 
 @mock_kinesis
@@ -257,12 +254,12 @@ def test_get_records_limit():
 
     # Retrieve only 3 records
     resp = client.get_records(ShardIterator=shard_iterator, Limit=3)
-    resp["Records"].should.have.length_of(3)
+    assert len(resp["Records"]) == 3
 
     # Then get the rest of the results
     next_shard_iterator = resp["NextShardIterator"]
     response = client.get_records(ShardIterator=next_shard_iterator)
-    response["Records"].should.have.length_of(2)
+    assert len(response["Records"]) == 2
 
 
 @mock_kinesis
@@ -300,8 +297,8 @@ def test_get_records_at_sequence_number():
 
     resp = client.get_records(ShardIterator=shard_iterator)
     # And the first result returned should be the second item
-    resp["Records"][0]["SequenceNumber"].should.equal(sequence_nr)
-    resp["Records"][0]["Data"].should.equal(b"data_2")
+    assert resp["Records"][0]["SequenceNumber"] == sequence_nr
+    assert resp["Records"][0]["Data"] == b"data_2"
 
 
 @mock_kinesis
@@ -339,9 +336,9 @@ def test_get_records_after_sequence_number():
 
     resp = client.get_records(ShardIterator=shard_iterator)
     # And the first result returned should be the second item
-    resp["Records"][0]["SequenceNumber"].should.equal("3")
-    resp["Records"][0]["Data"].should.equal(b"data_3")
-    resp["MillisBehindLatest"].should.equal(0)
+    assert resp["Records"][0]["SequenceNumber"] == "3"
+    assert resp["Records"][0]["Data"] == b"data_3"
+    assert resp["MillisBehindLatest"] == 0
 
 
 @mock_kinesis
@@ -383,11 +380,11 @@ def test_get_records_latest():
 
     resp = client.get_records(ShardIterator=shard_iterator)
     # And the first result returned should be the second item
-    resp["Records"].should.have.length_of(1)
-    resp["Records"][0]["SequenceNumber"].should.equal("5")
-    resp["Records"][0]["PartitionKey"].should.equal("last_record")
-    resp["Records"][0]["Data"].should.equal(b"last_record")
-    resp["MillisBehindLatest"].should.equal(0)
+    assert len(resp["Records"]) == 1
+    assert resp["Records"][0]["SequenceNumber"] == "5"
+    assert resp["Records"][0]["PartitionKey"] == "last_record"
+    assert resp["Records"][0]["Data"] == b"last_record"
+    assert resp["MillisBehindLatest"] == 0
 
 
 @mock_kinesis
@@ -428,10 +425,10 @@ def test_get_records_at_timestamp():
 
     response = conn.get_records(ShardIterator=shard_iterator)
 
-    response["Records"].should.have.length_of(len(keys))
+    assert len(response["Records"]) == len(keys)
     partition_keys = [r["PartitionKey"] for r in response["Records"]]
-    partition_keys.should.equal(keys)
-    response["MillisBehindLatest"].should.equal(0)
+    assert partition_keys == keys
+    assert response["MillisBehindLatest"] == 0
 
 
 @mock_kinesis
@@ -457,10 +454,10 @@ def test_get_records_at_very_old_timestamp():
     shard_iterator = response["ShardIterator"]
 
     response = conn.get_records(ShardIterator=shard_iterator)
-    response["Records"].should.have.length_of(len(keys))
+    assert len(response["Records"]) == len(keys)
     partition_keys = [r["PartitionKey"] for r in response["Records"]]
-    partition_keys.should.equal(keys)
-    response["MillisBehindLatest"].should.equal(0)
+    assert partition_keys == keys
+    assert response["MillisBehindLatest"] == 0
 
 
 @mock_kinesis
@@ -487,12 +484,10 @@ def test_get_records_timestamp_filtering():
     shard_iterator = response["ShardIterator"]
 
     response = conn.get_records(ShardIterator=shard_iterator)
-    response["Records"].should.have.length_of(1)
-    response["Records"][0]["PartitionKey"].should.equal("1")
-    response["Records"][0]["ApproximateArrivalTimestamp"].should.be.greater_than(
-        timestamp
-    )
-    response["MillisBehindLatest"].should.equal(0)
+    assert len(response["Records"]) == 1
+    assert response["Records"][0]["PartitionKey"] == "1"
+    assert response["Records"][0]["ApproximateArrivalTimestamp"] > timestamp
+    assert response["MillisBehindLatest"] == 0
 
 
 @mock_kinesis
@@ -513,8 +508,8 @@ def test_get_records_millis_behind_latest():
     shard_iterator = response["ShardIterator"]
 
     response = conn.get_records(ShardIterator=shard_iterator, Limit=1)
-    response["Records"].should.have.length_of(1)
-    response["MillisBehindLatest"].should.be.greater_than(0)
+    assert len(response["Records"]) == 1
+    assert response["MillisBehindLatest"] > 0
 
 
 @mock_kinesis
@@ -543,8 +538,8 @@ def test_get_records_at_very_new_timestamp():
 
     response = conn.get_records(ShardIterator=shard_iterator)
 
-    response["Records"].should.have.length_of(0)
-    response["MillisBehindLatest"].should.equal(0)
+    assert len(response["Records"]) == 0
+    assert response["MillisBehindLatest"] == 0
 
 
 @mock_kinesis
@@ -568,8 +563,8 @@ def test_get_records_from_empty_stream_at_timestamp():
 
     response = conn.get_records(ShardIterator=shard_iterator)
 
-    response["Records"].should.have.length_of(0)
-    response["MillisBehindLatest"].should.equal(0)
+    assert len(response["Records"]) == 0
+    assert response["MillisBehindLatest"] == 0
 
 
 @mock_kinesis
@@ -583,7 +578,7 @@ def test_valid_increase_stream_retention_period():
     )
 
     response = conn.describe_stream(StreamName=stream_name)
-    response["StreamDescription"]["RetentionPeriodHours"].should.equal(40)
+    assert response["StreamDescription"]["RetentionPeriodHours"] == 40
 
 
 @mock_kinesis
@@ -599,9 +594,10 @@ def test_invalid_increase_stream_retention_period():
         conn.increase_stream_retention_period(
             StreamName=stream_name, RetentionPeriodHours=25
         )
-    ex.value.response["Error"]["Code"].should.equal("InvalidArgumentException")
-    ex.value.response["Error"]["Message"].should.equal(
-        "Requested retention period (25 hours) for stream my_stream can not be shorter than existing retention period (30 hours). Use DecreaseRetentionPeriod API."
+    assert ex.value.response["Error"]["Code"] == "InvalidArgumentException"
+    assert (
+        ex.value.response["Error"]["Message"]
+        == "Requested retention period (25 hours) for stream my_stream can not be shorter than existing retention period (30 hours). Use DecreaseRetentionPeriod API."
     )
 
 
@@ -616,9 +612,10 @@ def test_invalid_increase_stream_retention_too_low():
             StreamName=stream_name, RetentionPeriodHours=20
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("InvalidArgumentException")
-    err["Message"].should.equal(
-        "Minimum allowed retention period is 24 hours. Requested retention period (20 hours) is too short."
+    assert err["Code"] == "InvalidArgumentException"
+    assert (
+        err["Message"]
+        == "Minimum allowed retention period is 24 hours. Requested retention period (20 hours) is too short."
     )
 
 
@@ -633,9 +630,10 @@ def test_invalid_increase_stream_retention_too_high():
             StreamName=stream_name, RetentionPeriodHours=9999
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("InvalidArgumentException")
-    err["Message"].should.equal(
-        "Maximum allowed retention period is 8760 hours. Requested retention period (9999 hours) is too long."
+    assert err["Code"] == "InvalidArgumentException"
+    assert (
+        err["Message"]
+        == "Maximum allowed retention period is 8760 hours. Requested retention period (9999 hours) is too long."
     )
 
 
@@ -654,13 +652,13 @@ def test_valid_decrease_stream_retention_period():
     )
 
     response = conn.describe_stream(StreamName=stream_name)
-    response["StreamDescription"]["RetentionPeriodHours"].should.equal(25)
+    assert response["StreamDescription"]["RetentionPeriodHours"] == 25
 
     conn.increase_stream_retention_period(StreamARN=stream_arn, RetentionPeriodHours=29)
     conn.decrease_stream_retention_period(StreamARN=stream_arn, RetentionPeriodHours=26)
 
     response = conn.describe_stream(StreamARN=stream_arn)
-    response["StreamDescription"]["RetentionPeriodHours"].should.equal(26)
+    assert response["StreamDescription"]["RetentionPeriodHours"] == 26
 
 
 @mock_kinesis
@@ -674,9 +672,10 @@ def test_decrease_stream_retention_period_upwards():
             StreamName=stream_name, RetentionPeriodHours=40
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("InvalidArgumentException")
-    err["Message"].should.equal(
-        "Requested retention period (40 hours) for stream decrease_stream can not be longer than existing retention period (24 hours). Use IncreaseRetentionPeriod API."
+    assert err["Code"] == "InvalidArgumentException"
+    assert (
+        err["Message"]
+        == "Requested retention period (40 hours) for stream decrease_stream can not be longer than existing retention period (24 hours). Use IncreaseRetentionPeriod API."
     )
 
 
@@ -691,9 +690,10 @@ def test_decrease_stream_retention_period_too_low():
             StreamName=stream_name, RetentionPeriodHours=4
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("InvalidArgumentException")
-    err["Message"].should.equal(
-        "Minimum allowed retention period is 24 hours. Requested retention period (4 hours) is too short."
+    assert err["Code"] == "InvalidArgumentException"
+    assert (
+        err["Message"]
+        == "Minimum allowed retention period is 24 hours. Requested retention period (4 hours) is too short."
     )
 
 
@@ -708,9 +708,10 @@ def test_decrease_stream_retention_period_too_high():
             StreamName=stream_name, RetentionPeriodHours=9999
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("InvalidArgumentException")
-    err["Message"].should.equal(
-        "Maximum allowed retention period is 8760 hours. Requested retention period (9999 hours) is too long."
+    assert err["Code"] == "InvalidArgumentException"
+    assert (
+        err["Message"]
+        == "Maximum allowed retention period is 8760 hours. Requested retention period (9999 hours) is too long."
     )
 
 
@@ -727,8 +728,8 @@ def test_invalid_shard_iterator_type():
             StreamName=stream_name, ShardId=shard_id, ShardIteratorType="invalid-type"
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("InvalidArgumentException")
-    err["Message"].should.equal("Invalid ShardIteratorType: invalid-type")
+    assert err["Code"] == "InvalidArgumentException"
+    assert err["Message"] == "Invalid ShardIteratorType: invalid-type"
 
 
 @mock_kinesis
@@ -743,32 +744,32 @@ def test_add_list_remove_tags():
     )
 
     tags = client.list_tags_for_stream(StreamName=stream_name)["Tags"]
-    tags.should.have.length_of(4)
-    tags.should.contain({"Key": "tag1", "Value": "val1"})
-    tags.should.contain({"Key": "tag2", "Value": "val2"})
-    tags.should.contain({"Key": "tag3", "Value": "val3"})
-    tags.should.contain({"Key": "tag4", "Value": "val4"})
+    assert len(tags) == 4
+    assert {"Key": "tag1", "Value": "val1"} in tags
+    assert {"Key": "tag2", "Value": "val2"} in tags
+    assert {"Key": "tag3", "Value": "val3"} in tags
+    assert {"Key": "tag4", "Value": "val4"} in tags
 
     client.add_tags_to_stream(StreamARN=stream_arn, Tags={"tag5": "val5"})
 
     tags = client.list_tags_for_stream(StreamARN=stream_arn)["Tags"]
-    tags.should.have.length_of(5)
-    tags.should.contain({"Key": "tag5", "Value": "val5"})
+    assert len(tags) == 5
+    assert {"Key": "tag5", "Value": "val5"} in tags
 
     client.remove_tags_from_stream(StreamName=stream_name, TagKeys=["tag2", "tag3"])
 
     tags = client.list_tags_for_stream(StreamName=stream_name)["Tags"]
-    tags.should.have.length_of(3)
-    tags.should.contain({"Key": "tag1", "Value": "val1"})
-    tags.should.contain({"Key": "tag4", "Value": "val4"})
-    tags.should.contain({"Key": "tag5", "Value": "val5"})
+    assert len(tags) == 3
+    assert {"Key": "tag1", "Value": "val1"} in tags
+    assert {"Key": "tag4", "Value": "val4"} in tags
+    assert {"Key": "tag5", "Value": "val5"} in tags
 
     client.remove_tags_from_stream(StreamARN=stream_arn, TagKeys=["tag4"])
 
     tags = client.list_tags_for_stream(StreamName=stream_name)["Tags"]
-    tags.should.have.length_of(2)
-    tags.should.contain({"Key": "tag1", "Value": "val1"})
-    tags.should.contain({"Key": "tag5", "Value": "val5"})
+    assert len(tags) == 2
+    assert {"Key": "tag1", "Value": "val1"} in tags
+    assert {"Key": "tag5", "Value": "val5"} in tags
 
 
 @mock_kinesis
@@ -793,7 +794,7 @@ def test_merge_shards():
 
     stream = client.describe_stream(StreamName=stream_name)["StreamDescription"]
     shards = stream["Shards"]
-    shards.should.have.length_of(4)
+    assert len(shards) == 4
 
     client.merge_shards(
         StreamName=stream_name,
@@ -805,7 +806,7 @@ def test_merge_shards():
     shards = stream["Shards"]
 
     # Old shards still exist, but are closed. A new shard is created out of the old one
-    shards.should.have.length_of(5)
+    assert len(shards) == 5
 
     # Only three shards are active - the two merged shards are closed
     active_shards = [
@@ -813,7 +814,7 @@ def test_merge_shards():
         for shard in shards
         if "EndingSequenceNumber" not in shard["SequenceNumberRange"]
     ]
-    active_shards.should.have.length_of(3)
+    assert len(active_shards) == 3
 
     client.merge_shards(
         StreamARN=stream_arn,
@@ -829,23 +830,21 @@ def test_merge_shards():
         for shard in shards
         if "EndingSequenceNumber" not in shard["SequenceNumberRange"]
     ]
-    active_shards.should.have.length_of(2)
+    assert len(active_shards) == 2
 
     for shard in active_shards:
         del shard["HashKeyRange"]
         del shard["SequenceNumberRange"]
 
     # Original shard #3 is still active (0,1,2 have been merged and closed
-    active_shards.should.contain({"ShardId": "shardId-000000000003"})
+    assert {"ShardId": "shardId-000000000003"} in active_shards
     # Shard #4 was the child of #0 and #1
     # Shard #5 is the child of #4 (parent) and #2 (adjacent-parent)
-    active_shards.should.contain(
-        {
-            "ShardId": "shardId-000000000005",
-            "ParentShardId": "shardId-000000000004",
-            "AdjacentParentShardId": "shardId-000000000002",
-        }
-    )
+    assert {
+        "ShardId": "shardId-000000000005",
+        "ParentShardId": "shardId-000000000004",
+        "AdjacentParentShardId": "shardId-000000000002",
+    } in active_shards
 
 
 @mock_kinesis
@@ -861,8 +860,8 @@ def test_merge_shards_invalid_arg():
             AdjacentShardToMerge="shardId-000000000002",
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("InvalidArgumentException")
-    err["Message"].should.equal("shardId-000000000002")
+    assert err["Code"] == "InvalidArgumentException"
+    assert err["Message"] == "shardId-000000000002"
 
 
 def get_stream_arn(client, stream_name):
diff --git a/tests/test_kinesis/test_kinesis_boto3.py b/tests/test_kinesis/test_kinesis_boto3.py
index 27bdc49c7..e41347769 100644
--- a/tests/test_kinesis/test_kinesis_boto3.py
+++ b/tests/test_kinesis/test_kinesis_boto3.py
@@ -6,8 +6,6 @@ from moto import mock_kinesis
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
 from .test_kinesis import get_stream_arn
 
-import sure  # noqa # pylint: disable=unused-import
-
 
 @mock_kinesis
 def test_describe_stream_limit_parameter():
@@ -17,26 +15,26 @@ def test_describe_stream_limit_parameter():
     client.create_stream(StreamName=stream_name, ShardCount=5)
 
     without_filter = client.describe_stream(StreamName=stream_name)["StreamDescription"]
-    without_filter["Shards"].should.have.length_of(5)
-    without_filter["HasMoreShards"].should.equal(False)
+    assert len(without_filter["Shards"]) == 5
+    assert without_filter["HasMoreShards"] is False
 
     with_filter = client.describe_stream(StreamName=stream_name, Limit=2)[
         "StreamDescription"
     ]
-    with_filter["Shards"].should.have.length_of(2)
-    with_filter["HasMoreShards"].should.equal(True)
+    assert len(with_filter["Shards"]) == 2
+    assert with_filter["HasMoreShards"] is True
 
     with_filter = client.describe_stream(StreamName=stream_name, Limit=5)[
         "StreamDescription"
     ]
-    with_filter["Shards"].should.have.length_of(5)
-    with_filter["HasMoreShards"].should.equal(False)
+    assert len(with_filter["Shards"]) == 5
+    assert with_filter["HasMoreShards"] is False
 
     with_filter = client.describe_stream(StreamName=stream_name, Limit=6)[
         "StreamDescription"
     ]
-    with_filter["Shards"].should.have.length_of(5)
-    with_filter["HasMoreShards"].should.equal(False)
+    assert len(with_filter["Shards"]) == 5
+    assert with_filter["HasMoreShards"] is False
 
 
 @mock_kinesis
@@ -53,23 +51,24 @@ def test_list_shards():
         )
 
     shard_list = conn.list_shards(StreamName=stream_name)["Shards"]
-    shard_list.should.have.length_of(2)
+    assert len(shard_list) == 2
     # Verify IDs
-    [s["ShardId"] for s in shard_list].should.equal(
-        ["shardId-000000000000", "shardId-000000000001"]
-    )
+    assert [s["ShardId"] for s in shard_list] == [
+        "shardId-000000000000",
+        "shardId-000000000001",
+    ]
     # Verify hash range
     for shard in shard_list:
-        shard.should.have.key("HashKeyRange")
-        shard["HashKeyRange"].should.have.key("StartingHashKey")
-        shard["HashKeyRange"].should.have.key("EndingHashKey")
-    shard_list[0]["HashKeyRange"]["EndingHashKey"].should.equal(
-        str(int(shard_list[1]["HashKeyRange"]["StartingHashKey"]) - 1)
+        assert "HashKeyRange" in shard
+        assert "StartingHashKey" in shard["HashKeyRange"]
+        assert "EndingHashKey" in shard["HashKeyRange"]
+    assert shard_list[0]["HashKeyRange"]["EndingHashKey"] == str(
+        int(shard_list[1]["HashKeyRange"]["StartingHashKey"]) - 1
     )
     # Verify sequence numbers
     for shard in shard_list:
-        shard.should.have.key("SequenceNumberRange")
-        shard["SequenceNumberRange"].should.have.key("StartingSequenceNumber")
+        assert "SequenceNumberRange" in shard
+        assert "StartingSequenceNumber" in shard["SequenceNumberRange"]
 
 
 @mock_kinesis
@@ -80,46 +79,43 @@ def test_list_shards_paging():
 
     # Get shard 1-10
     shard_list = client.list_shards(StreamName=stream_name)
-    shard_list["Shards"].should.have.length_of(10)
-    shard_list.should_not.have.key("NextToken")
+    assert len(shard_list["Shards"]) == 10
+    assert "NextToken" not in shard_list
 
     # Get shard 1-4
     resp = client.list_shards(StreamName=stream_name, MaxResults=4)
-    resp["Shards"].should.have.length_of(4)
-    [s["ShardId"] for s in resp["Shards"]].should.equal(
-        [
-            "shardId-000000000000",
-            "shardId-000000000001",
-            "shardId-000000000002",
-            "shardId-000000000003",
-        ]
-    )
-    resp.should.have.key("NextToken")
+    assert len(resp["Shards"]) == 4
+    assert [s["ShardId"] for s in resp["Shards"]] == [
+        "shardId-000000000000",
+        "shardId-000000000001",
+        "shardId-000000000002",
+        "shardId-000000000003",
+    ]
+    assert "NextToken" in resp
 
     # Get shard 4-8
     resp = client.list_shards(
         StreamName=stream_name, MaxResults=4, NextToken=str(resp["NextToken"])
     )
-    resp["Shards"].should.have.length_of(4)
-    [s["ShardId"] for s in resp["Shards"]].should.equal(
-        [
-            "shardId-000000000004",
-            "shardId-000000000005",
-            "shardId-000000000006",
-            "shardId-000000000007",
-        ]
-    )
-    resp.should.have.key("NextToken")
+    assert len(resp["Shards"]) == 4
+    assert [s["ShardId"] for s in resp["Shards"]] == [
+        "shardId-000000000004",
+        "shardId-000000000005",
+        "shardId-000000000006",
+        "shardId-000000000007",
+    ]
+    assert "NextToken" in resp
 
     # Get shard 8-10
     resp = client.list_shards(
         StreamName=stream_name, MaxResults=4, NextToken=str(resp["NextToken"])
     )
-    resp["Shards"].should.have.length_of(2)
-    [s["ShardId"] for s in resp["Shards"]].should.equal(
-        ["shardId-000000000008", "shardId-000000000009"]
-    )
-    resp.should_not.have.key("NextToken")
+    assert len(resp["Shards"]) == 2
+    assert [s["ShardId"] for s in resp["Shards"]] == [
+        "shardId-000000000008",
+        "shardId-000000000009",
+    ]
+    assert "NextToken" not in resp
 
 
 @mock_kinesis
@@ -129,26 +125,26 @@ def test_create_shard():
 
     resp = client.describe_stream(StreamName="my-stream")
     desc = resp["StreamDescription"]
-    desc.should.have.key("StreamName").equal("my-stream")
-    desc.should.have.key("StreamARN").equal(
-        f"arn:aws:kinesis:us-west-2:{ACCOUNT_ID}:stream/my-stream"
+    assert desc["StreamName"] == "my-stream"
+    assert (
+        desc["StreamARN"] == f"arn:aws:kinesis:us-west-2:{ACCOUNT_ID}:stream/my-stream"
     )
-    desc.should.have.key("Shards").length_of(2)
-    desc.should.have.key("StreamStatus").equals("ACTIVE")
-    desc.should.have.key("HasMoreShards").equals(False)
-    desc.should.have.key("RetentionPeriodHours").equals(24)
-    desc.should.have.key("StreamCreationTimestamp")
-    desc.should.have.key("EnhancedMonitoring").should.equal([{"ShardLevelMetrics": []}])
-    desc.should.have.key("EncryptionType").should.equal("NONE")
+    assert len(desc["Shards"]) == 2
+    assert desc["StreamStatus"] == "ACTIVE"
+    assert desc["HasMoreShards"] is False
+    assert desc["RetentionPeriodHours"] == 24
+    assert "StreamCreationTimestamp" in desc
+    assert desc["EnhancedMonitoring"] == [{"ShardLevelMetrics": []}]
+    assert desc["EncryptionType"] == "NONE"
 
     shards = desc["Shards"]
-    shards[0].should.have.key("ShardId").equal("shardId-000000000000")
-    shards[0].should.have.key("HashKeyRange")
-    shards[0]["HashKeyRange"].should.have.key("StartingHashKey").equals("0")
-    shards[0]["HashKeyRange"].should.have.key("EndingHashKey")
-    shards[0].should.have.key("SequenceNumberRange")
-    shards[0]["SequenceNumberRange"].should.have.key("StartingSequenceNumber")
-    shards[0]["SequenceNumberRange"].shouldnt.have.key("EndingSequenceNumber")
+    assert shards[0]["ShardId"] == "shardId-000000000000"
+    assert "HashKeyRange" in shards[0]
+    assert shards[0]["HashKeyRange"]["StartingHashKey"] == "0"
+    assert "EndingHashKey" in shards[0]["HashKeyRange"]
+    assert "SequenceNumberRange" in shards[0]
+    assert "StartingSequenceNumber" in shards[0]["SequenceNumberRange"]
+    assert "EndingSequenceNumber" not in shards[0]["SequenceNumberRange"]
 
 
 @mock_kinesis
@@ -163,9 +159,10 @@ def test_split_shard_with_invalid_name():
             NewStartingHashKey="170141183460469231731687303715884105728",
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.equal(
-        "1 validation error detected: Value '?' at 'shardToSplit' failed to satisfy constraint: Member must satisfy regular expression pattern: [a-zA-Z0-9_.-]+"
+    assert err["Code"] == "ValidationException"
+    assert (
+        err["Message"]
+        == "1 validation error detected: Value '?' at 'shardToSplit' failed to satisfy constraint: Member must satisfy regular expression pattern: [a-zA-Z0-9_.-]+"
     )
 
 
@@ -181,9 +178,10 @@ def test_split_shard_with_unknown_name():
             NewStartingHashKey="170141183460469231731687303715884105728",
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
-    err["Message"].should.equal(
-        "Could not find shard unknown in stream my-stream under account 123456789012."
+    assert err["Code"] == "ResourceNotFoundException"
+    assert (
+        err["Message"]
+        == "Could not find shard unknown in stream my-stream under account 123456789012."
     )
 
 
@@ -199,9 +197,10 @@ def test_split_shard_invalid_hashkey():
             NewStartingHashKey="sth",
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.equal(
-        "1 validation error detected: Value 'sth' at 'newStartingHashKey' failed to satisfy constraint: Member must satisfy regular expression pattern: 0|([1-9]\\d{0,38})"
+    assert err["Code"] == "ValidationException"
+    assert (
+        err["Message"]
+        == "1 validation error detected: Value 'sth' at 'newStartingHashKey' failed to satisfy constraint: Member must satisfy regular expression pattern: 0|([1-9]\\d{0,38})"
     )
 
 
@@ -217,9 +216,10 @@ def test_split_shard_hashkey_out_of_bounds():
             NewStartingHashKey="170141183460469231731687303715884000000",
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("InvalidArgumentException")
-    err["Message"].should.equal(
-        f"NewStartingHashKey 170141183460469231731687303715884000000 used in SplitShard() on shard shardId-000000000001 in stream my-stream under account {ACCOUNT_ID} is not both greater than one plus the shard's StartingHashKey 170141183460469231731687303715884105728 and less than the shard's EndingHashKey 340282366920938463463374607431768211455."
+    assert err["Code"] == "InvalidArgumentException"
+    assert (
+        err["Message"]
+        == f"NewStartingHashKey 170141183460469231731687303715884000000 used in SplitShard() on shard shardId-000000000001 in stream my-stream under account {ACCOUNT_ID} is not both greater than one plus the shard's StartingHashKey 170141183460469231731687303715884105728 and less than the shard's EndingHashKey 340282366920938463463374607431768211455."
     )
 
 
@@ -248,32 +248,34 @@ def test_split_shard():
 
     resp = client.describe_stream(StreamName=stream_name)["StreamDescription"]
     shards = resp["Shards"]
-    shards.should.have.length_of(4)
-    shards[0].should.have.key("ShardId").equals("shardId-000000000000")
-    shards[0].should.have.key("HashKeyRange")
-    shards[0].shouldnt.have.key("ParentShardId")
-
-    shards[1].should.have.key("ShardId").equals("shardId-000000000001")
-    shards[1].shouldnt.have.key("ParentShardId")
-    shards[1].should.have.key("HashKeyRange")
-    shards[1]["HashKeyRange"].should.have.key("StartingHashKey").equals(
-        original_shards[1]["HashKeyRange"]["StartingHashKey"]
+    assert len(shards) == 4
+    assert shards[0]["ShardId"] == "shardId-000000000000"
+    assert "HashKeyRange" in shards[0]
+    assert "ParentShardId" not in shards[0]
+
+    assert shards[1]["ShardId"] == "shardId-000000000001"
+    assert "ParentShardId" not in shards[1]
+    assert "HashKeyRange" in shards[1]
+    assert (
+        shards[1]["HashKeyRange"]["StartingHashKey"]
+        == original_shards[1]["HashKeyRange"]["StartingHashKey"]
     )
-    shards[1]["HashKeyRange"].should.have.key("EndingHashKey").equals(
-        original_shards[1]["HashKeyRange"]["EndingHashKey"]
+    assert (
+        shards[1]["HashKeyRange"]["EndingHashKey"]
+        == original_shards[1]["HashKeyRange"]["EndingHashKey"]
     )
-    shards[1]["SequenceNumberRange"].should.have.key("StartingSequenceNumber")
-    shards[1]["SequenceNumberRange"].should.have.key("EndingSequenceNumber")
+    assert "StartingSequenceNumber" in shards[1]["SequenceNumberRange"]
+    assert "EndingSequenceNumber" in shards[1]["SequenceNumberRange"]
 
-    shards[2].should.have.key("ShardId").equals("shardId-000000000002")
-    shards[2].should.have.key("ParentShardId").equals(shards[1]["ShardId"])
-    shards[2]["SequenceNumberRange"].should.have.key("StartingSequenceNumber")
-    shards[2]["SequenceNumberRange"].shouldnt.have.key("EndingSequenceNumber")
+    assert shards[2]["ShardId"] == "shardId-000000000002"
+    assert shards[2]["ParentShardId"] == shards[1]["ShardId"]
+    assert "StartingSequenceNumber" in shards[2]["SequenceNumberRange"]
+    assert "EndingSequenceNumber" not in shards[2]["SequenceNumberRange"]
 
-    shards[3].should.have.key("ShardId").equals("shardId-000000000003")
-    shards[3].should.have.key("ParentShardId").equals(shards[1]["ShardId"])
-    shards[3]["SequenceNumberRange"].should.have.key("StartingSequenceNumber")
-    shards[3]["SequenceNumberRange"].shouldnt.have.key("EndingSequenceNumber")
+    assert shards[3]["ShardId"] == "shardId-000000000003"
+    assert shards[3]["ParentShardId"] == shards[1]["ShardId"]
+    assert "StartingSequenceNumber" in shards[3]["SequenceNumberRange"]
+    assert "EndingSequenceNumber" not in shards[3]["SequenceNumberRange"]
 
 
 @mock_kinesis
@@ -295,9 +297,10 @@ def test_split_shard_that_was_split_before():
             NewStartingHashKey="170141183460469231731687303715884105829",
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("InvalidArgumentException")
-    err["Message"].should.equal(
-        f"Shard shardId-000000000001 in stream my-stream under account {ACCOUNT_ID} has already been merged or split, and thus is not eligible for merging or splitting."
+    assert err["Code"] == "InvalidArgumentException"
+    assert (
+        err["Message"]
+        == f"Shard shardId-000000000001 in stream my-stream under account {ACCOUNT_ID} has already been merged or split, and thus is not eligible for merging or splitting."
     )
 
 
@@ -322,22 +325,22 @@ def test_update_shard_count(initial, target, expected_total):
         StreamName="my-stream", TargetShardCount=target, ScalingType="UNIFORM_SCALING"
     )
 
-    resp.should.have.key("StreamName").equals("my-stream")
-    resp.should.have.key("CurrentShardCount").equals(initial)
-    resp.should.have.key("TargetShardCount").equals(target)
+    assert resp["StreamName"] == "my-stream"
+    assert resp["CurrentShardCount"] == initial
+    assert resp["TargetShardCount"] == target
 
     stream = client.describe_stream(StreamName="my-stream")["StreamDescription"]
-    stream["StreamStatus"].should.equal("ACTIVE")
-    stream["Shards"].should.have.length_of(expected_total)
+    assert stream["StreamStatus"] == "ACTIVE"
+    assert len(stream["Shards"]) == expected_total
 
     active_shards = [
         shard
         for shard in stream["Shards"]
         if "EndingSequenceNumber" not in shard["SequenceNumberRange"]
     ]
-    active_shards.should.have.length_of(target)
+    assert len(active_shards) == target
 
     resp = client.describe_stream_summary(StreamName="my-stream")
     stream = resp["StreamDescriptionSummary"]
 
-    stream["OpenShardCount"].should.equal(target)
+    assert stream["OpenShardCount"] == target
diff --git a/tests/test_kinesis/test_kinesis_cloudformation.py b/tests/test_kinesis/test_kinesis_cloudformation.py
index 7c2eaf0b9..c20ed60c9 100644
--- a/tests/test_kinesis/test_kinesis_cloudformation.py
+++ b/tests/test_kinesis/test_kinesis_cloudformation.py
@@ -1,5 +1,4 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 
 from moto import mock_kinesis, mock_cloudformation
 
@@ -17,8 +16,8 @@ def test_kinesis_cloudformation_create_stream():
     provisioned_resource = cf_conn.list_stack_resources(StackName=stack_name)[
         "StackResourceSummaries"
     ][0]
-    provisioned_resource["LogicalResourceId"].should.equal("MyStream")
-    len(provisioned_resource["PhysicalResourceId"]).should.be.greater_than(0)
+    assert provisioned_resource["LogicalResourceId"] == "MyStream"
+    assert len(provisioned_resource["PhysicalResourceId"]) > 0
 
 
 @mock_cloudformation
@@ -56,7 +55,7 @@ Outputs:
     stream_description = kinesis_conn.describe_stream(StreamName=output_stream_name)[
         "StreamDescription"
     ]
-    output_stream_arn.should.equal(stream_description["StreamARN"])
+    assert output_stream_arn == stream_description["StreamARN"]
 
 
 @mock_cloudformation
@@ -83,19 +82,19 @@ Resources:
 
     cf_conn.create_stack(StackName=stack_name, TemplateBody=template)
     stack_description = cf_conn.describe_stacks(StackName=stack_name)["Stacks"][0]
-    stack_description["StackName"].should.equal(stack_name)
+    assert stack_description["StackName"] == stack_name
 
     kinesis_conn = boto3.client("kinesis", region_name="us-east-1")
     stream_description = kinesis_conn.describe_stream(StreamName="MyStream")[
         "StreamDescription"
     ]
-    stream_description["RetentionPeriodHours"].should.equal(48)
+    assert stream_description["RetentionPeriodHours"] == 48
 
     tags = kinesis_conn.list_tags_for_stream(StreamName="MyStream")["Tags"]
     tag1_value = [tag for tag in tags if tag["Key"] == "TagKey1"][0]["Value"]
     tag2_value = [tag for tag in tags if tag["Key"] == "TagKey2"][0]["Value"]
-    tag1_value.should.equal("TagValue1")
-    tag2_value.should.equal("TagValue2")
+    assert tag1_value == "TagValue1"
+    assert tag2_value == "TagValue2"
 
     shards_provisioned = len(
         [
@@ -104,7 +103,7 @@ Resources:
             if "EndingSequenceNumber" not in shard["SequenceNumberRange"]
         ]
     )
-    shards_provisioned.should.equal(4)
+    assert shards_provisioned == 4
 
     template = """
     Resources:
@@ -125,13 +124,13 @@ Resources:
     stream_description = kinesis_conn.describe_stream(StreamName="MyStream")[
         "StreamDescription"
     ]
-    stream_description["RetentionPeriodHours"].should.equal(24)
+    assert stream_description["RetentionPeriodHours"] == 24
 
     tags = kinesis_conn.list_tags_for_stream(StreamName="MyStream")["Tags"]
     tag1_value = [tag for tag in tags if tag["Key"] == "TagKey1"][0]["Value"]
     tag2_value = [tag for tag in tags if tag["Key"] == "TagKey2"][0]["Value"]
-    tag1_value.should.equal("TagValue1a")
-    tag2_value.should.equal("TagValue2a")
+    assert tag1_value == "TagValue1a"
+    assert tag2_value == "TagValue2a"
 
     shards_provisioned = len(
         [
@@ -140,7 +139,7 @@ Resources:
             if "EndingSequenceNumber" not in shard["SequenceNumberRange"]
         ]
     )
-    shards_provisioned.should.equal(6)
+    assert shards_provisioned == 6
 
 
 @mock_cloudformation
@@ -160,14 +159,14 @@ Resources:
 
     cf_conn.create_stack(StackName=stack_name, TemplateBody=template)
     stack_description = cf_conn.describe_stacks(StackName=stack_name)["Stacks"][0]
-    stack_description["StackName"].should.equal(stack_name)
+    assert stack_description["StackName"] == stack_name
 
     kinesis_conn = boto3.client("kinesis", region_name="us-east-1")
     stream_description = kinesis_conn.describe_stream(StreamName="MyStream")[
         "StreamDescription"
     ]
-    stream_description["StreamName"].should.equal("MyStream")
+    assert stream_description["StreamName"] == "MyStream"
 
     cf_conn.delete_stack(StackName=stack_name)
     streams = kinesis_conn.list_streams()["StreamNames"]
-    len(streams).should.equal(0)
+    assert len(streams) == 0
diff --git a/tests/test_kinesis/test_kinesis_encryption.py b/tests/test_kinesis/test_kinesis_encryption.py
index 088ac2db1..76b1f81d9 100644
--- a/tests/test_kinesis/test_kinesis_encryption.py
+++ b/tests/test_kinesis/test_kinesis_encryption.py
@@ -11,8 +11,8 @@ def test_enable_encryption():
 
     resp = client.describe_stream(StreamName="my-stream")
     desc = resp["StreamDescription"]
-    desc.should.have.key("EncryptionType").should.equal("NONE")
-    desc.shouldnt.have.key("KeyId")
+    assert desc["EncryptionType"] == "NONE"
+    assert "KeyId" not in desc
 
     client.start_stream_encryption(
         StreamName="my-stream", EncryptionType="KMS", KeyId="n/a"
@@ -20,8 +20,8 @@ def test_enable_encryption():
 
     resp = client.describe_stream(StreamName="my-stream")
     desc = resp["StreamDescription"]
-    desc.should.have.key("EncryptionType").should.equal("KMS")
-    desc.should.have.key("KeyId").equals("n/a")
+    assert desc["EncryptionType"] == "KMS"
+    assert desc["KeyId"] == "n/a"
 
 
 @mock_kinesis
@@ -31,7 +31,7 @@ def test_disable_encryption():
 
     resp = client.describe_stream(StreamName="my-stream")
     desc = resp["StreamDescription"]
-    desc.should.have.key("EncryptionType").should.equal("NONE")
+    assert desc["EncryptionType"] == "NONE"
 
     client.start_stream_encryption(
         StreamName="my-stream", EncryptionType="KMS", KeyId="n/a"
@@ -43,8 +43,8 @@ def test_disable_encryption():
 
     resp = client.describe_stream(StreamName="my-stream")
     desc = resp["StreamDescription"]
-    desc.should.have.key("EncryptionType").should.equal("NONE")
-    desc.shouldnt.have.key("KeyId")
+    assert desc["EncryptionType"] == "NONE"
+    assert "KeyId" not in desc
 
 
 @mock_kinesis
@@ -55,7 +55,7 @@ def test_disable_encryption__using_arns():
 
     resp = client.describe_stream(StreamName="my-stream")
     desc = resp["StreamDescription"]
-    desc.should.have.key("EncryptionType").should.equal("NONE")
+    assert desc["EncryptionType"] == "NONE"
 
     client.start_stream_encryption(
         StreamARN=stream_arn, EncryptionType="KMS", KeyId="n/a"
@@ -67,5 +67,5 @@ def test_disable_encryption__using_arns():
 
     resp = client.describe_stream(StreamName="my-stream")
     desc = resp["StreamDescription"]
-    desc.should.have.key("EncryptionType").should.equal("NONE")
-    desc.shouldnt.have.key("KeyId")
+    assert desc["EncryptionType"] == "NONE"
+    assert "KeyId" not in desc
diff --git a/tests/test_kinesis/test_kinesis_monitoring.py b/tests/test_kinesis/test_kinesis_monitoring.py
index 5da00303a..45b1cf6f2 100644
--- a/tests/test_kinesis/test_kinesis_monitoring.py
+++ b/tests/test_kinesis/test_kinesis_monitoring.py
@@ -15,11 +15,12 @@ def test_enable_enhanced_monitoring_all():
         StreamName=stream_name, ShardLevelMetrics=["ALL"]
     )
 
-    resp.should.have.key("StreamName").equals(stream_name)
-    resp.should.have.key("CurrentShardLevelMetrics").equals([])
-    resp.should.have.key("DesiredShardLevelMetrics").equals(["ALL"])
-    resp.should.have.key("StreamARN").equals(
-        f"arn:aws:kinesis:us-east-1:{DEFAULT_ACCOUNT_ID}:stream/{stream_name}"
+    assert resp["StreamName"] == stream_name
+    assert resp["CurrentShardLevelMetrics"] == []
+    assert resp["DesiredShardLevelMetrics"] == ["ALL"]
+    assert (
+        resp["StreamARN"]
+        == f"arn:aws:kinesis:us-east-1:{DEFAULT_ACCOUNT_ID}:stream/{stream_name}"
     )
 
 
@@ -35,7 +36,7 @@ def test_enable_enhanced_monitoring_is_persisted():
 
     stream = client.describe_stream(StreamName=stream_name)["StreamDescription"]
     metrics = stream["EnhancedMonitoring"][0]["ShardLevelMetrics"]
-    set(metrics).should.equal({"IncomingBytes", "OutgoingBytes"})
+    assert set(metrics) == {"IncomingBytes", "OutgoingBytes"}
 
 
 @mock_kinesis
@@ -52,22 +53,20 @@ def test_enable_enhanced_monitoring_in_steps():
         StreamName=stream_name, ShardLevelMetrics=["WriteProvisionedThroughputExceeded"]
     )
 
-    resp.should.have.key("CurrentShardLevelMetrics").should.have.length_of(2)
-    resp["CurrentShardLevelMetrics"].should.contain("IncomingBytes")
-    resp["CurrentShardLevelMetrics"].should.contain("OutgoingBytes")
-    resp.should.have.key("DesiredShardLevelMetrics").should.have.length_of(3)
-    resp["DesiredShardLevelMetrics"].should.contain("IncomingBytes")
-    resp["DesiredShardLevelMetrics"].should.contain("OutgoingBytes")
-    resp["DesiredShardLevelMetrics"].should.contain(
-        "WriteProvisionedThroughputExceeded"
-    )
+    assert len(resp["CurrentShardLevelMetrics"]) == 2
+    assert "IncomingBytes" in resp["CurrentShardLevelMetrics"]
+    assert "OutgoingBytes" in resp["CurrentShardLevelMetrics"]
+    assert len(resp["DesiredShardLevelMetrics"]) == 3
+    assert "IncomingBytes" in resp["DesiredShardLevelMetrics"]
+    assert "OutgoingBytes" in resp["DesiredShardLevelMetrics"]
+    assert "WriteProvisionedThroughputExceeded" in resp["DesiredShardLevelMetrics"]
 
     stream = client.describe_stream(StreamName=stream_name)["StreamDescription"]
     metrics = stream["EnhancedMonitoring"][0]["ShardLevelMetrics"]
-    metrics.should.have.length_of(3)
-    metrics.should.contain("IncomingBytes")
-    metrics.should.contain("OutgoingBytes")
-    metrics.should.contain("WriteProvisionedThroughputExceeded")
+    assert len(metrics) == 3
+    assert "IncomingBytes" in metrics
+    assert "OutgoingBytes" in metrics
+    assert "WriteProvisionedThroughputExceeded" in metrics
 
 
 @mock_kinesis
@@ -90,35 +89,32 @@ def test_disable_enhanced_monitoring():
         StreamName=stream_name, ShardLevelMetrics=["OutgoingBytes"]
     )
 
-    resp.should.have.key("StreamName").equals(stream_name)
-    resp.should.have.key("StreamARN").equals(
-        f"arn:aws:kinesis:us-east-1:{DEFAULT_ACCOUNT_ID}:stream/{stream_name}"
+    assert resp["StreamName"] == stream_name
+    assert (
+        resp["StreamARN"]
+        == f"arn:aws:kinesis:us-east-1:{DEFAULT_ACCOUNT_ID}:stream/{stream_name}"
     )
 
-    resp.should.have.key("CurrentShardLevelMetrics").should.have.length_of(3)
-    resp["CurrentShardLevelMetrics"].should.contain("IncomingBytes")
-    resp["CurrentShardLevelMetrics"].should.contain("OutgoingBytes")
-    resp["CurrentShardLevelMetrics"].should.contain(
-        "WriteProvisionedThroughputExceeded"
-    )
-    resp.should.have.key("DesiredShardLevelMetrics").should.have.length_of(2)
-    resp["DesiredShardLevelMetrics"].should.contain("IncomingBytes")
-    resp["DesiredShardLevelMetrics"].should.contain(
-        "WriteProvisionedThroughputExceeded"
-    )
+    assert len(resp["CurrentShardLevelMetrics"]) == 3
+    assert "IncomingBytes" in resp["CurrentShardLevelMetrics"]
+    assert "OutgoingBytes" in resp["CurrentShardLevelMetrics"]
+    assert "WriteProvisionedThroughputExceeded" in resp["CurrentShardLevelMetrics"]
+    assert len(resp["DesiredShardLevelMetrics"]) == 2
+    assert "IncomingBytes" in resp["DesiredShardLevelMetrics"]
+    assert "WriteProvisionedThroughputExceeded" in resp["DesiredShardLevelMetrics"]
 
     stream = client.describe_stream(StreamName=stream_name)["StreamDescription"]
     metrics = stream["EnhancedMonitoring"][0]["ShardLevelMetrics"]
-    metrics.should.have.length_of(2)
-    metrics.should.contain("IncomingBytes")
-    metrics.should.contain("WriteProvisionedThroughputExceeded")
+    assert len(metrics) == 2
+    assert "IncomingBytes" in metrics
+    assert "WriteProvisionedThroughputExceeded" in metrics
 
     resp = client.disable_enhanced_monitoring(
         StreamARN=stream_arn, ShardLevelMetrics=["IncomingBytes"]
     )
 
-    resp.should.have.key("CurrentShardLevelMetrics").should.have.length_of(2)
-    resp.should.have.key("DesiredShardLevelMetrics").should.have.length_of(1)
+    assert len(resp["CurrentShardLevelMetrics"]) == 2
+    assert len(resp["DesiredShardLevelMetrics"]) == 1
 
 
 @mock_kinesis
@@ -142,4 +138,4 @@ def test_disable_enhanced_monitoring_all():
 
     stream = client.describe_stream(StreamName=stream_name)["StreamDescription"]
     metrics = stream["EnhancedMonitoring"][0]["ShardLevelMetrics"]
-    metrics.should.equal([])
+    assert metrics == []
diff --git a/tests/test_kinesis/test_kinesis_stream_consumers.py b/tests/test_kinesis/test_kinesis_stream_consumers.py
index d13ac0229..d494aa65d 100644
--- a/tests/test_kinesis/test_kinesis_stream_consumers.py
+++ b/tests/test_kinesis/test_kinesis_stream_consumers.py
@@ -20,7 +20,7 @@ def test_list_stream_consumers():
 
     resp = client.list_stream_consumers(StreamARN=stream_arn)
 
-    resp.should.have.key("Consumers").equals([])
+    assert resp["Consumers"] == []
 
 
 @mock_kinesis
@@ -31,27 +31,29 @@ def test_register_stream_consumer():
     resp = client.register_stream_consumer(
         StreamARN=stream_arn, ConsumerName="newconsumer"
     )
-    resp.should.have.key("Consumer")
+    assert "Consumer" in resp
 
     consumer = resp["Consumer"]
 
-    consumer.should.have.key("ConsumerName").equals("newconsumer")
-    consumer.should.have.key("ConsumerARN").equals(
-        f"arn:aws:kinesis:eu-west-1:{ACCOUNT_ID}:stream/my-stream/consumer/newconsumer"
+    assert consumer["ConsumerName"] == "newconsumer"
+    assert (
+        consumer["ConsumerARN"]
+        == f"arn:aws:kinesis:eu-west-1:{ACCOUNT_ID}:stream/my-stream/consumer/newconsumer"
     )
-    consumer.should.have.key("ConsumerStatus").equals("ACTIVE")
-    consumer.should.have.key("ConsumerCreationTimestamp")
+    assert consumer["ConsumerStatus"] == "ACTIVE"
+    assert "ConsumerCreationTimestamp" in consumer
 
     resp = client.list_stream_consumers(StreamARN=stream_arn)
 
-    resp.should.have.key("Consumers").length_of(1)
+    assert len(resp["Consumers"]) == 1
     consumer = resp["Consumers"][0]
-    consumer.should.have.key("ConsumerName").equals("newconsumer")
-    consumer.should.have.key("ConsumerARN").equals(
-        f"arn:aws:kinesis:eu-west-1:{ACCOUNT_ID}:stream/my-stream/consumer/newconsumer"
+    assert consumer["ConsumerName"] == "newconsumer"
+    assert (
+        consumer["ConsumerARN"]
+        == f"arn:aws:kinesis:eu-west-1:{ACCOUNT_ID}:stream/my-stream/consumer/newconsumer"
     )
-    consumer.should.have.key("ConsumerStatus").equals("ACTIVE")
-    consumer.should.have.key("ConsumerCreationTimestamp")
+    assert consumer["ConsumerStatus"] == "ACTIVE"
+    assert "ConsumerCreationTimestamp" in consumer
 
 
 @mock_kinesis
@@ -63,14 +65,14 @@ def test_describe_stream_consumer_by_name():
     resp = client.describe_stream_consumer(
         StreamARN=stream_arn, ConsumerName="newconsumer"
     )
-    resp.should.have.key("ConsumerDescription")
+    assert "ConsumerDescription" in resp
 
     consumer = resp["ConsumerDescription"]
-    consumer.should.have.key("ConsumerName").equals("newconsumer")
-    consumer.should.have.key("ConsumerARN")
-    consumer.should.have.key("ConsumerStatus").equals("ACTIVE")
-    consumer.should.have.key("ConsumerCreationTimestamp")
-    consumer.should.have.key("StreamARN").equals(stream_arn)
+    assert consumer["ConsumerName"] == "newconsumer"
+    assert "ConsumerARN" in consumer
+    assert consumer["ConsumerStatus"] == "ACTIVE"
+    assert "ConsumerCreationTimestamp" in consumer
+    assert consumer["StreamARN"] == stream_arn
 
 
 @mock_kinesis
@@ -83,14 +85,14 @@ def test_describe_stream_consumer_by_arn():
     consumer_arn = resp["Consumer"]["ConsumerARN"]
 
     resp = client.describe_stream_consumer(ConsumerARN=consumer_arn)
-    resp.should.have.key("ConsumerDescription")
+    assert "ConsumerDescription" in resp
 
     consumer = resp["ConsumerDescription"]
-    consumer.should.have.key("ConsumerName").equals("newconsumer")
-    consumer.should.have.key("ConsumerARN")
-    consumer.should.have.key("ConsumerStatus").equals("ACTIVE")
-    consumer.should.have.key("ConsumerCreationTimestamp")
-    consumer.should.have.key("StreamARN").equals(stream_arn)
+    assert consumer["ConsumerName"] == "newconsumer"
+    assert "ConsumerARN" in consumer
+    assert consumer["ConsumerStatus"] == "ACTIVE"
+    assert "ConsumerCreationTimestamp" in consumer
+    assert consumer["StreamARN"] == stream_arn
 
 
 @mock_kinesis
@@ -102,10 +104,8 @@ def test_describe_stream_consumer_unknown():
     with pytest.raises(ClientError) as exc:
         client.describe_stream_consumer(ConsumerARN=unknown_arn)
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
-    err["Message"].should.equal(
-        f"Consumer {unknown_arn}, account {ACCOUNT_ID} not found."
-    )
+    assert err["Code"] == "ResourceNotFoundException"
+    assert err["Message"] == f"Consumer {unknown_arn}, account {ACCOUNT_ID} not found."
 
 
 @mock_kinesis
@@ -116,15 +116,11 @@ def test_deregister_stream_consumer_by_name():
     client.register_stream_consumer(StreamARN=stream_arn, ConsumerName="consumer1")
     client.register_stream_consumer(StreamARN=stream_arn, ConsumerName="consumer2")
 
-    client.list_stream_consumers(StreamARN=stream_arn)[
-        "Consumers"
-    ].should.have.length_of(2)
+    assert len(client.list_stream_consumers(StreamARN=stream_arn)["Consumers"]) == 2
 
     client.deregister_stream_consumer(StreamARN=stream_arn, ConsumerName="consumer1")
 
-    client.list_stream_consumers(StreamARN=stream_arn)[
-        "Consumers"
-    ].should.have.length_of(1)
+    assert len(client.list_stream_consumers(StreamARN=stream_arn)["Consumers"]) == 1
 
 
 @mock_kinesis
@@ -138,12 +134,8 @@ def test_deregister_stream_consumer_by_arn():
     consumer1_arn = resp["Consumer"]["ConsumerARN"]
     client.register_stream_consumer(StreamARN=stream_arn, ConsumerName="consumer2")
 
-    client.list_stream_consumers(StreamARN=stream_arn)[
-        "Consumers"
-    ].should.have.length_of(2)
+    assert len(client.list_stream_consumers(StreamARN=stream_arn)["Consumers"]) == 2
 
     client.deregister_stream_consumer(ConsumerARN=consumer1_arn)
 
-    client.list_stream_consumers(StreamARN=stream_arn)[
-        "Consumers"
-    ].should.have.length_of(1)
+    assert len(client.list_stream_consumers(StreamARN=stream_arn)["Consumers"]) == 1
diff --git a/tests/test_kinesis/test_kinesis_stream_limits.py b/tests/test_kinesis/test_kinesis_stream_limits.py
index 3779be7f4..95c4fc4dc 100644
--- a/tests/test_kinesis/test_kinesis_stream_limits.py
+++ b/tests/test_kinesis/test_kinesis_stream_limits.py
@@ -1,6 +1,5 @@
 import boto3
 import pytest
-import sure  # noqa # pylint: disable=unused-import
 
 from botocore.exceptions import ClientError
 from moto import mock_kinesis
@@ -19,9 +18,10 @@ def test_record_data_exceeds_1mb():
             StreamName="my_stream",
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.equal(
-        "1 validation error detected: Value at 'records.1.member.data' failed to satisfy constraint: Member must have length less than or equal to 1048576"
+    assert err["Code"] == "ValidationException"
+    assert (
+        err["Message"]
+        == "1 validation error detected: Value at 'records.1.member.data' failed to satisfy constraint: Member must have length less than or equal to 1048576"
     )
 
 
@@ -39,9 +39,10 @@ def test_record_data_and_partition_key_exceeds_1mb():
             StreamName="my_stream",
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.equal(
-        "1 validation error detected: Value at 'records.1.member.data' failed to satisfy constraint: Member must have length less than or equal to 1048576"
+    assert err["Code"] == "ValidationException"
+    assert (
+        err["Message"]
+        == "1 validation error detected: Value at 'records.1.member.data' failed to satisfy constraint: Member must have length less than or equal to 1048576"
     )
 
 
@@ -84,8 +85,8 @@ def test_total_record_data_exceeds_5mb():
             StreamName="my_stream",
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("InvalidArgumentException")
-    err["Message"].should.equal("Records size exceeds 5 MB limit")
+    assert err["Code"] == "InvalidArgumentException"
+    assert err["Message"] == "Records size exceeds 5 MB limit"
 
 
 @mock_kinesis
@@ -112,7 +113,8 @@ def test_too_many_records():
             StreamName="my_stream",
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.equal(
-        "1 validation error detected: Value at 'records' failed to satisfy constraint: Member must have length less than or equal to 500"
+    assert err["Code"] == "ValidationException"
+    assert (
+        err["Message"]
+        == "1 validation error detected: Value at 'records' failed to satisfy constraint: Member must have length less than or equal to 500"
     )
diff --git a/tests/test_kinesis/test_server.py b/tests/test_kinesis/test_server.py
index 04d38230b..0222991a5 100644
--- a/tests/test_kinesis/test_server.py
+++ b/tests/test_kinesis/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_kinesis
@@ -13,4 +12,4 @@ def test_list_streams():
     res = test_client.get("/?Action=ListStreams")
 
     json_data = json.loads(res.data.decode("utf-8"))
-    json_data.should.equal({"HasMoreStreams": False, "StreamNames": []})
+    assert json_data == {"HasMoreStreams": False, "StreamNames": []}