Repository: getmoto/moto
Pull request #6660 (2023-08-14 17:58:19)

Techdebt: Replace sure with regular assertions in Utilities
See https://github.com/getmoto/moto/issues/6035

kbalk: @bblommers  `test_paginator.py` is a bit problematic in terms of pylint errors when using a less curated set of pylint checks.  I addressed some of them, but I wanted to let you know about the ones I ignored.

Some of the ones I addressed (I think I cleaned up some others before deciding to let you know):
```
tests/test_utilities/test_paginator.py:193:4: W0102: Dangerous default value [] as argument (dangerous-default-value)
tests/test_utilities/test_paginator.py:261:14: W0612: Unused variable 'token' (unused-variable)
```

The ones I ignored are listed below.  I believe I understand what's going on, but I thought I'd show you in case they should be addressed.
```
test_paginator.py:234:12: E1123: Unexpected keyword argument 'next_token' in method call (unexpected-keyword-arg)
test_paginator.py:248:12: E1123: Unexpected keyword argument 'next_token' in method call (unexpected-keyword-arg)
test_paginator.py:267:15: C0121: Comparison 'self.custom_limit == None' should be 'self.custom_limit is None' (singleton-comparison)
test_paginator.py:278:22: E1120: No value for argument 'resources' in method call (no-value-for-parameter)
test_paginator.py:281:22: E1123: Unexpected keyword argument 'next_token' in method call (unexpected-keyword-arg)
test_paginator.py:281:22: E1120: No value for argument 'resources' in method call (no-value-for-parameter)
test_paginator.py:288:22: E1123: Unexpected keyword argument 'next_token' in method call (unexpected-keyword-arg)
test_paginator.py:302:12: E1123: Unexpected keyword argument 'next_token' in method call (unexpected-keyword-arg)
test_paginator.py:184:8: W0201: Attribute 'custom_token' defined outside __init__ (attribute-defined-outside-init)
test_paginator.py:189:8: W0201: Attribute 'custom_limit' defined outside __init__ (attribute-defined-outside-init)
```

Patch:
diff --git a/moto/awslambda/exceptions.py b/moto/awslambda/exceptions.py
index d759060c5..19174d401 100644
--- a/moto/awslambda/exceptions.py
+++ b/moto/awslambda/exceptions.py
@@ -14,6 +14,14 @@ class CrossAccountNotAllowed(LambdaClientError):
         )
 
 
+class FunctionAlreadyExists(LambdaClientError):
+    code = 409
+
+    def __init__(self, function_name: str) -> None:
+        message = f"Function already exist: {function_name}"
+        super().__init__("ResourceConflictException", message)
+
+
 class InvalidParameterValueException(LambdaClientError):
     def __init__(self, message: str):
         super().__init__("InvalidParameterValueException", message)
diff --git a/moto/awslambda/models.py b/moto/awslambda/models.py
index 7120a71eb..9a5514a93 100644
--- a/moto/awslambda/models.py
+++ b/moto/awslambda/models.py
@@ -2034,6 +2034,31 @@ class LambdaBackend(BaseBackend):
     def put_function_concurrency(
         self, function_name: str, reserved_concurrency: str
     ) -> str:
+        """Establish concurrency limit/reservations for a function
+
+        Actual lambda restricts concurrency to 1000 (default) per region/account
+        across all functions; we approximate that behavior by summing across all
+        functions (hopefully all in the same account and region) and allowing the
+        caller to simulate an increased quota.
+
+        By default, no quota is enforced in order to preserve compatibility with
+        existing code that assumes it can do as many things as it likes. To model
+        actual AWS behavior, define the MOTO_LAMBDA_CONCURRENCY_QUOTA environment
+        variable prior to testing.
+        """
+
+        quota: Optional[str] = os.environ.get("MOTO_LAMBDA_CONCURRENCY_QUOTA")
+        if quota is not None:
+            # Enforce concurrency limits as described above
+            available = int(quota) - int(reserved_concurrency)
+            for fnx in self.list_functions():
+                if fnx.reserved_concurrency and fnx.function_name != function_name:
+                    available -= int(fnx.reserved_concurrency)
+            if available < 100:
+                raise InvalidParameterValueException(
+                    "Specified ReservedConcurrentExecutions for function decreases account's UnreservedConcurrentExecution below its minimum value of [100]."
+                )
+
         fn = self.get_function(function_name)
         fn.reserved_concurrency = reserved_concurrency
         return fn.reserved_concurrency
diff --git a/moto/awslambda/responses.py b/moto/awslambda/responses.py
index 2135a349e..b7349323f 100644
--- a/moto/awslambda/responses.py
+++ b/moto/awslambda/responses.py
@@ -6,6 +6,7 @@ from urllib.parse import unquote
 from moto.core.utils import path_url
 from moto.utilities.aws_headers import amz_crc32, amzn_request_id
 from moto.core.responses import BaseResponse, TYPE_RESPONSE
+from .exceptions import FunctionAlreadyExists, UnknownFunctionException
 from .models import lambda_backends, LambdaBackend
 
 
@@ -316,9 +317,14 @@ class LambdaResponse(BaseResponse):
         return 200, {}, json.dumps(result)
 
     def _create_function(self) -> TYPE_RESPONSE:
-        fn = self.backend.create_function(self.json_body)
-        config = fn.get_configuration(on_create=True)
-        return 201, {}, json.dumps(config)
+        function_name = self.json_body["FunctionName"].rsplit(":", 1)[-1]
+        try:
+            self.backend.get_function(function_name, None)
+        except UnknownFunctionException:
+            fn = self.backend.create_function(self.json_body)
+            config = fn.get_configuration(on_create=True)
+            return 201, {}, json.dumps(config)
+        raise FunctionAlreadyExists(function_name)
 
     def _create_function_url_config(self) -> TYPE_RESPONSE:
         function_name = unquote(self.path.split("/")[-2])
diff --git a/moto/s3/responses.py b/moto/s3/responses.py
index cef5bd7a5..e60027b21 100644
--- a/moto/s3/responses.py
+++ b/moto/s3/responses.py
@@ -292,7 +292,7 @@ class S3Response(BaseResponse):
     def _bucket_response(
         self, request: Any, full_url: str
     ) -> Union[str, TYPE_RESPONSE]:
-        querystring = self._get_querystring(request)
+        querystring = self._get_querystring(request, full_url)
         method = request.method
         region_name = parse_region_from_url(full_url, use_default_region=False)
         if region_name is None:
@@ -327,7 +327,7 @@ class S3Response(BaseResponse):
                 f"Method {method} has not been implemented in the S3 backend yet"
             )
 
-    def _get_querystring(self, request: Any) -> Dict[str, Any]:  # type: ignore[misc]
+    def _get_querystring(self, request: Any, full_url: str) -> Dict[str, Any]:  # type: ignore[misc]
         # Flask's Request has the querystring already parsed
         # In ServerMode, we can use this, instead of manually parsing this
         if hasattr(request, "args"):
@@ -338,6 +338,7 @@ class S3Response(BaseResponse):
                 query_dict[key] = val if isinstance(val, list) else [val]
             return query_dict
 
+        parsed_url = urlparse(full_url)
         # full_url can be one of two formats, depending on the version of werkzeug used:
         # http://foobaz.localhost:5000/?prefix=bar%2Bbaz
         # http://foobaz.localhost:5000/?prefix=bar+baz
@@ -346,7 +347,7 @@ class S3Response(BaseResponse):
         #
         # Workaround - manually reverse the encoding.
         # Keep the + encoded, ensuring that parse_qsl doesn't replace it, and parse_qsl will unquote it afterwards
-        qs = (self.parsed_url.query or "").replace("+", "%2B")
+        qs = (parsed_url.query or "").replace("+", "%2B")
         return parse_qs(qs, keep_blank_values=True)
 
     def _bucket_response_head(
@@ -1248,8 +1249,9 @@ class S3Response(BaseResponse):
     def _key_response(
         self, request: Any, full_url: str, headers: Dict[str, Any]
     ) -> TYPE_RESPONSE:
-        url_path = self.get_safe_path_from_url(self.parsed_url)
-        query = parse_qs(self.parsed_url.query, keep_blank_values=True)
+        parsed_url = urlparse(full_url)
+        url_path = self.get_safe_path_from_url(parsed_url)
+        query = parse_qs(parsed_url.query, keep_blank_values=True)
         method = request.method
 
         key_name = self.parse_key_name(request, url_path)


Test patch:
diff --git a/tests/test_awslambda/test_lambda.py b/tests/test_awslambda/test_lambda.py
index 6b86206bf..5a041343e 100644
--- a/tests/test_awslambda/test_lambda.py
+++ b/tests/test_awslambda/test_lambda.py
@@ -1236,19 +1236,20 @@ def test_create_function_with_already_exists():
         Publish=True,
     )
 
-    response = conn.create_function(
-        FunctionName=function_name,
-        Runtime="python2.7",
-        Role=get_role_name(),
-        Handler="lambda_function.lambda_handler",
-        Code={"S3Bucket": bucket_name, "S3Key": "test.zip"},
-        Description="test lambda function",
-        Timeout=3,
-        MemorySize=128,
-        Publish=True,
-    )
+    with pytest.raises(ClientError) as exc:
+        conn.create_function(
+            FunctionName=function_name,
+            Runtime="python2.7",
+            Role=get_role_name(),
+            Handler="lambda_function.lambda_handler",
+            Code={"S3Bucket": bucket_name, "S3Key": "test.zip"},
+            Description="test lambda function",
+            Timeout=3,
+            MemorySize=128,
+            Publish=True,
+        )
 
-    assert response["FunctionName"] == function_name
+    assert exc.value.response["Error"]["Code"] == "ResourceConflictException"
 
 
 @mock_lambda
@@ -1636,3 +1637,151 @@ def test_get_role_name_utility_race_condition():
     assert len(errors) + len(roles) == num_threads
     assert roles.count(roles[0]) == len(roles)
     assert len(errors) == 0
+
+
+@mock_lambda
+@mock.patch.dict(os.environ, {"MOTO_LAMBDA_CONCURRENCY_QUOTA": "1000"})
+def test_put_function_concurrency_success():
+    if settings.TEST_SERVER_MODE:
+        raise SkipTest(
+            "Envars not easily set in server mode, feature off by default, skipping..."
+        )
+    conn = boto3.client("lambda", _lambda_region)
+    zip_content = get_test_zip_file1()
+    function_name = str(uuid4())[0:6]
+    conn.create_function(
+        FunctionName=function_name,
+        Runtime="python2.7",
+        Role=get_role_name(),
+        Handler="lambda_function.lambda_handler",
+        Code={"ZipFile": zip_content},
+        Description="test lambda function",
+        Timeout=3,
+        MemorySize=128,
+        Publish=True,
+    )
+
+    response = conn.put_function_concurrency(
+        FunctionName=function_name, ReservedConcurrentExecutions=900
+    )
+    assert response["ReservedConcurrentExecutions"] == 900
+
+
+@mock_lambda
+@mock.patch.dict(os.environ, {"MOTO_LAMBDA_CONCURRENCY_QUOTA": "don't care"})
+def test_put_function_concurrency_not_enforced():
+    del os.environ["MOTO_LAMBDA_CONCURRENCY_QUOTA"]  # i.e. not set by user
+    conn = boto3.client("lambda", _lambda_region)
+    zip_content = get_test_zip_file1()
+    function_name = str(uuid4())[0:6]
+    conn.create_function(
+        FunctionName=function_name,
+        Runtime="python2.7",
+        Role=get_role_name(),
+        Handler="lambda_function.lambda_handler",
+        Code={"ZipFile": zip_content},
+        Description="test lambda function",
+        Timeout=3,
+        MemorySize=128,
+        Publish=True,
+    )
+
+    # This works, even though it normally would be disallowed by AWS
+    response = conn.put_function_concurrency(
+        FunctionName=function_name, ReservedConcurrentExecutions=901
+    )
+    assert response["ReservedConcurrentExecutions"] == 901
+
+
+@mock_lambda
+@mock.patch.dict(os.environ, {"MOTO_LAMBDA_CONCURRENCY_QUOTA": "1000"})
+def test_put_function_concurrency_failure():
+    if settings.TEST_SERVER_MODE:
+        raise SkipTest(
+            "Envars not easily set in server mode, feature off by default, skipping..."
+        )
+    conn = boto3.client("lambda", _lambda_region)
+    zip_content = get_test_zip_file1()
+    function_name = str(uuid4())[0:6]
+    conn.create_function(
+        FunctionName=function_name,
+        Runtime="python2.7",
+        Role=get_role_name(),
+        Handler="lambda_function.lambda_handler",
+        Code={"ZipFile": zip_content},
+        Description="test lambda function",
+        Timeout=3,
+        MemorySize=128,
+        Publish=True,
+    )
+
+    with pytest.raises(ClientError) as exc:
+        conn.put_function_concurrency(
+            FunctionName=function_name, ReservedConcurrentExecutions=901
+        )
+
+    assert exc.value.response["Error"]["Code"] == "InvalidParameterValueException"
+
+    # No reservation should have been set
+    response = conn.get_function_concurrency(FunctionName=function_name)
+    assert "ReservedConcurrentExecutions" not in response
+
+
+@mock_lambda
+@mock.patch.dict(os.environ, {"MOTO_LAMBDA_CONCURRENCY_QUOTA": "1000"})
+def test_put_function_concurrency_i_can_has_math():
+    if settings.TEST_SERVER_MODE:
+        raise SkipTest(
+            "Envars not easily set in server mode, feature off by default, skipping..."
+        )
+    conn = boto3.client("lambda", _lambda_region)
+    zip_content = get_test_zip_file1()
+    function_name_1 = str(uuid4())[0:6]
+    function_name_2 = str(uuid4())[0:6]
+    conn.create_function(
+        FunctionName=function_name_1,
+        Runtime="python2.7",
+        Role=get_role_name(),
+        Handler="lambda_function.lambda_handler",
+        Code={"ZipFile": zip_content},
+        Description="test lambda function",
+        Timeout=3,
+        MemorySize=128,
+        Publish=True,
+    )
+    conn.create_function(
+        FunctionName=function_name_2,
+        Runtime="python2.7",
+        Role=get_role_name(),
+        Handler="lambda_function.lambda_handler",
+        Code={"ZipFile": zip_content},
+        Description="test lambda function",
+        Timeout=3,
+        MemorySize=128,
+        Publish=True,
+    )
+
+    response = conn.put_function_concurrency(
+        FunctionName=function_name_1, ReservedConcurrentExecutions=600
+    )
+    assert response["ReservedConcurrentExecutions"] == 600
+    response = conn.put_function_concurrency(
+        FunctionName=function_name_2, ReservedConcurrentExecutions=100
+    )
+    assert response["ReservedConcurrentExecutions"] == 100
+
+    # Increasing function 1's limit should succeed, e.g. 700 + 100 <= 900
+    response = conn.put_function_concurrency(
+        FunctionName=function_name_1, ReservedConcurrentExecutions=700
+    )
+    assert response["ReservedConcurrentExecutions"] == 700
+
+    # Increasing function 2's limit should fail, e.g. 700 + 201 > 900
+    with pytest.raises(ClientError) as exc:
+        conn.put_function_concurrency(
+            FunctionName=function_name_2, ReservedConcurrentExecutions=201
+        )
+
+    assert exc.value.response["Error"]["Code"] == "InvalidParameterValueException"
+    response = conn.get_function_concurrency(FunctionName=function_name_2)
+    assert response["ReservedConcurrentExecutions"] == 100
diff --git a/tests/test_awslambda/test_lambda_layers.py b/tests/test_awslambda/test_lambda_layers.py
index ed04b9c62..609149089 100644
--- a/tests/test_awslambda/test_lambda_layers.py
+++ b/tests/test_awslambda/test_lambda_layers.py
@@ -115,6 +115,7 @@ def test_get_lambda_layers():
     assert result["LayerVersions"] == []
 
     # Test create function with non existant layer version
+    function_name = str(uuid4())[0:6]  # Must be different than above
     with pytest.raises(ClientError) as exc:
         conn.create_function(
             FunctionName=function_name,
diff --git a/tests/test_cloudfront/test_server.py b/tests/test_cloudfront/test_server.py
index 0cee4ea5b..534ca606a 100644
--- a/tests/test_cloudfront/test_server.py
+++ b/tests/test_cloudfront/test_server.py
@@ -1,4 +1,3 @@
-import sure  # noqa # pylint: disable=unused-import
 import xmltodict
 
 from moto import mock_cloudfront
@@ -12,5 +11,5 @@ def test_cloudfront_list():
 
     res = test_client.get("/2020-05-31/distribution")
     data = xmltodict.parse(res.data, dict_constructor=dict)
-    data.should.have.key("DistributionList")
-    data["DistributionList"].shouldnt.have.key("Items")
+    assert "DistributionList" in data
+    assert "Items" not in data["DistributionList"]
diff --git a/tests/test_emrcontainers/test_emrcontainers.py b/tests/test_emrcontainers/test_emrcontainers.py
index 3ecc95d18..6339e973f 100644
--- a/tests/test_emrcontainers/test_emrcontainers.py
+++ b/tests/test_emrcontainers/test_emrcontainers.py
@@ -1,17 +1,15 @@
 """Unit tests for emrcontainers-supported APIs."""
-import re
 from datetime import datetime, timezone, timedelta
+import re
+from unittest.mock import patch
 from unittest import SkipTest
 
 import boto3
-import pytest
-import sure  # noqa # pylint: disable=unused-import
 from botocore.exceptions import ClientError, ParamValidationError
+import pytest
 
 from moto import mock_emrcontainers, settings
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
-from unittest.mock import patch
-
 from moto.emrcontainers import REGION as DEFAULT_REGION
 
 
@@ -29,16 +27,14 @@ def fixture_virtual_cluster_factory(client):
     cluster_state = ["RUNNING", "TERMINATING", "TERMINATED", "ARRESTED"]
 
     cluster_list = []
-    for i in range(len(cluster_state)):
-        with patch(
-            "moto.emrcontainers.models.VIRTUAL_CLUSTER_STATUS", cluster_state[i]
-        ):
+    for idx, state in enumerate(cluster_state):
+        with patch("moto.emrcontainers.models.VIRTUAL_CLUSTER_STATUS", state):
             resp = client.create_virtual_cluster(
                 name="test-emr-virtual-cluster",
                 containerProvider={
                     "type": "EKS",
                     "id": "test-eks-cluster",
-                    "info": {"eksInfo": {"namespace": f"emr-container-{i}"}},
+                    "info": {"eksInfo": {"namespace": f"emr-container-{idx}"}},
                 },
             )
 
@@ -53,7 +49,10 @@ def fixture_job_factory(client, virtual_cluster_factory):
     default_job_driver = {
         "sparkSubmitJobDriver": {
             "entryPoint": "s3://code/pi.py",
-            "sparkSubmitParameters": "--conf spark.executor.instances=2 --conf spark.executor.memory=2G --conf spark.driver.memory=2G --conf spark.executor.cores=4",
+            "sparkSubmitParameters": (
+                "--conf spark.executor.instances=2 --conf spark.executor.memory=2G "
+                "--conf spark.driver.memory=2G --conf spark.executor.cores=4"
+            ),
         }
     }
     default_execution_role_arn = f"arn:aws:iam::{ACCOUNT_ID}:role/iamrole-emrcontainers"
@@ -70,10 +69,10 @@ def fixture_job_factory(client, virtual_cluster_factory):
     ]
 
     job_list = []
-    for i in range(len(job_state)):
-        with patch("moto.emrcontainers.models.JOB_STATUS", job_state[i]):
+    for idx, state in enumerate(job_state):
+        with patch("moto.emrcontainers.models.JOB_STATUS", state):
             resp = client.start_job_run(
-                name=f"test_job_{i}",
+                name=f"test_job_{idx}",
                 virtualClusterId=virtual_cluster_id,
                 executionRoleArn=default_execution_role_arn,
                 releaseLabel=default_release_label,
@@ -168,7 +167,10 @@ class TestDescribeVirtualCluster:
         resp = self.client.describe_virtual_cluster(id=self.virtual_cluster_ids[0])
 
         expected_resp = {
-            "arn": f"arn:aws:emr-containers:us-east-1:{ACCOUNT_ID}:/virtualclusters/{self.virtual_cluster_ids[0]}",
+            "arn": (
+                f"arn:aws:emr-containers:us-east-1:{ACCOUNT_ID}:"
+                f"/virtualclusters/{self.virtual_cluster_ids[0]}"
+            ),
             "containerProvider": {
                 "id": "test-eks-cluster",
                 "info": {"eksInfo": {"namespace": "emr-container-0"}},
@@ -261,7 +263,10 @@ class TestStartJobRun:
     default_job_driver = {
         "sparkSubmitJobDriver": {
             "entryPoint": "s3://code/pi.py",
-            "sparkSubmitParameters": "--conf spark.executor.instances=2 --conf spark.executor.memory=2G --conf spark.driver.memory=2G --conf spark.executor.cores=4",
+            "sparkSubmitParameters": (
+                "--conf spark.executor.instances=2 --conf spark.executor.memory=2G"
+                "--conf spark.driver.memory=2G --conf spark.executor.cores=4"
+            ),
         }
     }
 
@@ -302,9 +307,9 @@ class TestStartJobRun:
 
         assert re.match(r"[a-z,0-9]{19}", resp["id"])
         assert resp["name"] == "test_job"
-        assert (
-            resp["arn"]
-            == f"arn:aws:emr-containers:us-east-1:{ACCOUNT_ID}:/virtualclusters/{self.virtual_cluster_id}/jobruns/{resp['id']}"
+        assert resp["arn"] == (
+            f"arn:aws:emr-containers:us-east-1:{ACCOUNT_ID}:"
+            f"/virtualclusters/{self.virtual_cluster_id}/jobruns/{resp['id']}"
         )
         assert resp["virtualClusterId"] == self.virtual_cluster_id
 
@@ -320,9 +325,9 @@ class TestStartJobRun:
 
         assert exc.typename == "ParamValidationError"
         assert (
-            "Parameter validation failed:\nInvalid length for parameter executionRoleArn, value: 6, valid min length: 20"
-            in exc.value.args
-        )
+            "Parameter validation failed:\nInvalid length for parameter "
+            "executionRoleArn, value: 6, valid min length: 20"
+        ) in exc.value.args
 
     def test_invalid_virtual_cluster_id(self):
         with pytest.raises(ClientError) as exc:
@@ -508,7 +513,11 @@ class TestDescribeJobRun:
         )
 
         expected = {
-            "arn": f"arn:aws:emr-containers:us-east-1:{ACCOUNT_ID}:/virtualclusters/{self.virtual_cluster_id}/jobruns/{self.job_list[2]}",
+            "arn": (
+                f"arn:aws:emr-containers:us-east-1:{ACCOUNT_ID}"
+                f":/virtualclusters/{self.virtual_cluster_id}"
+                f"/jobruns/{self.job_list[2]}"
+            ),
             "createdAt": (
                 datetime.today()
                 .replace(hour=0, minute=0, second=0, microsecond=0)
diff --git a/tests/test_emrcontainers/test_server.py b/tests/test_emrcontainers/test_server.py
index 2e05a2d6c..f2255e1e1 100644
--- a/tests/test_emrcontainers/test_server.py
+++ b/tests/test_emrcontainers/test_server.py
@@ -1,11 +1,7 @@
+"""Test the different server responses."""
 import json
-import sure  # noqa # pylint: disable=unused-import
 import moto.server as server
 
-"""
-Test the different server responses
-"""
-
 
 def test_list_virtual_clusters():
     backend = server.create_backend_app("emr-containers")
@@ -13,4 +9,4 @@ def test_list_virtual_clusters():
 
     res = test_client.get("/virtualclusters")
 
-    json.loads(res.data).should.have.key("virtualClusters")
+    assert "virtualClusters" in json.loads(res.data)
diff --git a/tests/test_emrserverless/test_emrserverless.py b/tests/test_emrserverless/test_emrserverless.py
index b2b8975ad..df9958443 100644
--- a/tests/test_emrserverless/test_emrserverless.py
+++ b/tests/test_emrserverless/test_emrserverless.py
@@ -1,17 +1,17 @@
 """Unit tests for emrserverless-supported APIs."""
 import re
-from datetime import datetime, timezone
 from contextlib import contextmanager
+from datetime import datetime, timezone
+from unittest.mock import patch
 
 import boto3
-import pytest
-import sure  # noqa # pylint: disable=unused-import
 from botocore.exceptions import ClientError
+import pytest
+
 from moto import mock_emrserverless, settings
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
 from moto.emrserverless import REGION as DEFAULT_REGION
 from moto.emrserverless import RELEASE_LABEL as DEFAULT_RELEASE_LABEL
-from unittest.mock import patch
 
 
 @contextmanager
@@ -81,9 +81,9 @@ class TestCreateApplication:
 
         assert resp["name"] == "test-emr-serverless-application"
         assert re.match(r"[a-z,0-9]{16}", resp["applicationId"])
-        assert (
-            resp["arn"]
-            == f"arn:aws:emr-containers:us-east-1:{ACCOUNT_ID}:/applications/{resp['applicationId']}"
+        assert resp["arn"] == (
+            f"arn:aws:emr-containers:us-east-1:{ACCOUNT_ID}"
+            f":/applications/{resp['applicationId']}"
         )
 
     @staticmethod
@@ -114,9 +114,9 @@ class TestCreateApplication:
         err = exc.value.response["Error"]
 
         assert err["Code"] == "ValidationException"
-        assert (
-            err["Message"]
-            == "Type 'SPARK' is not supported for release label 'emr-fake' or release label does not exist"
+        assert err["Message"] == (
+            "Type 'SPARK' is not supported for release label 'emr-fake' "
+            "or release label does not exist"
         )
 
 
@@ -154,9 +154,10 @@ class TestDeleteApplication:
         if exc:
             err = exc.value.response["Error"]
             assert err["Code"] == "ValidationException"
-            assert (
-                err["Message"]
-                == f"Application {self.application_ids[index]} must be in one of the following statuses [CREATED, STOPPED]. Current status: {status}"
+            assert err["Message"] == (
+                f"Application {self.application_ids[index]} must be in one "
+                "of the following statuses [CREATED, STOPPED]. Current "
+                f"status: {status}"
             )
         else:
             assert resp is not None
@@ -289,7 +290,10 @@ class TestListApplication:
         expected_resp = {
             "id": self.application_ids[0],
             "name": "test-emr-serverless-application-STARTED",
-            "arn": f"arn:aws:emr-containers:us-east-1:123456789012:/applications/{self.application_ids[0]}",
+            "arn": (
+                f"arn:aws:emr-containers:us-east-1:123456789012"
+                f":/applications/{self.application_ids[0]}"
+            ),
             "releaseLabel": "emr-6.6.0",
             "type": "Spark",
             "state": "STARTED",
@@ -451,9 +455,10 @@ class TestUpdateApplication:
         if exc:
             err = exc.value.response["Error"]
             assert err["Code"] == "ValidationException"
-            assert (
-                err["Message"]
-                == f"Application {self.application_ids[index]} must be in one of the following statuses [CREATED, STOPPED]. Current status: {status}"
+            assert err["Message"] == (
+                f"Application {self.application_ids[index]} must be in one "
+                "of the following statuses [CREATED, STOPPED]. Current "
+                f"status: {status}"
             )
         else:
             assert resp is not None
diff --git a/tests/test_emrserverless/test_server.py b/tests/test_emrserverless/test_server.py
index f773d76bc..e2ba66d6b 100644
--- a/tests/test_emrserverless/test_server.py
+++ b/tests/test_emrserverless/test_server.py
@@ -1,6 +1,4 @@
 """Test different server responses."""
-import sure  # noqa # pylint: disable=unused-import
-
 import moto.server as server
 
 
@@ -9,5 +7,5 @@ def test_emrserverless_list():
     test_client = backend.test_client()
 
     resp = test_client.get("/applications")
-    resp.status_code.should.equal(200)
-    str(resp.data).should.contain("applications")
+    assert resp.status_code == 200
+    assert "applications" in str(resp.data)
diff --git a/tests/test_forecast/test_forecast.py b/tests/test_forecast/test_forecast.py
index f19371ff4..be5b2e09e 100644
--- a/tests/test_forecast/test_forecast.py
+++ b/tests/test_forecast/test_forecast.py
@@ -1,7 +1,7 @@
 import boto3
-import pytest
-import sure  # noqa # pylint: disable=unused-import
 from botocore.exceptions import ClientError
+import pytest
+
 from moto import mock_forecast
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
 
@@ -24,9 +24,9 @@ def test_forecast_dataset_group_create(domain):
     name = "example_dataset_group"
     client = boto3.client("forecast", region_name=region)
     response = client.create_dataset_group(DatasetGroupName=name, Domain=domain)
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    response["DatasetGroupArn"].should.equal(
-        "arn:aws:forecast:" + region + ":" + ACCOUNT_ID + ":dataset-group/" + name
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert response["DatasetGroupArn"] == (
+        f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset-group/{name}"
     )
 
 
@@ -38,11 +38,12 @@ def test_forecast_dataset_group_create_invalid_domain():
 
     with pytest.raises(ClientError) as exc:
         client.create_dataset_group(DatasetGroupName=name, Domain=invalid_domain)
-    exc.value.response["Error"]["Code"].should.equal("ValidationException")
-    exc.value.response["Error"]["Message"].should.equal(
-        "1 validation error detected: Value '"
-        + invalid_domain
-        + "' at 'domain' failed to satisfy constraint: Member must satisfy enum value set ['INVENTORY_PLANNING', 'METRICS', 'RETAIL', 'EC2_CAPACITY', 'CUSTOM', 'WEB_TRAFFIC', 'WORK_FORCE']"
+    assert exc.value.response["Error"]["Code"] == "ValidationException"
+    assert exc.value.response["Error"]["Message"] == (
+        f"1 validation error detected: Value '{invalid_domain}' at 'domain' "
+        "failed to satisfy constraint: Member must satisfy enum value set "
+        "['INVENTORY_PLANNING', 'METRICS', 'RETAIL', 'EC2_CAPACITY', "
+        "'CUSTOM', 'WEB_TRAFFIC', 'WORK_FORCE']"
     )
 
 
@@ -53,12 +54,11 @@ def test_forecast_dataset_group_create_invalid_name(name):
 
     with pytest.raises(ClientError) as exc:
         client.create_dataset_group(DatasetGroupName=name, Domain="CUSTOM")
-    exc.value.response["Error"]["Code"].should.equal("ValidationException")
-    exc.value.response["Error"]["Message"].should.contain(
-        "1 validation error detected: Value '"
-        + name
-        + "' at 'datasetGroupName' failed to satisfy constraint: Member must"
-    )
+    assert exc.value.response["Error"]["Code"] == "ValidationException"
+    assert (
+        f"1 validation error detected: Value '{name}' at 'datasetGroupName' "
+        "failed to satisfy constraint: Member must"
+    ) in exc.value.response["Error"]["Message"]
 
 
 @mock_forecast
@@ -69,7 +69,7 @@ def test_forecast_dataset_group_create_duplicate_fails():
     with pytest.raises(ClientError) as exc:
         client.create_dataset_group(DatasetGroupName="name", Domain="RETAIL")
 
-    exc.value.response["Error"]["Code"].should.equal("ResourceAlreadyExistsException")
+    assert exc.value.response["Error"]["Code"] == "ResourceAlreadyExistsException"
 
 
 @mock_forecast
@@ -77,7 +77,7 @@ def test_forecast_dataset_group_list_default_empty():
     client = boto3.client("forecast", region_name=region)
 
     resp = client.list_dataset_groups()
-    resp["DatasetGroups"].should.equal([])
+    assert resp["DatasetGroups"] == []
 
 
 @mock_forecast
@@ -88,8 +88,8 @@ def test_forecast_dataset_group_list_some():
     result = client.list_dataset_groups()
 
     assert len(result["DatasetGroups"]) == 1
-    result["DatasetGroups"][0]["DatasetGroupArn"].should.equal(
-        "arn:aws:forecast:" + region + ":" + ACCOUNT_ID + ":dataset-group/hello"
+    assert result["DatasetGroups"][0]["DatasetGroupArn"] == (
+        f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset-group/hello"
     )
 
 
@@ -97,12 +97,7 @@ def test_forecast_dataset_group_list_some():
 def test_forecast_delete_dataset_group():
     dataset_group_name = "name"
     dataset_group_arn = (
-        "arn:aws:forecast:"
-        + region
-        + ":"
-        + ACCOUNT_ID
-        + ":dataset-group/"
-        + dataset_group_name
+        f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset-group/{dataset_group_name}"
     )
     client = boto3.client("forecast", region_name=region)
     client.create_dataset_group(DatasetGroupName=dataset_group_name, Domain="CUSTOM")
@@ -112,15 +107,13 @@ def test_forecast_delete_dataset_group():
 @mock_forecast
 def test_forecast_delete_dataset_group_missing():
     client = boto3.client("forecast", region_name=region)
-    missing_dsg_arn = (
-        "arn:aws:forecast:" + region + ":" + ACCOUNT_ID + ":dataset-group/missing"
-    )
+    missing_dsg_arn = f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset-group/missing"
 
     with pytest.raises(ClientError) as exc:
         client.delete_dataset_group(DatasetGroupArn=missing_dsg_arn)
-    exc.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
-    exc.value.response["Error"]["Message"].should.equal(
-        "No resource found " + missing_dsg_arn
+    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+    assert (
+        exc.value.response["Error"]["Message"] == f"No resource found {missing_dsg_arn}"
     )
 
 
@@ -128,12 +121,7 @@ def test_forecast_delete_dataset_group_missing():
 def test_forecast_update_dataset_arns_empty():
     dataset_group_name = "name"
     dataset_group_arn = (
-        "arn:aws:forecast:"
-        + region
-        + ":"
-        + ACCOUNT_ID
-        + ":dataset-group/"
-        + dataset_group_name
+        f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset-group/{dataset_group_name}"
     )
     client = boto3.client("forecast", region_name=region)
     client.create_dataset_group(DatasetGroupName=dataset_group_name, Domain="CUSTOM")
@@ -143,14 +131,13 @@ def test_forecast_update_dataset_arns_empty():
 @mock_forecast
 def test_forecast_update_dataset_group_not_found():
     client = boto3.client("forecast", region_name=region)
-    dataset_group_arn = (
-        "arn:aws:forecast:" + region + ":" + ACCOUNT_ID + ":dataset-group/" + "test"
-    )
+    dataset_group_arn = f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset-group/test"
     with pytest.raises(ClientError) as exc:
         client.update_dataset_group(DatasetGroupArn=dataset_group_arn, DatasetArns=[])
-    exc.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
-    exc.value.response["Error"]["Message"].should.equal(
-        "No resource found " + dataset_group_arn
+    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+    assert (
+        exc.value.response["Error"]["Message"]
+        == f"No resource found {dataset_group_arn}"
     )
 
 
@@ -158,9 +145,7 @@ def test_forecast_update_dataset_group_not_found():
 def test_describe_dataset_group():
     name = "test"
     client = boto3.client("forecast", region_name=region)
-    dataset_group_arn = (
-        "arn:aws:forecast:" + region + ":" + ACCOUNT_ID + ":dataset-group/" + name
-    )
+    dataset_group_arn = f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset-group/{name}"
     client.create_dataset_group(DatasetGroupName=name, Domain="CUSTOM")
     result = client.describe_dataset_group(DatasetGroupArn=dataset_group_arn)
     assert result.get("DatasetGroupArn") == dataset_group_arn
@@ -171,28 +156,27 @@ def test_describe_dataset_group():
 @mock_forecast
 def test_describe_dataset_group_missing():
     client = boto3.client("forecast", region_name=region)
-    dataset_group_arn = (
-        "arn:aws:forecast:" + region + ":" + ACCOUNT_ID + ":dataset-group/name"
-    )
+    dataset_group_arn = f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset-group/name"
     with pytest.raises(ClientError) as exc:
         client.describe_dataset_group(DatasetGroupArn=dataset_group_arn)
-    exc.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
-    exc.value.response["Error"]["Message"].should.equal(
-        "No resource found " + dataset_group_arn
+    assert exc.value.response["Error"]["Code"] == "ResourceNotFoundException"
+    assert (
+        exc.value.response["Error"]["Message"]
+        == f"No resource found {dataset_group_arn}"
     )
 
 
 @mock_forecast
 def test_create_dataset_group_missing_datasets():
     client = boto3.client("forecast", region_name=region)
-    dataset_arn = "arn:aws:forecast:" + region + ":" + ACCOUNT_ID + ":dataset/name"
+    dataset_arn = f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset-group/name"
     with pytest.raises(ClientError) as exc:
         client.create_dataset_group(
             DatasetGroupName="name", Domain="CUSTOM", DatasetArns=[dataset_arn]
         )
-    exc.value.response["Error"]["Code"].should.equal("InvalidInputException")
-    exc.value.response["Error"]["Message"].should.equal(
-        "Dataset arns: [" + dataset_arn + "] are not found"
+    assert exc.value.response["Error"]["Code"] == "InvalidInputException"
+    assert exc.value.response["Error"]["Message"] == (
+        f"Dataset arns: [{dataset_arn}] are not found"
     )
 
 
@@ -200,17 +184,15 @@ def test_create_dataset_group_missing_datasets():
 def test_update_dataset_group_missing_datasets():
     name = "test"
     client = boto3.client("forecast", region_name=region)
-    dataset_group_arn = (
-        "arn:aws:forecast:" + region + ":" + ACCOUNT_ID + ":dataset-group/" + name
-    )
+    dataset_group_arn = f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset-group/{name}"
     client.create_dataset_group(DatasetGroupName=name, Domain="CUSTOM")
-    dataset_arn = "arn:aws:forecast:" + region + ":" + ACCOUNT_ID + ":dataset/name"
+    dataset_arn = f"arn:aws:forecast:{region}:{ACCOUNT_ID}:dataset/name"
 
     with pytest.raises(ClientError) as exc:
         client.update_dataset_group(
             DatasetGroupArn=dataset_group_arn, DatasetArns=[dataset_arn]
         )
-    exc.value.response["Error"]["Code"].should.equal("InvalidInputException")
-    exc.value.response["Error"]["Message"].should.equal(
-        "Dataset arns: [" + dataset_arn + "] are not found"
+    assert exc.value.response["Error"]["Code"] == "InvalidInputException"
+    assert exc.value.response["Error"]["Message"] == (
+        f"Dataset arns: [{dataset_arn}] are not found"
     )
diff --git a/tests/test_meteringmarketplace/test_meteringmarketplace.py b/tests/test_meteringmarketplace/test_meteringmarketplace.py
index cbc5928a9..ecb869b4f 100644
--- a/tests/test_meteringmarketplace/test_meteringmarketplace.py
+++ b/tests/test_meteringmarketplace/test_meteringmarketplace.py
@@ -1,7 +1,8 @@
-import boto3
 import copy
-import sure  # noqa # pylint: disable=unused-import
 from datetime import datetime
+
+import boto3
+
 from moto import mock_meteringmarketplace
 from moto.meteringmarketplace.models import Result
 
@@ -78,7 +79,7 @@ def test_batch_meter_usage():
         UsageRecords=USAGE_RECORDS, ProductCode="PUFXZLyUElvQvrsG"
     )
 
-    res.should.have.key("Results").length_of(10)
+    assert len(res["Results"]) == 10
 
     records_without_time = copy.copy(USAGE_RECORDS)
     for r in records_without_time:
diff --git a/tests/test_moto_api/mock_random/test_mock_random.py b/tests/test_moto_api/mock_random/test_mock_random.py
index 814abcd84..dd415a644 100644
--- a/tests/test_moto_api/mock_random/test_mock_random.py
+++ b/tests/test_moto_api/mock_random/test_mock_random.py
@@ -1,4 +1,3 @@
-import sure  # noqa # pylint: disable=unused-import
 from moto.moto_api._internal import mock_random
 
 
@@ -9,15 +8,15 @@ def test_semi_random_uuids():
     # Seed our generator - the next generation should be predetermined
     mock_random.seed(42)
     fixed_uuid = str(mock_random.uuid4())
-    fixed_uuid.should.equal("bdd640fb-0667-4ad1-9c80-317fa3b1799d")
+    assert fixed_uuid == "bdd640fb-0667-4ad1-9c80-317fa3b1799d"
 
     # Ensure they are different
-    fixed_uuid.shouldnt.equal(random_uuid)
+    assert fixed_uuid != random_uuid
 
     # Retrieving another 'fixed' UUID should not return a known UUID
     second_fixed = str(mock_random.uuid4())
-    second_fixed.shouldnt.equal(random_uuid)
-    second_fixed.shouldnt.equal(fixed_uuid)
+    assert second_fixed != random_uuid
+    assert second_fixed != fixed_uuid
 
 
 def test_semi_random_hex_strings():
@@ -27,12 +26,12 @@ def test_semi_random_hex_strings():
     # Seed our generator - the next generation should be predetermined
     mock_random.seed(42)
     fixed_hex = mock_random.get_random_hex()
-    fixed_hex.should.equal("30877432")
+    assert fixed_hex == "30877432"
 
     # Ensure they are different
-    fixed_hex.shouldnt.equal(random_hex)
+    assert fixed_hex != random_hex
 
     # Retrieving another 'fixed' UUID should not return a known UUID
     second_hex = mock_random.uuid4()
-    second_hex.shouldnt.equal(random_hex)
-    second_hex.shouldnt.equal(fixed_hex)
+    assert second_hex != random_hex
+    assert second_hex != fixed_hex
diff --git a/tests/test_moto_api/recorder/test_recorder.py b/tests/test_moto_api/recorder/test_recorder.py
index 5eef59190..90a70c2f1 100644
--- a/tests/test_moto_api/recorder/test_recorder.py
+++ b/tests/test_moto_api/recorder/test_recorder.py
@@ -3,7 +3,6 @@ import boto3
 import json
 import requests
 import os
-import sure  # noqa # pylint: disable=unused-import
 from moto import (
     settings,
     mock_apigateway,
@@ -47,7 +46,7 @@ class TestRecorder(TestCase):
             resp = requests.get(
                 "http://localhost:5000/moto-api/recorder/download-recording"
             )
-            resp.status_code.should.equal(200)
+            assert resp.status_code == 200
             return resp.content
         else:
             return recorder.download_recording()
@@ -71,7 +70,8 @@ class TestRecorder(TestCase):
         )
         ec2.run_instances(ImageId=EXAMPLE_AMI_ID, MinCount=1, MaxCount=1)
 
-        self._download_recording().should.be.empty
+        # ServerMode returns bytes
+        assert self._download_recording() in ["", b""]
 
     def test_ec2_instance_creation_recording_on(self):
         self._start_recording()
@@ -87,8 +87,8 @@ class TestRecorder(TestCase):
         else:
             body = content["body"]
 
-        body.should.contain("Action=RunInstances")
-        body.should.contain(f"ImageId={EXAMPLE_AMI_ID}")
+        assert "Action=RunInstances" in body
+        assert f"ImageId={EXAMPLE_AMI_ID}" in body
 
     def test_multiple_services(self):
         self._start_recording()
@@ -123,9 +123,9 @@ class TestRecorder(TestCase):
         rows = [json.loads(x) for x in content.splitlines()]
 
         actions = [row["headers"].get("X-Amz-Target") for row in rows]
-        actions.should.contain("DynamoDB_20120810.CreateTable")
-        actions.should.contain("DynamoDB_20120810.PutItem")
-        actions.should.contain("Timestream_20181101.CreateDatabase")
+        assert "DynamoDB_20120810.CreateTable" in actions
+        assert "DynamoDB_20120810.PutItem" in actions
+        assert "Timestream_20181101.CreateDatabase" in actions
 
     def test_replay(self):
         self._start_recording()
@@ -149,13 +149,13 @@ class TestRecorder(TestCase):
 
         self._replay_recording()
 
-        ddb.list_tables()["TableNames"].should.equal(["test"])
+        assert ddb.list_tables()["TableNames"] == ["test"]
 
         apis = apigw.get_rest_apis()["items"]
-        apis.should.have.length_of(1)
+        assert len(apis) == 1
         # The ID is uniquely generated everytime, but the name is the same
-        apis[0]["id"].shouldnt.equal(api_id)
-        apis[0]["name"].should.equal("my_api")
+        assert apis[0]["id"] != api_id
+        assert apis[0]["name"] == "my_api"
 
     def test_replay__partial_delete(self):
         self._start_recording()
@@ -180,11 +180,11 @@ class TestRecorder(TestCase):
         self._replay_recording()
 
         # The replay will create, then delete this Table
-        ddb.list_tables()["TableNames"].should.equal([])
+        assert ddb.list_tables()["TableNames"] == []
 
         # The replay will create the RestAPI - the deletion was not recorded
         apis = apigw.get_rest_apis()["items"]
-        apis.should.have.length_of(1)
+        assert len(apis) == 1
 
     def test_s3_upload_data(self):
         self._start_recording()
@@ -201,7 +201,7 @@ class TestRecorder(TestCase):
         # Replaying should recreate the file as is
         self._replay_recording()
         resp = s3.get_object(Bucket="mybucket", Key="data")
-        resp["Body"].read().should.equal(b"ABCD")
+        assert resp["Body"].read() == b"ABCD"
 
     def test_s3_upload_file_using_requests(self):
         s3 = boto3.client(
@@ -225,7 +225,7 @@ class TestRecorder(TestCase):
         # Replay upload, and assert it succeeded
         self._replay_recording()
         resp = s3.get_object(Bucket="mybucket", Key="file_upload")
-        resp["Body"].read().should.equal(b"test")
+        assert resp["Body"].read() == b"test"
         # cleanup
         os.remove("text.txt")
 
@@ -302,5 +302,5 @@ class TestThreadedMotoServer(TestCase):
             aws_secret_access_key="sk",
         )
         resp = s3.get_object(Bucket="mybucket", Key="data")
-        resp["Body"].read().should.equal(b"ABCD")
+        assert resp["Body"].read() == b"ABCD"
         server.stop()
diff --git a/tests/test_moto_api/state_manager/servermode/test_inmemory_server.py b/tests/test_moto_api/state_manager/servermode/test_inmemory_server.py
index 43380ed20..0f34a1105 100644
--- a/tests/test_moto_api/state_manager/servermode/test_inmemory_server.py
+++ b/tests/test_moto_api/state_manager/servermode/test_inmemory_server.py
@@ -1,6 +1,4 @@
 import json
-import sure  # noqa # pylint: disable=unused-import
-
 
 from moto import server
 
@@ -17,13 +15,13 @@ def test_set_transition():
         "http://localhost:5000/moto-api/state-manager/set-transition",
         data=json.dumps(post_body),
     )
-    resp.status_code.should.equal(201)
+    assert resp.status_code == 201
 
     resp = test_client.get(
         "http://localhost:5000/moto-api/state-manager/get-transition?model_name=server::test1"
     )
-    resp.status_code.should.equal(200)
-    json.loads(resp.data).should.equal({"progression": "waiter", "wait_times": 3})
+    assert resp.status_code == 200
+    assert json.loads(resp.data) == {"progression": "waiter", "wait_times": 3}
 
 
 def test_unset_transition():
@@ -44,13 +42,13 @@ def test_unset_transition():
         "http://localhost:5000/moto-api/state-manager/unset-transition",
         data=json.dumps(post_body),
     )
-    resp.status_code.should.equal(201)
+    assert resp.status_code == 201
 
     resp = test_client.get(
         "http://localhost:5000/moto-api/state-manager/get-transition?model_name=server::test2"
     )
-    resp.status_code.should.equal(200)
-    json.loads(resp.data).should.equal({"progression": "immediate"})
+    assert resp.status_code == 200
+    assert json.loads(resp.data) == {"progression": "immediate"}
 
 
 def test_get_default_transition():
@@ -60,5 +58,5 @@ def test_get_default_transition():
     resp = test_client.get(
         "http://localhost:5000/moto-api/state-manager/get-transition?model_name=unknown"
     )
-    resp.status_code.should.equal(200)
-    json.loads(resp.data).should.equal({"progression": "immediate"})
+    assert resp.status_code == 200
+    assert json.loads(resp.data) == {"progression": "immediate"}
diff --git a/tests/test_moto_api/state_manager/servermode/test_state_manager.py b/tests/test_moto_api/state_manager/servermode/test_state_manager.py
index 079bc5481..48d356582 100644
--- a/tests/test_moto_api/state_manager/servermode/test_state_manager.py
+++ b/tests/test_moto_api/state_manager/servermode/test_state_manager.py
@@ -1,7 +1,5 @@
 import json
 import requests
-import sure  # noqa # pylint: disable=unused-import
-
 
 from moto import settings
 from unittest import SkipTest
@@ -18,13 +16,13 @@ def test_set_transition():
         "http://localhost:5000/moto-api/state-manager/set-transition",
         data=json.dumps(post_body),
     )
-    resp.status_code.should.equal(201)
+    assert resp.status_code == 201
 
     resp = requests.get(
         "http://localhost:5000/moto-api/state-manager/get-transition?model_name=test_model0"
     )
-    resp.status_code.should.equal(200)
-    json.loads(resp.content).should.equal({"progression": "waiter", "wait_times": 3})
+    assert resp.status_code == 200
+    assert json.loads(resp.content) == {"progression": "waiter", "wait_times": 3}
 
 
 def test_unset_transition():
@@ -48,8 +46,8 @@ def test_unset_transition():
     resp = requests.get(
         "http://localhost:5000/moto-api/state-manager/get-transition?model_name=test::model1"
     )
-    resp.status_code.should.equal(200)
-    json.loads(resp.content).should.equal({"progression": "immediate"})
+    assert resp.status_code == 200
+    assert json.loads(resp.content) == {"progression": "immediate"}
 
 
 def test_get_default_transition():
@@ -59,5 +57,5 @@ def test_get_default_transition():
     resp = requests.get(
         "http://localhost:5000/moto-api/state-manager/get-transition?model_name=unknown"
     )
-    resp.status_code.should.equal(200)
-    json.loads(resp.content).should.equal({"progression": "immediate"})
+    assert resp.status_code == 200
+    assert json.loads(resp.content) == {"progression": "immediate"}
diff --git a/tests/test_moto_api/state_manager/test_batch_integration.py b/tests/test_moto_api/state_manager/test_batch_integration.py
index 7b4705f92..7cdfad621 100644
--- a/tests/test_moto_api/state_manager/test_batch_integration.py
+++ b/tests/test_moto_api/state_manager/test_batch_integration.py
@@ -2,8 +2,6 @@ from tests.markers import requires_docker
 from tests.test_batch import _get_clients, _setup
 from tests.test_batch.test_batch_jobs import prepare_job, _wait_for_job_status
 
-import sure  # noqa # pylint: disable=unused-import
-
 from moto import mock_batch, mock_iam, mock_ec2, mock_ecs, mock_logs, settings
 from moto.moto_api import state_manager
 from unittest import SkipTest
@@ -44,10 +42,10 @@ def test_cancel_pending_job():
     _wait_for_job_status(batch_client, job_id, "FAILED", seconds_to_wait=20)
 
     resp = batch_client.describe_jobs(jobs=[job_id])
-    resp["jobs"][0]["jobName"].should.equal("test_job_name")
-    resp["jobs"][0]["statusReason"].should.equal("test_cancel")
+    assert resp["jobs"][0]["jobName"] == "test_job_name"
+    assert resp["jobs"][0]["statusReason"] == "test_cancel"
 
 
 @mock_batch
 def test_state_manager_should_return_registered_model():
-    state_manager.get_registered_models().should.contain("batch::job")
+    assert "batch::job" in state_manager.get_registered_models()
diff --git a/tests/test_moto_api/state_manager/test_managed_state_model.py b/tests/test_moto_api/state_manager/test_managed_state_model.py
index 93fa0f9eb..00f778bd7 100644
--- a/tests/test_moto_api/state_manager/test_managed_state_model.py
+++ b/tests/test_moto_api/state_manager/test_managed_state_model.py
@@ -1,5 +1,3 @@
-import sure  # noqa # pylint: disable=unused-import
-
 from moto.moto_api._internal.managed_state_model import ManagedState
 from moto.moto_api import state_manager
 
@@ -16,13 +14,13 @@ class ExampleModel(ManagedState):
 
 
 def test_initial_state():
-    ExampleModel().status.should.equal("frist_status")
+    assert ExampleModel().status == "frist_status"
 
 
 def test_advancing_without_specifying_configuration_does_nothing():
     model = ExampleModel()
     for _ in range(5):
-        model.status.should.equal("frist_status")
+        assert model.status == "frist_status"
         model.advance()
 
 
@@ -38,11 +36,11 @@ def test_advance_immediately():
         model_name="example::model", transition={"progression": "immediate"}
     )
 
-    model.status.should.equal("fifth")
+    assert model.status == "fifth"
 
     model.advance()
 
-    model.status.should.equal("fifth")
+    assert model.status == "fifth"
 
 
 def test_advance_x_times():
@@ -52,18 +50,18 @@ def test_advance_x_times():
     )
     for _ in range(2):
         model.advance()
-        model.status.should.equal("frist_status")
+        assert model.status == "frist_status"
 
     # 3rd time is a charm
     model.advance()
-    model.status.should.equal("second_status")
+    assert model.status == "second_status"
 
     # Status is still the same if we keep asking for it
-    model.status.should.equal("second_status")
+    assert model.status == "second_status"
 
     # Advancing more does not make a difference - there's nothing to advance to
     model.advance()
-    model.status.should.equal("second_status")
+    assert model.status == "second_status"
 
 
 def test_advance_multiple_stages():
@@ -78,20 +76,20 @@ def test_advance_multiple_stages():
         model_name="example::model", transition={"progression": "manual", "times": 1}
     )
 
-    model.status.should.equal("frist_status")
-    model.status.should.equal("frist_status")
+    assert model.status == "frist_status"
+    assert model.status == "frist_status"
     model.advance()
-    model.status.should.equal("second")
-    model.status.should.equal("second")
+    assert model.status == "second"
+    assert model.status == "second"
     model.advance()
-    model.status.should.equal("third")
-    model.status.should.equal("third")
+    assert model.status == "third"
+    assert model.status == "third"
     model.advance()
-    model.status.should.equal("fourth")
-    model.status.should.equal("fourth")
+    assert model.status == "fourth"
+    assert model.status == "fourth"
     model.advance()
-    model.status.should.equal("fifth")
-    model.status.should.equal("fifth")
+    assert model.status == "fifth"
+    assert model.status == "fifth"
 
 
 def test_override_status():
@@ -102,22 +100,22 @@ def test_override_status():
         model_name="example::model", transition={"progression": "manual", "times": 1}
     )
 
-    model.status.should.equal("creating")
+    assert model.status == "creating"
     model.advance()
-    model.status.should.equal("ready")
+    assert model.status == "ready"
     model.advance()
     # We're still ready
-    model.status.should.equal("ready")
+    assert model.status == "ready"
 
     # Override status manually
     model.status = "updating"
 
-    model.status.should.equal("updating")
+    assert model.status == "updating"
     model.advance()
-    model.status.should.equal("ready")
-    model.status.should.equal("ready")
+    assert model.status == "ready"
+    assert model.status == "ready"
     model.advance()
-    model.status.should.equal("ready")
+    assert model.status == "ready"
 
 
 class SlowModel(ManagedState):
@@ -134,15 +132,15 @@ def test_realworld_delay():
         transition={"progression": "time", "seconds": 2},
     )
 
-    model.status.should.equal("first")
+    assert model.status == "first"
     # The status will stick to 'first' for a long time
     # Advancing the model doesn't do anything, really
     for _ in range(10):
         model.advance()
-        model.status.should.equal("first")
+        assert model.status == "first"
 
     import time
 
     time.sleep(2)
     # Status has only progressed after 2 seconds have passed
-    model.status.should.equal("second")
+    assert model.status == "second"
diff --git a/tests/test_moto_api/state_manager/test_state_manager.py b/tests/test_moto_api/state_manager/test_state_manager.py
index 99c7e30a0..2a4f8c90b 100644
--- a/tests/test_moto_api/state_manager/test_state_manager.py
+++ b/tests/test_moto_api/state_manager/test_state_manager.py
@@ -1,12 +1,10 @@
-import sure  # noqa # pylint: disable=unused-import
-
 from moto.moto_api._internal.state_manager import StateManager
 
 
 def test_public_api():
     from moto.moto_api import state_manager
 
-    state_manager.should.be.a(StateManager)
+    assert isinstance(state_manager, StateManager)
 
 
 def test_default_transition():
@@ -17,7 +15,7 @@ def test_default_transition():
     )
 
     actual = manager.get_transition(model_name="dax::cluster")
-    actual.should.equal({"progression": "manual"})
+    assert actual == {"progression": "manual"}
 
 
 def test_set_transition():
@@ -28,7 +26,7 @@ def test_set_transition():
     )
 
     actual = manager.get_transition(model_name="dax::cluster")
-    actual.should.equal({"progression": "waiter", "wait_times": 3})
+    assert actual == {"progression": "waiter", "wait_times": 3}
 
 
 def test_set_transition_overrides_default():
@@ -43,7 +41,7 @@ def test_set_transition_overrides_default():
     )
 
     actual = manager.get_transition(model_name="dax::cluster")
-    actual.should.equal({"progression": "waiter", "wait_times": 3})
+    assert actual == {"progression": "waiter", "wait_times": 3}
 
 
 def test_unset_transition():
@@ -60,17 +58,17 @@ def test_unset_transition():
     manager.unset_transition(model_name="dax::cluster")
 
     actual = manager.get_transition(model_name="dax::cluster")
-    actual.should.equal({"progression": "manual"})
+    assert actual == {"progression": "manual"}
 
 
 def test_get_default_transition():
     manager = StateManager()
 
     actual = manager.get_transition(model_name="unknown")
-    actual.should.equal({"progression": "immediate"})
+    assert actual == {"progression": "immediate"}
 
 
 def test_get_registered_models():
     manager = StateManager()
 
-    manager.get_registered_models().should.equal([])
+    assert manager.get_registered_models() == []
diff --git a/tests/test_mq/test_mq.py b/tests/test_mq/test_mq.py
index 370cc74d8..85724a456 100644
--- a/tests/test_mq/test_mq.py
+++ b/tests/test_mq/test_mq.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_mq
@@ -23,8 +22,8 @@ def test_create_broker_minimal():
         Users=[{"Username": "admin", "Password": "adm1n"}],
     )
 
-    resp.should.have.key("BrokerId")
-    resp.should.have.key("BrokerArn").match("arn:aws")
+    assert "BrokerId" in resp
+    assert resp["BrokerArn"].startswith("arn:aws")
 
 
 @mock_mq
@@ -44,7 +43,7 @@ def test_create_with_tags():
 
     resp = client.describe_broker(BrokerId=broker_id)
 
-    resp.should.have.key("Tags").equals({"key1": "val2", "key2": "val2"})
+    assert resp["Tags"] == {"key1": "val2", "key2": "val2"}
 
 
 @mock_mq
@@ -75,14 +74,14 @@ def test_create_with_multiple_users():
     )["BrokerId"]
 
     user1 = client.describe_user(BrokerId=broker_id, Username="SecondTest")
-    user1.should.have.key("Username").equals("SecondTest")
-    user1.should.have.key("Groups").equals(["second", "first", "third"])
-    user1.should.have.key("ConsoleAccess").equals(True)
+    assert user1["Username"] == "SecondTest"
+    assert user1["Groups"] == ["second", "first", "third"]
+    assert user1["ConsoleAccess"] is True
 
     user2 = client.describe_user(BrokerId=broker_id, Username="Test")
-    user2.should.have.key("Username").equals("Test")
-    user2.should.have.key("Groups").equals([])
-    user2.should.have.key("ConsoleAccess").equals(False)
+    assert user2["Username"] == "Test"
+    assert user2["Groups"] == []
+    assert user2["ConsoleAccess"] is False
 
 
 @mock_mq
@@ -103,10 +102,8 @@ def test_create_with_configuration():
 
     resp = client.describe_broker(BrokerId=broker_id)
 
-    resp.should.have.key("Configurations")
-    resp["Configurations"].should.have.key("Current").equals(
-        {"Id": "config_id_x", "Revision": 3}
-    )
+    assert "Configurations" in resp
+    assert resp["Configurations"]["Current"] == {"Id": "config_id_x", "Revision": 3}
 
 
 @mock_mq
@@ -131,10 +128,8 @@ def test_update_with_configuration():
 
     resp = client.describe_broker(BrokerId=broker_id)
 
-    resp.should.have.key("Configurations")
-    resp["Configurations"].should.have.key("Current").equals(
-        {"Id": "config_id_x", "Revision": 2}
-    )
+    assert "Configurations" in resp
+    assert resp["Configurations"]["Current"] == {"Id": "config_id_x", "Revision": 2}
 
 
 @mock_mq
@@ -152,9 +147,9 @@ def test_delete_broker():
     )["BrokerId"]
 
     resp = client.delete_broker(BrokerId=broker_id)
-    resp.should.have.key("BrokerId").equals(broker_id)
+    assert resp["BrokerId"] == broker_id
 
-    client.list_brokers().should.have.key("BrokerSummaries").length_of(0)
+    assert len(client.list_brokers()["BrokerSummaries"]) == 0
 
 
 @mock_mq
@@ -187,37 +182,33 @@ def test_describe_broker():
 
     resp = client.describe_broker(BrokerId=broker_id)
 
-    resp.should.have.key("BrokerId").equals(broker_id)
-    resp.should.have.key("BrokerArn").match("arn:aws")
-    resp.should.have.key("BrokerState").equals("RUNNING")
-
-    resp.should.have.key("Created")
-
-    resp.should.have.key("AuthenticationStrategy").equals("SIMPLE")
-    resp.should.have.key("AutoMinorVersionUpgrade").equals(False)
-    resp.should.have.key("BrokerName").equals("testbroker")
-    resp.should.have.key("DeploymentMode").equals("dm")
-    resp.should.have.key("EncryptionOptions").equals(
-        {"KmsKeyId": "kms-key", "UseAwsOwnedKey": False}
-    )
-    resp.should.have.key("EngineType").equals("ACTIVEMQ")
-    resp.should.have.key("EngineVersion").equals("version")
-    resp.should.have.key("HostInstanceType").equals("hit")
-    resp.should.have.key("LdapServerMetadata").equals(
-        {
-            "Hosts": ["host1"],
-            "RoleBase": "role_base_thingy",
-            "RoleSearchMatching": "rsm",
-            "ServiceAccountUsername": "sau",
-            "UserBase": "ub",
-            "UserSearchMatching": "usm",
-        }
-    )
-    resp.should.have.key("PubliclyAccessible").equals(True)
-    resp.should.have.key("SecurityGroups").equals(["secgroup1"])
-    resp.should.have.key("StorageType").equals("efs")
-    resp.should.have.key("SubnetIds").equals(["s-id"])
-    resp.should.have.key("Users").equals([{"Username": "admin"}])
+    assert resp["BrokerId"] == broker_id
+    assert resp["BrokerArn"].startswith("arn:aws")
+    assert resp["BrokerState"] == "RUNNING"
+
+    assert "Created" in resp
+
+    assert resp["AuthenticationStrategy"] == "SIMPLE"
+    assert resp["AutoMinorVersionUpgrade"] is False
+    assert resp["BrokerName"] == "testbroker"
+    assert resp["DeploymentMode"] == "dm"
+    assert resp["EncryptionOptions"] == {"KmsKeyId": "kms-key", "UseAwsOwnedKey": False}
+    assert resp["EngineType"] == "ACTIVEMQ"
+    assert resp["EngineVersion"] == "version"
+    assert resp["HostInstanceType"] == "hit"
+    assert resp["LdapServerMetadata"] == {
+        "Hosts": ["host1"],
+        "RoleBase": "role_base_thingy",
+        "RoleSearchMatching": "rsm",
+        "ServiceAccountUsername": "sau",
+        "UserBase": "ub",
+        "UserSearchMatching": "usm",
+    }
+    assert resp["PubliclyAccessible"] is True
+    assert resp["SecurityGroups"] == ["secgroup1"]
+    assert resp["StorageType"] == "efs"
+    assert resp["SubnetIds"] == ["s-id"]
+    assert resp["Users"] == [{"Username": "admin"}]
 
 
 @mock_mq
@@ -236,22 +227,24 @@ def test_describe_broker_with_defaults():
 
     resp = client.describe_broker(BrokerId=broker_id)
 
-    resp.should.have.key("BrokerInstances").length_of(1)
+    assert len(resp["BrokerInstances"]) == 1
 
-    resp.should.have.key("Configurations")
-    resp["Configurations"].should.have.key("Current")
-    resp["Configurations"].should.have.key("History").length_of(0)
-    resp["Configurations"].shouldnt.have.key("Pending")
+    assert "Configurations" in resp
+    assert "Current" in resp["Configurations"]
+    assert len(resp["Configurations"]["History"]) == 0
+    assert "Pending" not in resp["Configurations"]
 
-    resp.should.have.key("EncryptionOptions").equals({"UseAwsOwnedKey": True})
+    assert resp["EncryptionOptions"] == {"UseAwsOwnedKey": True}
 
-    resp.should.have.key("MaintenanceWindowStartTime").equals(
-        {"DayOfWeek": "Sunday", "TimeOfDay": "00:00", "TimeZone": "UTC"}
-    )
+    assert resp["MaintenanceWindowStartTime"] == {
+        "DayOfWeek": "Sunday",
+        "TimeOfDay": "00:00",
+        "TimeZone": "UTC",
+    }
 
-    resp.should.have.key("Logs").equals({"Audit": False, "General": False})
+    assert resp["Logs"] == {"Audit": False, "General": False}
 
-    resp.should.have.key("SubnetIds").length_of(1)
+    assert len(resp["SubnetIds"]) == 1
 
 
 @mock_mq
@@ -270,14 +263,15 @@ def test_describe_multiple_rabbits():
 
     resp = client.describe_broker(BrokerId=broker_id)
 
-    resp.should.have.key("BrokerInstances")
-    resp["BrokerInstances"][0]["ConsoleURL"].should.equal(
-        "https://0000.mq.us-east-2.amazonaws.com"
+    assert "BrokerInstances" in resp
+    assert (
+        resp["BrokerInstances"][0]["ConsoleURL"]
+        == "https://0000.mq.us-east-2.amazonaws.com"
     )
-    resp["BrokerInstances"][0]["Endpoints"].should.have.length_of(1)
-    resp.shouldnt.have.key("Configurations")
-    resp.should.have.key("Logs").equals({"General": False})
-    resp.should.have.key("SubnetIds").length_of(4)
+    assert len(resp["BrokerInstances"][0]["Endpoints"]) == 1
+    assert "Configurations" not in resp
+    assert resp["Logs"] == {"General": False}
+    assert len(resp["SubnetIds"]) == 4
 
 
 @mock_mq
@@ -297,8 +291,8 @@ def test_describe_active_mq_with_standby():
     resp = client.describe_broker(BrokerId=broker_id)
 
     # Instances and subnets in two regions - one active, one standby
-    resp.should.have.key("BrokerInstances").length_of(2)
-    resp.should.have.key("SubnetIds").length_of(2)
+    assert len(resp["BrokerInstances"]) == 2
+    assert len(resp["SubnetIds"]) == 2
 
 
 @mock_mq
@@ -308,9 +302,10 @@ def test_describe_broker_unknown():
     with pytest.raises(ClientError) as exc:
         client.describe_broker(BrokerId="unknown")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("NotFoundException")
-    err["Message"].should.equal(
-        "Can't find requested broker [unknown]. Make sure your broker exists."
+    assert err["Code"] == "NotFoundException"
+    assert (
+        err["Message"]
+        == "Can't find requested broker [unknown]. Make sure your broker exists."
     )
 
 
@@ -319,7 +314,7 @@ def test_list_brokers_empty():
     client = boto3.client("mq", region_name="eu-west-1")
     resp = client.list_brokers()
 
-    resp.should.have.key("BrokerSummaries").equals([])
+    assert resp["BrokerSummaries"] == []
 
 
 @mock_mq
@@ -338,19 +333,19 @@ def test_list_brokers():
 
     resp = client.list_brokers()
 
-    resp.should.have.key("BrokerSummaries").length_of(1)
+    assert len(resp["BrokerSummaries"]) == 1
 
     summary = resp["BrokerSummaries"][0]
-    summary.should.have.key("BrokerArn")
-    summary.should.have.key("BrokerId").equals(broker_id)
-    summary.should.have.key("BrokerName").equals("testbroker")
-    summary.should.have.key("BrokerState").equals("RUNNING")
-    summary.should.have.key("Created")
-    summary.should.have.key("DeploymentMode").equals("dm")
-    summary.should.have.key("EngineType").equals("ACTIVEMQ")
-    summary.should.have.key("HostInstanceType").equals("hit")
+    assert "BrokerArn" in summary
+    assert summary["BrokerId"] == broker_id
+    assert summary["BrokerName"] == "testbroker"
+    assert summary["BrokerState"] == "RUNNING"
+    assert "Created" in summary
+    assert summary["DeploymentMode"] == "dm"
+    assert summary["EngineType"] == "ACTIVEMQ"
+    assert summary["HostInstanceType"] == "hit"
 
-    summary.shouldnt.have.key("Users")
+    assert "Users" not in summary
 
 
 @mock_mq
@@ -369,11 +364,11 @@ def test_update_broker_single_attribute():
     resp = client.update_broker(AutoMinorVersionUpgrade=True, BrokerId=broker_id)
 
     # Changed
-    resp.should.have.key("AutoMinorVersionUpgrade").equals(True)
+    assert resp["AutoMinorVersionUpgrade"] is True
 
     # Unchanged
-    resp.should.have.key("BrokerId").equals(broker_id)
-    resp.should.have.key("EngineVersion").equals("version")
+    assert resp["BrokerId"] == broker_id
+    assert resp["EngineVersion"] == "version"
 
 
 @mock_mq
@@ -399,13 +394,13 @@ def test_update_broker_multiple_attributes():
     )
 
     # Changed
-    resp.should.have.key("AutoMinorVersionUpgrade").equals(True)
-    resp.should.have.key("Logs").equals({"Audit": True, "General": True})
-    resp.should.have.key("EngineVersion").equals("version2")
-    resp.should.have.key("SecurityGroups").equals(["sg-1", "sg-2"])
+    assert resp["AutoMinorVersionUpgrade"] is True
+    assert resp["Logs"] == {"Audit": True, "General": True}
+    assert resp["EngineVersion"] == "version2"
+    assert resp["SecurityGroups"] == ["sg-1", "sg-2"]
 
     # Unchanged
-    resp.should.have.key("BrokerId").equals(broker_id)
+    assert resp["BrokerId"] == broker_id
 
 
 @mock_mq
diff --git a/tests/test_mq/test_mq_configuration.py b/tests/test_mq/test_mq_configuration.py
index fe8f6a854..cba2f04da 100644
--- a/tests/test_mq/test_mq_configuration.py
+++ b/tests/test_mq/test_mq_configuration.py
@@ -3,7 +3,6 @@ import base64
 
 import boto3
 import pytest
-import sure  # noqa # pylint: disable=unused-import
 
 from botocore.exceptions import ClientError
 from moto import mock_mq
@@ -20,19 +19,20 @@ def test_create_configuration_minimal():
         EngineType="ACTIVEMQ", EngineVersion="rabbit1", Name="myconfig"
     )
 
-    resp.should.have.key("Id").match("^c-")
-    resp.should.have.key("Arn").equals(
-        f"arn:aws:mq:ap-southeast-1:{ACCOUNT_ID}:configuration:{resp['Id']}"
+    assert resp["Id"].startswith("c-")
+    assert (
+        resp["Arn"]
+        == f"arn:aws:mq:ap-southeast-1:{ACCOUNT_ID}:configuration:{resp['Id']}"
     )
-    resp.should.have.key("AuthenticationStrategy").equals("simple")
-    resp.should.have.key("Created")
-    resp.should.have.key("Name").equals("myconfig")
-    resp.should.have.key("LatestRevision")
+    assert resp["AuthenticationStrategy"] == "simple"
+    assert "Created" in resp
+    assert resp["Name"] == "myconfig"
+    assert "LatestRevision" in resp
 
     revision = resp["LatestRevision"]
-    revision.should.have.key("Created")
-    revision.should.have.key("Description")
-    revision.should.have.key("Revision").equals(1)
+    assert "Created" in revision
+    assert "Description" in revision
+    assert revision["Revision"] == 1
 
 
 @mock_mq
@@ -44,9 +44,10 @@ def test_create_configuration_for_rabbitmq():
             EngineType="RABBITMQ", EngineVersion="rabbit1", Name="myconfig"
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("BadRequestException")
-    err["Message"].should.equal(
-        "Broker engine type [RABBITMQ] does not support configuration."
+    assert err["Code"] == "BadRequestException"
+    assert (
+        err["Message"]
+        == "Broker engine type [RABBITMQ] does not support configuration."
     )
 
 
@@ -59,9 +60,10 @@ def test_create_configuration_for_unknown_engine():
             EngineType="unknown", EngineVersion="rabbit1", Name="myconfig"
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("BadRequestException")
-    err["Message"].should.equal(
-        "Broker engine type [unknown] is invalid. Valid values are: [ACTIVEMQ]"
+    assert err["Code"] == "BadRequestException"
+    assert (
+        err["Message"]
+        == "Broker engine type [unknown] is invalid. Valid values are: [ACTIVEMQ]"
     )
 
 
@@ -74,19 +76,19 @@ def test_describe_configuration():
 
     resp = client.describe_configuration(ConfigurationId=config_id)
 
-    resp.should.have.key("Id").match("^c-")
-    resp.should.have.key("Arn").equals(
-        f"arn:aws:mq:eu-north-1:{ACCOUNT_ID}:configuration:{resp['Id']}"
+    assert resp["Id"].startswith("c-")
+    assert (
+        resp["Arn"] == f"arn:aws:mq:eu-north-1:{ACCOUNT_ID}:configuration:{resp['Id']}"
     )
-    resp.should.have.key("AuthenticationStrategy").equals("simple")
-    resp.should.have.key("Created")
-    resp.should.have.key("Name").equals("myconfig")
-    resp.should.have.key("LatestRevision")
+    assert resp["AuthenticationStrategy"] == "simple"
+    assert "Created" in resp
+    assert resp["Name"] == "myconfig"
+    assert "LatestRevision" in resp
 
     revision = resp["LatestRevision"]
-    revision.should.have.key("Created")
-    revision.should.have.key("Description")
-    revision.should.have.key("Revision").equals(1)
+    assert "Created" in revision
+    assert "Description" in revision
+    assert revision["Revision"] == 1
 
 
 @mock_mq
@@ -100,13 +102,13 @@ def test_describe_configuration_revision():
         ConfigurationId=config_id, ConfigurationRevision="1"
     )
 
-    resp.should.have.key("ConfigurationId").equals(config_id)
-    resp.should.have.key("Created")
-    resp.should.have.key("Description").equals(
-        "Auto-generated default for myconfig on ActiveMQ 5.16.3"
+    assert resp["ConfigurationId"] == config_id
+    assert "Created" in resp
+    assert (
+        resp["Description"] == "Auto-generated default for myconfig on ActiveMQ 5.16.3"
     )
 
-    resp.should.have.key("Data")
+    assert "Data" in resp
 
 
 @mock_mq
@@ -117,9 +119,10 @@ def test_describe_configuration_unknown():
         client.describe_configuration(ConfigurationId="c-unknown")
     err = exc.value.response["Error"]
 
-    err["Code"].should.equal("NotFoundException")
-    err["Message"].should.equal(
-        "Can't find requested configuration [c-unknown]. Make sure your configuration exists."
+    assert err["Code"] == "NotFoundException"
+    assert (
+        err["Message"]
+        == "Can't find requested configuration [c-unknown]. Make sure your configuration exists."
     )
 
 
@@ -129,7 +132,7 @@ def test_list_configurations_empty():
 
     resp = client.list_configurations()
 
-    resp.should.have.key("Configurations").equals([])
+    assert resp["Configurations"] == []
 
 
 @mock_mq
@@ -141,15 +144,15 @@ def test_list_configurations():
 
     resp = client.list_configurations()
 
-    resp.should.have.key("Configurations").length_of(1)
+    assert len(resp["Configurations"]) == 1
 
     config = resp["Configurations"][0]
-    config.should.have.key("Arn").match("arn:aws")
-    config.should.have.key("Created")
-    config.should.have.key("Id").equals(config_id)
-    config.should.have.key("Name").equals("myconfig")
-    config.should.have.key("EngineType").equals("ACTIVEMQ")
-    config.should.have.key("EngineVersion").equals("active1")
+    assert config["Arn"].startswith("arn:aws")
+    assert "Created" in config
+    assert config["Id"] == config_id
+    assert config["Name"] == "myconfig"
+    assert config["EngineType"] == "ACTIVEMQ"
+    assert config["EngineVersion"] == "active1"
 
 
 @mock_mq
@@ -165,16 +168,16 @@ def test_update_configuration():
         Description="updated config",
     )
 
-    resp.should.have.key("Arn").match("arn:aws:mq")
-    resp.should.have.key("Created")
-    resp.should.have.key("Id")
-    resp.should.have.key("Name").equals("myconfig")
-    resp.should.have.key("LatestRevision")
+    assert resp["Arn"].startswith("arn:aws:mq")
+    assert "Created" in resp
+    assert "Id" in resp
+    assert resp["Name"] == "myconfig"
+    assert "LatestRevision" in resp
 
     revision = resp["LatestRevision"]
-    revision.should.have.key("Created")
-    revision.should.have.key("Description").equals("updated config")
-    revision.should.have.key("Revision").equals(2)
+    assert "Created" in revision
+    assert revision["Description"] == "updated config"
+    assert revision["Revision"] == 2
 
 
 @mock_mq
@@ -207,4 +210,4 @@ def test_update_configuration_to_ldap():
 
     resp = client.describe_configuration(ConfigurationId=config_id)
 
-    resp.should.have.key("AuthenticationStrategy").equals("ldap")
+    assert resp["AuthenticationStrategy"] == "ldap"
diff --git a/tests/test_mq/test_mq_tags.py b/tests/test_mq/test_mq_tags.py
index ccf109834..6dd94b8ba 100644
--- a/tests/test_mq/test_mq_tags.py
+++ b/tests/test_mq/test_mq_tags.py
@@ -1,5 +1,4 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 
 from moto import mock_mq
 
@@ -21,7 +20,7 @@ def test_create_broker_with_tags():
 
     resp = client.describe_broker(BrokerId=broker_id)
 
-    resp.should.have.key("Tags").equals({"key1": "val2", "key2": "val2"})
+    assert resp["Tags"] == {"key1": "val2", "key2": "val2"}
 
 
 @mock_mq
@@ -45,7 +44,7 @@ def test_create_tags():
 
     resp = client.describe_broker(BrokerId=broker_id)
 
-    resp.should.have.key("Tags").equals({"key1": "val2", "key2": "val2"})
+    assert resp["Tags"] == {"key1": "val2", "key2": "val2"}
 
 
 @mock_mq
@@ -71,7 +70,7 @@ def test_delete_tags():
 
     resp = client.describe_broker(BrokerId=broker_id)
 
-    resp.should.have.key("Tags").equals({"key2": "val2"})
+    assert resp["Tags"] == {"key2": "val2"}
 
 
 @mock_mq
@@ -85,11 +84,11 @@ def test_create_configuration_with_tags():
     )
 
     # The CreateConfiguration call does not return tags
-    resp.shouldnt.have.key("Tags")
+    assert "Tags" not in resp
 
     # Only when describing will they be returned
     resp = client.describe_configuration(ConfigurationId=resp["Id"])
-    resp.should.have.key("Tags").equals({"key1": "val1", "key2": "val2"})
+    assert resp["Tags"] == {"key1": "val1", "key2": "val2"}
 
 
 @mock_mq
@@ -106,4 +105,4 @@ def test_add_tags_to_configuration():
 
     # Only when describing will they be returned
     resp = client.describe_configuration(ConfigurationId=resp["Id"])
-    resp.should.have.key("Tags").equals({"key1": "val1", "key2": "val2"})
+    assert resp["Tags"] == {"key1": "val1", "key2": "val2"}
diff --git a/tests/test_mq/test_mq_users.py b/tests/test_mq/test_mq_users.py
index 4c3f04099..5584fee27 100644
--- a/tests/test_mq/test_mq_users.py
+++ b/tests/test_mq/test_mq_users.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_mq
@@ -24,7 +23,7 @@ def test_create_user():
 
     resp = client.describe_broker(BrokerId=broker_id)
 
-    resp.should.have.key("Users").equals([{"Username": "admin"}])
+    assert resp["Users"] == [{"Username": "admin"}]
 
 
 @mock_mq
@@ -51,10 +50,10 @@ def test_describe_user():
 
     resp = client.describe_user(BrokerId=broker_id, Username="admin")
 
-    resp.should.have.key("BrokerId").equals(broker_id)
-    resp.should.have.key("ConsoleAccess").equals(True)
-    resp.should.have.key("Groups").equals(["group1", "group2"])
-    resp.should.have.key("Username").equals("admin")
+    assert resp["BrokerId"] == broker_id
+    assert resp["ConsoleAccess"] is True
+    assert resp["Groups"] == ["group1", "group2"]
+    assert resp["Username"] == "admin"
 
 
 @mock_mq
@@ -74,9 +73,10 @@ def test_describe_user_unknown():
     with pytest.raises(ClientError) as exc:
         client.describe_user(BrokerId=broker_id, Username="unknown")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("NotFoundException")
-    err["Message"].should.equal(
-        "Can't find requested user [unknown]. Make sure your user exists."
+    assert err["Code"] == "NotFoundException"
+    assert (
+        err["Message"]
+        == "Can't find requested user [unknown]. Make sure your user exists."
     )
 
 
@@ -96,8 +96,8 @@ def test_list_users_empty():
 
     resp = client.list_users(BrokerId=broker_id)
 
-    resp.should.have.key("BrokerId").equals(broker_id)
-    resp.should.have.key("Users").equals([])
+    assert resp["BrokerId"] == broker_id
+    assert resp["Users"] == []
 
 
 @mock_mq
@@ -118,10 +118,10 @@ def test_list_users():
 
     resp = client.list_users(BrokerId=broker_id)
 
-    resp.should.have.key("BrokerId").equals(broker_id)
-    resp.should.have.key("Users").length_of(2)
-    resp["Users"].should.contain({"Username": "admin"})
-    resp["Users"].should.contain({"Username": "user1"})
+    assert resp["BrokerId"] == broker_id
+    assert len(resp["Users"]) == 2
+    assert {"Username": "admin"} in resp["Users"]
+    assert {"Username": "user1"} in resp["Users"]
 
 
 @mock_mq
@@ -142,9 +142,9 @@ def test_update_user():
 
     resp = client.describe_user(BrokerId=broker_id, Username="admin")
 
-    resp.should.have.key("BrokerId").equals(broker_id)
-    resp.should.have.key("Groups").equals(["administrators"])
-    resp.should.have.key("Username").equals("admin")
+    assert resp["BrokerId"] == broker_id
+    assert resp["Groups"] == ["administrators"]
+    assert resp["Username"] == "admin"
 
 
 @mock_mq
@@ -167,6 +167,6 @@ def test_delete_user():
 
     resp = client.list_users(BrokerId=broker_id)
 
-    resp.should.have.key("BrokerId").equals(broker_id)
-    resp.should.have.key("Users").length_of(1)
-    resp["Users"].should.contain({"Username": "user1"})
+    assert resp["BrokerId"] == broker_id
+    assert len(resp["Users"]) == 1
+    assert {"Username": "user1"} in resp["Users"]
diff --git a/tests/test_mq/test_server.py b/tests/test_mq/test_server.py
index b667e1145..4842ca270 100644
--- a/tests/test_mq/test_server.py
+++ b/tests/test_mq/test_server.py
@@ -1,5 +1,4 @@
 import json
-import sure  # noqa # pylint: disable=unused-import
 
 from moto import mock_mq
 import moto.server as server
@@ -11,5 +10,5 @@ def test_mq_list():
     test_client = backend.test_client()
 
     resp = test_client.get("/v1/brokers")
-    resp.status_code.should.equal(200)
-    json.loads(resp.data).should.equal({"brokerSummaries": []})
+    assert resp.status_code == 200
+    assert json.loads(resp.data) == {"brokerSummaries": []}
diff --git a/tests/test_neptune/test_cluster_options.py b/tests/test_neptune/test_cluster_options.py
index c30f88a2d..12869305c 100644
--- a/tests/test_neptune/test_cluster_options.py
+++ b/tests/test_neptune/test_cluster_options.py
@@ -1,5 +1,4 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 from moto import mock_neptune
 
 
@@ -9,14 +8,14 @@ def test_db_cluster_options():
     # We're not checking the exact data here, that is already done in TF
     client = boto3.client("neptune", region_name="us-east-1")
     response = client.describe_orderable_db_instance_options(Engine="neptune")
-    response["OrderableDBInstanceOptions"].should.have.length_of(286)
+    assert len(response["OrderableDBInstanceOptions"]) == 286
 
     response = client.describe_orderable_db_instance_options(
         Engine="neptune", EngineVersion="1.0.2.1"
     )
-    response["OrderableDBInstanceOptions"].should.have.length_of(0)
+    assert len(response["OrderableDBInstanceOptions"]) == 0
 
     response = client.describe_orderable_db_instance_options(
         Engine="neptune", EngineVersion="1.0.3.0"
     )
-    response["OrderableDBInstanceOptions"].should.have.length_of(12)
+    assert len(response["OrderableDBInstanceOptions"]) == 12
diff --git a/tests/test_neptune/test_cluster_tags.py b/tests/test_neptune/test_cluster_tags.py
index 195e7599d..0c2651c86 100644
--- a/tests/test_neptune/test_cluster_tags.py
+++ b/tests/test_neptune/test_cluster_tags.py
@@ -17,9 +17,9 @@ def test_add_tags_to_cluster():
     )
 
     tags = conn.list_tags_for_resource(ResourceName=cluster_arn)["TagList"]
-    tags.should.equal([{"Key": "k1", "Value": "v1"}, {"Key": "k2", "Value": "v2"}])
+    assert tags == [{"Key": "k1", "Value": "v1"}, {"Key": "k2", "Value": "v2"}]
 
     conn.remove_tags_from_resource(ResourceName=cluster_arn, TagKeys=["k1"])
 
     tags = conn.list_tags_for_resource(ResourceName=cluster_arn)["TagList"]
-    tags.should.equal([{"Key": "k2", "Value": "v2"}])
+    assert tags == [{"Key": "k2", "Value": "v2"}]
diff --git a/tests/test_neptune/test_clusters.py b/tests/test_neptune/test_clusters.py
index 18602a582..04f9827ca 100644
--- a/tests/test_neptune/test_clusters.py
+++ b/tests/test_neptune/test_clusters.py
@@ -1,7 +1,6 @@
 """Unit tests for neptune-supported APIs."""
 import boto3
 import pytest
-import sure  # noqa # pylint: disable=unused-import
 from botocore.exceptions import ClientError
 from moto import mock_neptune
 
@@ -15,23 +14,21 @@ def test_create_db_cluster():
     resp = client.create_db_cluster(DBClusterIdentifier="cluster-id", Engine="neptune")[
         "DBCluster"
     ]
-    resp.should.have.key("DBClusterIdentifier").equals("cluster-id")
-    resp.should.have.key("DbClusterResourceId")
-    resp.should.have.key("DBClusterArn")
-    resp.should.have.key("Engine").equals("neptune")
-    resp.should.have.key("EngineVersion").equals("1.2.0.2")
-    resp.should.have.key("StorageEncrypted").equals(True)
-    resp.should.have.key("DBClusterParameterGroup").equals("")
-    resp.should.have.key("Endpoint")
-    resp.should.have.key("DbClusterResourceId").match("cluster-")
-    resp.should.have.key("AvailabilityZones").equals(
-        ["us-east-2a", "us-east-2b", "us-east-2c"]
-    )
-    resp.shouldnt.have.key("ServerlessV2ScalingConfiguration")
+    assert resp["DBClusterIdentifier"] == "cluster-id"
+    assert "DbClusterResourceId" in resp
+    assert "DBClusterArn" in resp
+    assert resp["Engine"] == "neptune"
+    assert resp["EngineVersion"] == "1.2.0.2"
+    assert resp["StorageEncrypted"] is True
+    assert resp["DBClusterParameterGroup"] == ""
+    assert "Endpoint" in resp
+    assert "cluster-" in resp["DbClusterResourceId"]
+    assert resp["AvailabilityZones"] == ["us-east-2a", "us-east-2b", "us-east-2c"]
+    assert "ServerlessV2ScalingConfiguration" not in resp
 
     # Double check this cluster is not available in another region
     europe_client = boto3.client("neptune", region_name="eu-west-2")
-    europe_client.describe_db_clusters()["DBClusters"].should.have.length_of(0)
+    assert len(europe_client.describe_db_clusters()["DBClusters"]) == 0
 
 
 @mock_neptune
@@ -47,29 +44,30 @@ def test_create_db_cluster__with_additional_params():
         ServerlessV2ScalingConfiguration={"MinCapacity": 1.0, "MaxCapacity": 2.0},
         DatabaseName="sth",
     )["DBCluster"]
-    resp.should.have.key("StorageEncrypted").equals(False)
-    resp.should.have.key("DBClusterParameterGroup").equals("myprm")
-    resp.should.have.key("EngineVersion").equals("1.1.0.1")
-    resp.should.have.key("KmsKeyId").equals("key")
-    resp.should.have.key("ServerlessV2ScalingConfiguration").equals(
-        {"MinCapacity": 1.0, "MaxCapacity": 2.0}
-    )
-    resp.should.have.key("DatabaseName").equals("sth")
+    assert resp["StorageEncrypted"] is False
+    assert resp["DBClusterParameterGroup"] == "myprm"
+    assert resp["EngineVersion"] == "1.1.0.1"
+    assert resp["KmsKeyId"] == "key"
+    assert resp["ServerlessV2ScalingConfiguration"] == {
+        "MinCapacity": 1.0,
+        "MaxCapacity": 2.0,
+    }
+    assert resp["DatabaseName"] == "sth"
 
 
 @mock_neptune
 def test_describe_db_clusters():
     client = boto3.client("neptune", region_name="ap-southeast-1")
-    client.describe_db_clusters()["DBClusters"].should.equal([])
+    assert client.describe_db_clusters()["DBClusters"] == []
 
     client.create_db_cluster(DBClusterIdentifier="cluster-id", Engine="neptune")
 
     clusters = client.describe_db_clusters(DBClusterIdentifier="cluster-id")[
         "DBClusters"
     ]
-    clusters.should.have.length_of(1)
-    clusters[0]["DBClusterIdentifier"].should.equal("cluster-id")
-    clusters[0].should.have.key("Engine").equals("neptune")
+    assert len(clusters) == 1
+    assert clusters[0]["DBClusterIdentifier"] == "cluster-id"
+    assert clusters[0]["Engine"] == "neptune"
 
 
 @mock_neptune
@@ -79,7 +77,7 @@ def test_delete_db_cluster():
     client.create_db_cluster(DBClusterIdentifier="cluster-id", Engine="neptune")
     client.delete_db_cluster(DBClusterIdentifier="cluster-id")
 
-    client.describe_db_clusters()["DBClusters"].should.equal([])
+    assert client.describe_db_clusters()["DBClusters"] == []
 
 
 @mock_neptune
@@ -89,7 +87,7 @@ def test_delete_unknown_db_cluster():
     with pytest.raises(ClientError) as exc:
         client.delete_db_cluster(DBClusterIdentifier="unknown-id")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("DBClusterNotFoundFault")
+    assert err["Code"] == "DBClusterNotFoundFault"
 
 
 @mock_neptune
@@ -102,9 +100,9 @@ def test_modify_db_cluster():
         DBClusterParameterGroupName="myprm",
         PreferredBackupWindow="window",
     )["DBCluster"]
-    resp.should.have.key("DBClusterParameterGroup").equals("myprm")
-    resp.should.have.key("EngineVersion").equals("1.1.0.1")
-    resp.should.have.key("PreferredBackupWindow").equals("window")
+    assert resp["DBClusterParameterGroup"] == "myprm"
+    assert resp["EngineVersion"] == "1.1.0.1"
+    assert resp["PreferredBackupWindow"] == "window"
 
 
 @mock_neptune
@@ -115,4 +113,4 @@ def test_start_db_cluster():
     ]
 
     cluster = client.start_db_cluster(DBClusterIdentifier="cluster-id")["DBCluster"]
-    cluster.should.have.key("Status").equals("started")
+    assert cluster["Status"] == "started"
diff --git a/tests/test_neptune/test_global_clusters.py b/tests/test_neptune/test_global_clusters.py
index 83f4d5a9b..3198b0e2f 100644
--- a/tests/test_neptune/test_global_clusters.py
+++ b/tests/test_neptune/test_global_clusters.py
@@ -1,12 +1,11 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 from moto import mock_neptune
 
 
 @mock_neptune
 def test_describe():
     client = boto3.client("neptune", "us-east-2")
-    client.describe_global_clusters()["GlobalClusters"].should.equal([])
+    assert client.describe_global_clusters()["GlobalClusters"] == []
 
 
 @mock_neptune
@@ -15,19 +14,19 @@ def test_create_global_cluster():
     resp = client.create_global_cluster(
         GlobalClusterIdentifier="g-id", Engine="neptune"
     )["GlobalCluster"]
-    resp.should.have.key("GlobalClusterIdentifier").equals("g-id")
-    resp.should.have.key("GlobalClusterResourceId")
-    resp.should.have.key("GlobalClusterArn")
-    resp.should.have.key("Engine").equals("neptune")
-    resp.should.have.key("EngineVersion").equals("1.2.0.0")
-    resp.should.have.key("StorageEncrypted").equals(False)
-    resp.should.have.key("DeletionProtection").equals(False)
+    assert resp["GlobalClusterIdentifier"] == "g-id"
+    assert "GlobalClusterResourceId" in resp
+    assert "GlobalClusterArn" in resp
+    assert resp["Engine"] == "neptune"
+    assert resp["EngineVersion"] == "1.2.0.0"
+    assert resp["StorageEncrypted"] is False
+    assert resp["DeletionProtection"] is False
 
-    client.describe_global_clusters()["GlobalClusters"].should.have.length_of(1)
+    assert len(client.describe_global_clusters()["GlobalClusters"]) == 1
 
     # As a global cluster, verify it can be retrieved everywhere
     europe_client = boto3.client("neptune", "eu-north-1")
-    europe_client.describe_global_clusters()["GlobalClusters"].should.have.length_of(1)
+    assert len(europe_client.describe_global_clusters()["GlobalClusters"]) == 1
 
 
 @mock_neptune
@@ -40,10 +39,10 @@ def test_create_global_cluster_with_additional_params():
         DeletionProtection=True,
         StorageEncrypted=True,
     )["GlobalCluster"]
-    resp.should.have.key("Engine").equals("neptune")
-    resp.should.have.key("EngineVersion").equals("1.0")
-    resp.should.have.key("StorageEncrypted").equals(True)
-    resp.should.have.key("DeletionProtection").equals(True)
+    assert resp["Engine"] == "neptune"
+    assert resp["EngineVersion"] == "1.0"
+    assert resp["StorageEncrypted"] is True
+    assert resp["DeletionProtection"] is True
 
 
 @mock_neptune
@@ -53,4 +52,4 @@ def test_delete_global_cluster():
 
     client.delete_global_cluster(GlobalClusterIdentifier="g-id2")
 
-    client.describe_global_clusters()["GlobalClusters"].should.equal([])
+    assert client.describe_global_clusters()["GlobalClusters"] == []
diff --git a/tests/test_transcribe/test_transcribe_boto3.py b/tests/test_transcribe/test_transcribe_boto3.py
index d64af5462..a39d8156d 100644
--- a/tests/test_transcribe/test_transcribe_boto3.py
+++ b/tests/test_transcribe/test_transcribe_boto3.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 import boto3
-import sure  # noqa # pylint: disable=unused-import
+import pytest
 
 from moto import mock_transcribe
 
@@ -21,55 +21,56 @@ def test_run_medical_transcription_job_minimal_params():
         "Type": "CONVERSATION",
     }
     resp = client.start_medical_transcription_job(**args)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
     # CREATED
     resp = client.get_medical_transcription_job(MedicalTranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["MedicalTranscriptionJob"]
-    transcription_job["MedicalTranscriptionJobName"].should.equal(
+    assert transcription_job["MedicalTranscriptionJobName"] == (
         args["MedicalTranscriptionJobName"]
     )
-    transcription_job["TranscriptionJobStatus"].should.equal("QUEUED")
-    transcription_job["LanguageCode"].should.equal(args["LanguageCode"])
-    transcription_job["Media"].should.equal(args["Media"])
-    transcription_job.should.contain("CreationTime")
-    transcription_job.doesnt.contain("StartTime")
-    transcription_job.doesnt.contain("CompletionTime")
-    transcription_job.doesnt.contain("Transcript")
-    transcription_job["Settings"]["ChannelIdentification"].should.equal(False)
-    transcription_job["Settings"]["ShowAlternatives"].should.equal(False)
-    transcription_job["Specialty"].should.equal(args["Specialty"])
-    transcription_job["Type"].should.equal(args["Type"])
+    assert transcription_job["TranscriptionJobStatus"] == "QUEUED"
+    assert transcription_job["LanguageCode"] == args["LanguageCode"]
+    assert transcription_job["Media"] == args["Media"]
+    assert "CreationTime" in transcription_job
+    assert "StartTime" not in transcription_job
+    assert "CompletionTime" not in transcription_job
+    assert "Transcript" not in transcription_job
+    assert transcription_job["Settings"]["ChannelIdentification"] is False
+    assert transcription_job["Settings"]["ShowAlternatives"] is False
+    assert transcription_job["Specialty"] == args["Specialty"]
+    assert transcription_job["Type"] == args["Type"]
 
     # IN_PROGRESS
     resp = client.get_medical_transcription_job(MedicalTranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["MedicalTranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("IN_PROGRESS")
-    transcription_job["MediaFormat"].should.equal("wav")
-    transcription_job.should.contain("StartTime")
-    transcription_job.doesnt.contain("CompletionTime")
-    transcription_job.doesnt.contain("Transcript")
-    transcription_job["MediaSampleRateHertz"].should.equal(44100)
+    assert transcription_job["TranscriptionJobStatus"] == "IN_PROGRESS"
+    assert transcription_job["MediaFormat"] == "wav"
+    assert "StartTime" in transcription_job
+    assert "CompletionTime" not in transcription_job
+    assert "Transcript" not in transcription_job
+    assert transcription_job["MediaSampleRateHertz"] == 44100
 
     # COMPLETED
     resp = client.get_medical_transcription_job(MedicalTranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["MedicalTranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("COMPLETED")
-    transcription_job.should.contain("CompletionTime")
-    transcription_job["Transcript"].should.equal(
-        {
-            "TranscriptFileUri": f"https://s3.{region_name}.amazonaws.com/{args['OutputBucketName']}/medical/{args['MedicalTranscriptionJobName']}.json"
-        }
-    )
+    assert transcription_job["TranscriptionJobStatus"] == "COMPLETED"
+    assert "CompletionTime" in transcription_job
+    assert transcription_job["Transcript"] == {
+        "TranscriptFileUri": (
+            f"https://s3.{region_name}.amazonaws.com"
+            f"/{args['OutputBucketName']}/medical"
+            f"/{args['MedicalTranscriptionJobName']}.json"
+        ),
+    }
 
     # Delete
     client.delete_medical_transcription_job(MedicalTranscriptionJobName=job_name)
-    client.get_medical_transcription_job.when.called_with(
-        MedicalTranscriptionJobName=job_name
-    ).should.throw(client.exceptions.BadRequestException)
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.get_medical_transcription_job(MedicalTranscriptionJobName=job_name)
 
 
 @mock_transcribe
@@ -84,7 +85,7 @@ def test_run_medical_transcription_job_all_params():
         LanguageCode="en-US",
         VocabularyFileUri="https://s3.us-east-1.amazonaws.com/AWSDOC-EXAMPLE-BUCKET/vocab.txt",
     )
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
     job_name = "MyJob2"
     args = {
@@ -94,7 +95,10 @@ def test_run_medical_transcription_job_all_params():
         "MediaFormat": "flac",
         "Media": {"MediaFileUri": "s3://my-bucket/my-media-file.dat"},
         "OutputBucketName": "my-output-bucket",
-        "OutputEncryptionKMSKeyId": "arn:aws:kms:us-east-1:012345678901:key/37111b5e-8eff-4706-ae3a-d4f9d1d559fc",
+        "OutputEncryptionKMSKeyId": (
+            "arn:aws:kms:us-east-1:012345678901:key"
+            "/37111b5e-8eff-4706-ae3a-d4f9d1d559fc"
+        ),
         "Settings": {
             "ShowSpeakerLabels": True,
             "MaxSpeakerLabels": 5,
@@ -107,66 +111,68 @@ def test_run_medical_transcription_job_all_params():
         "Type": "CONVERSATION",
     }
     resp = client.start_medical_transcription_job(**args)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
     # CREATED
     resp = client.get_medical_transcription_job(MedicalTranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["MedicalTranscriptionJob"]
-    transcription_job["MedicalTranscriptionJobName"].should.equal(
+    assert transcription_job["MedicalTranscriptionJobName"] == (
         args["MedicalTranscriptionJobName"]
     )
-    transcription_job["TranscriptionJobStatus"].should.equal("QUEUED")
-    transcription_job["LanguageCode"].should.equal(args["LanguageCode"])
-    transcription_job["Media"].should.equal(args["Media"])
-    transcription_job.should.contain("CreationTime")
-    transcription_job.doesnt.contain("StartTime")
-    transcription_job.doesnt.contain("CompletionTime")
-    transcription_job.doesnt.contain("Transcript")
-    transcription_job["Settings"]["ShowSpeakerLabels"].should.equal(
+    assert transcription_job["TranscriptionJobStatus"] == "QUEUED"
+    assert transcription_job["LanguageCode"] == args["LanguageCode"]
+    assert transcription_job["Media"] == args["Media"]
+    assert "CreationTime" in transcription_job
+    assert "StartTime" not in transcription_job
+    assert "CompletionTime" not in transcription_job
+    assert "Transcript" not in transcription_job
+    assert transcription_job["Settings"]["ShowSpeakerLabels"] == (
         args["Settings"]["ShowSpeakerLabels"]
     )
-    transcription_job["Settings"]["MaxSpeakerLabels"].should.equal(
+    assert transcription_job["Settings"]["MaxSpeakerLabels"] == (
         args["Settings"]["MaxSpeakerLabels"]
     )
-    transcription_job["Settings"]["ChannelIdentification"].should.equal(
+    assert transcription_job["Settings"]["ChannelIdentification"] == (
         args["Settings"]["ChannelIdentification"]
     )
-    transcription_job["Settings"]["ShowAlternatives"].should.equal(
+    assert transcription_job["Settings"]["ShowAlternatives"] == (
         args["Settings"]["ShowAlternatives"]
     )
-    transcription_job["Settings"]["MaxAlternatives"].should.equal(
+    assert transcription_job["Settings"]["MaxAlternatives"] == (
         args["Settings"]["MaxAlternatives"]
     )
-    transcription_job["Settings"]["VocabularyName"].should.equal(
+    assert transcription_job["Settings"]["VocabularyName"] == (
         args["Settings"]["VocabularyName"]
     )
 
-    transcription_job["Specialty"].should.equal(args["Specialty"])
-    transcription_job["Type"].should.equal(args["Type"])
+    assert transcription_job["Specialty"] == args["Specialty"]
+    assert transcription_job["Type"] == args["Type"]
 
     # IN_PROGRESS
     resp = client.get_medical_transcription_job(MedicalTranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["MedicalTranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("IN_PROGRESS")
-    transcription_job["MediaFormat"].should.equal("flac")
-    transcription_job.should.contain("StartTime")
-    transcription_job.doesnt.contain("CompletionTime")
-    transcription_job.doesnt.contain("Transcript")
-    transcription_job["MediaSampleRateHertz"].should.equal(48000)
+    assert transcription_job["TranscriptionJobStatus"] == "IN_PROGRESS"
+    assert transcription_job["MediaFormat"] == "flac"
+    assert "StartTime" in transcription_job
+    assert "CompletionTime" not in transcription_job
+    assert "Transcript" not in transcription_job
+    assert transcription_job["MediaSampleRateHertz"] == 48000
 
     # COMPLETED
     resp = client.get_medical_transcription_job(MedicalTranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["MedicalTranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("COMPLETED")
-    transcription_job.should.contain("CompletionTime")
-    transcription_job["Transcript"].should.equal(
-        {
-            "TranscriptFileUri": f"https://s3.{region_name}.amazonaws.com/{args['OutputBucketName']}/medical/{args['MedicalTranscriptionJobName']}.json"
-        }
-    )
+    assert transcription_job["TranscriptionJobStatus"] == "COMPLETED"
+    assert "CompletionTime" in transcription_job
+    assert transcription_job["Transcript"] == {
+        "TranscriptFileUri": (
+            f"https://s3.{region_name}.amazonaws.com"
+            f"/{args['OutputBucketName']}/medical"
+            f"/{args['MedicalTranscriptionJobName']}.json"
+        ),
+    }
 
 
 @mock_transcribe
@@ -181,7 +187,7 @@ def test_run_transcription_job_all_params():
         LanguageCode="en-US",
         VocabularyFileUri="https://s3.us-east-1.amazonaws.com/AWSDOC-EXAMPLE-BUCKET/vocab.txt",
     )
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
     job_name = "MyJob2"
     args = {
@@ -191,7 +197,10 @@ def test_run_transcription_job_all_params():
         "MediaFormat": "flac",
         "Media": {"MediaFileUri": "s3://my-bucket/my-media-file.dat"},
         "OutputBucketName": "my-output-bucket",
-        "OutputEncryptionKMSKeyId": "arn:aws:kms:us-east-1:012345678901:key/37111b5e-8eff-4706-ae3a-d4f9d1d559fc",
+        "OutputEncryptionKMSKeyId": (
+            "arn:aws:kms:us-east-1:012345678901:key"
+            "/37111b5e-8eff-4706-ae3a-d4f9d1d559fc"
+        ),
         "Settings": {
             "ShowSpeakerLabels": True,
             "MaxSpeakerLabels": 5,
@@ -200,63 +209,66 @@ def test_run_transcription_job_all_params():
             "MaxAlternatives": 6,
             "VocabularyName": vocabulary_name,
         },
-        # Missing `ContentRedaction`, `JobExecutionSettings`, `VocabularyFilterName`, `LanguageModel`
+        # Missing `ContentRedaction`, `JobExecutionSettings`,
+        # `VocabularyFilterName`, `LanguageModel`
     }
     resp = client.start_transcription_job(**args)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
     # CREATED
     resp = client.get_transcription_job(TranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job["TranscriptionJobName"].should.equal(args["TranscriptionJobName"])
-    transcription_job["TranscriptionJobStatus"].should.equal("QUEUED")
-    transcription_job["LanguageCode"].should.equal(args["LanguageCode"])
-    transcription_job["Media"].should.equal(args["Media"])
-    transcription_job.should.contain("CreationTime")
-    transcription_job.doesnt.contain("StartTime")
-    transcription_job.doesnt.contain("CompletionTime")
-    transcription_job.doesnt.contain("Transcript")
-    transcription_job["Settings"]["ShowSpeakerLabels"].should.equal(
+    assert transcription_job["TranscriptionJobName"] == args["TranscriptionJobName"]
+    assert transcription_job["TranscriptionJobStatus"] == "QUEUED"
+    assert transcription_job["LanguageCode"] == args["LanguageCode"]
+    assert transcription_job["Media"] == args["Media"]
+    assert "CreationTime" in transcription_job
+    assert "StartTime" not in transcription_job
+    assert "CompletionTime" not in transcription_job
+    assert "Transcript" not in transcription_job
+    assert transcription_job["Settings"]["ShowSpeakerLabels"] == (
         args["Settings"]["ShowSpeakerLabels"]
     )
-    transcription_job["Settings"]["MaxSpeakerLabels"].should.equal(
+    assert transcription_job["Settings"]["MaxSpeakerLabels"] == (
         args["Settings"]["MaxSpeakerLabels"]
     )
-    transcription_job["Settings"]["ChannelIdentification"].should.equal(
+    assert transcription_job["Settings"]["ChannelIdentification"] == (
         args["Settings"]["ChannelIdentification"]
     )
-    transcription_job["Settings"]["ShowAlternatives"].should.equal(
+    assert transcription_job["Settings"]["ShowAlternatives"] == (
         args["Settings"]["ShowAlternatives"]
     )
-    transcription_job["Settings"]["MaxAlternatives"].should.equal(
+    assert transcription_job["Settings"]["MaxAlternatives"] == (
         args["Settings"]["MaxAlternatives"]
     )
-    transcription_job["Settings"]["VocabularyName"].should.equal(
+    assert transcription_job["Settings"]["VocabularyName"] == (
         args["Settings"]["VocabularyName"]
     )
     # IN_PROGRESS
     resp = client.get_transcription_job(TranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("IN_PROGRESS")
-    transcription_job["MediaFormat"].should.equal("flac")
-    transcription_job.should.contain("StartTime")
-    transcription_job.doesnt.contain("CompletionTime")
-    transcription_job.doesnt.contain("Transcript")
-    transcription_job["MediaSampleRateHertz"].should.equal(48000)
+    assert transcription_job["TranscriptionJobStatus"] == "IN_PROGRESS"
+    assert transcription_job["MediaFormat"] == "flac"
+    assert "StartTime" in transcription_job
+    assert "CompletionTime" not in transcription_job
+    assert "Transcript" not in transcription_job
+    assert transcription_job["MediaSampleRateHertz"] == 48000
 
     # COMPLETED
     resp = client.get_transcription_job(TranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("COMPLETED")
-    transcription_job.should.contain("CompletionTime")
-    transcription_job["Transcript"].should.equal(
-        {
-            "TranscriptFileUri": f"https://s3.{region_name}.amazonaws.com/{args['OutputBucketName']}/{args['TranscriptionJobName']}.json"
-        }
-    )
+    assert transcription_job["TranscriptionJobStatus"] == "COMPLETED"
+    assert "CompletionTime" in transcription_job
+    assert transcription_job["Transcript"] == {
+        "TranscriptFileUri": (
+            f"https://s3.{region_name}.amazonaws.com"
+            f"/{args['OutputBucketName']}"
+            f"/{args['TranscriptionJobName']}.json"
+        ),
+    }
 
 
 @mock_transcribe
@@ -272,57 +284,56 @@ def test_run_transcription_job_minimal_params():
         "Media": {"MediaFileUri": "s3://my-bucket/my-media-file.wav"},
     }
     resp = client.start_transcription_job(**args)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job.should.contain("Settings")
-    transcription_job["Settings"]["ChannelIdentification"].should.equal(False)
-    transcription_job["Settings"]["ShowAlternatives"].should.equal(False)
+    assert "Settings" in transcription_job
+    assert transcription_job["Settings"]["ChannelIdentification"] is False
+    assert transcription_job["Settings"]["ShowAlternatives"] is False
 
     # CREATED
     resp = client.get_transcription_job(TranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job["TranscriptionJobName"].should.equal(args["TranscriptionJobName"])
-    transcription_job["TranscriptionJobStatus"].should.equal("QUEUED")
-    transcription_job["LanguageCode"].should.equal(args["LanguageCode"])
-    transcription_job["Media"].should.equal(args["Media"])
-    transcription_job.should.contain("Settings")
-    transcription_job["Settings"]["ChannelIdentification"].should.equal(False)
-    transcription_job["Settings"]["ShowAlternatives"].should.equal(False)
-    transcription_job.should.contain("CreationTime")
-    transcription_job.doesnt.contain("StartTime")
-    transcription_job.doesnt.contain("CompletionTime")
-    transcription_job.doesnt.contain("Transcript")
+    assert transcription_job["TranscriptionJobName"] == args["TranscriptionJobName"]
+    assert transcription_job["TranscriptionJobStatus"] == "QUEUED"
+    assert transcription_job["LanguageCode"] == args["LanguageCode"]
+    assert transcription_job["Media"] == args["Media"]
+    assert "Settings" in transcription_job
+    assert transcription_job["Settings"]["ChannelIdentification"] is False
+    assert transcription_job["Settings"]["ShowAlternatives"] is False
+    assert "CreationTime" in transcription_job
+    assert "StartTime" not in transcription_job
+    assert "CompletionTime" not in transcription_job
+    assert "Transcript" not in transcription_job
 
     # QUEUED
     resp = client.get_transcription_job(TranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("IN_PROGRESS")
-    transcription_job.should.contain("CreationTime")
-    transcription_job.should.contain("StartTime")
-    transcription_job.doesnt.contain("CompletionTime")
-    transcription_job.doesnt.contain("Transcript")
+    assert transcription_job["TranscriptionJobStatus"] == "IN_PROGRESS"
+    assert "CreationTime" in transcription_job
+    assert "StartTime" in transcription_job
+    assert "CompletionTime" not in transcription_job
+    assert "Transcript" not in transcription_job
 
     # IN_PROGESS
     resp = client.get_transcription_job(TranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("COMPLETED")
-    transcription_job.should.contain("CreationTime")
-    transcription_job.should.contain("StartTime")
-    transcription_job.should.contain("CompletionTime")
-    transcription_job.should.contain("Transcript")
+    assert transcription_job["TranscriptionJobStatus"] == "COMPLETED"
+    assert "CreationTime" in transcription_job
+    assert "StartTime" in transcription_job
+    assert "CompletionTime" in transcription_job
+    assert "Transcript" in transcription_job
     # Check aws hosted bucket
-    transcription_job["Transcript"]["TranscriptFileUri"].should.contain(
+    assert (
         f"https://s3.{region_name}.amazonaws.com/aws-transcribe-{region_name}-prod/"
-    )
+    ) in transcription_job["Transcript"]["TranscriptFileUri"]
 
     # Delete
     client.delete_transcription_job(TranscriptionJobName=job_name)
-    client.get_transcription_job.when.called_with(
-        TranscriptionJobName=job_name
-    ).should.throw(client.exceptions.BadRequestException)
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.get_transcription_job(TranscriptionJobName=job_name)
 
 
 @mock_transcribe
@@ -340,36 +351,36 @@ def test_run_transcription_job_s3output_params():
         "OutputKey": "bucket-key",
     }
     resp = client.start_transcription_job(**args)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
     # CREATED
     resp = client.get_transcription_job(TranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job["TranscriptionJobName"].should.equal(args["TranscriptionJobName"])
-    transcription_job["TranscriptionJobStatus"].should.equal("QUEUED")
+    assert transcription_job["TranscriptionJobName"] == args["TranscriptionJobName"]
+    assert transcription_job["TranscriptionJobStatus"] == "QUEUED"
     # ... already tested in test_run_transcription_job_minimal_awsoutput_params
 
     # QUEUED
     resp = client.get_transcription_job(TranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("IN_PROGRESS")
+    assert transcription_job["TranscriptionJobStatus"] == "IN_PROGRESS"
     # ... already tested in test_run_transcription_job_minimal_awsoutput_params
 
     # IN_PROGESS
     resp = client.get_transcription_job(TranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("COMPLETED")
-    transcription_job.should.contain("CreationTime")
-    transcription_job.should.contain("StartTime")
-    transcription_job.should.contain("CompletionTime")
-    transcription_job.should.contain("Transcript")
+    assert transcription_job["TranscriptionJobStatus"] == "COMPLETED"
+    assert "CreationTime" in transcription_job
+    assert "StartTime" in transcription_job
+    assert "CompletionTime" in transcription_job
+    assert "Transcript" in transcription_job
     # Check aws hosted bucket
-    transcription_job["Transcript"]["TranscriptFileUri"].should.contain(
+    assert (
         "https://s3.us-east-1.amazonaws.com/my-output-bucket/bucket-key/MyJob.json"
-    )
+    ) in transcription_job["Transcript"]["TranscriptFileUri"]
     # A new job without an "OutputKey"
     job_name = "MyJob2"
     args = {
@@ -383,15 +394,15 @@ def test_run_transcription_job_s3output_params():
     client.get_transcription_job(TranscriptionJobName=job_name)
     client.get_transcription_job(TranscriptionJobName=job_name)
     resp = client.get_transcription_job(TranscriptionJobName=job_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
     transcription_job = resp["TranscriptionJob"]
-    transcription_job["TranscriptionJobStatus"].should.equal("COMPLETED")
-    transcription_job.should.contain("CreationTime")
-    transcription_job.should.contain("StartTime")
-    transcription_job.should.contain("CompletionTime")
-    transcription_job.should.contain("Transcript")
+    assert transcription_job["TranscriptionJobStatus"] == "COMPLETED"
+    assert "CreationTime" in transcription_job
+    assert "StartTime" in transcription_job
+    assert "CompletionTime" in transcription_job
+    assert "Transcript" in transcription_job
     # Check aws hosted bucket
-    transcription_job["Transcript"]["TranscriptFileUri"].should.equal(
+    assert transcription_job["Transcript"]["TranscriptFileUri"] == (
         "https://s3.us-east-1.amazonaws.com/my-output-bucket/MyJob2.json"
     )
 
@@ -417,20 +428,20 @@ def test_run_transcription_job_identify_languages_params():
         client.list_transcription_jobs(),  # IN_PROGRESS
     ]
     for resp in resp_data:
-        resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+        assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
         if "TranscriptionJob" in resp:
             transcription_job = resp["TranscriptionJob"]
         elif "TranscriptionJobSummaries" in resp:
             transcription_job = resp["TranscriptionJobSummaries"][0]
-        transcription_job.should.contain("IdentifyLanguage")
-        transcription_job.should_not.contain("LanguageCodes")
-        transcription_job.should_not.contain("IdentifyMultipleLanguages")
+        assert "IdentifyLanguage" in transcription_job
+        assert "LanguageCodes" not in transcription_job
+        assert "IdentifyMultipleLanguages" not in transcription_job
         if "TranscriptionJobStatus" in transcription_job and (
             transcription_job["TranscriptionJobStatus"] == "IN_PROGRESS"
             or transcription_job["TranscriptionJobStatus"] == "COMPLETED"
         ):
-            transcription_job["LanguageCode"].should.equal("en-US")
-            transcription_job["IdentifiedLanguageScore"].should.equal(0.999645948)
+            assert transcription_job["LanguageCode"] == "en-US"
+            assert transcription_job["IdentifiedLanguageScore"] == 0.999645948
 
     # IdentifyMultipleLanguages
     job_name = "MyJob2"
@@ -447,27 +458,23 @@ def test_run_transcription_job_identify_languages_params():
         client.list_transcription_jobs(),  # IN_PROGRESS
     ]
     for resp in resp_data:
-        resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+        assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
         if "TranscriptionJob" in resp:
             transcription_job = resp["TranscriptionJob"]
         elif "TranscriptionJobSummaries" in resp:
             transcription_job = resp["TranscriptionJobSummaries"][1]
-        transcription_job.should.contain("IdentifyMultipleLanguages")
-        transcription_job.should_not.contain("LanguageCode")
-        transcription_job.should_not.contain("IdentifyLanguage")
+        assert "IdentifyMultipleLanguages" in transcription_job
+        assert "LanguageCode" not in transcription_job
+        assert "IdentifyLanguage" not in transcription_job
         if "TranscriptionJobStatus" in transcription_job and (
             transcription_job["TranscriptionJobStatus"] == "IN_PROGRESS"
             or transcription_job["TranscriptionJobStatus"] == "COMPLETED"
         ):
-            transcription_job["LanguageCodes"][0]["LanguageCode"].should.equal("en-US")
-            transcription_job["LanguageCodes"][0]["DurationInSeconds"].should.equal(
-                123.0
-            )
-            transcription_job["LanguageCodes"][1]["LanguageCode"].should.equal("en-GB")
-            transcription_job["LanguageCodes"][1]["DurationInSeconds"].should.equal(
-                321.0
-            )
-            transcription_job["IdentifiedLanguageScore"].should.equal(0.999645948)
+            assert transcription_job["LanguageCodes"][0]["LanguageCode"] == "en-US"
+            assert transcription_job["LanguageCodes"][0]["DurationInSeconds"] == 123.0
+            assert transcription_job["LanguageCodes"][1]["LanguageCode"] == "en-GB"
+            assert transcription_job["LanguageCodes"][1]["DurationInSeconds"] == 321.0
+            assert transcription_job["IdentifiedLanguageScore"] == 0.999645948
 
 
 @mock_transcribe
@@ -475,9 +482,10 @@ def test_get_nonexistent_medical_transcription_job():
     region_name = "us-east-1"
     client = boto3.client("transcribe", region_name=region_name)
 
-    client.get_medical_transcription_job.when.called_with(
-        MedicalTranscriptionJobName="NonexistentJobName"
-    ).should.throw(client.exceptions.BadRequestException)
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.get_medical_transcription_job(
+            MedicalTranscriptionJobName="NonexistentJobName"
+        )
 
 
 @mock_transcribe
@@ -485,9 +493,8 @@ def test_get_nonexistent_transcription_job():
     region_name = "us-east-1"
     client = boto3.client("transcribe", region_name=region_name)
 
-    client.get_transcription_job.when.called_with(
-        TranscriptionJobName="NonexistentJobName"
-    ).should.throw(client.exceptions.BadRequestException)
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.get_transcription_job(TranscriptionJobName="NonexistentJobName")
 
 
 @mock_transcribe
@@ -506,11 +513,10 @@ def test_run_medical_transcription_job_with_existing_job_name():
         "Type": "CONVERSATION",
     }
     resp = client.start_medical_transcription_job(**args)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
-    client.start_medical_transcription_job.when.called_with(**args).should.throw(
-        client.exceptions.ConflictException
-    )
+    with pytest.raises(client.exceptions.ConflictException):
+        client.start_medical_transcription_job(**args)
 
 
 @mock_transcribe
@@ -526,11 +532,10 @@ def test_run_transcription_job_with_existing_job_name():
         "Media": {"MediaFileUri": "s3://my-bucket/my-media-file.wav"},
     }
     resp = client.start_transcription_job(**args)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
-    client.start_transcription_job.when.called_with(**args).should.throw(
-        client.exceptions.ConflictException
-    )
+    with pytest.raises(client.exceptions.ConflictException):
+        client.start_transcription_job(**args)
 
 
 @mock_transcribe
@@ -549,9 +554,8 @@ def test_run_medical_transcription_job_nonexistent_vocabulary():
         "Specialty": "PRIMARYCARE",
         "Type": "CONVERSATION",
     }
-    client.start_medical_transcription_job.when.called_with(**args).should.throw(
-        client.exceptions.BadRequestException
-    )
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.start_medical_transcription_job(**args)
 
 
 @mock_transcribe
@@ -568,9 +572,8 @@ def test_run_transcription_job_nonexistent_vocabulary():
         "OutputBucketName": "my-output-bucket",
         "Settings": {"VocabularyName": "NonexistentVocabulary"},
     }
-    client.start_transcription_job.when.called_with(**args).should.throw(
-        client.exceptions.BadRequestException
-    )
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.start_transcription_job(**args)
 
 
 @mock_transcribe
@@ -590,7 +593,7 @@ def test_list_medical_transcription_jobs():
             "Type": "CONVERSATION",
         }
         resp = client.start_medical_transcription_job(**args)
-        resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+        assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
         # IMPLICITLY PROMOTE JOB STATUS TO QUEUED
         resp = client.get_medical_transcription_job(
@@ -623,46 +626,46 @@ def test_list_medical_transcription_jobs():
 
     # List all
     response = client.list_medical_transcription_jobs()
-    response.should.contain("MedicalTranscriptionJobSummaries")
-    len(response["MedicalTranscriptionJobSummaries"]).should.equal(30)
-    response.shouldnt.contain("NextToken")
-    response.shouldnt.contain("Status")
+    assert "MedicalTranscriptionJobSummaries" in response
+    assert len(response["MedicalTranscriptionJobSummaries"]) == 30
+    assert "NextToken" not in response
+    assert "Status" not in response
 
     # List IN_PROGRESS
     response = client.list_medical_transcription_jobs(Status="IN_PROGRESS")
-    response.should.contain("MedicalTranscriptionJobSummaries")
-    len(response["MedicalTranscriptionJobSummaries"]).should.equal(10)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("Status")
-    response["Status"].should.equal("IN_PROGRESS")
+    assert "MedicalTranscriptionJobSummaries" in response
+    assert len(response["MedicalTranscriptionJobSummaries"]) == 10
+    assert "NextToken" not in response
+    assert "Status" in response
+    assert response["Status"] == "IN_PROGRESS"
 
     # List JobName contains "8"
     response = client.list_medical_transcription_jobs(JobNameContains="8")
-    response.should.contain("MedicalTranscriptionJobSummaries")
-    len(response["MedicalTranscriptionJobSummaries"]).should.equal(3)
-    response.shouldnt.contain("NextToken")
-    response.shouldnt.contain("Status")
+    assert "MedicalTranscriptionJobSummaries" in response
+    assert len(response["MedicalTranscriptionJobSummaries"]) == 3
+    assert "NextToken" not in response
+    assert "Status" not in response
 
     # Pagination by 11
     response = client.list_medical_transcription_jobs(MaxResults=11)
-    response.should.contain("MedicalTranscriptionJobSummaries")
-    len(response["MedicalTranscriptionJobSummaries"]).should.equal(11)
-    response.should.contain("NextToken")
-    response.shouldnt.contain("Status")
+    assert "MedicalTranscriptionJobSummaries" in response
+    assert len(response["MedicalTranscriptionJobSummaries"]) == 11
+    assert "NextToken" in response
+    assert "Status" not in response
 
     response = client.list_medical_transcription_jobs(
         NextToken=response["NextToken"], MaxResults=11
     )
-    response.should.contain("MedicalTranscriptionJobSummaries")
-    len(response["MedicalTranscriptionJobSummaries"]).should.equal(11)
-    response.should.contain("NextToken")
+    assert "MedicalTranscriptionJobSummaries" in response
+    assert len(response["MedicalTranscriptionJobSummaries"]) == 11
+    assert "NextToken" in response
 
     response = client.list_medical_transcription_jobs(
         NextToken=response["NextToken"], MaxResults=11
     )
-    response.should.contain("MedicalTranscriptionJobSummaries")
-    len(response["MedicalTranscriptionJobSummaries"]).should.equal(8)
-    response.shouldnt.contain("NextToken")
+    assert "MedicalTranscriptionJobSummaries" in response
+    assert len(response["MedicalTranscriptionJobSummaries"]) == 8
+    assert "NextToken" not in response
 
 
 @mock_transcribe
@@ -680,7 +683,7 @@ def test_list_transcription_jobs():
             "IdentifyLanguage": True,
         }
         resp = client.start_transcription_job(**args)
-        resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+        assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
         # IMPLICITLY PROMOTE JOB STATUS TO QUEUED
         resp = client.get_transcription_job(TranscriptionJobName=job_name)
@@ -707,46 +710,46 @@ def test_list_transcription_jobs():
 
     # List all
     response = client.list_transcription_jobs()
-    response.should.contain("TranscriptionJobSummaries")
-    len(response["TranscriptionJobSummaries"]).should.equal(30)
-    response.shouldnt.contain("NextToken")
-    response.shouldnt.contain("Status")
+    assert "TranscriptionJobSummaries" in response
+    assert len(response["TranscriptionJobSummaries"]) == 30
+    assert "NextToken" not in response
+    assert "Status" not in response
 
     # List IN_PROGRESS
     response = client.list_transcription_jobs(Status="IN_PROGRESS")
-    response.should.contain("TranscriptionJobSummaries")
-    len(response["TranscriptionJobSummaries"]).should.equal(10)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("Status")
-    response["Status"].should.equal("IN_PROGRESS")
+    assert "TranscriptionJobSummaries" in response
+    assert len(response["TranscriptionJobSummaries"]) == 10
+    assert "NextToken" not in response
+    assert "Status" in response
+    assert response["Status"] == "IN_PROGRESS"
 
     # List JobName contains "8"
     response = client.list_transcription_jobs(JobNameContains="8")
-    response.should.contain("TranscriptionJobSummaries")
-    len(response["TranscriptionJobSummaries"]).should.equal(3)
-    response.shouldnt.contain("NextToken")
-    response.shouldnt.contain("Status")
+    assert "TranscriptionJobSummaries" in response
+    assert len(response["TranscriptionJobSummaries"]) == 3
+    assert "NextToken" not in response
+    assert "Status" not in response
 
     # Pagination by 11
     response = client.list_transcription_jobs(MaxResults=11)
-    response.should.contain("TranscriptionJobSummaries")
-    len(response["TranscriptionJobSummaries"]).should.equal(11)
-    response.should.contain("NextToken")
-    response.shouldnt.contain("Status")
+    assert "TranscriptionJobSummaries" in response
+    assert len(response["TranscriptionJobSummaries"]) == 11
+    assert "NextToken" in response
+    assert "Status" not in response
 
     response = client.list_transcription_jobs(
         NextToken=response["NextToken"], MaxResults=11
     )
-    response.should.contain("TranscriptionJobSummaries")
-    len(response["TranscriptionJobSummaries"]).should.equal(11)
-    response.should.contain("NextToken")
+    assert "TranscriptionJobSummaries" in response
+    assert len(response["TranscriptionJobSummaries"]) == 11
+    assert "NextToken" in response
 
     response = client.list_transcription_jobs(
         NextToken=response["NextToken"], MaxResults=11
     )
-    response.should.contain("TranscriptionJobSummaries")
-    len(response["TranscriptionJobSummaries"]).should.equal(8)
-    response.shouldnt.contain("NextToken")
+    assert "TranscriptionJobSummaries" in response
+    assert len(response["TranscriptionJobSummaries"]) == 8
+    assert "NextToken" not in response
 
 
 @mock_transcribe
@@ -761,28 +764,27 @@ def test_create_medical_vocabulary():
         LanguageCode="en-US",
         VocabularyFileUri="https://s3.us-east-1.amazonaws.com/AWSDOC-EXAMPLE-BUCKET/vocab.txt",
     )
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
     # PENDING
     resp = client.get_medical_vocabulary(VocabularyName=vocabulary_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    resp["VocabularyName"].should.equal(vocabulary_name)
-    resp["LanguageCode"].should.equal("en-US")
-    resp["VocabularyState"].should.equal("PENDING")
-    resp.should.contain("LastModifiedTime")
-    resp.shouldnt.contain("FailureReason")
-    resp["DownloadUri"].should.contain(vocabulary_name)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert resp["VocabularyName"] == vocabulary_name
+    assert resp["LanguageCode"] == "en-US"
+    assert resp["VocabularyState"] == "PENDING"
+    assert "LastModifiedTime" in resp
+    assert "FailureReason" not in resp
+    assert vocabulary_name in resp["DownloadUri"]
 
     # IN_PROGRESS
     resp = client.get_medical_vocabulary(VocabularyName=vocabulary_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    resp["VocabularyState"].should.equal("READY")
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert resp["VocabularyState"] == "READY"
 
     # Delete
     client.delete_medical_vocabulary(VocabularyName=vocabulary_name)
-    client.get_medical_vocabulary.when.called_with(
-        VocabularyName=vocabulary_name
-    ).should.throw(client.exceptions.BadRequestException)
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.get_medical_vocabulary(VocabularyName=vocabulary_name)
 
 
 @mock_transcribe
@@ -797,28 +799,27 @@ def test_create_vocabulary():
         LanguageCode="en-US",
         VocabularyFileUri="https://s3.us-east-1.amazonaws.com/AWSDOC-EXAMPLE-BUCKET/vocab.txt",
     )
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
     # PENDING
     resp = client.get_vocabulary(VocabularyName=vocabulary_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    resp["VocabularyName"].should.equal(vocabulary_name)
-    resp["LanguageCode"].should.equal("en-US")
-    resp["VocabularyState"].should.equal("PENDING")
-    resp.should.contain("LastModifiedTime")
-    resp.shouldnt.contain("FailureReason")
-    resp["DownloadUri"].should.contain(vocabulary_name)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert resp["VocabularyName"] == vocabulary_name
+    assert resp["LanguageCode"] == "en-US"
+    assert resp["VocabularyState"] == "PENDING"
+    assert "LastModifiedTime" in resp
+    assert "FailureReason" not in resp
+    assert vocabulary_name in resp["DownloadUri"]
 
     # IN_PROGRESS
     resp = client.get_vocabulary(VocabularyName=vocabulary_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    resp["VocabularyState"].should.equal("READY")
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert resp["VocabularyState"] == "READY"
 
     # Delete
     client.delete_vocabulary(VocabularyName=vocabulary_name)
-    client.get_vocabulary.when.called_with(VocabularyName=vocabulary_name).should.throw(
-        client.exceptions.BadRequestException
-    )
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.get_vocabulary(VocabularyName=vocabulary_name)
 
     # Create another vocabulary with Phrases
     client.create_vocabulary(
@@ -827,18 +828,18 @@ def test_create_vocabulary():
         Phrases=["moto", "is", "awesome"],
     )
     resp = client.get_vocabulary(VocabularyName=vocabulary_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    resp["VocabularyName"].should.equal(vocabulary_name)
-    resp["LanguageCode"].should.equal("en-US")
-    resp["VocabularyState"].should.equal("PENDING")
-    resp["DownloadUri"].should.contain(vocabulary_name)
-    resp["DownloadUri"].should.contain(
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert resp["VocabularyName"] == vocabulary_name
+    assert resp["LanguageCode"] == "en-US"
+    assert resp["VocabularyState"] == "PENDING"
+    assert vocabulary_name in resp["DownloadUri"]
+    assert (
         f"https://s3.{region_name}.amazonaws.com/aws-transcribe-dictionary-model-{region_name}-prod"
-    )
+    ) in resp["DownloadUri"]
     # IN_PROGRESS
     resp = client.get_vocabulary(VocabularyName=vocabulary_name)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    resp["VocabularyState"].should.equal("READY")
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert resp["VocabularyState"] == "READY"
 
 
 @mock_transcribe
@@ -855,7 +856,7 @@ def test_list_vocabularies():
             "Phrases": ["moto", "is", "awesome"],
         }
         resp = client.create_vocabulary(**args)
-        resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+        assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
         # Forward to "PENDING"
         resp = client.get_vocabulary(VocabularyName=vocabulary_name)
@@ -874,54 +875,54 @@ def test_list_vocabularies():
 
     # List all
     response = client.list_vocabularies()
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(15)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 15
+    assert "NextToken" not in response
+    assert "ResponseMetadata" in response
 
     # List PENDING
     response = client.list_vocabularies(StateEquals="PENDING")
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(5)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 5
+    assert "NextToken" not in response
+    assert "ResponseMetadata" in response
 
     # List READY
     response = client.list_vocabularies(StateEquals="READY")
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(10)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 10
+    assert "NextToken" not in response
+    assert "ResponseMetadata" in response
 
     # List VocabularyName contains "8"
     response = client.list_vocabularies(NameContains="8")
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(1)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 1
+    assert "NextToken" not in response
+    assert "ResponseMetadata" in response
 
     # Pagination by 3
     response = client.list_vocabularies(MaxResults=3)
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(3)
-    response.should.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 3
+    assert "NextToken" in response
+    assert "ResponseMetadata" in response
 
     response = client.list_vocabularies(NextToken=response["NextToken"], MaxResults=3)
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(3)
-    response.should.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 3
+    assert "NextToken" in response
+    assert "ResponseMetadata" in response
 
     response = client.list_vocabularies(NextToken=response["NextToken"], MaxResults=30)
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(9)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 9
+    assert "NextToken" not in response
+    assert "ResponseMetadata" in response
 
     client.delete_vocabulary(VocabularyName="Vocab_5")
     response = client.list_vocabularies()
-    len(response["Vocabularies"]).should.equal(14)
+    assert len(response["Vocabularies"]) == 14
 
 
 @mock_transcribe
@@ -937,7 +938,7 @@ def test_list_medical_vocabularies():
             LanguageCode="en-US",
             VocabularyFileUri="https://s3.us-east-1.amazonaws.com/AWSDOC-EXAMPLE-BUCKET/vocab.txt",
         )
-        resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+        assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
         # Forward to "PENDING"
         resp = client.get_medical_vocabulary(VocabularyName=vocabulary_name)
@@ -956,58 +957,58 @@ def test_list_medical_vocabularies():
 
     # List all
     response = client.list_medical_vocabularies()
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(15)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 15
+    assert "NextToken" not in response
+    assert "ResponseMetadata" in response
 
     # List PENDING
     response = client.list_medical_vocabularies(StateEquals="PENDING")
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(5)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 5
+    assert "NextToken" not in response
+    assert "ResponseMetadata" in response
 
     # List READY
     response = client.list_medical_vocabularies(StateEquals="READY")
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(10)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 10
+    assert "NextToken" not in response
+    assert "ResponseMetadata" in response
 
     # List VocabularyName contains "8"
     response = client.list_medical_vocabularies(NameContains="8")
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(1)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 1
+    assert "NextToken" not in response
+    assert "ResponseMetadata" in response
 
     # Pagination by 3
     response = client.list_medical_vocabularies(MaxResults=3)
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(3)
-    response.should.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 3
+    assert "NextToken" in response
+    assert "ResponseMetadata" in response
 
     response = client.list_medical_vocabularies(
         NextToken=response["NextToken"], MaxResults=3
     )
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(3)
-    response.should.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 3
+    assert "NextToken" in response
+    assert "ResponseMetadata" in response
 
     response = client.list_medical_vocabularies(
         NextToken=response["NextToken"], MaxResults=30
     )
-    response.should.contain("Vocabularies")
-    len(response["Vocabularies"]).should.equal(9)
-    response.shouldnt.contain("NextToken")
-    response.should.contain("ResponseMetadata")
+    assert "Vocabularies" in response
+    assert len(response["Vocabularies"]) == 9
+    assert "NextToken" not in response
+    assert "ResponseMetadata" in response
 
     client.delete_medical_vocabulary(VocabularyName="Vocab_5")
     response = client.list_medical_vocabularies()
-    len(response["Vocabularies"]).should.equal(14)
+    assert len(response["Vocabularies"]) == 14
 
 
 @mock_transcribe
@@ -1015,9 +1016,8 @@ def test_get_nonexistent_medical_vocabulary():
     region_name = "us-east-1"
     client = boto3.client("transcribe", region_name=region_name)
 
-    client.get_medical_vocabulary.when.called_with(
-        VocabularyName="NonexistentVocabularyName"
-    ).should.throw(client.exceptions.BadRequestException)
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.get_medical_vocabulary(VocabularyName="NonexistentVocabularyName")
 
 
 @mock_transcribe
@@ -1025,9 +1025,8 @@ def test_get_nonexistent_vocabulary():
     region_name = "us-east-1"
     client = boto3.client("transcribe", region_name=region_name)
 
-    client.get_vocabulary.when.called_with(
-        VocabularyName="NonexistentVocabularyName"
-    ).should.throw(client.exceptions.BadRequestException)
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.get_vocabulary(VocabularyName="NonexistentVocabularyName")
 
 
 @mock_transcribe
@@ -1043,11 +1042,10 @@ def test_create_medical_vocabulary_with_existing_vocabulary_name():
         "VocabularyFileUri": "https://s3.us-east-1.amazonaws.com/AWSDOC-EXAMPLE-BUCKET/vocab.txt",
     }
     resp = client.create_medical_vocabulary(**args)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
-    client.create_medical_vocabulary.when.called_with(**args).should.throw(
-        client.exceptions.ConflictException
-    )
+    with pytest.raises(client.exceptions.ConflictException):
+        client.create_medical_vocabulary(**args)
 
 
 @mock_transcribe
@@ -1063,11 +1061,10 @@ def test_create_vocabulary_with_existing_vocabulary_name():
         "VocabularyFileUri": "https://s3.us-east-1.amazonaws.com/AWSDOC-EXAMPLE-BUCKET/vocab.txt",
     }
     resp = client.create_vocabulary(**args)
-    resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
-    client.create_vocabulary.when.called_with(**args).should.throw(
-        client.exceptions.ConflictException
-    )
+    with pytest.raises(client.exceptions.ConflictException):
+        client.create_vocabulary(**args)
 
 
 @mock_transcribe
@@ -1081,14 +1078,13 @@ def test_create_vocabulary_with_bad_request():
         "VocabularyName": vocabulary_name,
         "LanguageCode": "en-US",
     }
-    client.create_vocabulary.when.called_with(**args).should.throw(
-        client.exceptions.BadRequestException
-    )
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.create_vocabulary(**args)
+
     args = {
         "VocabularyName": vocabulary_name,
         "Phrases": [],
         "LanguageCode": "en-US",
     }
-    client.create_vocabulary.when.called_with(**args).should.throw(
-        client.exceptions.BadRequestException
-    )
+    with pytest.raises(client.exceptions.BadRequestException):
+        client.create_vocabulary(**args)
diff --git a/tests/test_utilities/test_docker_utilities.py b/tests/test_utilities/test_docker_utilities.py
index a7687a4f4..59d03b0a0 100644
--- a/tests/test_utilities/test_docker_utilities.py
+++ b/tests/test_utilities/test_docker_utilities.py
@@ -1,4 +1,3 @@
-import sure  # noqa # pylint: disable=unused-import
 import pytest
 
 from moto.utilities.docker_utilities import parse_image_ref
@@ -19,13 +18,11 @@ from moto.utilities.docker_utilities import parse_image_ref
     ],
 )
 def test_parse_image_ref(image_name, expected):
-    expected.should.be.equal(parse_image_ref(image_name))
+    assert expected == parse_image_ref(image_name)
 
 
 def test_parse_image_ref_default_container_registry(monkeypatch):
     import moto.settings
 
     monkeypatch.setattr(moto.settings, "DEFAULT_CONTAINER_REGISTRY", "quay.io")
-    ("quay.io/centos/centos", "latest").should.be.equal(
-        parse_image_ref("centos/centos")
-    )
+    assert ("quay.io/centos/centos", "latest") == parse_image_ref("centos/centos")
diff --git a/tests/test_utilities/test_paginator.py b/tests/test_utilities/test_paginator.py
index ed612e6a4..57ac62c67 100644
--- a/tests/test_utilities/test_paginator.py
+++ b/tests/test_utilities/test_paginator.py
@@ -1,7 +1,7 @@
 import unittest
 
 import pytest
-import sure  # noqa # pylint: disable=unused-import
+
 from moto.utilities.paginator import Paginator, paginate
 from moto.core.exceptions import InvalidToken
 
@@ -31,11 +31,11 @@ def test_paginator_without_max_results__throws_error():
 def test_paginator__paginate_with_just_max_results():
     p = Paginator(max_results=50)
     resp = p.paginate(results)
-    resp.should.have.length_of(2)
+    assert len(resp) == 2
 
     page, next_token = resp
-    next_token.should.equal(None)
-    page.should.equal(results)
+    assert next_token is None
+    assert page == results
 
 
 def test_paginator__paginate_without_range_key__throws_error():
@@ -53,11 +53,11 @@ def test_paginator__paginate_with_unknown_range_key__throws_error():
 def test_paginator__paginate_5():
     p = Paginator(max_results=5, unique_attribute=["name"])
     resp = p.paginate(results)
-    resp.should.have.length_of(2)
+    assert len(resp) == 2
 
     page, next_token = resp
-    next_token.shouldnt.equal(None)
-    page.should.equal(results[0:5])
+    assert next_token is not None
+    assert page == results[0:5]
 
 
 def test_paginator__paginate_5__use_different_range_keys():
@@ -67,19 +67,19 @@ def test_paginator__paginate_5__use_different_range_keys():
     p = Paginator(max_results=5, unique_attribute=["name"])
     _, token_as_lst = p.paginate(results)
 
-    token_as_lst.shouldnt.be(None)
-    token_as_lst.should.equal(token_as_str)
+    assert token_as_lst is not None
+    assert token_as_lst == token_as_str
 
     p = Paginator(max_results=5, unique_attribute=["name", "arn"])
     _, token_multiple = p.paginate(results)
-    token_multiple.shouldnt.be(None)
-    token_multiple.shouldnt.equal(token_as_str)
+    assert token_multiple is not None
+    assert token_multiple != token_as_str
 
 
 def test_paginator__paginate_twice():
     p = Paginator(max_results=5, unique_attribute=["name"])
     resp = p.paginate(results)
-    resp.should.have.length_of(2)
+    assert len(resp) == 2
 
     page, next_token = resp
 
@@ -87,8 +87,8 @@ def test_paginator__paginate_twice():
     resp = p.paginate(results)
 
     page, next_token = resp
-    next_token.should.equal(None)
-    page.should.equal(results[5:])
+    assert next_token is None
+    assert page == results[5:]
 
 
 def test_paginator__invalid_token():
@@ -105,8 +105,8 @@ def test_paginator__invalid_token__but_we_just_dont_care():
     )
     res, token = p.paginate(results)
 
-    res.should.equal([])
-    token.should.equal(None)
+    assert res == []
+    assert token is None
 
 
 class CustomInvalidTokenException(BaseException):
@@ -177,7 +177,7 @@ class TestDecorator(unittest.TestCase):
 
     @paginate(pagination_model=PAGINATION_MODEL)  # type: ignore[misc]
     def method_returning_args(self, *args, **kwargs):
-        return [*args] + [(k, v) for k, v in kwargs.items()]
+        return [*args] + list(kwargs.items())
 
     @paginate(pagination_model=PAGINATION_MODEL)  # type: ignore[misc]
     def method_expecting_token_as_kwarg(self, custom_token=None):
@@ -190,7 +190,9 @@ class TestDecorator(unittest.TestCase):
         return [{"name": "item1"}, {"name": "item2"}]
 
     @paginate(pagination_model=PAGINATION_MODEL)  # type: ignore[misc]
-    def method_with_list_as_kwarg(self, resources=[]):
+    def method_with_list_as_kwarg(self, resources=None):
+        if not resources:
+            resources = []
         return resources or results
 
     @paginate(PAGINATION_MODEL)  # type: ignore[misc]
@@ -203,26 +205,25 @@ class TestDecorator(unittest.TestCase):
 
     def test__method_returning_dict(self):
         page, token = self.method_returning_dict()
-        page.should.equal(results)
-        token.should.equal(None)
+        assert page == results
+        assert token is None
 
     def test__method_returning_instances(self):
         page, token = self.method_returning_instances()
-        page.should.equal(model_results[0:10])
-        token.shouldnt.equal(None)
+        assert page == model_results[0:10]
+        assert token is not None
 
     def test__method_without_configuration(self):
         with pytest.raises(ValueError):
             self.method_without_configuration()
 
     def test__input_arguments_are_returned(self):
-        resp, token = self.method_returning_args(1, "2", next_token=None, max_results=5)
-        resp.should.have.length_of(4)
-        resp.should.contain(1)
-        resp.should.contain("2")
-        resp.should.contain(("next_token", None))
-        resp.should.contain(("max_results", 5))
-        token.should.equal(None)
+        resp, _ = self.method_returning_args(1, "2", next_token=None, max_results=5)
+        assert len(resp) == 4
+        assert 1 in resp
+        assert "2" in resp
+        assert ("next_token", None) in resp
+        assert ("max_results", 5) in resp
 
     def test__pass_exception_on_invalid_token(self):
         # works fine if no token is specified
@@ -233,67 +234,69 @@ class TestDecorator(unittest.TestCase):
             self.method_specifying_invalidtoken_exception(
                 next_token="some invalid token"
             )
-        exc.value.should.be.a(CustomInvalidTokenException)
-        exc.value.message.should.equal("Invalid token: some invalid token")
+        assert isinstance(exc.value, CustomInvalidTokenException)
+        assert exc.value.message == "Invalid token: some invalid token"
 
     def test__pass_generic_exception_on_invalid_token(self):
         # works fine if no token is specified
         self.method_specifying_generic_invalidtoken_exception()
 
         # throws exception if next_token is invalid
-        # Exception does not take any arguments - our paginator needs to verify whether the next_token arg is expected
+        # Exception does not take any arguments - our paginator needs to
+        # verify whether the next_token arg is expected
         with pytest.raises(GenericInvalidTokenException) as exc:
             self.method_specifying_generic_invalidtoken_exception(
                 next_token="some invalid token"
             )
-        exc.value.should.be.a(GenericInvalidTokenException)
-        exc.value.message.should.equal("Invalid token!")
+        assert isinstance(exc.value, GenericInvalidTokenException)
+        assert exc.value.message == "Invalid token!"
 
     def test__invoke_function_that_expects_token_as_keyword(self):
         resp, first_token = self.method_expecting_token_as_kwarg()
-        resp.should.equal([{"name": "item1"}])
-        first_token.shouldnt.equal(None)
-        self.custom_token.should.equal(None)
+        assert resp == [{"name": "item1"}]
+        assert first_token is not None
+        assert self.custom_token is None
 
         # Verify the custom_token is received in the business method
         # Could be handy for additional validation
-        resp, token = self.method_expecting_token_as_kwarg(custom_token=first_token)
-        self.custom_token.should.equal(first_token)
+        resp, _ = self.method_expecting_token_as_kwarg(custom_token=first_token)
+        assert self.custom_token == first_token
 
     def test__invoke_function_that_expects_limit_as_keyword(self):
         self.method_expecting_limit_as_kwarg(custom_limit=None)
-        self.custom_limit.should.equal(None)
+        assert self.custom_limit is None
 
         # Verify the custom_limit is received in the business method
         # Could be handy for additional validation
         self.method_expecting_limit_as_kwarg(custom_limit=1)
-        self.custom_limit.should.equal(1)
+        assert self.custom_limit == 1
 
     def test__verify_kwargs_can_be_a_list(self):
         # Use case - verify that the kwarg can be of type list
         # Paginator creates a hash for all kwargs
         # We need to be make sure that the hash-function can deal with lists
         resp, token = self.method_with_list_as_kwarg()
-        resp.should.equal(results[0:1])
+        assert resp == results[0:1]
 
         resp, token = self.method_with_list_as_kwarg(next_token=token)
-        resp.should.equal(results[1:2])
+        assert resp == results[1:2]
 
         custom_list = [{"name": "a"}, {"name": "b"}]
         resp, token = self.method_with_list_as_kwarg(resources=custom_list)
-        resp.should.equal(custom_list[0:1])
+        assert resp == custom_list[0:1]
 
         resp, token = self.method_with_list_as_kwarg(
             resources=custom_list, next_token=token
         )
-        resp.should.equal(custom_list[1:])
-        token.should.equal(None)
+        assert resp == custom_list[1:]
+        assert token is None
 
     def test__paginator_fails_with_inconsistent_arguments(self):
         custom_list = [{"name": "a"}, {"name": "b"}]
         resp, token = self.method_with_list_as_kwarg(resources=custom_list)
-        resp.should.equal(custom_list[0:1])
+        assert resp == custom_list[0:1]
 
         with pytest.raises(InvalidToken):
-            # This should fail, as our 'resources' argument is inconsistent with the original resources that were provided
+            # This should fail, as our 'resources' argument is inconsistent
+            # with the original resources that were provided
             self.method_with_list_as_kwarg(resources=results, next_token=token)
diff --git a/tests/test_utilities/test_tagging_service.py b/tests/test_utilities/test_tagging_service.py
index 2fedb2df1..b86ff2419 100644
--- a/tests/test_utilities/test_tagging_service.py
+++ b/tests/test_utilities/test_tagging_service.py
@@ -6,7 +6,7 @@ def test_list_empty():
     svc = TaggingService()
     result = svc.list_tags_for_resource("test")
 
-    {"Tags": []}.should.be.equal(result)
+    assert {"Tags": []} == result
 
 
 def test_create_tag():
@@ -16,7 +16,7 @@ def test_create_tag():
     actual = svc.list_tags_for_resource("arn")
     expected = {"TheTags": [{"TagKey": "key_key", "TagValue": "value_value"}]}
 
-    expected.should.be.equal(actual)
+    assert expected == actual
 
 
 def test_create_tag_without_value():
@@ -26,7 +26,7 @@ def test_create_tag_without_value():
     actual = svc.list_tags_for_resource("arn")
     expected = {"Tags": [{"Key": "key_key", "Value": None}]}
 
-    expected.should.be.equal(actual)
+    assert expected == actual
 
 
 def test_delete_tag_using_names():
@@ -36,7 +36,7 @@ def test_delete_tag_using_names():
     svc.untag_resource_using_names("arn", ["key_key"])
     result = svc.list_tags_for_resource("arn")
 
-    {"Tags": []}.should.be.equal(result)
+    assert {"Tags": []} == result
 
 
 def test_delete_all_tags_for_resource():
@@ -48,7 +48,7 @@ def test_delete_all_tags_for_resource():
     svc.delete_all_tags_for_resource("arn")
     result = svc.list_tags_for_resource("arn")
 
-    {"Tags": []}.should.be.equal(result)
+    assert {"Tags": []} == result
 
 
 def test_list_empty_delete():
@@ -56,7 +56,7 @@ def test_list_empty_delete():
     svc.untag_resource_using_names("arn", ["key_key"])
     result = svc.list_tags_for_resource("arn")
 
-    {"Tags": []}.should.be.equal(result)
+    assert {"Tags": []} == result
 
 
 def test_delete_tag_using_tags():
@@ -66,7 +66,7 @@ def test_delete_tag_using_tags():
     svc.untag_resource_using_tags("arn", tags)
     result = svc.list_tags_for_resource("arn")
 
-    {"Tags": []}.should.be.equal(result)
+    assert {"Tags": []} == result
 
 
 def test_extract_tag_names():
@@ -75,7 +75,7 @@ def test_extract_tag_names():
     actual = svc.extract_tag_names(tags)
     expected = ["key1", "key2"]
 
-    expected.should.be.equal(actual)
+    assert expected == actual
 
 
 def test_copy_non_existing_arn():
@@ -89,7 +89,7 @@ def test_copy_non_existing_arn():
     actual = sorted(
         svc.list_tags_for_resource("new_arn")["Tags"], key=lambda t: t["Key"]
     )
-    actual.should.equal(tags)
+    assert actual == tags
 
 
 def test_copy_existing_arn():
@@ -104,9 +104,10 @@ def test_copy_existing_arn():
     actual = sorted(
         svc.list_tags_for_resource("new_arn")["Tags"], key=lambda t: t["Key"]
     )
-    actual.should.equal(
-        [{"Key": "key1", "Value": "value1"}, {"Key": "key2", "Value": "value2"}]
-    )
+    assert actual == [
+        {"Key": "key1", "Value": "value1"},
+        {"Key": "key2", "Value": "value2"},
+    ]
 
 
 def test_validate_tags():
diff --git a/tests/test_utilities/test_threaded_server.py b/tests/test_utilities/test_threaded_server.py
index cab8fdfc0..8199959ec 100644
--- a/tests/test_utilities/test_threaded_server.py
+++ b/tests/test_utilities/test_threaded_server.py
@@ -1,10 +1,11 @@
+import unittest
+from unittest import SkipTest
+
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 import requests
-import unittest
+
 from moto import mock_s3, settings
 from moto.server import ThreadedMotoServer
-from unittest import SkipTest
 
 
 class TestThreadedMotoServer(unittest.TestCase):
@@ -27,8 +28,8 @@ class TestThreadedMotoServer(unittest.TestCase):
         )
         s3_client.create_bucket(Bucket="test")
         buckets = s3_client.list_buckets()["Buckets"]
-        buckets.should.have.length_of(1)
-        [b["Name"] for b in buckets].should.equal(["test"])
+        assert len(buckets) == 1
+        assert [b["Name"] for b in buckets] == ["test"]
 
     def test_server_can_handle_multiple_services(self):
         s3_client = boto3.client(
@@ -49,9 +50,9 @@ class TestThreadedMotoServer(unittest.TestCase):
         )
 
         buckets = s3_client.list_buckets()["Buckets"]
-        [b["Name"] for b in buckets].should.equal(["test"])
+        assert [b["Name"] for b in buckets] == ["test"]
 
-        dynamodb_client.list_tables()["TableNames"].should.equal(["table1"])
+        assert dynamodb_client.list_tables()["TableNames"] == ["table1"]
 
     @mock_s3
     def test_load_data_from_inmemory_client(self):
@@ -65,7 +66,7 @@ class TestThreadedMotoServer(unittest.TestCase):
 
         in_mem_client = boto3.client("s3")
         buckets = in_mem_client.list_buckets()["Buckets"]
-        [b["Name"] for b in buckets].should.equal(["test"])
+        assert [b["Name"] for b in buckets] == ["test"]
 
 
 def test_threaded_moto_server__different_port():
@@ -83,7 +84,7 @@ def test_threaded_moto_server__different_port():
         )
         s3_client.create_bucket(Bucket="test")
         buckets = s3_client.list_buckets()["Buckets"]
-        [b["Name"] for b in buckets].should.equal(["test"])
+        assert [b["Name"] for b in buckets] == ["test"]
     finally:
         server.stop()
 
@@ -96,8 +97,7 @@ def test_threaded_moto_server__using_requests():
     requests.post("http://localhost:5001/moto-api/reset")
     try:
         r = requests.get("http://localhost:5001/moto-api")
-        r.content.should.contain(b"<title>Moto</title>")
-        r.status_code.should.equal(200)
+        assert b"<title>Moto</title>" in r.content
+        assert r.status_code == 200
     finally:
         server.stop()
-        pass