Repository: getmoto/moto
Pull request #6657 (2023-08-13 18:53:08)

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


Patch:
diff --git a/moto/identitystore/models.py b/moto/identitystore/models.py
index 07decf2c8..456c1f7fc 100644
--- a/moto/identitystore/models.py
+++ b/moto/identitystore/models.py
@@ -71,6 +71,12 @@ class IdentityStoreBackend(BaseBackend):
             "limit_default": 100,
             "unique_attribute": "MembershipId",
         },
+        "list_groups": {
+            "input_token": "next_token",
+            "limit_key": "max_results",
+            "limit_default": 100,
+            "unique_attribute": "GroupId",
+        },
     }
 
     def __init__(self, region_name: str, account_id: str) -> None:
@@ -225,6 +231,23 @@ class IdentityStoreBackend(BaseBackend):
             if m["GroupId"] == group_id
         ]
 
+    @paginate(pagination_model=PAGINATION_MODEL)  # type: ignore
+    def list_groups(
+        self, identity_store_id: str, filters: List[Dict[str, str]]
+    ) -> List[Dict[str, str]]:
+        identity_store = self.__get_identity_store(identity_store_id)
+
+        if filters:
+            if filters[0].get("AttributePath") == "DisplayName":
+                displayname = filters[0].get("AttributeValue")
+                return [
+                    m
+                    for m in identity_store.groups.values()
+                    if m["DisplayName"] == displayname
+                ]
+
+        return [m for m in identity_store.groups.values()]
+
     def delete_group_membership(
         self, identity_store_id: str, membership_id: str
     ) -> None:
diff --git a/moto/identitystore/responses.py b/moto/identitystore/responses.py
index 4467709ad..ce18dd06a 100644
--- a/moto/identitystore/responses.py
+++ b/moto/identitystore/responses.py
@@ -136,6 +136,20 @@ class IdentityStoreResponse(BaseResponse):
             dict(GroupMemberships=group_memberships, NextToken=next_token)
         )
 
+    def list_groups(self) -> str:
+        identity_store_id = self._get_param("IdentityStoreId")
+        max_results = self._get_param("MaxResults")
+        next_token = self._get_param("NextToken")
+        filters = self._get_param("Filters")
+        (groups, next_token,) = self.identitystore_backend.list_groups(
+            identity_store_id=identity_store_id,
+            max_results=max_results,
+            next_token=next_token,
+            filters=filters,
+        )
+
+        return json.dumps(dict(Groups=groups, NextToken=next_token))
+
     def delete_group(self) -> str:
         identity_store_id = self._get_param("IdentityStoreId")
         group_id = self._get_param("GroupId")
diff --git a/moto/ssm/resources/regions.json b/moto/ssm/resources/regions.json
index aaed3bc58..3a683e5a7 100644
--- a/moto/ssm/resources/regions.json
+++ b/moto/ssm/resources/regions.json
@@ -1258,6 +1258,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "schemas": {
+                "Value": "schemas",
+                "endpoint": {
+                  "Value": "schemas.af-south-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "secretsmanager": {
                 "Value": "secretsmanager",
                 "endpoint": {
@@ -2291,6 +2300,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "identitystore": {
+                "Value": "identitystore",
+                "endpoint": {
+                  "Value": "identitystore.ap-east-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "imagebuilder": {
                 "Value": "imagebuilder",
                 "endpoint": {
@@ -9084,6 +9102,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "schemas": {
+                "Value": "schemas",
+                "endpoint": {
+                  "Value": "schemas.ap-northeast-3.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "secretsmanager": {
                 "Value": "secretsmanager",
                 "endpoint": {
@@ -9858,15 +9885,6 @@
                   "Value": "HTTPS"
                 }
               },
-              "connect-contact-lens": {
-                "Value": "connect-contact-lens",
-                "endpoint": {
-                  "Value": "contact-lens.ap-south-1.amazonaws.com"
-                },
-                "protocols": {
-                  "Value": "HTTPS"
-                }
-              },
               "controltower": {
                 "Value": "controltower",
                 "endpoint": {
@@ -16777,6 +16795,9 @@
                   "Value": "HTTPS"
                 }
               },
+              "monitron": {
+                "Value": "monitron"
+              },
               "mq": {
                 "Value": "mq",
                 "endpoint": {
@@ -18689,6 +18710,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "schemas": {
+                "Value": "schemas",
+                "endpoint": {
+                  "Value": "schemas.ap-southeast-3.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "secretsmanager": {
                 "Value": "secretsmanager",
                 "endpoint": {
@@ -22090,6 +22120,15 @@
               "vpc": {
                 "Value": "vpc"
               },
+              "vpc-lattice": {
+                "Value": "vpc-lattice",
+                "endpoint": {
+                  "Value": "vpc-lattice.ca-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "vpn": {
                 "Value": "vpn",
                 "endpoint": {
@@ -22300,6 +22339,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "arc-zonal-shift": {
+                "Value": "arc-zonal-shift",
+                "endpoint": {
+                  "Value": "arc-zonal-shift.cn-north-1.amazonaws.com.cn"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "athena": {
                 "Value": "athena",
                 "endpoint": {
@@ -23242,6 +23290,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "schemas": {
+                "Value": "schemas",
+                "endpoint": {
+                  "Value": "schemas.cn-north-1.amazonaws.com.cn"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "secretsmanager": {
                 "Value": "secretsmanager",
                 "endpoint": {
@@ -23594,6 +23651,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "arc-zonal-shift": {
+                "Value": "arc-zonal-shift",
+                "endpoint": {
+                  "Value": "arc-zonal-shift.cn-northwest-1.amazonaws.com.cn"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "athena": {
                 "Value": "athena",
                 "endpoint": {
@@ -24500,6 +24566,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "schemas": {
+                "Value": "schemas",
+                "endpoint": {
+                  "Value": "schemas.cn-northwest-1.amazonaws.com.cn"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "secretsmanager": {
                 "Value": "secretsmanager",
                 "endpoint": {
@@ -27290,6 +27365,15 @@
               "vpc": {
                 "Value": "vpc"
               },
+              "vpc-lattice": {
+                "Value": "vpc-lattice",
+                "endpoint": {
+                  "Value": "vpc-lattice.eu-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "vpn": {
                 "Value": "vpn",
                 "endpoint": {
@@ -28214,6 +28298,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "schemas": {
+                "Value": "schemas",
+                "endpoint": {
+                  "Value": "schemas.eu-central-2.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "secretsmanager": {
                 "Value": "secretsmanager",
                 "endpoint": {
@@ -30300,6 +30393,15 @@
               "vpc": {
                 "Value": "vpc"
               },
+              "vpc-lattice": {
+                "Value": "vpc-lattice",
+                "endpoint": {
+                  "Value": "vpc-lattice.eu-north-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "vpn": {
                 "Value": "vpn",
                 "endpoint": {
@@ -31561,6 +31663,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "schemas": {
+                "Value": "schemas",
+                "endpoint": {
+                  "Value": "schemas.eu-south-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "secretsmanager": {
                 "Value": "secretsmanager",
                 "endpoint": {
@@ -32642,6 +32753,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "schemas": {
+                "Value": "schemas",
+                "endpoint": {
+                  "Value": "schemas.eu-south-2.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "secretsmanager": {
                 "Value": "secretsmanager",
                 "endpoint": {
@@ -37831,6 +37951,15 @@
               "vpc": {
                 "Value": "vpc"
               },
+              "vpc-lattice": {
+                "Value": "vpc-lattice",
+                "endpoint": {
+                  "Value": "vpc-lattice.eu-west-2.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "vpn": {
                 "Value": "vpn",
                 "endpoint": {
@@ -39848,6 +39977,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "acm-pca": {
+                "Value": "acm-pca",
+                "endpoint": {
+                  "Value": "acm-pca.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "apigateway": {
                 "Value": "apigateway",
                 "endpoint": {
@@ -40076,6 +40214,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "efs": {
+                "Value": "efs",
+                "endpoint": {
+                  "Value": "elasticfilesystem.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "eks": {
                 "Value": "eks",
                 "endpoint": {
@@ -40196,6 +40343,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "kinesisanalytics": {
+                "Value": "kinesisanalytics",
+                "endpoint": {
+                  "Value": "kinesisanalytics.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "kms": {
                 "Value": "kms",
                 "endpoint": {
@@ -40223,6 +40379,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "license-manager-linux-subscriptions": {
+                "Value": "license-manager-linux-subscriptions",
+                "endpoint": {
+                  "Value": "license-manager-linux-subscriptions.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "logs": {
                 "Value": "logs",
                 "endpoint": {
@@ -40400,6 +40565,24 @@
                   "Value": "HTTPS"
                 }
               },
+              "securityhub": {
+                "Value": "securityhub",
+                "endpoint": {
+                  "Value": "securityhub.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
+              "servicecatalog": {
+                "Value": "servicecatalog",
+                "endpoint": {
+                  "Value": "servicecatalog.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "servicediscovery": {
                 "Value": "servicediscovery",
                 "endpoint": {
@@ -41271,6 +41454,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "neptune": {
+                "Value": "neptune",
+                "endpoint": {
+                  "Value": "rds.me-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS, HTTP"
+                }
+              },
               "network-firewall": {
                 "Value": "network-firewall",
                 "endpoint": {
@@ -41454,6 +41646,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "schemas": {
+                "Value": "schemas",
+                "endpoint": {
+                  "Value": "schemas.me-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "secretsmanager": {
                 "Value": "secretsmanager",
                 "endpoint": {
@@ -42457,6 +42658,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "identitystore": {
+                "Value": "identitystore",
+                "endpoint": {
+                  "Value": "identitystore.me-south-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "imagebuilder": {
                 "Value": "imagebuilder",
                 "endpoint": {
@@ -42961,6 +43171,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "schemas": {
+                "Value": "schemas",
+                "endpoint": {
+                  "Value": "schemas.me-south-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "secretsmanager": {
                 "Value": "secretsmanager",
                 "endpoint": {
@@ -51453,6 +51672,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "license-manager-linux-subscriptions": {
+                "Value": "license-manager-linux-subscriptions",
+                "endpoint": {
+                  "Value": "license-manager-linux-subscriptions.us-gov-east-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "logs": {
                 "Value": "logs",
                 "endpoint": {
@@ -52897,6 +53125,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "license-manager-linux-subscriptions": {
+                "Value": "license-manager-linux-subscriptions",
+                "endpoint": {
+                  "Value": "license-manager-linux-subscriptions.us-gov-west-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "logs": {
                 "Value": "logs",
                 "endpoint": {
@@ -54419,6 +54656,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "identitystore": {
+                "Value": "identitystore",
+                "endpoint": {
+                  "Value": "identitystore.us-west-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "imagebuilder": {
                 "Value": "imagebuilder",
                 "endpoint": {
diff --git a/moto/ssm/resources/services.json b/moto/ssm/resources/services.json
index e0442ed8a..1082367cc 100644
--- a/moto/ssm/resources/services.json
+++ b/moto/ssm/resources/services.json
@@ -1056,6 +1056,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "il-central-1": {
+                "Value": "il-central-1",
+                "endpoint": {
+                  "Value": "acm-pca.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "me-central-1": {
                 "Value": "me-central-1",
                 "endpoint": {
@@ -4825,6 +4834,24 @@
                   "Value": "HTTPS"
                 }
               },
+              "cn-north-1": {
+                "Value": "cn-north-1",
+                "endpoint": {
+                  "Value": "arc-zonal-shift.cn-north-1.amazonaws.com.cn"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
+              "cn-northwest-1": {
+                "Value": "cn-northwest-1",
+                "endpoint": {
+                  "Value": "arc-zonal-shift.cn-northwest-1.amazonaws.com.cn"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "eu-central-1": {
                 "Value": "eu-central-1",
                 "endpoint": {
@@ -14079,15 +14106,6 @@
                   "Value": "HTTPS"
                 }
               },
-              "ap-south-1": {
-                "Value": "ap-south-1",
-                "endpoint": {
-                  "Value": "contact-lens.ap-south-1.amazonaws.com"
-                },
-                "protocols": {
-                  "Value": "HTTPS"
-                }
-              },
               "ap-southeast-1": {
                 "Value": "ap-southeast-1",
                 "endpoint": {
@@ -19716,6 +19734,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "il-central-1": {
+                "Value": "il-central-1",
+                "endpoint": {
+                  "Value": "elasticfilesystem.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "me-central-1": {
                 "Value": "me-central-1",
                 "endpoint": {
@@ -27869,6 +27896,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "ap-east-1": {
+                "Value": "ap-east-1",
+                "endpoint": {
+                  "Value": "identitystore.ap-east-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "ap-northeast-1": {
                 "Value": "ap-northeast-1",
                 "endpoint": {
@@ -27995,6 +28031,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "me-south-1": {
+                "Value": "me-south-1",
+                "endpoint": {
+                  "Value": "identitystore.me-south-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "sa-east-1": {
                 "Value": "sa-east-1",
                 "endpoint": {
@@ -28040,6 +28085,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "us-west-1": {
+                "Value": "us-west-1",
+                "endpoint": {
+                  "Value": "identitystore.us-west-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "us-west-2": {
                 "Value": "us-west-2",
                 "endpoint": {
@@ -32555,6 +32609,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "il-central-1": {
+                "Value": "il-central-1",
+                "endpoint": {
+                  "Value": "kinesisanalytics.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "me-central-1": {
                 "Value": "me-central-1",
                 "endpoint": {
@@ -34549,6 +34612,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "il-central-1": {
+                "Value": "il-central-1",
+                "endpoint": {
+                  "Value": "license-manager-linux-subscriptions.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "me-central-1": {
                 "Value": "me-central-1",
                 "endpoint": {
@@ -34594,6 +34666,24 @@
                   "Value": "HTTPS"
                 }
               },
+              "us-gov-east-1": {
+                "Value": "us-gov-east-1",
+                "endpoint": {
+                  "Value": "license-manager-linux-subscriptions.us-gov-east-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
+              "us-gov-west-1": {
+                "Value": "us-gov-west-1",
+                "endpoint": {
+                  "Value": "license-manager-linux-subscriptions.us-gov-west-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "us-west-1": {
                 "Value": "us-west-1",
                 "endpoint": {
@@ -38902,6 +38992,9 @@
               "Value": "https://aws.amazon.com/pm/monitron/"
             },
             "regions": {
+              "ap-southeast-2": {
+                "Value": "ap-southeast-2"
+              },
               "eu-west-1": {
                 "Value": "eu-west-1"
               },
@@ -39423,6 +39516,15 @@
                   "Value": "HTTPS, HTTP"
                 }
               },
+              "me-central-1": {
+                "Value": "me-central-1",
+                "endpoint": {
+                  "Value": "rds.me-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS, HTTP"
+                }
+              },
               "me-south-1": {
                 "Value": "me-south-1",
                 "endpoint": {
@@ -43028,6 +43130,9 @@
             "longName": {
               "Value": "AWS Private 5G"
             },
+            "marketingHomeURL": {
+              "Value": "https://aws.amazon.com/private5g/"
+            },
             "regions": {
               "us-east-1": {
                 "Value": "us-east-1",
@@ -49891,6 +49996,15 @@
               "Value": "AWS EventBridge Schemas"
             },
             "regions": {
+              "af-south-1": {
+                "Value": "af-south-1",
+                "endpoint": {
+                  "Value": "schemas.af-south-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "ap-east-1": {
                 "Value": "ap-east-1",
                 "endpoint": {
@@ -49918,6 +50032,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "ap-northeast-3": {
+                "Value": "ap-northeast-3",
+                "endpoint": {
+                  "Value": "schemas.ap-northeast-3.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "ap-south-1": {
                 "Value": "ap-south-1",
                 "endpoint": {
@@ -49945,6 +50068,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "ap-southeast-3": {
+                "Value": "ap-southeast-3",
+                "endpoint": {
+                  "Value": "schemas.ap-southeast-3.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "ca-central-1": {
                 "Value": "ca-central-1",
                 "endpoint": {
@@ -49954,6 +50086,24 @@
                   "Value": "HTTPS"
                 }
               },
+              "cn-north-1": {
+                "Value": "cn-north-1",
+                "endpoint": {
+                  "Value": "schemas.cn-north-1.amazonaws.com.cn"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
+              "cn-northwest-1": {
+                "Value": "cn-northwest-1",
+                "endpoint": {
+                  "Value": "schemas.cn-northwest-1.amazonaws.com.cn"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "eu-central-1": {
                 "Value": "eu-central-1",
                 "endpoint": {
@@ -49963,6 +50113,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "eu-central-2": {
+                "Value": "eu-central-2",
+                "endpoint": {
+                  "Value": "schemas.eu-central-2.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "eu-north-1": {
                 "Value": "eu-north-1",
                 "endpoint": {
@@ -49972,6 +50131,24 @@
                   "Value": "HTTPS"
                 }
               },
+              "eu-south-1": {
+                "Value": "eu-south-1",
+                "endpoint": {
+                  "Value": "schemas.eu-south-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
+              "eu-south-2": {
+                "Value": "eu-south-2",
+                "endpoint": {
+                  "Value": "schemas.eu-south-2.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "eu-west-1": {
                 "Value": "eu-west-1",
                 "endpoint": {
@@ -49999,6 +50176,24 @@
                   "Value": "HTTPS"
                 }
               },
+              "me-central-1": {
+                "Value": "me-central-1",
+                "endpoint": {
+                  "Value": "schemas.me-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
+              "me-south-1": {
+                "Value": "me-south-1",
+                "endpoint": {
+                  "Value": "schemas.me-south-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "sa-east-1": {
                 "Value": "sa-east-1",
                 "endpoint": {
@@ -50635,6 +50830,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "il-central-1": {
+                "Value": "il-central-1",
+                "endpoint": {
+                  "Value": "securityhub.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "me-central-1": {
                 "Value": "me-central-1",
                 "endpoint": {
@@ -51549,6 +51753,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "il-central-1": {
+                "Value": "il-central-1",
+                "endpoint": {
+                  "Value": "servicecatalog.il-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "me-central-1": {
                 "Value": "me-central-1",
                 "endpoint": {
@@ -58924,6 +59137,33 @@
                   "Value": "HTTPS"
                 }
               },
+              "ca-central-1": {
+                "Value": "ca-central-1",
+                "endpoint": {
+                  "Value": "vpc-lattice.ca-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
+              "eu-central-1": {
+                "Value": "eu-central-1",
+                "endpoint": {
+                  "Value": "vpc-lattice.eu-central-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
+              "eu-north-1": {
+                "Value": "eu-north-1",
+                "endpoint": {
+                  "Value": "vpc-lattice.eu-north-1.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "eu-west-1": {
                 "Value": "eu-west-1",
                 "endpoint": {
@@ -58933,6 +59173,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "eu-west-2": {
+                "Value": "eu-west-2",
+                "endpoint": {
+                  "Value": "vpc-lattice.eu-west-2.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "us-east-1": {
                 "Value": "us-east-1",
                 "endpoint": {


Test patch:
diff --git a/tests/test_identitystore/test_identitystore.py b/tests/test_identitystore/test_identitystore.py
index ad7520d37..73c626d15 100644
--- a/tests/test_identitystore/test_identitystore.py
+++ b/tests/test_identitystore/test_identitystore.py
@@ -16,7 +16,8 @@ from moto.moto_api._internal import mock_random
 
 
 def get_identity_store_id() -> str:
-    return f"d-{random.choices(string.ascii_lowercase, k=10)}"
+    rand = "".join(random.choices(string.ascii_lowercase, k=10))
+    return f"d-{rand}"
 
 
 @mock_identitystore
@@ -371,7 +372,7 @@ def test_get_group_id():
     # Create a bunch of groups
     for _ in range(1, 10):
         group = __create_test_group(client, identity_store_id)
-        groups[group[0]] = group[1]
+        groups[group[0]] = group[2]
 
     # Make sure we can get their ID
     for name, group_id in groups.items():
@@ -413,6 +414,96 @@ def test_get_group_id_does_not_exist():
     assert "RequestId" in err.response
 
 
+@mock_identitystore
+def test_list_groups():
+    client = boto3.client("identitystore", region_name="us-east-2")
+    identity_store_id = get_identity_store_id()
+
+    start = 0
+    end = 266
+    batch_size = 100
+    next_token = None
+
+    expected_groups = list()
+    for _ in range(end):
+        display_name, description, group_id = __create_test_group(
+            client=client, store_id=identity_store_id
+        )
+        expected_groups.append(
+            {
+                "GroupId": group_id,
+                "DisplayName": display_name,
+                "Description": description,
+                "IdentityStoreId": identity_store_id,
+            }
+        )
+
+    groups = list()
+    for iteration in range(start, end, batch_size):
+        last_iteration = end - iteration <= batch_size
+        expected_size = batch_size if not last_iteration else end - iteration
+
+        if next_token is not None:
+            list_response = client.list_groups(
+                IdentityStoreId=identity_store_id,
+                MaxResults=batch_size,
+                NextToken=next_token,
+            )
+        else:
+            list_response = client.list_groups(
+                IdentityStoreId=identity_store_id,
+                MaxResults=batch_size,
+            )
+
+        assert len(list_response["Groups"]) == expected_size
+        groups.extend(list_response["Groups"])
+        if last_iteration:
+            assert "NextToken" not in list_response
+        else:
+            assert "NextToken" in list_response
+            next_token = list_response["NextToken"]
+
+    assert groups == expected_groups
+
+
+@mock_identitystore
+def test_list_groups_filter():
+    client = boto3.client("identitystore", region_name="us-east-2")
+    identity_store_id = get_identity_store_id()
+
+    display_name, description, group_id = __create_test_group(
+        client=client, store_id=identity_store_id
+    )
+    expected_group = {
+        "GroupId": group_id,
+        "DisplayName": display_name,
+        "Description": description,
+        "IdentityStoreId": identity_store_id,
+    }
+
+    # Create a second test group to see if it is not returned
+    __create_test_group(client=client, store_id=identity_store_id)
+
+    groups = client.list_groups(
+        IdentityStoreId=identity_store_id,
+        Filters=[
+            {"AttributePath": "DisplayName", "AttributeValue": display_name},
+        ],
+    )["Groups"]
+
+    assert len(groups) == 1
+    assert groups[0] == expected_group
+
+    no_groups = client.list_groups(
+        IdentityStoreId=identity_store_id,
+        Filters=[
+            {"AttributePath": "DisplayName", "AttributeValue": "non_existant_group"},
+        ],
+    )["Groups"]
+
+    assert len(no_groups) == 0
+
+
 @mock_identitystore
 def test_list_group_memberships():
     client = boto3.client("identitystore", region_name="us-east-2")
@@ -484,7 +575,7 @@ def test_delete_group():
     test_group = __create_test_group(client, identity_store_id)
     assert __group_exists(client, test_group[0], identity_store_id)
 
-    resp = client.delete_group(IdentityStoreId=identity_store_id, GroupId=test_group[1])
+    resp = client.delete_group(IdentityStoreId=identity_store_id, GroupId=test_group[2])
     assert "ResponseMetadata" in resp
     assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
 
@@ -510,7 +601,7 @@ def test_delete_group_membership():
     client = boto3.client("identitystore", region_name="eu-west-1")
     identity_store_id = get_identity_store_id()
     user_id = __create_and_verify_sparse_user(client, identity_store_id)
-    _, group_id = __create_test_group(client, identity_store_id)
+    _, _, group_id = __create_test_group(client, identity_store_id)
 
     membership = client.create_group_membership(
         IdentityStoreId=identity_store_id,
@@ -563,14 +654,15 @@ def test_delete_user_doesnt_exist():
 def __create_test_group(client, store_id: str):
     rand = "".join(random.choices(string.ascii_lowercase, k=8))
     group_name = f"test_group_{rand}"
+    description = f"random_description_{rand}"
 
     create_resp = client.create_group(
         IdentityStoreId=store_id,
         DisplayName=group_name,
-        Description="description",
+        Description=description,
     )
 
-    return group_name, create_resp["GroupId"]
+    return group_name, description, create_resp["GroupId"]
 
 
 def __group_exists(client, group_name: str, store_id: str) -> bool:
diff --git a/tests/test_mediastore/test_mediastore.py b/tests/test_mediastore/test_mediastore.py
index 8c5e0871f..ccb9e91f9 100644
--- a/tests/test_mediastore/test_mediastore.py
+++ b/tests/test_mediastore/test_mediastore.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_mediastore
@@ -14,43 +13,40 @@ def test_create_container_succeeds():
     response = client.create_container(
         ContainerName="Awesome container!", Tags=[{"Key": "customer"}]
     )
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+
     container = response["Container"]
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    container["ARN"].should.equal(f"arn:aws:mediastore:container:{container['Name']}")
-    container["Name"].should.equal("Awesome container!")
-    container["Status"].should.equal("CREATING")
+    assert container["ARN"] == f"arn:aws:mediastore:container:{container['Name']}"
+    assert container["Name"] == "Awesome container!"
+    assert container["Status"] == "CREATING"
 
 
 @mock_mediastore
 def test_describe_container_succeeds():
     client = boto3.client("mediastore", region_name=region)
-    create_response = client.create_container(
-        ContainerName="Awesome container!", Tags=[{"Key": "customer"}]
-    )
-    container_name = create_response["Container"]["Name"]
-    response = client.describe_container(ContainerName=container_name)
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
+    name = "Awesome container!"
+    client.create_container(ContainerName=name, Tags=[{"Key": "customer"}])
+
+    response = client.describe_container(ContainerName=name)
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+
     container = response["Container"]
-    container["ARN"].should.equal(f"arn:aws:mediastore:container:{container_name}")
-    container["Name"].should.equal("Awesome container!")
-    container["Status"].should.equal("ACTIVE")
+    assert container["ARN"] == f"arn:aws:mediastore:container:{name}"
+    assert container["Name"] == name
+    assert container["Status"] == "ACTIVE"
 
 
 @mock_mediastore
 def test_list_containers_succeeds():
     client = boto3.client("mediastore", region_name=region)
-    client.create_container(
-        ContainerName="Awesome container!", Tags=[{"Key": "customer"}]
-    )
-    list_response = client.list_containers(NextToken="next-token", MaxResults=123)
-    containers_list = list_response["Containers"]
-    len(containers_list).should.equal(1)
-    client.create_container(
-        ContainerName="Awesome container2!", Tags=[{"Key": "customer"}]
-    )
-    list_response = client.list_containers(NextToken="next-token", MaxResults=123)
-    containers_list = list_response["Containers"]
-    len(containers_list).should.equal(2)
+    name = "Awesome container!"
+    client.create_container(ContainerName=name, Tags=[{"Key": "customer"}])
+    containers = client.list_containers()["Containers"]
+    assert len(containers) == 1
+
+    client.create_container(ContainerName=f"{name}2", Tags=[{"Key": "customer"}])
+    containers = client.list_containers()["Containers"]
+    assert len(containers) == 2
 
 
 @mock_mediastore
@@ -58,32 +54,27 @@ def test_describe_container_raises_error_if_container_does_not_exist():
     client = boto3.client("mediastore", region_name=region)
     with pytest.raises(ClientError) as ex:
         client.describe_container(ContainerName="container-name")
-    ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "ResourceNotFoundException"
 
 
 @mock_mediastore
 def test_put_lifecycle_policy_succeeds():
     client = boto3.client("mediastore", region_name=region)
-    container_response = client.create_container(
-        ContainerName="container-name", Tags=[{"Key": "customer"}]
-    )
-    container = container_response["Container"]
-    client.put_lifecycle_policy(
-        ContainerName=container["Name"], LifecyclePolicy="lifecycle-policy"
-    )
-    response = client.get_lifecycle_policy(ContainerName=container["Name"])
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    response["LifecyclePolicy"].should.equal("lifecycle-policy")
+    name = "container-name"
+    client.create_container(ContainerName=name, Tags=[{"Key": "customer"}])
+
+    client.put_lifecycle_policy(ContainerName=name, LifecyclePolicy="lifecycle-policy")
+    response = client.get_lifecycle_policy(ContainerName=name)
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert response["LifecyclePolicy"] == "lifecycle-policy"
 
 
 @mock_mediastore
 def test_put_lifecycle_policy_raises_error_if_container_does_not_exist():
     client = boto3.client("mediastore", region_name=region)
     with pytest.raises(ClientError) as ex:
-        client.put_lifecycle_policy(
-            ContainerName="container-name", LifecyclePolicy="lifecycle-policy"
-        )
-    ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
+        client.put_lifecycle_policy(ContainerName="name", LifecyclePolicy="policy")
+    assert ex.value.response["Error"]["Code"] == "ResourceNotFoundException"
 
 
 @mock_mediastore
@@ -91,7 +82,7 @@ def test_get_lifecycle_policy_raises_error_if_container_does_not_exist():
     client = boto3.client("mediastore", region_name=region)
     with pytest.raises(ClientError) as ex:
         client.get_lifecycle_policy(ContainerName="container-name")
-    ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "ResourceNotFoundException"
 
 
 @mock_mediastore
@@ -100,32 +91,27 @@ def test_get_lifecycle_policy_raises_error_if_container_does_not_have_lifecycle_
     client.create_container(ContainerName="container-name", Tags=[{"Key": "customer"}])
     with pytest.raises(ClientError) as ex:
         client.get_lifecycle_policy(ContainerName="container-name")
-    ex.value.response["Error"]["Code"].should.equal("PolicyNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "PolicyNotFoundException"
 
 
 @mock_mediastore
 def test_put_container_policy_succeeds():
     client = boto3.client("mediastore", region_name=region)
-    container_response = client.create_container(
-        ContainerName="container-name", Tags=[{"Key": "customer"}]
-    )
-    container = container_response["Container"]
-    response = client.put_container_policy(
-        ContainerName=container["Name"], Policy="container-policy"
-    )
-    response = client.get_container_policy(ContainerName=container["Name"])
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    response["Policy"].should.equal("container-policy")
+    name = "container-name"
+    client.create_container(ContainerName=name)
+
+    client.put_container_policy(ContainerName=name, Policy="container-policy")
+    response = client.get_container_policy(ContainerName=name)
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert response["Policy"] == "container-policy"
 
 
 @mock_mediastore
 def test_put_container_policy_raises_error_if_container_does_not_exist():
     client = boto3.client("mediastore", region_name=region)
     with pytest.raises(ClientError) as ex:
-        client.put_container_policy(
-            ContainerName="container-name", Policy="container-policy"
-        )
-    ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
+        client.put_container_policy(ContainerName="name", Policy="policy")
+    assert ex.value.response["Error"]["Code"] == "ResourceNotFoundException"
 
 
 @mock_mediastore
@@ -133,7 +119,7 @@ def test_get_container_policy_raises_error_if_container_does_not_exist():
     client = boto3.client("mediastore", region_name=region)
     with pytest.raises(ClientError) as ex:
         client.get_container_policy(ContainerName="container-name")
-    ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "ResourceNotFoundException"
 
 
 @mock_mediastore
@@ -142,23 +128,21 @@ def test_get_container_policy_raises_error_if_container_does_not_have_container_
     client.create_container(ContainerName="container-name", Tags=[{"Key": "customer"}])
     with pytest.raises(ClientError) as ex:
         client.get_container_policy(ContainerName="container-name")
-    ex.value.response["Error"]["Code"].should.equal("PolicyNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "PolicyNotFoundException"
 
 
 @mock_mediastore
 def test_put_metric_policy_succeeds():
     client = boto3.client("mediastore", region_name=region)
-    container_response = client.create_container(
-        ContainerName="container-name", Tags=[{"Key": "customer"}]
-    )
-    container = container_response["Container"]
-    response = client.put_metric_policy(
-        ContainerName=container["Name"],
+    name = "container-name"
+    client.create_container(ContainerName=name)
+    client.put_metric_policy(
+        ContainerName=name,
         MetricPolicy={"ContainerLevelMetrics": "ENABLED"},
     )
-    response = client.get_metric_policy(ContainerName=container["Name"])
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    response["MetricPolicy"].should.equal({"ContainerLevelMetrics": "ENABLED"})
+    response = client.get_metric_policy(ContainerName=name)
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert response["MetricPolicy"] == {"ContainerLevelMetrics": "ENABLED"}
 
 
 @mock_mediastore
@@ -169,7 +153,7 @@ def test_put_metric_policy_raises_error_if_container_does_not_exist():
             ContainerName="container-name",
             MetricPolicy={"ContainerLevelMetrics": "ENABLED"},
         )
-    ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "ResourceNotFoundException"
 
 
 @mock_mediastore
@@ -177,7 +161,7 @@ def test_get_metric_policy_raises_error_if_container_does_not_exist():
     client = boto3.client("mediastore", region_name=region)
     with pytest.raises(ClientError) as ex:
         client.get_metric_policy(ContainerName="container-name")
-    ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "ResourceNotFoundException"
 
 
 @mock_mediastore
@@ -186,7 +170,7 @@ def test_get_metric_policy_raises_error_if_container_does_not_have_metric_policy
     client.create_container(ContainerName="container-name", Tags=[{"Key": "customer"}])
     with pytest.raises(ClientError) as ex:
         client.get_metric_policy(ContainerName="container-name")
-    ex.value.response["Error"]["Code"].should.equal("PolicyNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "PolicyNotFoundException"
 
 
 @mock_mediastore
@@ -194,24 +178,24 @@ def test_list_tags_for_resource():
     client = boto3.client("mediastore", region_name=region)
     tags = [{"Key": "customer"}]
 
-    create_response = client.create_container(
-        ContainerName="Awesome container!", Tags=tags
-    )
-    container = create_response["Container"]
-    response = client.list_tags_for_resource(Resource=container["Name"])
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    response["Tags"].should.equal(tags)
+    name = "Awesome container!"
+    client.create_container(ContainerName=name, Tags=tags)
+
+    response = client.list_tags_for_resource(Resource=name)
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert response["Tags"] == tags
 
 
 @mock_mediastore
 def test_list_tags_for_resource_return_none_if_no_tags():
     client = boto3.client("mediastore", region_name=region)
 
-    create_response = client.create_container(ContainerName="Awesome container!")
-    container = create_response["Container"]
-    response = client.list_tags_for_resource(Resource=container["Name"])
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    response.get("Tags").should.equal(None)
+    name = "Awesome container!"
+    client.create_container(ContainerName=name)
+
+    response = client.list_tags_for_resource(Resource=name)
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert response.get("Tags") is None
 
 
 @mock_mediastore
@@ -219,20 +203,20 @@ def test_list_tags_for_resource_return_error_for_unknown_resource():
     client = boto3.client("mediastore", region_name=region)
     with pytest.raises(ClientError) as ex:
         client.list_tags_for_resource(Resource="not_existing")
-    ex.value.response["Error"]["Code"].should.equal("ContainerNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "ContainerNotFoundException"
 
 
 @mock_mediastore
 def test_delete_container():
     client = boto3.client("mediastore", region_name=region)
     container_name = "Awesome container!"
-    create_response = client.create_container(ContainerName=container_name)
-    container = create_response["Container"]
-    response = client.delete_container(ContainerName=container["Name"])
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    containers = client.list_containers(NextToken="next-token")["Containers"]
-    container_exists = any(d["Name"] == container_name for d in containers)
-    container_exists.should.equal(False)
+    client.create_container(ContainerName=container_name)
+
+    response = client.delete_container(ContainerName=container_name)
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+
+    containers = client.list_containers()["Containers"]
+    assert not any(d["Name"] == container_name for d in containers)
 
 
 @mock_mediastore
@@ -242,4 +226,4 @@ def test_delete_container_raise_error_if_container_not_found():
 
     with pytest.raises(ClientError) as ex:
         client.delete_container(ContainerName="notAvailable")
-    ex.value.response["Error"]["Code"].should.equal("ContainerNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "ContainerNotFoundException"
diff --git a/tests/test_mediastore/test_server.py b/tests/test_mediastore/test_server.py
index dd37ff8ba..d88e96f4d 100644
--- a/tests/test_mediastore/test_server.py
+++ b/tests/test_mediastore/test_server.py
@@ -1,4 +1,4 @@
-import sure  # noqa # pylint: disable=unused-import
+import json
 
 import moto.server as server
 from moto import mock_mediastore
@@ -18,4 +18,4 @@ def test_mediastore_lists_containers():
     )
 
     result = res.data.decode("utf-8")
-    result.should.contain('"Containers": []')
+    assert json.loads(result) == {"Containers": [], "NextToken": None}
diff --git a/tests/test_mediastoredata/test_mediastoredata.py b/tests/test_mediastoredata/test_mediastoredata.py
index e14860813..b210248ef 100644
--- a/tests/test_mediastoredata/test_mediastoredata.py
+++ b/tests/test_mediastoredata/test_mediastoredata.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_mediastoredata
@@ -12,11 +11,11 @@ region = "eu-west-1"
 def test_put_object():
     client = boto3.client("mediastore-data", region_name=region)
     response = client.put_object(Body="011001", Path="foo")
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    response["StorageClass"].should.equal("TEMPORAL")
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert response["StorageClass"] == "TEMPORAL"
+
     items = client.list_items()["Items"]
-    object_exists = any(d["Name"] == "foo" for d in items)
-    object_exists.should.equal(True)
+    assert any(d["Name"] == "foo" for d in items)
 
 
 @mock_mediastoredata
@@ -24,7 +23,7 @@ def test_get_object_throws_not_found_error():
     client = boto3.client("mediastore-data", region_name=region)
     with pytest.raises(ClientError) as ex:
         client.get_object(Path="foo")
-    ex.value.response["Error"]["Code"].should.equal("ObjectNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "ObjectNotFoundException"
 
 
 @mock_mediastoredata
@@ -32,10 +31,9 @@ def test_get_object():
     client = boto3.client("mediastore-data", region_name=region)
     client.put_object(Body="011001", Path="foo")
     response = client.get_object(Path="foo")
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    response["ResponseMetadata"]["HTTPHeaders"]["path"].should.equal("foo")
-    data = response["Body"].read()
-    data.should.equal(b"011001")
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+    assert response["ResponseMetadata"]["HTTPHeaders"]["path"] == "foo"
+    assert response["Body"].read() == b"011001"
 
 
 @mock_mediastoredata
@@ -43,7 +41,7 @@ def test_delete_object_error():
     client = boto3.client("mediastore-data", region_name=region)
     with pytest.raises(ClientError) as ex:
         client.delete_object(Path="foo")
-    ex.value.response["Error"]["Code"].should.equal("ObjectNotFoundException")
+    assert ex.value.response["Error"]["Code"] == "ObjectNotFoundException"
 
 
 @mock_mediastoredata
@@ -52,19 +50,19 @@ def test_delete_object_succeeds():
     object_path = "foo"
     client.put_object(Body="011001", Path=object_path)
     response = client.delete_object(Path=object_path)
-    response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
-    items = client.list_items()["Items"]
-    len(items).should.equal(0)
+    assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
+
+    assert len(client.list_items()["Items"]) == 0
 
 
 @mock_mediastoredata
 def test_list_items():
     client = boto3.client("mediastore-data", region_name=region)
-    items = client.list_items()["Items"]
-    len(items).should.equal(0)
+    assert len(client.list_items()["Items"]) == 0
+
     object_path = "foo"
     client.put_object(Body="011001", Path=object_path)
+
     items = client.list_items()["Items"]
-    len(items).should.equal(1)
-    object_exists = any(d["Name"] == object_path for d in items)
-    object_exists.should.equal(True)
+    assert len(items) == 1
+    assert any(d["Name"] == object_path for d in items)
diff --git a/tests/test_mediastoredata/test_server.py b/tests/test_mediastoredata/test_server.py
index bd4315da7..7e6bd3fb6 100644
--- a/tests/test_mediastoredata/test_server.py
+++ b/tests/test_mediastoredata/test_server.py
@@ -1,4 +1,4 @@
-import sure  # noqa # pylint: disable=unused-import
+import json
 
 import moto.server as server
 from moto import mock_mediastoredata
@@ -12,5 +12,5 @@ Test the different server responses
 def test_mediastore_lists_containers():
     backend = server.create_backend_app("mediastore-data")
     test_client = backend.test_client()
-    response = test_client.get("/").data
-    response.should.contain(b'"Items": []')
+    body = test_client.get("/").data.decode("utf-8")
+    assert json.loads(body) == {"Items": []}
diff --git a/tests/test_ses/test_ses_sns_boto3.py b/tests/test_ses/test_ses_sns_boto3.py
index 1d9b16153..f56ef4b12 100644
--- a/tests/test_ses/test_ses_sns_boto3.py
+++ b/tests/test_ses/test_ses_sns_boto3.py
@@ -2,7 +2,6 @@ import json
 
 import boto3
 
-import sure  # noqa # pylint: disable=unused-import
 from moto import mock_ses, mock_sns, mock_sqs
 from moto.ses.models import SESFeedback
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
diff --git a/tests/test_ssm/test_ssm_boto3.py b/tests/test_ssm/test_ssm_boto3.py
index 9a97573bf..8655e17be 100644
--- a/tests/test_ssm/test_ssm_boto3.py
+++ b/tests/test_ssm/test_ssm_boto3.py
@@ -1,11 +1,10 @@
+import datetime
+import re
 import string
+import uuid
 
 import boto3
 import botocore.exceptions
-import sure  # noqa # pylint: disable=unused-import
-import datetime
-import uuid
-
 from botocore.exceptions import ClientError
 import pytest
 
@@ -24,12 +23,12 @@ def test_delete_parameter():
     )
 
     response = client.get_parameters(Names=["test"])
-    len(response["Parameters"]).should.equal(1)
+    assert len(response["Parameters"]) == 1
 
     client.delete_parameter(Name="test")
 
     response = client.get_parameters(Names=["test"])
-    len(response["Parameters"]).should.equal(0)
+    assert len(response["Parameters"]) == 0
 
 
 @mock_ssm
@@ -38,10 +37,8 @@ def test_delete_nonexistent_parameter():
 
     with pytest.raises(ClientError) as ex:
         client.delete_parameter(Name="test_noexist")
-    ex.value.response["Error"]["Code"].should.equal("ParameterNotFound")
-    ex.value.response["Error"]["Message"].should.equal(
-        "Parameter test_noexist not found."
-    )
+    assert ex.value.response["Error"]["Code"] == "ParameterNotFound"
+    assert ex.value.response["Error"]["Message"] == "Parameter test_noexist not found."
 
 
 @mock_ssm
@@ -53,14 +50,14 @@ def test_delete_parameters():
     )
 
     response = client.get_parameters(Names=["test"])
-    len(response["Parameters"]).should.equal(1)
+    assert len(response["Parameters"]) == 1
 
     result = client.delete_parameters(Names=["test", "invalid"])
-    len(result["DeletedParameters"]).should.equal(1)
-    len(result["InvalidParameters"]).should.equal(1)
+    assert len(result["DeletedParameters"]) == 1
+    assert len(result["InvalidParameters"]) == 1
 
     response = client.get_parameters(Names=["test"])
-    len(response["Parameters"]).should.equal(0)
+    assert len(response["Parameters"]) == 0
 
 
 @mock_ssm
@@ -101,115 +98,108 @@ def test_get_parameters_by_path():
     client.put_parameter(Name="baz", Value="qux", Type="String")
 
     response = client.get_parameters_by_path(Path="/", Recursive=False)
-    len(response["Parameters"]).should.equal(2)
-    {p["Value"] for p in response["Parameters"]}.should.equal(set(["bar", "qux"]))
-    {p["ARN"] for p in response["Parameters"]}.should.equal(
-        set(
-            [
-                f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/foo",
-                f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/baz",
-            ]
-        )
+    assert len(response["Parameters"]) == 2
+    assert {p["Value"] for p in response["Parameters"]} == set(["bar", "qux"])
+    assert {p["ARN"] for p in response["Parameters"]} == set(
+        [
+            f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/foo",
+            f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/baz",
+        ]
     )
-    {
-        p["LastModifiedDate"].should.be.a(datetime.datetime)
-        for p in response["Parameters"]
-    }
+    for p in response["Parameters"]:
+        assert isinstance(p["LastModifiedDate"], datetime.datetime)
 
     response = client.get_parameters_by_path(Path="/", Recursive=True)
-    len(response["Parameters"]).should.equal(9)
+    assert len(response["Parameters"]) == 9
 
     response = client.get_parameters_by_path(Path="/foo")
-    len(response["Parameters"]).should.equal(2)
-    {p["Value"] for p in response["Parameters"]}.should.equal(set(["value1", "value2"]))
+    assert len(response["Parameters"]) == 2
+    assert {p["Value"] for p in response["Parameters"]} == set(["value1", "value2"])
 
     response = client.get_parameters_by_path(Path="/bar", Recursive=False)
-    len(response["Parameters"]).should.equal(1)
-    response["Parameters"][0]["Value"].should.equal("value3")
+    assert len(response["Parameters"]) == 1
+    assert response["Parameters"][0]["Value"] == "value3"
 
     response = client.get_parameters_by_path(Path="/bar", Recursive=True)
-    len(response["Parameters"]).should.equal(2)
-    {p["Value"] for p in response["Parameters"]}.should.equal(set(["value3", "value4"]))
+    assert len(response["Parameters"]) == 2
+    assert {p["Value"] for p in response["Parameters"]} == set(["value3", "value4"])
 
     response = client.get_parameters_by_path(Path="/baz")
-    len(response["Parameters"]).should.equal(3)
+    assert len(response["Parameters"]) == 3
 
     filters = [{"Key": "Type", "Option": "Equals", "Values": ["StringList"]}]
     response = client.get_parameters_by_path(Path="/baz", ParameterFilters=filters)
-    len(response["Parameters"]).should.equal(1)
-    {p["Name"] for p in response["Parameters"]}.should.equal(set(["/baz/name1"]))
+    assert len(response["Parameters"]) == 1
+    assert {p["Name"] for p in response["Parameters"]} == set(["/baz/name1"])
 
     # note: 'Option' is optional (default: 'Equals')
     filters = [{"Key": "Type", "Values": ["StringList"]}]
     response = client.get_parameters_by_path(Path="/baz", ParameterFilters=filters)
-    len(response["Parameters"]).should.equal(1)
-    {p["Name"] for p in response["Parameters"]}.should.equal(set(["/baz/name1"]))
+    assert len(response["Parameters"]) == 1
+    assert {p["Name"] for p in response["Parameters"]} == set(["/baz/name1"])
 
     filters = [{"Key": "Type", "Option": "Equals", "Values": ["String"]}]
     response = client.get_parameters_by_path(Path="/baz", ParameterFilters=filters)
-    len(response["Parameters"]).should.equal(1)
-    {p["Name"] for p in response["Parameters"]}.should.equal(set(["/baz/name2"]))
+    assert len(response["Parameters"]) == 1
+    assert {p["Name"] for p in response["Parameters"]} == set(["/baz/name2"])
 
     filters = [
         {"Key": "Type", "Option": "Equals", "Values": ["String", "SecureString"]}
     ]
     response = client.get_parameters_by_path(Path="/baz", ParameterFilters=filters)
-    len(response["Parameters"]).should.equal(2)
-    {p["Name"] for p in response["Parameters"]}.should.equal(
-        set(["/baz/name2", "/baz/pwd"])
+    assert len(response["Parameters"]) == 2
+    assert {p["Name"] for p in response["Parameters"]} == set(
+        ["/baz/name2", "/baz/pwd"]
     )
 
     filters = [{"Key": "Type", "Option": "BeginsWith", "Values": ["String"]}]
     response = client.get_parameters_by_path(Path="/baz", ParameterFilters=filters)
-    len(response["Parameters"]).should.equal(2)
-    {p["Name"] for p in response["Parameters"]}.should.equal(
-        set(["/baz/name1", "/baz/name2"])
+    assert len(response["Parameters"]) == 2
+    assert {p["Name"] for p in response["Parameters"]} == set(
+        ["/baz/name1", "/baz/name2"]
     )
 
     filters = [{"Key": "KeyId", "Option": "Equals", "Values": ["alias/aws/ssm"]}]
     response = client.get_parameters_by_path(Path="/baz", ParameterFilters=filters)
-    len(response["Parameters"]).should.equal(1)
-    {p["Name"] for p in response["Parameters"]}.should.equal(set(["/baz/pwd"]))
+    assert len(response["Parameters"]) == 1
+    assert {p["Name"] for p in response["Parameters"]} == set(["/baz/pwd"])
 
     response = client.get_parameters_by_path(Path="/", Recursive=True, MaxResults=4)
-    len(response["Parameters"]).should.equal(4)
-    response["NextToken"].should.equal("4")
+    assert len(response["Parameters"]) == 4
+    assert response["NextToken"] == "4"
     response = client.get_parameters_by_path(
         Path="/", Recursive=True, MaxResults=4, NextToken=response["NextToken"]
     )
-    len(response["Parameters"]).should.equal(4)
-    response["NextToken"].should.equal("8")
+    assert len(response["Parameters"]) == 4
+    assert response["NextToken"] == "8"
     response = client.get_parameters_by_path(
         Path="/", Recursive=True, MaxResults=4, NextToken=response["NextToken"]
     )
-    len(response["Parameters"]).should.equal(1)
-    response.should_not.have.key("NextToken")
+    assert len(response["Parameters"]) == 1
+    assert "NextToken" not in response
 
     filters = [{"Key": "Name", "Values": ["error"]}]
-    client.get_parameters_by_path.when.called_with(
-        Path="/baz", ParameterFilters=filters
-    ).should.throw(
-        ClientError,
+    with pytest.raises(ClientError) as client_err:
+        client.get_parameters_by_path(Path="/baz", ParameterFilters=filters)
+    assert client_err.value.response["Error"]["Message"] == (
         "The following filter key is not valid: Name. "
-        "Valid filter keys include: [Type, KeyId].",
+        "Valid filter keys include: [Type, KeyId]."
     )
 
     filters = [{"Key": "Path", "Values": ["/error"]}]
-    client.get_parameters_by_path.when.called_with(
-        Path="/baz", ParameterFilters=filters
-    ).should.throw(
-        ClientError,
+    with pytest.raises(ClientError) as client_err:
+        client.get_parameters_by_path(Path="/baz", ParameterFilters=filters)
+    assert client_err.value.response["Error"]["Message"] == (
         "The following filter key is not valid: Path. "
-        "Valid filter keys include: [Type, KeyId].",
+        "Valid filter keys include: [Type, KeyId]."
     )
 
     filters = [{"Key": "Tier", "Values": ["Standard"]}]
-    client.get_parameters_by_path.when.called_with(
-        Path="/baz", ParameterFilters=filters
-    ).should.throw(
-        ClientError,
+    with pytest.raises(ClientError) as client_err:
+        client.get_parameters_by_path(Path="/baz", ParameterFilters=filters)
+    assert client_err.value.response["Error"]["Message"] == (
         "The following filter key is not valid: Tier. "
-        "Valid filter keys include: [Type, KeyId].",
+        "Valid filter keys include: [Type, KeyId]."
     )
 
     # Label filter in get_parameters_by_path
@@ -217,8 +207,8 @@ def test_get_parameters_by_path():
 
     filters = [{"Key": "Label", "Values": ["Label1"]}]
     response = client.get_parameters_by_path(Path="/foo", ParameterFilters=filters)
-    len(response["Parameters"]).should.equal(1)
-    {p["Name"] for p in response["Parameters"]}.should.equal(set(["/foo/name2"]))
+    assert len(response["Parameters"]) == 1
+    assert {p["Name"] for p in response["Parameters"]} == set(["/foo/name2"])
 
 
 @pytest.mark.parametrize("name", ["test", "my-cool-parameter"])
@@ -229,18 +219,18 @@ def test_put_parameter(name):
         Name=name, Description="A test parameter", Value="value", Type="String"
     )
 
-    response["Version"].should.equal(1)
+    assert response["Version"] == 1
 
     response = client.get_parameters(Names=[name], WithDecryption=False)
 
-    len(response["Parameters"]).should.equal(1)
-    response["Parameters"][0]["Name"].should.equal(name)
-    response["Parameters"][0]["Value"].should.equal("value")
-    response["Parameters"][0]["Type"].should.equal("String")
-    response["Parameters"][0]["Version"].should.equal(1)
-    response["Parameters"][0]["DataType"].should.equal("text")
-    response["Parameters"][0]["LastModifiedDate"].should.be.a(datetime.datetime)
-    response["Parameters"][0]["ARN"].should.equal(
+    assert len(response["Parameters"]) == 1
+    assert response["Parameters"][0]["Name"] == name
+    assert response["Parameters"][0]["Value"] == "value"
+    assert response["Parameters"][0]["Type"] == "String"
+    assert response["Parameters"][0]["Version"] == 1
+    assert response["Parameters"][0]["DataType"] == "text"
+    assert isinstance(response["Parameters"][0]["LastModifiedDate"], datetime.datetime)
+    assert response["Parameters"][0]["ARN"] == (
         f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/{name}"
     )
     initial_modification_date = response["Parameters"][0]["LastModifiedDate"]
@@ -251,24 +241,23 @@ def test_put_parameter(name):
         )
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("PutParameter")
-        err.response["Error"]["Message"].should.equal(
-            "The parameter already exists. To overwrite this value, set the overwrite option in the request to true."
+        assert err.operation_name == "PutParameter"
+        assert err.response["Error"]["Message"] == (
+            "The parameter already exists. To overwrite this value, set the "
+            "overwrite option in the request to true."
         )
 
     response = client.get_parameters(Names=[name], WithDecryption=False)
 
     # without overwrite nothing change
-    len(response["Parameters"]).should.equal(1)
-    response["Parameters"][0]["Name"].should.equal(name)
-    response["Parameters"][0]["Value"].should.equal("value")
-    response["Parameters"][0]["Type"].should.equal("String")
-    response["Parameters"][0]["Version"].should.equal(1)
-    response["Parameters"][0]["DataType"].should.equal("text")
-    response["Parameters"][0]["LastModifiedDate"].should.equal(
-        initial_modification_date
-    )
-    response["Parameters"][0]["ARN"].should.equal(
+    assert len(response["Parameters"]) == 1
+    assert response["Parameters"][0]["Name"] == name
+    assert response["Parameters"][0]["Value"] == "value"
+    assert response["Parameters"][0]["Type"] == "String"
+    assert response["Parameters"][0]["Version"] == 1
+    assert response["Parameters"][0]["DataType"] == "text"
+    assert response["Parameters"][0]["LastModifiedDate"] == initial_modification_date
+    assert response["Parameters"][0]["ARN"] == (
         f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/{name}"
     )
     new_data_type = "aws:ec2:image"
@@ -294,22 +283,20 @@ def test_put_parameter(name):
         DataType=new_data_type,
     )
 
-    response["Version"].should.equal(2)
+    assert response["Version"] == 2
 
     response = client.get_parameters(Names=[name], WithDecryption=False)
 
     # without overwrite nothing change
-    len(response["Parameters"]).should.equal(1)
-    response["Parameters"][0]["Name"].should.equal(name)
-    response["Parameters"][0]["Value"].should.equal("value 3")
-    response["Parameters"][0]["Type"].should.equal("String")
-    response["Parameters"][0]["Version"].should.equal(2)
-    response["Parameters"][0]["DataType"].should_not.equal("text")
-    response["Parameters"][0]["DataType"].should.equal(new_data_type)
-    response["Parameters"][0]["LastModifiedDate"].should_not.equal(
-        initial_modification_date
-    )
-    response["Parameters"][0]["ARN"].should.equal(
+    assert len(response["Parameters"]) == 1
+    assert response["Parameters"][0]["Name"] == name
+    assert response["Parameters"][0]["Value"] == "value 3"
+    assert response["Parameters"][0]["Type"] == "String"
+    assert response["Parameters"][0]["Version"] == 2
+    assert response["Parameters"][0]["DataType"] != "text"
+    assert response["Parameters"][0]["DataType"] == new_data_type
+    assert response["Parameters"][0]["LastModifiedDate"] != initial_modification_date
+    assert response["Parameters"][0]["ARN"] == (
         f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/{name}"
     )
 
@@ -320,10 +307,10 @@ def test_put_parameter_empty_string_value():
     with pytest.raises(ClientError) as e:
         client.put_parameter(Name="test_name", Value="", Type="String")
     ex = e.value
-    ex.operation_name.should.equal("PutParameter")
-    ex.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
-    ex.response["Error"]["Code"].should.contain("ValidationException")
-    ex.response["Error"]["Message"].should.equal(
+    assert ex.operation_name == "PutParameter"
+    assert ex.response["ResponseMetadata"]["HTTPStatusCode"] == 400
+    assert "ValidationException" in ex.response["Error"]["Code"]
+    assert ex.response["Error"]["Message"] == (
         "1 validation error detected: "
         "Value '' at 'value' failed to satisfy constraint: "
         "Member must have length greater than or equal to 1."
@@ -338,51 +325,55 @@ def test_put_parameter_invalid_names():
         'Parameter name: can\'t be prefixed with "aws" or "ssm" (case-insensitive).'
     )
 
-    client.put_parameter.when.called_with(
-        Name="ssm_test", Value="value", Type="String"
-    ).should.throw(ClientError, invalid_prefix_err)
+    with pytest.raises(ClientError) as client_err:
+        client.put_parameter(Name="ssm_test", Value="value", Type="String")
+    assert client_err.value.response["Error"]["Message"] == invalid_prefix_err
 
-    client.put_parameter.when.called_with(
-        Name="SSM_TEST", Value="value", Type="String"
-    ).should.throw(ClientError, invalid_prefix_err)
+    with pytest.raises(ClientError) as client_err:
+        client.put_parameter(Name="SSM_TEST", Value="value", Type="String")
+    assert client_err.value.response["Error"]["Message"] == invalid_prefix_err
 
-    client.put_parameter.when.called_with(
-        Name="aws_test", Value="value", Type="String"
-    ).should.throw(ClientError, invalid_prefix_err)
+    with pytest.raises(ClientError) as client_err:
+        client.put_parameter(Name="aws_test", Value="value", Type="String")
+    assert client_err.value.response["Error"]["Message"] == invalid_prefix_err
 
-    client.put_parameter.when.called_with(
-        Name="AWS_TEST", Value="value", Type="String"
-    ).should.throw(ClientError, invalid_prefix_err)
+    with pytest.raises(ClientError) as client_err:
+        client.put_parameter(Name="AWS_TEST", Value="value", Type="String")
+    assert client_err.value.response["Error"]["Message"] == invalid_prefix_err
 
     ssm_path = "/ssm_test/path/to/var"
-    client.put_parameter.when.called_with(
-        Name=ssm_path, Value="value", Type="String"
-    ).should.throw(
-        ClientError,
-        'Parameter name: can\'t be prefixed with "ssm" (case-insensitive). If formed as a path, it can consist of '
-        "sub-paths divided by slash symbol; each sub-path can be formed as a mix of letters, numbers and the following "
-        "3 symbols .-_",
+    with pytest.raises(ClientError) as client_err:
+        client.put_parameter(Name=ssm_path, Value="value", Type="String")
+    assert client_err.value.response["Error"]["Message"] == (
+        'Parameter name: can\'t be prefixed with "ssm" (case-insensitive). '
+        "If formed as a path, it can consist of sub-paths divided by slash "
+        "symbol; each sub-path can be formed as a mix of letters, numbers "
+        "and the following 3 symbols .-_"
     )
 
     ssm_path = "/SSM/PATH/TO/VAR"
-    client.put_parameter.when.called_with(
-        Name=ssm_path, Value="value", Type="String"
-    ).should.throw(
-        ClientError,
-        'Parameter name: can\'t be prefixed with "ssm" (case-insensitive). If formed as a path, it can consist of '
-        "sub-paths divided by slash symbol; each sub-path can be formed as a mix of letters, numbers and the following "
-        "3 symbols .-_",
+    with pytest.raises(ClientError) as client_err:
+        client.put_parameter(Name=ssm_path, Value="value", Type="String")
+    assert client_err.value.response["Error"]["Message"] == (
+        'Parameter name: can\'t be prefixed with "ssm" (case-insensitive). '
+        "If formed as a path, it can consist of sub-paths divided by slash "
+        "symbol; each sub-path can be formed as a mix of letters, numbers "
+        "and the following 3 symbols .-_"
     )
 
     aws_path = "/aws_test/path/to/var"
-    client.put_parameter.when.called_with(
-        Name=aws_path, Value="value", Type="String"
-    ).should.throw(ClientError, f"No access to reserved parameter name: {aws_path}.")
+    with pytest.raises(ClientError) as client_err:
+        client.put_parameter(Name=aws_path, Value="value", Type="String")
+    assert client_err.value.response["Error"]["Message"] == (
+        f"No access to reserved parameter name: {aws_path}."
+    )
 
     aws_path = "/AWS/PATH/TO/VAR"
-    client.put_parameter.when.called_with(
-        Name=aws_path, Value="value", Type="String"
-    ).should.throw(ClientError, f"No access to reserved parameter name: {aws_path}.")
+    with pytest.raises(ClientError) as client_err:
+        client.put_parameter(Name=aws_path, Value="value", Type="String")
+    assert client_err.value.response["Error"]["Message"] == (
+        f"No access to reserved parameter name: {aws_path}."
+    )
 
 
 @mock_ssm
@@ -393,7 +384,7 @@ def test_put_parameter_china():
         Name="test", Description="A test parameter", Value="value", Type="String"
     )
 
-    response["Version"].should.equal(1)
+    assert response["Version"] == 1
 
 
 @mock_ssm
@@ -405,10 +396,10 @@ def test_put_parameter_invalid_data_type(bad_data_type):
             Name="test_name", Value="some_value", Type="String", DataType=bad_data_type
         )
     ex = e.value
-    ex.operation_name.should.equal("PutParameter")
-    ex.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
-    ex.response["Error"]["Code"].should.contain("ValidationException")
-    ex.response["Error"]["Message"].should.equal(
+    assert ex.operation_name == "PutParameter"
+    assert ex.response["ResponseMetadata"]["HTTPStatusCode"] == 400
+    assert "ValidationException" in ex.response["Error"]["Code"]
+    assert ex.response["Error"]["Message"] == (
         f"The following data type is not supported: {bad_data_type}"
         " (Data type names are all lowercase.)"
     )
@@ -423,11 +414,13 @@ def test_put_parameter_invalid_type():
             Name="test_name", Value="some_value", Type=bad_type, DataType="text"
         )
     ex = e.value
-    ex.operation_name.should.equal("PutParameter")
-    ex.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
-    ex.response["Error"]["Code"].should.contain("ValidationException")
-    ex.response["Error"]["Message"].should.equal(
-        f"1 validation error detected: Value '{bad_type}' at 'type' failed to satisfy constraint: Member must satisfy enum value set: [SecureString, StringList, String]"
+    assert ex.operation_name == "PutParameter"
+    assert ex.response["ResponseMetadata"]["HTTPStatusCode"] == 400
+    assert "ValidationException" in ex.response["Error"]["Code"]
+    assert ex.response["Error"]["Message"] == (
+        f"1 validation error detected: Value '{bad_type}' at 'type' "
+        "failed to satisfy constraint: Member must satisfy enum value set: "
+        "[SecureString, StringList, String]"
     )
 
 
@@ -500,12 +493,12 @@ def test_update_parameter_already_exists_error():
 
     # Verify
     ex = exc.value
-    assert ex.operation_name.should.equal("PutParameter")
-    assert ex.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
+    assert ex.operation_name == "PutParameter"
+    assert ex.response["ResponseMetadata"]["HTTPStatusCode"] == 400
     assert ex.response["Error"]["Code"] == "ParameterAlreadyExists"
-    assert (
-        ex.response["Error"]["Message"]
-        == "The parameter already exists. To overwrite this value, set the overwrite option in the request to true."
+    assert ex.response["Error"]["Message"] == (
+        "The parameter already exists. To overwrite this value, set the "
+        "overwrite option in the request to true."
     )
 
 
@@ -519,12 +512,12 @@ def test_get_parameter():
 
     response = client.get_parameter(Name="test", WithDecryption=False)
 
-    response["Parameter"]["Name"].should.equal("test")
-    response["Parameter"]["Value"].should.equal("value")
-    response["Parameter"]["Type"].should.equal("String")
-    response["Parameter"]["DataType"].should.equal("text")
-    response["Parameter"]["LastModifiedDate"].should.be.a(datetime.datetime)
-    response["Parameter"]["ARN"].should.equal(
+    assert response["Parameter"]["Name"] == "test"
+    assert response["Parameter"]["Value"] == "value"
+    assert response["Parameter"]["Type"] == "String"
+    assert response["Parameter"]["DataType"] == "text"
+    assert isinstance(response["Parameter"]["LastModifiedDate"], datetime.datetime)
+    assert response["Parameter"]["ARN"] == (
         f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/test"
     )
 
@@ -546,53 +539,51 @@ def test_get_parameter_with_version_and_labels():
 
     response = client.get_parameter(Name="test-1:1", WithDecryption=False)
 
-    response["Parameter"]["Name"].should.equal("test-1")
-    response["Parameter"]["Value"].should.equal("value")
-    response["Parameter"]["Type"].should.equal("String")
-    response["Parameter"]["DataType"].should.equal("text")
-    response["Parameter"]["LastModifiedDate"].should.be.a(datetime.datetime)
-    response["Parameter"]["ARN"].should.equal(
+    assert response["Parameter"]["Name"] == "test-1"
+    assert response["Parameter"]["Value"] == "value"
+    assert response["Parameter"]["Type"] == "String"
+    assert response["Parameter"]["DataType"] == "text"
+    assert isinstance(response["Parameter"]["LastModifiedDate"], datetime.datetime)
+    assert response["Parameter"]["ARN"] == (
         f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/test-1"
     )
 
     response = client.get_parameter(Name="test-2:1", WithDecryption=False)
-    response["Parameter"]["Name"].should.equal("test-2")
-    response["Parameter"]["Value"].should.equal("value")
-    response["Parameter"]["Type"].should.equal("String")
-    response["Parameter"]["DataType"].should.equal("text")
-    response["Parameter"]["LastModifiedDate"].should.be.a(datetime.datetime)
-    response["Parameter"]["ARN"].should.equal(
+    assert response["Parameter"]["Name"] == "test-2"
+    assert response["Parameter"]["Value"] == "value"
+    assert response["Parameter"]["Type"] == "String"
+    assert response["Parameter"]["DataType"] == "text"
+    assert isinstance(response["Parameter"]["LastModifiedDate"], datetime.datetime)
+    assert response["Parameter"]["ARN"] == (
         f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/test-2"
     )
 
     response = client.get_parameter(Name="test-2:test-label", WithDecryption=False)
-    response["Parameter"]["Name"].should.equal("test-2")
-    response["Parameter"]["Value"].should.equal("value")
-    response["Parameter"]["Type"].should.equal("String")
-    response["Parameter"]["DataType"].should.equal("text")
-    response["Parameter"]["LastModifiedDate"].should.be.a(datetime.datetime)
-    response["Parameter"]["ARN"].should.equal(
+    assert response["Parameter"]["Name"] == "test-2"
+    assert response["Parameter"]["Value"] == "value"
+    assert response["Parameter"]["Type"] == "String"
+    assert response["Parameter"]["DataType"] == "text"
+    assert isinstance(response["Parameter"]["LastModifiedDate"], datetime.datetime)
+    assert response["Parameter"]["ARN"] == (
         f"arn:aws:ssm:us-east-1:{ACCOUNT_ID}:parameter/test-2"
     )
 
     with pytest.raises(ClientError) as ex:
         client.get_parameter(Name="test-2:2:3", WithDecryption=False)
-    ex.value.response["Error"]["Code"].should.equal("ParameterNotFound")
-    ex.value.response["Error"]["Message"].should.equal(
-        "Parameter test-2:2:3 not found."
-    )
+    assert ex.value.response["Error"]["Code"] == "ParameterNotFound"
+    assert ex.value.response["Error"]["Message"] == ("Parameter test-2:2:3 not found.")
 
     with pytest.raises(ClientError) as ex:
         client.get_parameter(Name="test-2:2", WithDecryption=False)
-    ex.value.response["Error"]["Code"].should.equal("ParameterVersionNotFound")
-    ex.value.response["Error"]["Message"].should.equal(
+    assert ex.value.response["Error"]["Code"] == "ParameterVersionNotFound"
+    assert ex.value.response["Error"]["Message"] == (
         "Systems Manager could not find version 2 of test-2. Verify the version and try again."
     )
 
     with pytest.raises(ClientError) as ex:
         client.get_parameter(Name="test-3:2", WithDecryption=False)
-    ex.value.response["Error"]["Code"].should.equal("ParameterNotFound")
-    ex.value.response["Error"]["Message"].should.equal("Parameter test-3:2 not found.")
+    assert ex.value.response["Error"]["Code"] == "ParameterNotFound"
+    assert ex.value.response["Error"]["Message"] == "Parameter test-3:2 not found."
 
 
 @mock_ssm
@@ -607,11 +598,11 @@ def test_get_parameters_errors():
     with pytest.raises(ClientError) as e:
         client.get_parameters(Names=list(ssm_parameters.keys()))
     ex = e.value
-    ex.operation_name.should.equal("GetParameters")
-    ex.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
-    ex.response["Error"]["Code"].should.contain("ValidationException")
+    assert ex.operation_name == "GetParameters"
+    assert ex.response["ResponseMetadata"]["HTTPStatusCode"] == 400
+    assert "ValidationException" in ex.response["Error"]["Code"]
     all_keys = ", ".join(ssm_parameters.keys())
-    ex.response["Error"]["Message"].should.equal(
+    assert ex.response["Error"]["Message"] == (
         "1 validation error detected: "
         f"Value '[{all_keys}]' at 'names' failed to satisfy constraint: "
         "Member must have length less than or equal to 10."
@@ -626,10 +617,8 @@ def test_get_nonexistant_parameter():
         client.get_parameter(Name="test_noexist", WithDecryption=False)
         raise RuntimeError("Should have failed")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("GetParameter")
-        err.response["Error"]["Message"].should.equal(
-            "Parameter test_noexist not found."
-        )
+        assert err.operation_name == "GetParameter"
+        assert err.response["Error"]["Message"] == "Parameter test_noexist not found."
 
 
 @mock_ssm
@@ -647,11 +636,11 @@ def test_describe_parameters():
     response = client.describe_parameters()
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("test")
-    parameters[0]["Type"].should.equal("String")
-    parameters[0]["DataType"].should.equal("text")
-    parameters[0]["AllowedPattern"].should.equal(r".*")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "test"
+    assert parameters[0]["Type"] == "String"
+    assert parameters[0]["DataType"] == "text"
+    assert parameters[0]["AllowedPattern"] == r".*"
 
 
 @mock_ssm
@@ -662,28 +651,28 @@ def test_describe_parameters_paging():
         client.put_parameter(Name=f"param-{i}", Value=f"value-{i}", Type="String")
 
     response = client.describe_parameters()
-    response["Parameters"].should.have.length_of(10)
-    response["NextToken"].should.equal("10")
+    assert len(response["Parameters"]) == 10
+    assert response["NextToken"] == "10"
 
     response = client.describe_parameters(NextToken=response["NextToken"])
-    response["Parameters"].should.have.length_of(10)
-    response["NextToken"].should.equal("20")
+    assert len(response["Parameters"]) == 10
+    assert response["NextToken"] == "20"
 
     response = client.describe_parameters(NextToken=response["NextToken"])
-    response["Parameters"].should.have.length_of(10)
-    response["NextToken"].should.equal("30")
+    assert len(response["Parameters"]) == 10
+    assert response["NextToken"] == "30"
 
     response = client.describe_parameters(NextToken=response["NextToken"])
-    response["Parameters"].should.have.length_of(10)
-    response["NextToken"].should.equal("40")
+    assert len(response["Parameters"]) == 10
+    assert response["NextToken"] == "40"
 
     response = client.describe_parameters(NextToken=response["NextToken"])
-    response["Parameters"].should.have.length_of(10)
-    response["NextToken"].should.equal("50")
+    assert len(response["Parameters"]) == 10
+    assert response["NextToken"] == "50"
 
     response = client.describe_parameters(NextToken=response["NextToken"])
-    response["Parameters"].should.have.length_of(0)
-    response.should_not.have.key("NextToken")
+    assert len(response["Parameters"]) == 0
+    assert "NextToken" not in response
 
 
 @mock_ssm
@@ -702,10 +691,10 @@ def test_describe_parameters_filter_names():
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("param-22")
-    parameters[0]["Type"].should.equal("String")
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "param-22"
+    assert parameters[0]["Type"] == "String"
+    assert "NextToken" not in response
 
 
 @mock_ssm
@@ -724,9 +713,9 @@ def test_describe_parameters_filter_type():
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(10)
-    parameters[0]["Type"].should.equal("SecureString")
-    response.should.have.key("NextToken").which.should.equal("10")
+    assert len(parameters) == 10
+    assert parameters[0]["Type"] == "SecureString"
+    assert response["NextToken"] == "10"
 
 
 @mock_ssm
@@ -745,10 +734,10 @@ def test_describe_parameters_filter_keyid():
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("param-10")
-    parameters[0]["Type"].should.equal("SecureString")
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "param-10"
+    assert parameters[0]["Type"] == "SecureString"
+    assert "NextToken" not in response
 
 
 @mock_ssm
@@ -768,28 +757,28 @@ def test_describe_parameters_with_parameter_filters_keyid():
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("secure-param")
-    parameters[0]["Type"].should.equal("SecureString")
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "secure-param"
+    assert parameters[0]["Type"] == "SecureString"
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "KeyId", "Values": ["alias/custom"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("custom-secure-param")
-    parameters[0]["Type"].should.equal("SecureString")
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "custom-secure-param"
+    assert parameters[0]["Type"] == "SecureString"
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "KeyId", "Option": "BeginsWith", "Values": ["alias"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(2)
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 2
+    assert "NextToken" not in response
 
 
 @mock_ssm
@@ -806,54 +795,54 @@ def test_describe_parameters_with_parameter_filters_name():
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("param")
-    parameters[0]["Type"].should.equal("String")
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "param"
+    assert parameters[0]["Type"] == "String"
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Name", "Values": ["/param"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("param")
-    parameters[0]["Type"].should.equal("String")
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "param"
+    assert parameters[0]["Type"] == "String"
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Name", "Values": ["param-2"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("/param-2")
-    parameters[0]["Type"].should.equal("String")
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "/param-2"
+    assert parameters[0]["Type"] == "String"
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Name", "Option": "BeginsWith", "Values": ["param"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(2)
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 2
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Name", "Option": "Contains", "Values": ["ram"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(3)
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 3
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Name", "Option": "Contains", "Values": ["/tan"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(2)
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 2
+    assert "NextToken" not in response
 
 
 @mock_ssm
@@ -874,40 +863,43 @@ def test_describe_parameters_with_parameter_filters_path():
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(0)
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 0
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Path", "Values": ["/"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("foo")
-    parameters[0]["Type"].should.equal("String")
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "foo"
+    assert parameters[0]["Type"] == "String"
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Path", "Values": ["/", "/foo"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(3)
-    {parameter["Name"] for parameter in response["Parameters"]}.should.equal(
-        {"/foo/name1", "/foo/name2", "foo"}
-    )
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 3
+    assert {parameter["Name"] for parameter in response["Parameters"]} == {
+        "/foo/name1",
+        "/foo/name2",
+        "foo",
+    }
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Path", "Values": ["/foo/"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(2)
-    {parameter["Name"] for parameter in response["Parameters"]}.should.equal(
-        {"/foo/name1", "/foo/name2"}
-    )
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 2
+    assert {parameter["Name"] for parameter in response["Parameters"]} == {
+        "/foo/name1",
+        "/foo/name2",
+    }
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[
@@ -916,26 +908,26 @@ def test_describe_parameters_with_parameter_filters_path():
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("/bar/name3/name4")
-    parameters[0]["Type"].should.equal("String")
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "/bar/name3/name4"
+    assert parameters[0]["Type"] == "String"
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Path", "Option": "Recursive", "Values": ["/fo"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(0)
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 0
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Path", "Option": "Recursive", "Values": ["/"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(5)
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 5
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[
@@ -944,22 +936,26 @@ def test_describe_parameters_with_parameter_filters_path():
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(4)
-    {parameter["Name"] for parameter in response["Parameters"]}.should.equal(
-        {"/foo/name1", "/foo/name2", "/bar/name3", "/bar/name3/name4"}
-    )
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 4
+    assert {parameter["Name"] for parameter in response["Parameters"]} == {
+        "/foo/name1",
+        "/foo/name2",
+        "/bar/name3",
+        "/bar/name3/name4",
+    }
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[{"Key": "Path", "Option": "Recursive", "Values": ["/foo/"]}]
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(2)
-    {parameter["Name"] for parameter in response["Parameters"]}.should.equal(
-        {"/foo/name1", "/foo/name2"}
-    )
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 2
+    assert {parameter["Name"] for parameter in response["Parameters"]} == {
+        "/foo/name1",
+        "/foo/name2",
+    }
+    assert "NextToken" not in response
 
     response = client.describe_parameters(
         ParameterFilters=[
@@ -968,21 +964,22 @@ def test_describe_parameters_with_parameter_filters_path():
     )
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(1)
-    parameters[0]["Name"].should.equal("/bar/name3/name4")
-    parameters[0]["Type"].should.equal("String")
-    response.should_not.have.key("NextToken")
+    assert len(parameters) == 1
+    assert parameters[0]["Name"] == "/bar/name3/name4"
+    assert parameters[0]["Type"] == "String"
+    assert "NextToken" not in response
 
 
 @mock_ssm
 def test_describe_parameters_needs_param():
     client = boto3.client("ssm", region_name="us-east-1")
-    client.describe_parameters.when.called_with(
-        Filters=[{"Key": "Name", "Values": ["test"]}],
-        ParameterFilters=[{"Key": "Name", "Values": ["test"]}],
-    ).should.throw(
-        ClientError,
-        "You can use either Filters or ParameterFilters in a single request.",
+    with pytest.raises(ClientError) as client_err:
+        client.describe_parameters(
+            Filters=[{"Key": "Name", "Values": ["test"]}],
+            ParameterFilters=[{"Key": "Name", "Values": ["test"]}],
+        )
+    assert client_err.value.response["Error"]["Message"] == (
+        "You can use either Filters or ParameterFilters in a single request."
     )
 
 
@@ -991,7 +988,10 @@ def test_describe_parameters_needs_param():
     [
         (
             [{"Key": "key"}],
-            "Member must satisfy regular expression pattern: tag:.+|Name|Type|KeyId|Path|Label|Tier",
+            (
+                "Member must satisfy regular expression pattern: "
+                "tag:.+|Name|Type|KeyId|Path|Label|Tier"
+            ),
         ),
         (
             [{"Key": "tag:" + "t" * 129}],
@@ -1007,7 +1007,10 @@ def test_describe_parameters_needs_param():
         ),
         (
             [{"Key": "Name", "Values": ["t" * 1025]}],
-            "Member must have length less than or equal to 1024, Member must have length greater than or equal to 1",
+            (
+                "Member must have length less than or equal to 1024, "
+                "Member must have length greater than or equal to 1"
+            ),
         ),
         (
             [{"Key": "Name", "Option": "over 10 chars"}, {"Key": "key"}],
@@ -1015,7 +1018,10 @@ def test_describe_parameters_needs_param():
         ),
         (
             [{"Key": "Label"}],
-            "The following filter key is not valid: Label. Valid filter keys include: [Path, Name, Type, KeyId, Tier]",
+            (
+                "The following filter key is not valid: Label. Valid "
+                "filter keys include: [Path, Name, Type, KeyId, Tier]"
+            ),
         ),
         (
             [{"Key": "Name"}],
@@ -1026,27 +1032,45 @@ def test_describe_parameters_needs_param():
                 {"Key": "Name", "Values": ["test"]},
                 {"Key": "Name", "Values": ["test test"]},
             ],
-            "The following filter is duplicated in the request: Name. A request can contain only one occurrence of a specific filter.",
+            (
+                "The following filter is duplicated in the request: Name. "
+                "A request can contain only one occurrence of a specific filter."
+            ),
         ),
         (
             [{"Key": "Path", "Values": ["/aws", "/ssm"]}],
-            'Filters for common parameters can\'t be prefixed with "aws" or "ssm" (case-insensitive).',
+            (
+                "Filters for common parameters can't be prefixed with "
+                '"aws" or "ssm" (case-insensitive).'
+            ),
         ),
         (
             [{"Key": "Path", "Option": "Equals", "Values": ["test"]}],
-            "The following filter option is not valid: Equals. Valid options include: [Recursive, OneLevel]",
+            (
+                "The following filter option is not valid: Equals. "
+                "Valid options include: [Recursive, OneLevel]"
+            ),
         ),
         (
             [{"Key": "Tier", "Values": ["test"]}],
-            "The following filter value is not valid: test. Valid values include: [Standard, Advanced, Intelligent-Tiering]",
+            (
+                "The following filter value is not valid: test. Valid "
+                "values include: [Standard, Advanced, Intelligent-Tiering]"
+            ),
         ),
         (
             [{"Key": "Type", "Values": ["test"]}],
-            "The following filter value is not valid: test. Valid values include: [String, StringList, SecureString]",
+            (
+                "The following filter value is not valid: test. Valid "
+                "values include: [String, StringList, SecureString]"
+            ),
         ),
         (
             [{"Key": "Name", "Option": "option", "Values": ["test"]}],
-            "The following filter option is not valid: option. Valid options include: [BeginsWith, Equals].",
+            (
+                "The following filter option is not valid: option. Valid "
+                "options include: [BeginsWith, Equals]."
+            ),
         ),
     ],
 )
@@ -1056,7 +1080,7 @@ def test_describe_parameters_invalid_parameter_filters(filters, error_msg):
 
     with pytest.raises(ClientError) as e:
         client.describe_parameters(ParameterFilters=filters)
-    e.value.response["Error"]["Message"].should.contain(error_msg)
+    assert error_msg in e.value.response["Error"]["Message"]
 
 
 @pytest.mark.parametrize("value", ["/###", "//", "test"])
@@ -1069,16 +1093,18 @@ def test_describe_parameters_invalid_path(value):
             ParameterFilters=[{"Key": "Path", "Values": [value]}]
         )
     msg = e.value.response["Error"]["Message"]
-    msg.should.contain("The parameter doesn't meet the parameter name requirements")
-    msg.should.contain('The parameter name must begin with a forward slash "/".')
-    msg.should.contain('It can\'t be prefixed with "aws" or "ssm" (case-insensitive).')
-    msg.should.contain(
-        "It must use only letters, numbers, or the following symbols: . (period), - (hyphen), _ (underscore)."
-    )
-    msg.should.contain(
-        'Special characters are not allowed. All sub-paths, if specified, must use the forward slash symbol "/".'
-    )
-    msg.should.contain("Valid example: /get/parameters2-/by1./path0_.")
+    assert "The parameter doesn't meet the parameter name requirements" in msg
+    assert 'The parameter name must begin with a forward slash "/".' in msg
+    assert 'It can\'t be prefixed with "aws" or "ssm" (case-insensitive).' in msg
+    assert (
+        "It must use only letters, numbers, or the following symbols: . "
+        "(period), - (hyphen), _ (underscore)."
+    ) in msg
+    assert (
+        "Special characters are not allowed. All sub-paths, if specified, "
+        'must use the forward slash symbol "/".'
+    ) in msg
+    assert "Valid example: /get/parameters2-/by1./path0_." in msg
 
 
 @mock_ssm
@@ -1094,15 +1120,15 @@ def test_describe_parameters_attributes():
     response = client.describe_parameters()
 
     parameters = response["Parameters"]
-    parameters.should.have.length_of(2)
+    assert len(parameters) == 2
 
-    parameters[0]["Description"].should.equal("my description")
-    parameters[0]["Version"].should.equal(1)
-    parameters[0]["LastModifiedDate"].should.be.a(datetime.date)
-    parameters[0]["LastModifiedUser"].should.equal("N/A")
+    assert parameters[0]["Description"] == "my description"
+    assert parameters[0]["Version"] == 1
+    assert isinstance(parameters[0]["LastModifiedDate"], datetime.date)
+    assert parameters[0]["LastModifiedUser"] == "N/A"
 
-    parameters[1].should_not.have.key("Description")
-    parameters[1]["Version"].should.equal(1)
+    assert "Description" not in parameters[1]
+    assert parameters[1]["Version"] == 1
 
 
 @mock_ssm
@@ -1148,7 +1174,7 @@ def test_describe_parameters__multiple_tags():
             {"Key": "tag:hello", "Option": "Equals", "Values": ["world"]},
         ]
     )
-    response["Parameters"].should.have.length_of(1)
+    assert len(response["Parameters"]) == 1
 
     # Both params contains hello:world - ensure we also check the second tag, x=b
     response = client.describe_parameters(
@@ -1157,19 +1183,29 @@ def test_describe_parameters__multiple_tags():
             {"Key": "tag:x", "Option": "Equals", "Values": ["b"]},
         ]
     )
-    response["Parameters"].should.have.length_of(1)
+    assert len(response["Parameters"]) == 1
 
     # tag begins_with should also work
-    client.describe_parameters(
-        ParameterFilters=[
-            {"Key": "tag:hello", "Option": "BeginsWith", "Values": ["w"]},
-        ]
-    )["Parameters"].should.have.length_of(2)
-    client.describe_parameters(
-        ParameterFilters=[
-            {"Key": "tag:x", "Option": "BeginsWith", "Values": ["a"]},
-        ]
-    )["Parameters"].should.have.length_of(1)
+    assert (
+        len(
+            client.describe_parameters(
+                ParameterFilters=[
+                    {"Key": "tag:hello", "Option": "BeginsWith", "Values": ["w"]},
+                ]
+            )["Parameters"]
+        )
+        == 2
+    )
+    assert (
+        len(
+            client.describe_parameters(
+                ParameterFilters=[
+                    {"Key": "tag:x", "Option": "BeginsWith", "Values": ["a"]},
+                ]
+            )["Parameters"]
+        )
+        == 1
+    )
 
 
 @mock_ssm
@@ -1218,9 +1254,9 @@ def test_get_parameter_invalid():
     client = client = boto3.client("ssm", region_name="us-east-1")
     response = client.get_parameters(Names=["invalid"], WithDecryption=False)
 
-    len(response["Parameters"]).should.equal(0)
-    len(response["InvalidParameters"]).should.equal(1)
-    response["InvalidParameters"][0].should.equal("invalid")
+    assert len(response["Parameters"]) == 0
+    assert len(response["InvalidParameters"]) == 1
+    assert response["InvalidParameters"][0] == "invalid"
 
 
 @mock_ssm
@@ -1233,17 +1269,17 @@ def test_put_parameter_secure_default_kms():
 
     response = client.get_parameters(Names=["test"], WithDecryption=False)
 
-    len(response["Parameters"]).should.equal(1)
-    response["Parameters"][0]["Name"].should.equal("test")
-    response["Parameters"][0]["Value"].should.equal("kms:alias/aws/ssm:value")
-    response["Parameters"][0]["Type"].should.equal("SecureString")
+    assert len(response["Parameters"]) == 1
+    assert response["Parameters"][0]["Name"] == "test"
+    assert response["Parameters"][0]["Value"] == "kms:alias/aws/ssm:value"
+    assert response["Parameters"][0]["Type"] == "SecureString"
 
     response = client.get_parameters(Names=["test"], WithDecryption=True)
 
-    len(response["Parameters"]).should.equal(1)
-    response["Parameters"][0]["Name"].should.equal("test")
-    response["Parameters"][0]["Value"].should.equal("value")
-    response["Parameters"][0]["Type"].should.equal("SecureString")
+    assert len(response["Parameters"]) == 1
+    assert response["Parameters"][0]["Name"] == "test"
+    assert response["Parameters"][0]["Value"] == "value"
+    assert response["Parameters"][0]["Type"] == "SecureString"
 
 
 @mock_ssm
@@ -1260,17 +1296,17 @@ def test_put_parameter_secure_custom_kms():
 
     response = client.get_parameters(Names=["test"], WithDecryption=False)
 
-    len(response["Parameters"]).should.equal(1)
-    response["Parameters"][0]["Name"].should.equal("test")
-    response["Parameters"][0]["Value"].should.equal("kms:foo:value")
-    response["Parameters"][0]["Type"].should.equal("SecureString")
+    assert len(response["Parameters"]) == 1
+    assert response["Parameters"][0]["Name"] == "test"
+    assert response["Parameters"][0]["Value"] == "kms:foo:value"
+    assert response["Parameters"][0]["Type"] == "SecureString"
 
     response = client.get_parameters(Names=["test"], WithDecryption=True)
 
-    len(response["Parameters"]).should.equal(1)
-    response["Parameters"][0]["Name"].should.equal("test")
-    response["Parameters"][0]["Value"].should.equal("value")
-    response["Parameters"][0]["Type"].should.equal("SecureString")
+    assert len(response["Parameters"]) == 1
+    assert response["Parameters"][0]["Name"] == "test"
+    assert response["Parameters"][0]["Value"] == "value"
+    assert response["Parameters"][0]["Type"] == "SecureString"
 
 
 @mock_ssm
@@ -1292,14 +1328,14 @@ def test_get_parameter_history():
     parameters_response = response["Parameters"]
 
     for index, param in enumerate(parameters_response):
-        param["Name"].should.equal(test_parameter_name)
-        param["Type"].should.equal("String")
-        param["Value"].should.equal(f"value-{index}")
-        param["Version"].should.equal(index + 1)
-        param["Description"].should.equal(f"A test parameter version {index}")
-        param["Labels"].should.equal([])
+        assert param["Name"] == test_parameter_name
+        assert param["Type"] == "String"
+        assert param["Value"] == f"value-{index}"
+        assert param["Version"] == index + 1
+        assert param["Description"] == f"A test parameter version {index}"
+        assert param["Labels"] == []
 
-    len(parameters_response).should.equal(3)
+    assert len(parameters_response) == 3
 
 
 @mock_ssm
@@ -1324,19 +1360,19 @@ def test_get_parameter_history_with_secure_string():
         parameters_response = response["Parameters"]
 
         for index, param in enumerate(parameters_response):
-            param["Name"].should.equal(test_parameter_name)
-            param["Type"].should.equal("SecureString")
+            assert param["Name"] == test_parameter_name
+            assert param["Type"] == "SecureString"
             expected_plaintext_value = f"value-{index}"
             if with_decryption:
-                param["Value"].should.equal(expected_plaintext_value)
+                assert param["Value"] == expected_plaintext_value
             else:
-                param["Value"].should.equal(
+                assert param["Value"] == (
                     f"kms:alias/aws/ssm:{expected_plaintext_value}"
                 )
-            param["Version"].should.equal(index + 1)
-            param["Description"].should.equal(f"A test parameter version {index}")
+            assert param["Version"] == index + 1
+            assert param["Description"] == f"A test parameter version {index}"
 
-        len(parameters_response).should.equal(3)
+        assert len(parameters_response) == 3
 
 
 @mock_ssm
@@ -1354,8 +1390,8 @@ def test_label_parameter_version():
     response = client.label_parameter_version(
         Name=test_parameter_name, Labels=["test-label"]
     )
-    response["InvalidLabels"].should.equal([])
-    response["ParameterVersion"].should.equal(1)
+    assert response["InvalidLabels"] == []
+    assert response["ParameterVersion"] == 1
 
 
 @mock_ssm
@@ -1373,8 +1409,8 @@ def test_label_parameter_version_with_specific_version():
     response = client.label_parameter_version(
         Name=test_parameter_name, ParameterVersion=1, Labels=["test-label"]
     )
-    response["InvalidLabels"].should.equal([])
-    response["ParameterVersion"].should.equal(1)
+    assert response["InvalidLabels"] == []
+    assert response["ParameterVersion"] == 1
 
 
 @mock_ssm
@@ -1393,17 +1429,17 @@ def test_label_parameter_version_twice():
     response = client.label_parameter_version(
         Name=test_parameter_name, ParameterVersion=1, Labels=test_labels
     )
-    response["InvalidLabels"].should.equal([])
-    response["ParameterVersion"].should.equal(1)
+    assert response["InvalidLabels"] == []
+    assert response["ParameterVersion"] == 1
     response = client.label_parameter_version(
         Name=test_parameter_name, ParameterVersion=1, Labels=test_labels
     )
-    response["InvalidLabels"].should.equal([])
-    response["ParameterVersion"].should.equal(1)
+    assert response["InvalidLabels"] == []
+    assert response["ParameterVersion"] == 1
 
     response = client.get_parameter_history(Name=test_parameter_name)
-    len(response["Parameters"]).should.equal(1)
-    response["Parameters"][0]["Labels"].should.equal(test_labels)
+    assert len(response["Parameters"]) == 1
+    assert response["Parameters"][0]["Labels"] == test_labels
 
 
 @mock_ssm
@@ -1425,27 +1461,27 @@ def test_label_parameter_moving_versions():
     response = client.label_parameter_version(
         Name=test_parameter_name, ParameterVersion=1, Labels=test_labels
     )
-    response["InvalidLabels"].should.equal([])
-    response["ParameterVersion"].should.equal(1)
+    assert response["InvalidLabels"] == []
+    assert response["ParameterVersion"] == 1
     response = client.label_parameter_version(
         Name=test_parameter_name, ParameterVersion=2, Labels=test_labels
     )
-    response["InvalidLabels"].should.equal([])
-    response["ParameterVersion"].should.equal(2)
+    assert response["InvalidLabels"] == []
+    assert response["ParameterVersion"] == 2
 
     response = client.get_parameter_history(Name=test_parameter_name)
     parameters_response = response["Parameters"]
 
     for index, param in enumerate(parameters_response):
-        param["Name"].should.equal(test_parameter_name)
-        param["Type"].should.equal("String")
-        param["Value"].should.equal(f"value-{index}")
-        param["Version"].should.equal(index + 1)
-        param["Description"].should.equal(f"A test parameter version {index}")
+        assert param["Name"] == test_parameter_name
+        assert param["Type"] == "String"
+        assert param["Value"] == f"value-{index}"
+        assert param["Version"] == index + 1
+        assert param["Description"] == f"A test parameter version {index}"
         labels = test_labels if param["Version"] == 2 else []
-        param["Labels"].should.equal(labels)
+        assert param["Labels"] == labels
 
-    len(parameters_response).should.equal(3)
+    assert len(parameters_response) == 3
 
 
 @mock_ssm
@@ -1468,33 +1504,33 @@ def test_label_parameter_moving_versions_complex():
         ParameterVersion=1,
         Labels=["test-label1", "test-label2", "test-label3"],
     )
-    response["InvalidLabels"].should.equal([])
-    response["ParameterVersion"].should.equal(1)
+    assert response["InvalidLabels"] == []
+    assert response["ParameterVersion"] == 1
     response = client.label_parameter_version(
         Name=test_parameter_name,
         ParameterVersion=2,
         Labels=["test-label2", "test-label3"],
     )
-    response["InvalidLabels"].should.equal([])
-    response["ParameterVersion"].should.equal(2)
+    assert response["InvalidLabels"] == []
+    assert response["ParameterVersion"] == 2
 
     response = client.get_parameter_history(Name=test_parameter_name)
     parameters_response = response["Parameters"]
 
     for index, param in enumerate(parameters_response):
-        param["Name"].should.equal(test_parameter_name)
-        param["Type"].should.equal("String")
-        param["Value"].should.equal(f"value-{index}")
-        param["Version"].should.equal(index + 1)
-        param["Description"].should.equal(f"A test parameter version {index}")
+        assert param["Name"] == test_parameter_name
+        assert param["Type"] == "String"
+        assert param["Value"] == f"value-{index}"
+        assert param["Version"] == index + 1
+        assert param["Description"] == f"A test parameter version {index}"
         labels = (
             ["test-label2", "test-label3"]
             if param["Version"] == 2
             else (["test-label1"] if param["Version"] == 1 else [])
         )
-        param["Labels"].should.equal(labels)
+        assert param["Labels"] == labels
 
-    len(parameters_response).should.equal(3)
+    assert len(parameters_response) == 3
 
 
 @mock_ssm
@@ -1522,13 +1558,15 @@ def test_label_parameter_version_exception_ten_labels_at_once():
         Value="value",
         Type="String",
     )
-    client.label_parameter_version.when.called_with(
-        Name="test", ParameterVersion=1, Labels=test_labels
-    ).should.throw(
-        ClientError,
-        "An error occurred (ParameterVersionLabelLimitExceeded) when calling the LabelParameterVersion operation: "
+    with pytest.raises(ClientError) as client_err:
+        client.label_parameter_version(
+            Name="test", ParameterVersion=1, Labels=test_labels
+        )
+    assert client_err.value.response["Error"]["Message"] == (
+        "An error occurred (ParameterVersionLabelLimitExceeded) when "
+        "calling the LabelParameterVersion operation: "
         "A parameter version can have maximum 10 labels."
-        "Move one or more labels to another version and try again.",
+        "Move one or more labels to another version and try again."
     )
 
 
@@ -1555,22 +1593,24 @@ def test_label_parameter_version_exception_ten_labels_over_multiple_calls():
             "test-label5",
         ],
     )
-    client.label_parameter_version.when.called_with(
-        Name="test",
-        ParameterVersion=1,
-        Labels=[
-            "test-label6",
-            "test-label7",
-            "test-label8",
-            "test-label9",
-            "test-label10",
-            "test-label11",
-        ],
-    ).should.throw(
-        ClientError,
-        "An error occurred (ParameterVersionLabelLimitExceeded) when calling the LabelParameterVersion operation: "
+    with pytest.raises(ClientError) as client_err:
+        client.label_parameter_version(
+            Name="test",
+            ParameterVersion=1,
+            Labels=[
+                "test-label6",
+                "test-label7",
+                "test-label8",
+                "test-label9",
+                "test-label10",
+                "test-label11",
+            ],
+        )
+    assert client_err.value.response["Error"]["Message"] == (
+        "An error occurred (ParameterVersionLabelLimitExceeded) when "
+        "calling the LabelParameterVersion operation: "
         "A parameter version can have maximum 10 labels."
-        "Move one or more labels to another version and try again.",
+        "Move one or more labels to another version and try again."
     )
 
 
@@ -1580,13 +1620,9 @@ def test_label_parameter_version_invalid_name():
 
     test_parameter_name = "test"
 
-    client.label_parameter_version.when.called_with(
-        Name=test_parameter_name, Labels=["test-label"]
-    ).should.throw(
-        ClientError,
-        "An error occurred (ParameterNotFound) when calling the LabelParameterVersion operation: "
-        "Parameter test not found.",
-    )
+    with pytest.raises(ClientError) as client_err:
+        client.label_parameter_version(Name=test_parameter_name, Labels=["test-label"])
+    assert client_err.value.response["Error"]["Message"] == "Parameter test not found."
 
 
 @mock_ssm
@@ -1601,13 +1637,13 @@ def test_label_parameter_version_invalid_parameter_version():
         Type="String",
     )
 
-    client.label_parameter_version.when.called_with(
-        Name=test_parameter_name, Labels=["test-label"], ParameterVersion=5
-    ).should.throw(
-        ClientError,
-        "An error occurred (ParameterVersionNotFound) when calling the LabelParameterVersion operation: "
+    with pytest.raises(ClientError) as client_err:
+        client.label_parameter_version(
+            Name=test_parameter_name, Labels=["test-label"], ParameterVersion=5
+        )
+    assert client_err.value.response["Error"]["Message"] == (
         "Systems Manager could not find version 5 of test. "
-        "Verify the version and try again.",
+        "Verify the version and try again."
     )
 
 
@@ -1625,32 +1661,34 @@ def test_label_parameter_version_invalid_label():
     response = client.label_parameter_version(
         Name=test_parameter_name, ParameterVersion=1, Labels=["awsabc"]
     )
-    response["InvalidLabels"].should.equal(["awsabc"])
+    assert response["InvalidLabels"] == ["awsabc"]
 
     response = client.label_parameter_version(
         Name=test_parameter_name, ParameterVersion=1, Labels=["ssmabc"]
     )
-    response["InvalidLabels"].should.equal(["ssmabc"])
+    assert response["InvalidLabels"] == ["ssmabc"]
 
     response = client.label_parameter_version(
         Name=test_parameter_name, ParameterVersion=1, Labels=["9abc"]
     )
-    response["InvalidLabels"].should.equal(["9abc"])
+    assert response["InvalidLabels"] == ["9abc"]
 
     response = client.label_parameter_version(
         Name=test_parameter_name, ParameterVersion=1, Labels=["abc/123"]
     )
-    response["InvalidLabels"].should.equal(["abc/123"])
+    assert response["InvalidLabels"] == ["abc/123"]
 
     long_name = "a" * 101
-    client.label_parameter_version.when.called_with(
-        Name=test_parameter_name, ParameterVersion=1, Labels=[long_name]
-    ).should.throw(
-        ClientError,
+    with pytest.raises(ClientError) as client_err:
+        client.label_parameter_version(
+            Name=test_parameter_name, ParameterVersion=1, Labels=[long_name]
+        )
+    assert client_err.value.response["Error"]["Message"] == (
         "1 validation error detected: "
         f"Value '[{long_name}]' at 'labels' failed to satisfy constraint: "
         "Member must satisfy constraint: "
-        "[Member must have length less than or equal to 100, Member must have length greater than or equal to 1]",
+        "[Member must have length less than or equal to 100, Member must "
+        "have length greater than or equal to 1]"
     )
 
 
@@ -1678,15 +1716,15 @@ def test_get_parameter_history_with_label():
     parameters_response = response["Parameters"]
 
     for index, param in enumerate(parameters_response):
-        param["Name"].should.equal(test_parameter_name)
-        param["Type"].should.equal("String")
-        param["Value"].should.equal(f"value-{index}")
-        param["Version"].should.equal(index + 1)
-        param["Description"].should.equal(f"A test parameter version {index}")
+        assert param["Name"] == test_parameter_name
+        assert param["Type"] == "String"
+        assert param["Value"] == f"value-{index}"
+        assert param["Version"] == index + 1
+        assert param["Description"] == f"A test parameter version {index}"
         labels = test_labels if param["Version"] == 1 else []
-        param["Labels"].should.equal(labels)
+        assert param["Labels"] == labels
 
-    len(parameters_response).should.equal(3)
+    assert len(parameters_response) == 3
 
 
 @mock_ssm
@@ -1713,15 +1751,15 @@ def test_get_parameter_history_with_label_non_latest():
     parameters_response = response["Parameters"]
 
     for index, param in enumerate(parameters_response):
-        param["Name"].should.equal(test_parameter_name)
-        param["Type"].should.equal("String")
-        param["Value"].should.equal(f"value-{index}")
-        param["Version"].should.equal(index + 1)
-        param["Description"].should.equal(f"A test parameter version {index}")
+        assert param["Name"] == test_parameter_name
+        assert param["Type"] == "String"
+        assert param["Value"] == f"value-{index}"
+        assert param["Version"] == index + 1
+        assert param["Description"] == f"A test parameter version {index}"
         labels = test_labels if param["Version"] == 2 else []
-        param["Labels"].should.equal(labels)
+        assert param["Labels"] == labels
 
-    len(parameters_response).should.equal(3)
+    assert len(parameters_response) == 3
 
 
 @mock_ssm
@@ -1746,15 +1784,15 @@ def test_get_parameter_history_with_label_latest_assumed():
     parameters_response = response["Parameters"]
 
     for index, param in enumerate(parameters_response):
-        param["Name"].should.equal(test_parameter_name)
-        param["Type"].should.equal("String")
-        param["Value"].should.equal(f"value-{index}")
-        param["Version"].should.equal(index + 1)
-        param["Description"].should.equal(f"A test parameter version {index}")
+        assert param["Name"] == test_parameter_name
+        assert param["Type"] == "String"
+        assert param["Value"] == f"value-{index}"
+        assert param["Version"] == index + 1
+        assert param["Description"] == f"A test parameter version {index}"
         labels = test_labels if param["Version"] == 3 else []
-        param["Labels"].should.equal(labels)
+        assert param["Labels"] == labels
 
-    len(parameters_response).should.equal(3)
+    assert len(parameters_response) == 3
 
 
 @mock_ssm
@@ -1765,10 +1803,8 @@ def test_get_parameter_history_missing_parameter():
         client.get_parameter_history(Name="test_noexist")
         raise RuntimeError("Should have failed")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("GetParameterHistory")
-        err.response["Error"]["Message"].should.equal(
-            "Parameter test_noexist not found."
-        )
+        assert err.operation_name == "GetParameterHistory"
+        assert err.response["Error"]["Message"] == "Parameter test_noexist not found."
 
 
 @mock_ssm
@@ -1793,9 +1829,9 @@ def test_add_remove_list_tags_for_resource():
     response = client.list_tags_for_resource(
         ResourceId="test", ResourceType="Parameter"
     )
-    len(response["TagList"]).should.equal(1)
-    response["TagList"][0]["Key"].should.equal("test-key")
-    response["TagList"][0]["Value"].should.equal("test-value")
+    assert len(response["TagList"]) == 1
+    assert response["TagList"][0]["Key"] == "test-key"
+    assert response["TagList"][0]["Value"] == "test-value"
 
     client.remove_tags_from_resource(
         ResourceId="test", ResourceType="Parameter", TagKeys=["test-key"]
@@ -1804,7 +1840,7 @@ def test_add_remove_list_tags_for_resource():
     response = client.list_tags_for_resource(
         ResourceId="test", ResourceType="Parameter"
     )
-    len(response["TagList"]).should.equal(0)
+    assert len(response["TagList"]) == 0
 
 
 @mock_ssm
@@ -1830,17 +1866,17 @@ def test_send_command():
     )
     cmd = response["Command"]
 
-    cmd["CommandId"].should_not.be(None)
+    assert cmd["CommandId"] is not None
     assert cmd["Comment"] == "some comment"
-    cmd["DocumentName"].should.equal(ssm_document)
-    cmd["Parameters"].should.equal(params)
+    assert cmd["DocumentName"] == ssm_document
+    assert cmd["Parameters"] == params
 
-    cmd["OutputS3Region"].should.equal("us-east-2")
-    cmd["OutputS3BucketName"].should.equal("the-bucket")
-    cmd["OutputS3KeyPrefix"].should.equal("pref")
+    assert cmd["OutputS3Region"] == "us-east-2"
+    assert cmd["OutputS3BucketName"] == "the-bucket"
+    assert cmd["OutputS3KeyPrefix"] == "pref"
 
-    cmd["ExpiresAfter"].should.be.greater_than(before)
-    cmd["DeliveryTimedOutCount"].should.equal(0)
+    assert cmd["ExpiresAfter"] > before
+    assert cmd["DeliveryTimedOutCount"] == 0
 
     assert cmd["TimeoutSeconds"] == 42
     assert cmd["MaxConcurrency"] == "360"
@@ -1851,8 +1887,8 @@ def test_send_command():
 
     cmd = response["Command"]
 
-    cmd["CommandId"].should_not.be(None)
-    cmd["DocumentName"].should.equal(ssm_document)
+    assert cmd["CommandId"] is not None
+    assert cmd["DocumentName"] == ssm_document
 
 
 @mock_ssm
@@ -1878,8 +1914,8 @@ def test_list_commands():
     response = client.list_commands(CommandId=cmd_id)
 
     cmds = response["Commands"]
-    len(cmds).should.equal(1)
-    cmds[0]["CommandId"].should.equal(cmd_id)
+    assert len(cmds) == 1
+    assert cmds[0]["CommandId"] == cmd_id
 
     # add another command with the same instance id to test listing by
     # instance id
@@ -1888,11 +1924,11 @@ def test_list_commands():
     response = client.list_commands(InstanceId="i-123456")
 
     cmds = response["Commands"]
-    len(cmds).should.equal(2)
+    assert len(cmds) == 2
 
     for cmd in cmds:
-        cmd["InstanceIds"].should.contain("i-123456")
-        cmd.should.have.key("DeliveryTimedOutCount").equals(0)
+        assert "i-123456" in cmd["InstanceIds"]
+        assert cmd["DeliveryTimedOutCount"] == 0
 
     # test the error case for an invalid command id
     with pytest.raises(ClientError):
@@ -1923,8 +1959,8 @@ def test_get_command_invocation():
         CommandId=cmd_id, InstanceId=instance_id, PluginName="aws:runShellScript"
     )
 
-    invocation_response["CommandId"].should.equal(cmd_id)
-    invocation_response["InstanceId"].should.equal(instance_id)
+    assert invocation_response["CommandId"] == cmd_id
+    assert invocation_response["InstanceId"] == instance_id
 
     # test the error case for an invalid instance id
     with pytest.raises(ClientError):
@@ -1957,7 +1993,7 @@ def test_get_command_invocations_by_instance_tag():
     instance_ids = []
     for instance in resp["Instances"]:
         instance_ids.append(instance["InstanceId"])
-    instance_ids.should.have.length_of(num_instances)
+    assert len(instance_ids) == num_instances
 
     command_id = ssm.send_command(
         DocumentName="AWS-RunShellScript",
@@ -1965,11 +2001,11 @@ def test_get_command_invocations_by_instance_tag():
     )["Command"]["CommandId"]
 
     resp = ssm.list_commands(CommandId=command_id)
-    resp["Commands"][0]["TargetCount"].should.equal(num_instances)
+    assert resp["Commands"][0]["TargetCount"] == num_instances
 
     for instance_id in instance_ids:
         resp = ssm.get_command_invocation(CommandId=command_id, InstanceId=instance_id)
-        resp["Status"].should.equal("Success")
+        assert resp["Status"] == "Success"
 
 
 @mock_ssm
@@ -1990,11 +2026,11 @@ def test_parameter_version_limit():
         item for page in page_iterator for item in page["Parameters"]
     )
 
-    len(parameter_history).should.equal(PARAMETER_VERSION_LIMIT)
-    parameter_history[0]["Value"].should.equal("value-2")
+    assert len(parameter_history) == PARAMETER_VERSION_LIMIT
+    assert parameter_history[0]["Value"] == "value-2"
     latest_version_index = PARAMETER_VERSION_LIMIT - 1
     latest_version_value = f"value-{PARAMETER_VERSION_LIMIT + 1}"
-    parameter_history[latest_version_index]["Value"].should.equal(latest_version_value)
+    assert parameter_history[latest_version_index]["Value"] == latest_version_value
 
 
 @mock_ssm
@@ -2017,11 +2053,16 @@ def test_parameter_overwrite_fails_when_limit_reached_and_oldest_version_has_lab
             Name=parameter_name, Value="new-value", Type="String", Overwrite=True
         )
     error = ex.value.response["Error"]
-    error["Code"].should.equal("ParameterMaxVersionLimitExceeded")
-    error["Message"].should.contain(parameter_name)
-    error["Message"].should.contain("Version 1")
-    error["Message"].should.match(
-        r"the oldest version, can't be deleted because it has a label associated with it. Move the label to another version of the parameter, and try again."
+    assert error["Code"] == "ParameterMaxVersionLimitExceeded"
+    assert parameter_name in error["Message"]
+    assert "Version 1" in error["Message"]
+    assert re.search(
+        (
+            r"the oldest version, can't be deleted because it has a label "
+            "associated with it. Move the label to another version of the "
+            "parameter, and try again."
+        ),
+        error["Message"],
     )
 
 
@@ -2046,15 +2087,13 @@ def test_get_parameters_includes_invalid_parameter_when_requesting_invalid_versi
         ]
     )
 
-    len(response["InvalidParameters"]).should.equal(1)
-    response["InvalidParameters"][0].should.equal(
-        f"test-param:{versions_to_create + 1}"
-    )
+    assert len(response["InvalidParameters"]) == 1
+    assert response["InvalidParameters"][0] == f"test-param:{versions_to_create + 1}"
 
-    len(response["Parameters"]).should.equal(1)
-    response["Parameters"][0]["Name"].should.equal("test-param")
-    response["Parameters"][0]["Value"].should.equal("value-4")
-    response["Parameters"][0]["Type"].should.equal("String")
+    assert len(response["Parameters"]) == 1
+    assert response["Parameters"][0]["Name"] == "test-param"
+    assert response["Parameters"][0]["Value"] == "value-4"
+    assert response["Parameters"][0]["Type"] == "String"
 
 
 @mock_ssm
@@ -2084,10 +2123,10 @@ def test_get_parameters_includes_invalid_parameter_when_requesting_invalid_label
         ]
     )
 
-    len(response["InvalidParameters"]).should.equal(1)
-    response["InvalidParameters"][0].should.equal("test-param:invalid-label")
+    assert len(response["InvalidParameters"]) == 1
+    assert response["InvalidParameters"][0] == "test-param:invalid-label"
 
-    len(response["Parameters"]).should.equal(3)
+    assert len(response["Parameters"]) == 3
 
 
 @mock_ssm
@@ -2099,7 +2138,7 @@ def test_get_parameters_should_only_return_unique_requests():
 
     response = client.get_parameters(Names=["test-param", "test-param"])
 
-    len(response["Parameters"]).should.equal(1)
+    assert len(response["Parameters"]) == 1
 
 
 @mock_ssm
@@ -2118,10 +2157,11 @@ def test_get_parameter_history_should_throw_exception_when_MaxResults_is_too_lar
         )
 
     error = ex.value.response["Error"]
-    error["Code"].should.equal("ValidationException")
-    error["Message"].should.equal(
+    assert error["Code"] == "ValidationException"
+    assert error["Message"] == (
         "1 validation error detected: "
-        f"Value '{PARAMETER_HISTORY_MAX_RESULTS + 1}' at 'maxResults' failed to satisfy constraint: "
+        f"Value '{PARAMETER_HISTORY_MAX_RESULTS + 1}' at 'maxResults' "
+        "failed to satisfy constraint: "
         "Member must have value less than or equal to 50."
     )
 
@@ -2150,7 +2190,7 @@ def test_get_parameter_history_NextTokenImplementation():
         param_history.extend(response["Parameters"])
         next_token = response.get("NextToken", None)
 
-    len(param_history).should.equal(100)
+    assert len(param_history) == 100
 
 
 @mock_ssm
@@ -2161,5 +2201,5 @@ def test_get_parameter_history_exception_when_requesting_invalid_parameter():
         client.get_parameter_history(Name="invalid_parameter_name")
 
     error = ex.value.response["Error"]
-    error["Code"].should.equal("ParameterNotFound")
-    error["Message"].should.equal("Parameter invalid_parameter_name not found.")
+    assert error["Code"] == "ParameterNotFound"
+    assert error["Message"] == "Parameter invalid_parameter_name not found."
diff --git a/tests/test_ssm/test_ssm_cloudformation.py b/tests/test_ssm/test_ssm_cloudformation.py
index b1922027f..ff7e42abb 100644
--- a/tests/test_ssm/test_ssm_cloudformation.py
+++ b/tests/test_ssm/test_ssm_cloudformation.py
@@ -1,6 +1,6 @@
-import boto3
 import json
 
+import boto3
 
 from moto import mock_ssm, mock_cloudformation
 from tests import EXAMPLE_AMI_ID
diff --git a/tests/test_ssm/test_ssm_default_amis.py b/tests/test_ssm/test_ssm_default_amis.py
index 252beb9d2..d64f1c79e 100644
--- a/tests/test_ssm/test_ssm_default_amis.py
+++ b/tests/test_ssm/test_ssm_default_amis.py
@@ -1,5 +1,4 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 
 from moto import mock_ssm
 
@@ -12,14 +11,14 @@ def test_ssm_get_latest_ami_by_path():
     client = boto3.client("ssm", region_name="us-west-1")
     path = "/aws/service/ami-amazon-linux-latest"
     params = client.get_parameters_by_path(Path=path)["Parameters"]
-    params.should.have.length_of(10)
+    assert len(params) == 10
 
     assert all(
-        [p["Name"].startswith("/aws/service/ami-amazon-linux-latest") for p in params]
+        {p["Name"].startswith("/aws/service/ami-amazon-linux-latest") for p in params}
     )
-    assert all([p["Type"] == "String" for p in params])
-    assert all([p["DataType"] == "text" for p in params])
-    assert all([p["ARN"].startswith("arn:aws:ssm:us-west-1") for p in params])
+    assert all({p["Type"] == "String" for p in params})
+    assert all({p["DataType"] == "text" for p in params})
+    assert all({p["ARN"].startswith("arn:aws:ssm:us-west-1") for p in params})
 
 
 @mock_ssm
@@ -30,4 +29,4 @@ def test_ssm_latest_amis_are_different_in_regions():
     client = boto3.client("ssm", region_name="eu-north-1")
     ami_eunorth = client.get_parameter(Name=test_ami)["Parameter"]["Value"]
 
-    ami_uswest.shouldnt.equal(ami_eunorth)
+    assert ami_uswest != ami_eunorth
diff --git a/tests/test_ssm/test_ssm_defaults.py b/tests/test_ssm/test_ssm_defaults.py
index 7b06b401c..a1eeca440 100644
--- a/tests/test_ssm/test_ssm_defaults.py
+++ b/tests/test_ssm/test_ssm_defaults.py
@@ -1,5 +1,4 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 
 from moto import mock_ssm
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
@@ -12,15 +11,14 @@ def test_ssm_get_by_path():
     params = client.get_parameters_by_path(Path=path)["Parameters"]
 
     pacific = [p for p in params if p["Value"] == "af-south-1"][0]
-    pacific["Name"].should.equal(
-        "/aws/service/global-infrastructure/regions/af-south-1"
+    assert pacific["Name"] == "/aws/service/global-infrastructure/regions/af-south-1"
+    assert pacific["Type"] == "String"
+    assert pacific["Version"] == 1
+    assert pacific["ARN"] == (
+        f"arn:aws:ssm:us-west-1:{ACCOUNT_ID}:parameter/aws/service"
+        "/global-infrastructure/regions/af-south-1"
     )
-    pacific["Type"].should.equal("String")
-    pacific["Version"].should.equal(1)
-    pacific["ARN"].should.equal(
-        f"arn:aws:ssm:us-west-1:{ACCOUNT_ID}:parameter/aws/service/global-infrastructure/regions/af-south-1"
-    )
-    pacific.should.have.key("LastModifiedDate")
+    assert "LastModifiedDate" in pacific
 
 
 @mock_ssm
@@ -28,7 +26,7 @@ def test_global_infrastructure_services():
     client = boto3.client("ssm", region_name="us-west-1")
     path = "/aws/service/global-infrastructure/services"
     params = client.get_parameters_by_path(Path=path)["Parameters"]
-    params[0]["Name"].should.equal(
+    assert params[0]["Name"] == (
         "/aws/service/global-infrastructure/services/accessanalyzer"
     )
 
@@ -41,5 +39,4 @@ def test_ssm_region_query():
     )
 
     value = param["Parameter"]["Value"]
-
-    value.should.equal("US West (N. California)")
+    assert value == "US West (N. California)"
diff --git a/tests/test_ssm/test_ssm_doc_permissions.py b/tests/test_ssm/test_ssm_doc_permissions.py
index e44cacd8d..af0ac18a7 100644
--- a/tests/test_ssm/test_ssm_doc_permissions.py
+++ b/tests/test_ssm/test_ssm_doc_permissions.py
@@ -1,8 +1,10 @@
-import boto3
-import pytest
+import re
 import yaml
 
+import boto3
 from botocore.exceptions import ClientError
+import pytest
+
 from moto import mock_ssm
 from .test_ssm_docs import _get_yaml_template
 
@@ -16,8 +18,8 @@ def test_describe_document_permissions_unknown_document():
             Name="UnknownDocument", PermissionType="Share"
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("InvalidDocument")
-    err["Message"].should.equal("The specified document does not exist.")
+    assert err["Code"] == "InvalidDocument"
+    assert err["Message"] == "The specified document does not exist."
 
 
 def get_client():
@@ -41,8 +43,8 @@ def test_describe_document_permissions_initial():
     res = client.describe_document_permission(
         Name="TestDocument", PermissionType="Share"
     )
-    res.should.have.key("AccountIds").equal([])
-    res.should.have.key("AccountSharingInfoList").equal([])
+    assert res["AccountIds"] == []
+    assert res["AccountSharingInfoList"] == []
 
 
 @pytest.mark.parametrize(
@@ -60,14 +62,14 @@ def test_modify_document_permission_add_account_id(ids):
     res = client.describe_document_permission(
         Name="TestDocument", PermissionType="Share"
     )
-    res.should.have.key("AccountIds")
-    set(res["AccountIds"]).should.equal(set(ids))
-    res.should.have.key("AccountSharingInfoList").length_of(len(ids))
+    assert "AccountIds" in res
+    assert set(res["AccountIds"]) == set(ids)
+    assert len(res["AccountSharingInfoList"]) == len(ids)
 
     expected_account_sharing = [
         {"AccountId": _id, "SharedDocumentVersion": "$DEFAULT"} for _id in ids
     ]
-    res.should.have.key("AccountSharingInfoList").equal(expected_account_sharing)
+    assert res["AccountSharingInfoList"] == expected_account_sharing
 
 
 @pytest.mark.parametrize(
@@ -96,15 +98,15 @@ def test_modify_document_permission_remove_account_id(initial, to_remove):
     res = client.describe_document_permission(
         Name="TestDocument", PermissionType="Share"
     )
-    res.should.have.key("AccountIds")
-    expected_new_list = set([x for x in initial if x not in to_remove])
-    set(res["AccountIds"]).should.equal(expected_new_list)
+    assert "AccountIds" in res
+    expected_new_list = {x for x in initial if x not in to_remove}
+    assert set(res["AccountIds"]) == expected_new_list
 
     expected_account_sharing = [
         {"AccountId": _id, "SharedDocumentVersion": "$DEFAULT"}
         for _id in expected_new_list
     ]
-    res.should.have.key("AccountSharingInfoList").equal(expected_account_sharing)
+    assert res["AccountSharingInfoList"] == expected_account_sharing
 
 
 @mock_ssm
@@ -115,8 +117,8 @@ def test_fail_modify_document_permission_wrong_permission_type():
             Name="TestDocument", PermissionType="WrongValue", AccountIdsToAdd=[]
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("InvalidPermissionType")
-    err["Message"].should.match(r"Member must satisfy enum value set: \[Share\]")
+    assert err["Code"] == "InvalidPermissionType"
+    assert re.search(r"Member must satisfy enum value set: \[Share\]", err["Message"])
 
 
 @mock_ssm
@@ -130,8 +132,8 @@ def test_fail_modify_document_permission_wrong_document_version():
             AccountIdsToAdd=[],
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.match(r"Member must satisfy regular expression pattern")
+    assert err["Code"] == "ValidationException"
+    assert re.search(r"Member must satisfy regular expression pattern", err["Message"])
 
 
 @pytest.mark.parametrize(
@@ -147,8 +149,8 @@ def test_fail_modify_document_permission_add_invalid_account_ids(value):
             Name="TestDocument", PermissionType="Share", AccountIdsToAdd=value
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.match(r"Member must satisfy regular expression pattern:")
+    assert err["Code"] == "ValidationException"
+    assert re.search(r"Member must satisfy regular expression pattern:", err["Message"])
 
 
 @pytest.mark.parametrize(
@@ -164,8 +166,8 @@ def test_fail_modify_document_permission_remove_invalid_account_ids(value):
             Name="TestDocument", PermissionType="Share", AccountIdsToRemove=value
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.match(r"Member must satisfy regular expression pattern:")
+    assert err["Code"] == "ValidationException"
+    assert re.search(r"Member must satisfy regular expression pattern:", err["Message"])
 
 
 @mock_ssm
@@ -178,8 +180,8 @@ def test_fail_modify_document_permission_add_all_and_specific():
             AccountIdsToAdd=["all", "123412341234"],
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("DocumentPermissionLimit")
-    err["Message"].should.equal("Accounts can either be all or a group of AWS accounts")
+    assert err["Code"] == "DocumentPermissionLimit"
+    assert err["Message"] == "Accounts can either be all or a group of AWS accounts"
 
 
 @mock_ssm
@@ -192,5 +194,5 @@ def test_fail_modify_document_permission_remove_all_and_specific():
             AccountIdsToRemove=["all", "123412341234"],
         )
     err = ex.value.response["Error"]
-    err["Code"].should.equal("DocumentPermissionLimit")
-    err["Message"].should.equal("Accounts can either be all or a group of AWS accounts")
+    assert err["Code"] == "DocumentPermissionLimit"
+    assert err["Message"] == "Accounts can either be all or a group of AWS accounts"
diff --git a/tests/test_ssm/test_ssm_docs.py b/tests/test_ssm/test_ssm_docs.py
index ef3058395..ba04c0d8d 100644
--- a/tests/test_ssm/test_ssm_docs.py
+++ b/tests/test_ssm/test_ssm_docs.py
@@ -1,19 +1,17 @@
-import boto3
-import botocore.exceptions
-import sure  # noqa # pylint: disable=unused-import
+import copy
 import datetime
 from datetime import timezone
-import json
-import yaml
 import hashlib
-import copy
+import json
 import pkgutil
-import pytest
+import yaml
 
+import boto3
+import botocore.exceptions
 from botocore.exceptions import ClientError
+import pytest
 
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
-
 from moto import mock_ssm
 
 
@@ -32,107 +30,99 @@ def _validate_document_description(
 ):
 
     if expected_format == "JSON":
-        doc_description["Hash"].should.equal(
+        assert doc_description["Hash"] == (
             hashlib.sha256(json.dumps(json_doc).encode("utf-8")).hexdigest()
         )
     else:
-        doc_description["Hash"].should.equal(
+        assert doc_description["Hash"] == (
             hashlib.sha256(yaml.dump(json_doc).encode("utf-8")).hexdigest()
         )
 
-    doc_description["HashType"].should.equal("Sha256")
-    doc_description["Name"].should.equal(doc_name)
-    doc_description["Owner"].should.equal(ACCOUNT_ID)
+    assert doc_description["HashType"] == "Sha256"
+    assert doc_description["Name"] == doc_name
+    assert doc_description["Owner"] == ACCOUNT_ID
 
     difference = datetime.datetime.now(tz=timezone.utc) - doc_description["CreatedDate"]
     if difference.min > datetime.timedelta(minutes=1):
         assert False
 
-    doc_description["Status"].should.equal("Active")
-    doc_description["DocumentVersion"].should.equal(expected_document_version)
-    doc_description["Description"].should.equal(json_doc["description"])
+    assert doc_description["Status"] == "Active"
+    assert doc_description["DocumentVersion"] == expected_document_version
+    assert doc_description["Description"] == json_doc["description"]
 
     doc_description["Parameters"] = sorted(
         doc_description["Parameters"], key=lambda doc: doc["Name"]
     )
 
-    doc_description["Parameters"][0]["Name"].should.equal("Parameter1")
-    doc_description["Parameters"][0]["Type"].should.equal("Integer")
-    doc_description["Parameters"][0]["Description"].should.equal("Command Duration.")
-    doc_description["Parameters"][0]["DefaultValue"].should.equal("3")
+    assert doc_description["Parameters"][0]["Name"] == "Parameter1"
+    assert doc_description["Parameters"][0]["Type"] == "Integer"
+    assert doc_description["Parameters"][0]["Description"] == "Command Duration."
+    assert doc_description["Parameters"][0]["DefaultValue"] == "3"
 
-    doc_description["Parameters"][1]["Name"].should.equal("Parameter2")
-    doc_description["Parameters"][1]["Type"].should.equal("String")
-    doc_description["Parameters"][1]["DefaultValue"].should.equal("def")
+    assert doc_description["Parameters"][1]["Name"] == "Parameter2"
+    assert doc_description["Parameters"][1]["Type"] == "String"
+    assert doc_description["Parameters"][1]["DefaultValue"] == "def"
 
-    doc_description["Parameters"][2]["Name"].should.equal("Parameter3")
-    doc_description["Parameters"][2]["Type"].should.equal("Boolean")
-    doc_description["Parameters"][2]["Description"].should.equal("A boolean")
-    doc_description["Parameters"][2]["DefaultValue"].should.equal("False")
+    assert doc_description["Parameters"][2]["Name"] == "Parameter3"
+    assert doc_description["Parameters"][2]["Type"] == "Boolean"
+    assert doc_description["Parameters"][2]["Description"] == "A boolean"
+    assert doc_description["Parameters"][2]["DefaultValue"] == "False"
 
-    doc_description["Parameters"][3]["Name"].should.equal("Parameter4")
-    doc_description["Parameters"][3]["Type"].should.equal("StringList")
-    doc_description["Parameters"][3]["Description"].should.equal("A string list")
-    doc_description["Parameters"][3]["DefaultValue"].should.equal('["abc", "def"]')
+    assert doc_description["Parameters"][3]["Name"] == "Parameter4"
+    assert doc_description["Parameters"][3]["Type"] == "StringList"
+    assert doc_description["Parameters"][3]["Description"] == "A string list"
+    assert doc_description["Parameters"][3]["DefaultValue"] == '["abc", "def"]'
 
-    doc_description["Parameters"][4]["Name"].should.equal("Parameter5")
-    doc_description["Parameters"][4]["Type"].should.equal("StringMap")
+    assert doc_description["Parameters"][4]["Name"] == "Parameter5"
+    assert doc_description["Parameters"][4]["Type"] == "StringMap"
 
-    doc_description["Parameters"][5]["Name"].should.equal("Parameter6")
-    doc_description["Parameters"][5]["Type"].should.equal("MapList")
+    assert doc_description["Parameters"][5]["Name"] == "Parameter6"
+    assert doc_description["Parameters"][5]["Type"] == "MapList"
 
     if expected_format == "JSON":
         # We have to replace single quotes from the response to package it back up
-        json.loads(doc_description["Parameters"][4]["DefaultValue"]).should.equal(
-            {
-                "NotificationArn": "$dependency.topicArn",
-                "NotificationEvents": ["Failed"],
-                "NotificationType": "Command",
-            }
-        )
-
-        json.loads(doc_description["Parameters"][5]["DefaultValue"]).should.equal(
-            [
-                {"DeviceName": "/dev/sda1", "Ebs": {"VolumeSize": "50"}},
-                {"DeviceName": "/dev/sdm", "Ebs": {"VolumeSize": "100"}},
-            ]
-        )
+        assert json.loads(doc_description["Parameters"][4]["DefaultValue"]) == {
+            "NotificationArn": "$dependency.topicArn",
+            "NotificationEvents": ["Failed"],
+            "NotificationType": "Command",
+        }
+
+        assert json.loads(doc_description["Parameters"][5]["DefaultValue"]) == [
+            {"DeviceName": "/dev/sda1", "Ebs": {"VolumeSize": "50"}},
+            {"DeviceName": "/dev/sdm", "Ebs": {"VolumeSize": "100"}},
+        ]
     else:
-        yaml.safe_load(doc_description["Parameters"][4]["DefaultValue"]).should.equal(
-            {
-                "NotificationArn": "$dependency.topicArn",
-                "NotificationEvents": ["Failed"],
-                "NotificationType": "Command",
-            }
-        )
-        yaml.safe_load(doc_description["Parameters"][5]["DefaultValue"]).should.equal(
-            [
-                {"DeviceName": "/dev/sda1", "Ebs": {"VolumeSize": "50"}},
-                {"DeviceName": "/dev/sdm", "Ebs": {"VolumeSize": "100"}},
-            ]
-        )
-
-    doc_description["DocumentType"].should.equal("Command")
-    doc_description["SchemaVersion"].should.equal("2.2")
-    doc_description["LatestVersion"].should.equal(expected_latest_version)
-    doc_description["DefaultVersion"].should.equal(expected_default_version)
-    doc_description["DocumentFormat"].should.equal(expected_format)
+        assert yaml.safe_load(doc_description["Parameters"][4]["DefaultValue"]) == {
+            "NotificationArn": "$dependency.topicArn",
+            "NotificationEvents": ["Failed"],
+            "NotificationType": "Command",
+        }
+        assert yaml.safe_load(doc_description["Parameters"][5]["DefaultValue"]) == [
+            {"DeviceName": "/dev/sda1", "Ebs": {"VolumeSize": "50"}},
+            {"DeviceName": "/dev/sdm", "Ebs": {"VolumeSize": "100"}},
+        ]
+
+    assert doc_description["DocumentType"] == "Command"
+    assert doc_description["SchemaVersion"] == "2.2"
+    assert doc_description["LatestVersion"] == expected_latest_version
+    assert doc_description["DefaultVersion"] == expected_default_version
+    assert doc_description["DocumentFormat"] == expected_format
 
 
 def _get_doc_validator(
     response, version_name, doc_version, json_doc_content, document_format
 ):
-    response["Name"].should.equal("TestDocument3")
+    assert response["Name"] == "TestDocument3"
     if version_name:
-        response["VersionName"].should.equal(version_name)
-    response["DocumentVersion"].should.equal(doc_version)
-    response["Status"].should.equal("Active")
+        assert response["VersionName"] == version_name
+    assert response["DocumentVersion"] == doc_version
+    assert response["Status"] == "Active"
     if document_format == "JSON":
-        json.loads(response["Content"]).should.equal(json_doc_content)
+        assert json.loads(response["Content"]) == json_doc_content
     else:
-        yaml.safe_load(response["Content"]).should.equal(json_doc_content)
-    response["DocumentType"].should.equal("Command")
-    response["DocumentFormat"].should.equal(document_format)
+        assert yaml.safe_load(response["Content"]) == json_doc_content
+    assert response["DocumentType"] == "Command"
+    assert response["DocumentFormat"] == document_format
 
 
 @mock_ssm
@@ -174,9 +164,9 @@ def test_create_document():
         Tags=[{"Key": "testing", "Value": "testingValue"}],
     )
     doc_description = response["DocumentDescription"]
-    doc_description["VersionName"].should.equal("Base")
-    doc_description["TargetType"].should.equal("/AWS::EC2::Instance")
-    doc_description["Tags"].should.equal([{"Key": "testing", "Value": "testingValue"}])
+    assert doc_description["VersionName"] == "Base"
+    assert doc_description["TargetType"] == "/AWS::EC2::Instance"
+    assert doc_description["Tags"] == [{"Key": "testing", "Value": "testingValue"}]
 
     _validate_document_description(
         "TestDocument3", doc_description, json_doc, "1", "1", "1", "JSON"
@@ -191,9 +181,9 @@ def test_create_document():
         )
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("CreateDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document already exists."
+        assert err.operation_name == "CreateDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document already exists."
         )
 
     try:
@@ -205,9 +195,10 @@ def test_create_document():
         )
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("CreateDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The content for the document is not valid."
+        assert err.operation_name == "CreateDocument"
+        assert (
+            err.response["Error"]["Message"]
+            == "The content for the document is not valid."
         )
 
     del json_doc["parameters"]
@@ -219,25 +210,25 @@ def test_create_document():
     )
     doc_description = response["DocumentDescription"]
 
-    doc_description["Hash"].should.equal(
+    assert doc_description["Hash"] == (
         hashlib.sha256(yaml.dump(json_doc).encode("utf-8")).hexdigest()
     )
-    doc_description["HashType"].should.equal("Sha256")
-    doc_description["Name"].should.equal("EmptyParamDoc")
-    doc_description["Owner"].should.equal(ACCOUNT_ID)
+    assert doc_description["HashType"] == "Sha256"
+    assert doc_description["Name"] == "EmptyParamDoc"
+    assert doc_description["Owner"] == ACCOUNT_ID
 
     difference = datetime.datetime.now(tz=timezone.utc) - doc_description["CreatedDate"]
     if difference.min > datetime.timedelta(minutes=1):
         assert False
 
-    doc_description["Status"].should.equal("Active")
-    doc_description["DocumentVersion"].should.equal("1")
-    doc_description["Description"].should.equal(json_doc["description"])
-    doc_description["DocumentType"].should.equal("Command")
-    doc_description["SchemaVersion"].should.equal("2.2")
-    doc_description["LatestVersion"].should.equal("1")
-    doc_description["DefaultVersion"].should.equal("1")
-    doc_description["DocumentFormat"].should.equal("YAML")
+    assert doc_description["Status"] == "Active"
+    assert doc_description["DocumentVersion"] == "1"
+    assert doc_description["Description"] == json_doc["description"]
+    assert doc_description["DocumentType"] == "Command"
+    assert doc_description["SchemaVersion"] == "2.2"
+    assert doc_description["LatestVersion"] == "1"
+    assert doc_description["DefaultVersion"] == "1"
+    assert doc_description["DocumentFormat"] == "YAML"
 
 
 @mock_ssm
@@ -251,9 +242,9 @@ def test_get_document():
         client.get_document(Name="DNE")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("GetDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "GetDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     client.create_document(
@@ -306,18 +297,18 @@ def test_get_document():
         )
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("GetDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "GetDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     try:
         response = client.get_document(Name="TestDocument3", DocumentVersion="3")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("GetDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "GetDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     # Updating default should update normal get
@@ -337,9 +328,9 @@ def test_delete_document():
         client.delete_document(Name="DNE")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("DeleteDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "DeleteDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     # Test simple
@@ -357,9 +348,9 @@ def test_delete_document():
         client.get_document(Name="TestDocument3")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("GetDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "GetDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     # Delete default version with other version is bad
@@ -407,8 +398,8 @@ def test_delete_document():
         client.delete_document(Name="TestDocument3", DocumentVersion="1")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("DeleteDocument")
-        err.response["Error"]["Message"].should.equal(
+        assert err.operation_name == "DeleteDocument"
+        assert err.response["Error"]["Message"] == (
             "Default version of the document can't be deleted."
         )
 
@@ -416,8 +407,8 @@ def test_delete_document():
         client.delete_document(Name="TestDocument3", VersionName="Base")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("DeleteDocument")
-        err.response["Error"]["Message"].should.equal(
+        assert err.operation_name == "DeleteDocument"
+        assert err.response["Error"]["Message"] == (
             "Default version of the document can't be deleted."
         )
 
@@ -429,7 +420,7 @@ def test_delete_document():
 
     # Check that latest version is changed
     response = client.describe_document(Name="TestDocument3")
-    response["Document"]["LatestVersion"].should.equal("4")
+    assert response["Document"]["LatestVersion"] == "4"
 
     client.delete_document(Name="TestDocument3", VersionName="NewBase")
 
@@ -444,31 +435,31 @@ def test_delete_document():
         client.get_document(Name="TestDocument3", DocumentVersion="1")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("GetDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "GetDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     try:
         client.get_document(Name="TestDocument3", DocumentVersion="3")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("GetDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "GetDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     try:
         client.get_document(Name="TestDocument3", DocumentVersion="4")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("GetDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "GetDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     response = client.list_documents()
-    len(response["DocumentIdentifiers"]).should.equal(0)
+    assert len(response["DocumentIdentifiers"]) == 0
 
 
 @mock_ssm
@@ -481,9 +472,9 @@ def test_update_document_default_version():
         client.update_document_default_version(Name="DNE", DocumentVersion="1")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("UpdateDocumentDefaultVersion")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "UpdateDocumentDefaultVersion"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     client.create_document(
@@ -511,8 +502,8 @@ def test_update_document_default_version():
     response = client.update_document_default_version(
         Name="TestDocument", DocumentVersion="2"
     )
-    response["Description"]["Name"].should.equal("TestDocument")
-    response["Description"]["DefaultVersion"].should.equal("2")
+    assert response["Description"]["Name"] == "TestDocument"
+    assert response["Description"]["DefaultVersion"] == "2"
 
     json_doc["description"] = "a new description3"
 
@@ -526,9 +517,9 @@ def test_update_document_default_version():
     response = client.update_document_default_version(
         Name="TestDocument", DocumentVersion="4"
     )
-    response["Description"]["Name"].should.equal("TestDocument")
-    response["Description"]["DefaultVersion"].should.equal("4")
-    response["Description"]["DefaultVersionName"].should.equal("NewBase")
+    assert response["Description"]["Name"] == "TestDocument"
+    assert response["Description"]["DefaultVersion"] == "4"
+    assert response["Description"]["DefaultVersionName"] == "NewBase"
 
 
 @mock_ssm
@@ -547,9 +538,9 @@ def test_update_document():
         )
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("UpdateDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "UpdateDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     client.create_document(
@@ -569,8 +560,8 @@ def test_update_document():
         )
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("UpdateDocument")
-        err.response["Error"]["Message"].should.equal(
+        assert err.operation_name == "UpdateDocument"
+        assert err.response["Error"]["Message"] == (
             "The document version is not valid or does not exist."
         )
 
@@ -584,8 +575,8 @@ def test_update_document():
         )
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("UpdateDocument")
-        err.response["Error"]["Message"].should.equal(
+        assert err.operation_name == "UpdateDocument"
+        assert err.response["Error"]["Message"] == (
             "The content of the association document matches another "
             "document. Change the content of the document and try again."
         )
@@ -602,8 +593,8 @@ def test_update_document():
         )
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("UpdateDocument")
-        err.response["Error"]["Message"].should.equal(
+        assert err.operation_name == "UpdateDocument"
+        assert err.response["Error"]["Message"] == (
             "The specified version name is a duplicate."
         )
 
@@ -614,10 +605,10 @@ def test_update_document():
         DocumentVersion="1",
         DocumentFormat="JSON",
     )
-    response["DocumentDescription"]["Description"].should.equal("a new description")
-    response["DocumentDescription"]["DocumentVersion"].should.equal("2")
-    response["DocumentDescription"]["LatestVersion"].should.equal("2")
-    response["DocumentDescription"]["DefaultVersion"].should.equal("1")
+    assert response["DocumentDescription"]["Description"] == "a new description"
+    assert response["DocumentDescription"]["DocumentVersion"] == "2"
+    assert response["DocumentDescription"]["LatestVersion"] == "2"
+    assert response["DocumentDescription"]["DefaultVersion"] == "1"
 
     json_doc["description"] = "a new description2"
 
@@ -628,11 +619,11 @@ def test_update_document():
         DocumentFormat="JSON",
         VersionName="NewBase",
     )
-    response["DocumentDescription"]["Description"].should.equal("a new description2")
-    response["DocumentDescription"]["DocumentVersion"].should.equal("3")
-    response["DocumentDescription"]["LatestVersion"].should.equal("3")
-    response["DocumentDescription"]["DefaultVersion"].should.equal("1")
-    response["DocumentDescription"]["VersionName"].should.equal("NewBase")
+    assert response["DocumentDescription"]["Description"] == "a new description2"
+    assert response["DocumentDescription"]["DocumentVersion"] == "3"
+    assert response["DocumentDescription"]["LatestVersion"] == "3"
+    assert response["DocumentDescription"]["DefaultVersion"] == "1"
+    assert response["DocumentDescription"]["VersionName"] == "NewBase"
 
 
 @mock_ssm
@@ -645,9 +636,9 @@ def test_describe_document():
         client.describe_document(Name="DNE")
         raise RuntimeError("Should fail")
     except botocore.exceptions.ClientError as err:
-        err.operation_name.should.equal("DescribeDocument")
-        err.response["Error"]["Message"].should.equal(
-            "The specified document does not exist."
+        assert err.operation_name == "DescribeDocument"
+        assert (
+            err.response["Error"]["Message"] == "The specified document does not exist."
         )
 
     client.create_document(
@@ -707,29 +698,29 @@ def test_list_documents():
     )
 
     response = client.list_documents()
-    len(response["DocumentIdentifiers"]).should.equal(3)
-    response["DocumentIdentifiers"][0]["Name"].should.equal("TestDocument")
-    response["DocumentIdentifiers"][1]["Name"].should.equal("TestDocument2")
-    response["DocumentIdentifiers"][2]["Name"].should.equal("TestDocument3")
-    response["NextToken"].should.equal("")
+    assert len(response["DocumentIdentifiers"]) == 3
+    assert response["DocumentIdentifiers"][0]["Name"] == "TestDocument"
+    assert response["DocumentIdentifiers"][1]["Name"] == "TestDocument2"
+    assert response["DocumentIdentifiers"][2]["Name"] == "TestDocument3"
+    assert response["NextToken"] == ""
 
     response = client.list_documents(MaxResults=1)
-    len(response["DocumentIdentifiers"]).should.equal(1)
-    response["DocumentIdentifiers"][0]["Name"].should.equal("TestDocument")
-    response["DocumentIdentifiers"][0]["DocumentVersion"].should.equal("1")
-    response["NextToken"].should.equal("1")
+    assert len(response["DocumentIdentifiers"]) == 1
+    assert response["DocumentIdentifiers"][0]["Name"] == "TestDocument"
+    assert response["DocumentIdentifiers"][0]["DocumentVersion"] == "1"
+    assert response["NextToken"] == "1"
 
     response = client.list_documents(MaxResults=1, NextToken=response["NextToken"])
-    len(response["DocumentIdentifiers"]).should.equal(1)
-    response["DocumentIdentifiers"][0]["Name"].should.equal("TestDocument2")
-    response["DocumentIdentifiers"][0]["DocumentVersion"].should.equal("1")
-    response["NextToken"].should.equal("2")
+    assert len(response["DocumentIdentifiers"]) == 1
+    assert response["DocumentIdentifiers"][0]["Name"] == "TestDocument2"
+    assert response["DocumentIdentifiers"][0]["DocumentVersion"] == "1"
+    assert response["NextToken"] == "2"
 
     response = client.list_documents(MaxResults=1, NextToken=response["NextToken"])
-    len(response["DocumentIdentifiers"]).should.equal(1)
-    response["DocumentIdentifiers"][0]["Name"].should.equal("TestDocument3")
-    response["DocumentIdentifiers"][0]["DocumentVersion"].should.equal("1")
-    response["NextToken"].should.equal("")
+    assert len(response["DocumentIdentifiers"]) == 1
+    assert response["DocumentIdentifiers"][0]["Name"] == "TestDocument3"
+    assert response["DocumentIdentifiers"][0]["DocumentVersion"] == "1"
+    assert response["NextToken"] == ""
 
     # making sure no bad interactions with update
     json_doc["description"] = "a new description"
@@ -750,24 +741,24 @@ def test_list_documents():
     client.update_document_default_version(Name="TestDocument", DocumentVersion="2")
 
     response = client.list_documents()
-    len(response["DocumentIdentifiers"]).should.equal(3)
-    response["DocumentIdentifiers"][0]["Name"].should.equal("TestDocument")
-    response["DocumentIdentifiers"][0]["DocumentVersion"].should.equal("2")
+    assert len(response["DocumentIdentifiers"]) == 3
+    assert response["DocumentIdentifiers"][0]["Name"] == "TestDocument"
+    assert response["DocumentIdentifiers"][0]["DocumentVersion"] == "2"
 
-    response["DocumentIdentifiers"][1]["Name"].should.equal("TestDocument2")
-    response["DocumentIdentifiers"][1]["DocumentVersion"].should.equal("1")
+    assert response["DocumentIdentifiers"][1]["Name"] == "TestDocument2"
+    assert response["DocumentIdentifiers"][1]["DocumentVersion"] == "1"
 
-    response["DocumentIdentifiers"][2]["Name"].should.equal("TestDocument3")
-    response["DocumentIdentifiers"][2]["DocumentVersion"].should.equal("1")
-    response["NextToken"].should.equal("")
+    assert response["DocumentIdentifiers"][2]["Name"] == "TestDocument3"
+    assert response["DocumentIdentifiers"][2]["DocumentVersion"] == "1"
+    assert response["NextToken"] == ""
 
     response = client.list_documents(Filters=[{"Key": "Owner", "Values": ["Self"]}])
-    len(response["DocumentIdentifiers"]).should.equal(3)
+    assert len(response["DocumentIdentifiers"]) == 3
 
     response = client.list_documents(
         Filters=[{"Key": "TargetType", "Values": ["/AWS::EC2::Instance"]}]
     )
-    len(response["DocumentIdentifiers"]).should.equal(1)
+    assert len(response["DocumentIdentifiers"]) == 1
 
 
 @mock_ssm
diff --git a/tests/test_ssm/test_ssm_ec2_integration.py b/tests/test_ssm/test_ssm_ec2_integration.py
index 94a34d179..c7a89c6ea 100644
--- a/tests/test_ssm/test_ssm_ec2_integration.py
+++ b/tests/test_ssm/test_ssm_ec2_integration.py
@@ -1,5 +1,4 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 
 from moto import mock_ec2, mock_ssm
 
@@ -14,4 +13,4 @@ def test_ssm_get_latest_ami_by_path():
     ami = ssm.get_parameter(Name=test_ami)["Parameter"]["Value"]
 
     ec2 = boto3.client("ec2", region_name="us-east-1")
-    ec2.describe_images(ImageIds=[ami])["Images"].should.have.length_of(1)
+    assert len(ec2.describe_images(ImageIds=[ami])["Images"]) == 1
diff --git a/tests/test_ssm/test_ssm_ecs_images.py b/tests/test_ssm/test_ssm_ecs_images.py
index ffd7af68e..efb8fda52 100644
--- a/tests/test_ssm/test_ssm_ecs_images.py
+++ b/tests/test_ssm/test_ssm_ecs_images.py
@@ -1,5 +1,4 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 
 from moto import mock_ec2, mock_ssm
 
@@ -10,10 +9,10 @@ def test_ssm_get_latest_ami_by_path():
     ssm = boto3.client("ssm", region_name="us-east-1")
     path = "/aws/service/ecs/optimized-ami"
     params = ssm.get_parameters_by_path(Path=path, Recursive=True)["Parameters"]
-    params.should.have.length_of(10)
+    assert len(params) == 10
 
     ec2 = boto3.client("ec2", region_name="us-east-1")
     for param in params:
         if "Value" in param and isinstance(param["Value"], dict):
             ami = param["Value"]["image_id"]
-            ec2.describe_images(ImageIds=[ami])["Images"].should.have.length_of(1)
+            assert len(ec2.describe_images(ImageIds=[ami])["Images"]) == 1
diff --git a/tests/test_ssm/test_ssm_maintenance_windows.py b/tests/test_ssm/test_ssm_maintenance_windows.py
index 9d0e2ca26..ebb53bf1f 100644
--- a/tests/test_ssm/test_ssm_maintenance_windows.py
+++ b/tests/test_ssm/test_ssm_maintenance_windows.py
@@ -1,5 +1,4 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 
 from moto import mock_ssm
 
@@ -9,12 +8,12 @@ def test_describe_maintenance_window():
     ssm = boto3.client("ssm", region_name="us-east-1")
 
     resp = ssm.describe_maintenance_windows()
-    resp.should.have.key("WindowIdentities").equals([])
+    assert resp["WindowIdentities"] == []
 
     resp = ssm.describe_maintenance_windows(
         Filters=[{"Key": "Name", "Values": ["fake-maintenance-window-name"]}]
     )
-    resp.should.have.key("WindowIdentities").equals([])
+    assert resp["WindowIdentities"] == []
 
 
 @mock_ssm
@@ -28,25 +27,25 @@ def test_create_maintenance_windows_simple():
         Cutoff=1,
         AllowUnassociatedTargets=False,
     )
-    resp.should.have.key("WindowId")
+    assert "WindowId" in resp
     _id = resp["WindowId"]  # mw-01d6bbfdf6af2c39a
 
     resp = ssm.describe_maintenance_windows()
-    resp.should.have.key("WindowIdentities").have.length_of(1)
+    assert len(resp["WindowIdentities"]) == 1
 
     my_window = resp["WindowIdentities"][0]
-    my_window.should.have.key("WindowId").equal(_id)
-    my_window.should.have.key("Name").equal("simple-window")
-    my_window.should.have.key("Enabled").equal(True)
-    my_window.should.have.key("Duration").equal(2)
-    my_window.should.have.key("Cutoff").equal(1)
-    my_window.should.have.key("Schedule").equal("cron(15 12 * * ? *)")
-    # my_window.should.have.key("NextExecutionTime")
-    my_window.shouldnt.have.key("Description")
-    my_window.shouldnt.have.key("ScheduleTimezone")
-    my_window.shouldnt.have.key("ScheduleOffset")
-    my_window.shouldnt.have.key("EndDate")
-    my_window.shouldnt.have.key("StartDate")
+    assert my_window["WindowId"] == _id
+    assert my_window["Name"] == "simple-window"
+    assert my_window["Enabled"] is True
+    assert my_window["Duration"] == 2
+    assert my_window["Cutoff"] == 1
+    assert my_window["Schedule"] == "cron(15 12 * * ? *)"
+    # assert "NextExecutionTime" in my_window
+    assert "Description" not in my_window
+    assert "ScheduleTimezone" not in my_window
+    assert "ScheduleOffset" not in my_window
+    assert "EndDate" not in my_window
+    assert "StartDate" not in my_window
 
 
 @mock_ssm
@@ -65,25 +64,25 @@ def test_create_maintenance_windows_advanced():
         StartDate="2021-11-01",
         EndDate="2021-12-31",
     )
-    resp.should.have.key("WindowId")
+    assert "WindowId" in resp
     _id = resp["WindowId"]  # mw-01d6bbfdf6af2c39a
 
     resp = ssm.describe_maintenance_windows()
-    resp.should.have.key("WindowIdentities").have.length_of(1)
+    assert len(resp["WindowIdentities"]) == 1
 
     my_window = resp["WindowIdentities"][0]
-    my_window.should.have.key("WindowId").equal(_id)
-    my_window.should.have.key("Name").equal("simple-window")
-    my_window.should.have.key("Enabled").equal(True)
-    my_window.should.have.key("Duration").equal(5)
-    my_window.should.have.key("Cutoff").equal(4)
-    my_window.should.have.key("Schedule").equal("cron(15 12 * * ? *)")
-    # my_window.should.have.key("NextExecutionTime")
-    my_window.should.have.key("Description").equals("French windows are just too fancy")
-    my_window.should.have.key("ScheduleTimezone").equals("Europe/London")
-    my_window.should.have.key("ScheduleOffset").equals(1)
-    my_window.should.have.key("StartDate").equals("2021-11-01")
-    my_window.should.have.key("EndDate").equals("2021-12-31")
+    assert my_window["WindowId"] == _id
+    assert my_window["Name"] == "simple-window"
+    assert my_window["Enabled"] is True
+    assert my_window["Duration"] == 5
+    assert my_window["Cutoff"] == 4
+    assert my_window["Schedule"] == "cron(15 12 * * ? *)"
+    # assert "NextExecutionTime" in my_window
+    assert my_window["Description"] == "French windows are just too fancy"
+    assert my_window["ScheduleTimezone"] == "Europe/London"
+    assert my_window["ScheduleOffset"] == 1
+    assert my_window["StartDate"] == "2021-11-01"
+    assert my_window["EndDate"] == "2021-12-31"
 
 
 @mock_ssm
@@ -97,22 +96,22 @@ def test_get_maintenance_windows():
         Cutoff=1,
         AllowUnassociatedTargets=False,
     )
-    resp.should.have.key("WindowId")
+    assert "WindowId" in resp
     _id = resp["WindowId"]  # mw-01d6bbfdf6af2c39a
 
     my_window = ssm.get_maintenance_window(WindowId=_id)
-    my_window.should.have.key("WindowId").equal(_id)
-    my_window.should.have.key("Name").equal("my-window")
-    my_window.should.have.key("Enabled").equal(True)
-    my_window.should.have.key("Duration").equal(2)
-    my_window.should.have.key("Cutoff").equal(1)
-    my_window.should.have.key("Schedule").equal("cron(15 12 * * ? *)")
-    # my_window.should.have.key("NextExecutionTime")
-    my_window.shouldnt.have.key("Description")
-    my_window.shouldnt.have.key("ScheduleTimezone")
-    my_window.shouldnt.have.key("ScheduleOffset")
-    my_window.shouldnt.have.key("EndDate")
-    my_window.shouldnt.have.key("StartDate")
+    assert my_window["WindowId"] == _id
+    assert my_window["Name"] == "my-window"
+    assert my_window["Enabled"] is True
+    assert my_window["Duration"] == 2
+    assert my_window["Cutoff"] == 1
+    assert my_window["Schedule"] == "cron(15 12 * * ? *)"
+    # assert "NextExecutionTime" in my_window
+    assert "Description" not in my_window
+    assert "ScheduleTimezone" not in my_window
+    assert "ScheduleOffset" not in my_window
+    assert "EndDate" not in my_window
+    assert "StartDate" not in my_window
 
 
 @mock_ssm
@@ -129,12 +128,12 @@ def test_describe_maintenance_windows():
         )
 
     resp = ssm.describe_maintenance_windows()
-    resp.should.have.key("WindowIdentities").have.length_of(4)
+    assert len(resp["WindowIdentities"]) == 4
 
     resp = ssm.describe_maintenance_windows(
         Filters=[{"Key": "Name", "Values": ["window_0", "window_2"]}]
     )
-    resp.should.have.key("WindowIdentities").have.length_of(2)
+    assert len(resp["WindowIdentities"]) == 2
 
 
 @mock_ssm
@@ -149,10 +148,10 @@ def test_delete_maintenance_windows():
         AllowUnassociatedTargets=False,
     )
 
-    ssm.delete_maintenance_window(WindowId=(resp["WindowId"]))
+    ssm.delete_maintenance_window(WindowId=resp["WindowId"])
 
     resp = ssm.describe_maintenance_windows()
-    resp.should.have.key("WindowIdentities").equals([])
+    assert resp["WindowIdentities"] == []
 
 
 @mock_ssm
@@ -232,17 +231,17 @@ def test_register_maintenance_window_target():
         ResourceType="INSTANCE",
         Targets=[{"Key": "tag:Name", "Values": ["my-instance"]}],
     )
-    resp.should.have.key("WindowTargetId")
+    assert "WindowTargetId" in resp
     _id = resp["WindowTargetId"]
 
     resp = ssm.describe_maintenance_window_targets(
         WindowId=window_id,
     )
-    resp.should.have.key("Targets").should.have.length_of(1)
-    resp["Targets"][0].should.have.key("ResourceType").equal("INSTANCE")
-    resp["Targets"][0].should.have.key("WindowTargetId").equal(_id)
-    resp["Targets"][0]["Targets"][0].should.have.key("Key").equal("tag:Name")
-    resp["Targets"][0]["Targets"][0].should.have.key("Values").equal(["my-instance"])
+    assert len(resp["Targets"]) == 1
+    assert resp["Targets"][0]["ResourceType"] == "INSTANCE"
+    assert resp["Targets"][0]["WindowTargetId"] == _id
+    assert resp["Targets"][0]["Targets"][0]["Key"] == "tag:Name"
+    assert resp["Targets"][0]["Targets"][0]["Values"] == ["my-instance"]
 
 
 @mock_ssm
@@ -273,7 +272,7 @@ def test_deregister_target_from_maintenance_window():
     resp = ssm.describe_maintenance_window_targets(
         WindowId=window_id,
     )
-    resp.should.have.key("Targets").should.have.length_of(0)
+    assert len(resp["Targets"]) == 0
 
 
 @mock_ssm
@@ -292,12 +291,12 @@ def test_describe_maintenance_window_with_no_task_or_targets():
     resp = ssm.describe_maintenance_window_tasks(
         WindowId=window_id,
     )
-    resp.should.have.key("Tasks").should.have.length_of(0)
+    assert len(resp["Tasks"]) == 0
 
     resp = ssm.describe_maintenance_window_targets(
         WindowId=window_id,
     )
-    resp.should.have.key("Targets").should.have.length_of(0)
+    assert len(resp["Targets"]) == 0
 
 
 @mock_ssm
@@ -329,18 +328,18 @@ def test_register_maintenance_window_task():
         MaxErrors="1",
     )
 
-    resp.should.have.key("WindowTaskId")
+    assert "WindowTaskId" in resp
     _id = resp["WindowTaskId"]
 
     resp = ssm.describe_maintenance_window_tasks(
         WindowId=window_id,
     )
-    resp.should.have.key("Tasks").should.have.length_of(1)
-    resp["Tasks"][0].should.have.key("WindowTaskId").equal(_id)
-    resp["Tasks"][0].should.have.key("WindowId").equal(window_id)
-    resp["Tasks"][0].should.have.key("TaskArn").equal("AWS-RunShellScript")
-    resp["Tasks"][0].should.have.key("MaxConcurrency").equal("1")
-    resp["Tasks"][0].should.have.key("MaxErrors").equal("1")
+    assert len(resp["Tasks"]) == 1
+    assert resp["Tasks"][0]["WindowTaskId"] == _id
+    assert resp["Tasks"][0]["WindowId"] == window_id
+    assert resp["Tasks"][0]["TaskArn"] == "AWS-RunShellScript"
+    assert resp["Tasks"][0]["MaxConcurrency"] == "1"
+    assert resp["Tasks"][0]["MaxErrors"] == "1"
 
 
 @mock_ssm
@@ -381,4 +380,4 @@ def test_deregister_maintenance_window_task():
     resp = ssm.describe_maintenance_window_tasks(
         WindowId=window_id,
     )
-    resp.should.have.key("Tasks").should.have.length_of(0)
+    assert len(resp["Tasks"]) == 0
diff --git a/tests/test_ssm/test_ssm_parameterstore.py b/tests/test_ssm/test_ssm_parameterstore.py
index 9ca1e66b6..1d0ebf01c 100644
--- a/tests/test_ssm/test_ssm_parameterstore.py
+++ b/tests/test_ssm/test_ssm_parameterstore.py
@@ -1,5 +1,3 @@
-import sure  # noqa # pylint: disable=unused-import
-
 from moto.ssm.models import ParameterDict
 
 
@@ -7,42 +5,40 @@ def test_simple_setget():
     store = ParameterDict("accnt", "region")
     store["/a/b/c"] = "some object"
 
-    store.get("/a/b/c").should.equal("some object")
+    assert store.get("/a/b/c") == "some object"
 
 
 def test_get_none():
     store = ParameterDict("accnt", "region")
 
-    store.get(None).should.equal(None)
+    assert store.get(None) is None
 
 
 def test_get_aws_param():
     store = ParameterDict("accnt", "region")
 
     p = store["/aws/service/global-infrastructure/regions/us-west-1/longName"]
-    p.should.have.length_of(1)
-    p[0].value.should.equal("US West (N. California)")
+    assert len(p) == 1
+    assert p[0].value == "US West (N. California)"
 
 
 def test_iter():
     store = ParameterDict("accnt", "region")
     store["/a/b/c"] = "some object"
 
-    "/a/b/c".should.be.within(store)
-    "/a/b/d".shouldnt.be.within(store)
+    assert "/a/b/c" in store
+    assert "/a/b/d" not in store
 
 
 def test_iter_none():
     store = ParameterDict("accnt", "region")
-    None.shouldnt.be.within(store)
+    assert None not in store
 
 
 def test_iter_aws():
     store = ParameterDict("accnt", "region")
 
-    "/aws/service/global-infrastructure/regions/us-west-1/longName".should.be.within(
-        store
-    )
+    assert "/aws/service/global-infrastructure/regions/us-west-1/longName" in store
 
 
 def test_get_key_beginning_with():
@@ -52,20 +48,17 @@ def test_get_key_beginning_with():
     store["/a/c/d"] = "some third object"
 
     begins_with_ab = list(store.get_keys_beginning_with("/a/b", recursive=False))
-    begins_with_ab.should.equal(["/a/b/c"])
+    assert begins_with_ab == ["/a/b/c"]
 
     begins_with_a = list(store.get_keys_beginning_with("/a", recursive=False))
-    begins_with_a.should.equal([])
+    assert not begins_with_a
 
     begins_with_a_recursive = list(store.get_keys_beginning_with("/a", recursive=True))
-    set(begins_with_a_recursive).should.equal({"/a/b/c", "/a/c/d"})
+    assert set(begins_with_a_recursive) == {"/a/b/c", "/a/c/d"}
 
 
 def test_get_key_beginning_with_aws():
-    """
-    ParameterDict should load the default parameters if we request a key starting with '/aws'
-    :return:
-    """
+    """Test ParameterDict loads default params for key starting with '/aws'."""
     store = ParameterDict("accnt", "region")
 
     uswest_params = set(
@@ -73,22 +66,20 @@ def test_get_key_beginning_with_aws():
             "/aws/service/global-infrastructure/regions/us-west-1", recursive=False
         )
     )
-    uswest_params.should.equal(
-        {
-            "/aws/service/global-infrastructure/regions/us-west-1",
-            "/aws/service/global-infrastructure/regions/us-west-1/domain",
-            "/aws/service/global-infrastructure/regions/us-west-1/geolocationCountry",
-            "/aws/service/global-infrastructure/regions/us-west-1/geolocationRegion",
-            "/aws/service/global-infrastructure/regions/us-west-1/longName",
-            "/aws/service/global-infrastructure/regions/us-west-1/partition",
-        }
-    )
+    assert uswest_params == {
+        "/aws/service/global-infrastructure/regions/us-west-1",
+        "/aws/service/global-infrastructure/regions/us-west-1/domain",
+        "/aws/service/global-infrastructure/regions/us-west-1/geolocationCountry",
+        "/aws/service/global-infrastructure/regions/us-west-1/geolocationRegion",
+        "/aws/service/global-infrastructure/regions/us-west-1/longName",
+        "/aws/service/global-infrastructure/regions/us-west-1/partition",
+    }
 
 
 def test_ssm_parameter_from_unknown_region():
     store = ParameterDict("accnt", "region")
-    list(
+    assert not list(
         store.get_keys_beginning_with(
             "/aws/service/ami-amazon-linux-latest", recursive=False
         )
-    ).should.equal([])
+    )
diff --git a/tests/test_ssm/test_ssm_patch_baseline.py b/tests/test_ssm/test_ssm_patch_baseline.py
index 2e4971b87..692aac84a 100644
--- a/tests/test_ssm/test_ssm_patch_baseline.py
+++ b/tests/test_ssm/test_ssm_patch_baseline.py
@@ -1,5 +1,4 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
 
 from moto import mock_ssm
 
@@ -48,13 +47,13 @@ def test_create_patch_baseLine():
         ],
         MaxResults=50,
     )
-    response.should.have.key("BaselineIdentities").have.length_of(1)
+    assert len(response["BaselineIdentities"]) == 1
     baseline = response["BaselineIdentities"][0]
-    baseline.should.have.key("BaselineId").equal(_id)
-    baseline.should.have.key("BaselineName").equal(baseline_name)
-    baseline.should.have.key("DefaultBaseline").equal(False)
-    baseline.should.have.key("OperatingSystem").equal("AMAZON_LINUX")
-    baseline.should.have.key("BaselineDescription").equal(baseline_description)
+    assert baseline["BaselineId"] == _id
+    assert baseline["BaselineName"] == baseline_name
+    assert baseline["DefaultBaseline"] is False
+    assert baseline["OperatingSystem"] == "AMAZON_LINUX"
+    assert baseline["BaselineDescription"] == baseline_description
 
 
 @mock_ssm
@@ -97,4 +96,4 @@ def test_delete_patch_baseline():
         ],
         MaxResults=50,
     )
-    response.should.have.key("BaselineIdentities").have.length_of(0)
+    assert len(response["BaselineIdentities"]) == 0
diff --git a/tests/test_ssm/test_ssm_secretsmanager.py b/tests/test_ssm/test_ssm_secretsmanager.py
index d8637a62c..276b8dce2 100644
--- a/tests/test_ssm/test_ssm_secretsmanager.py
+++ b/tests/test_ssm/test_ssm_secretsmanager.py
@@ -1,8 +1,9 @@
-import boto3
 import json
-import pytest
 
+import boto3
 from botocore.exceptions import ClientError
+import pytest
+
 from moto import mock_ssm, mock_secretsmanager
 
 
@@ -22,18 +23,18 @@ def test_get_value_from_secrets_manager__by_name():
     param = ssm.get_parameter(
         Name=f"/aws/reference/secretsmanager/{secret_name}", WithDecryption=True
     )["Parameter"]
-    param.should.have.key("Name").equals("mysecret")
-    param.should.have.key("Type").equals("SecureString")
-    param.should.have.key("Value").equals("some secret")
-    param.should.have.key("Version").equals(0)
-    param.should.have.key("SourceResult")
+    assert param["Name"] == "mysecret"
+    assert param["Type"] == "SecureString"
+    assert param["Value"] == "some secret"
+    assert param["Version"] == 0
+    assert "SourceResult" in param
 
     secret = secrets_manager.describe_secret(SecretId=secret_name)
     source_result = json.loads(param["SourceResult"])
 
-    source_result["ARN"].should.equal(secret["ARN"])
-    source_result["Name"].should.equal(secret["Name"])
-    source_result["VersionIdsToStages"].should.equal(secret["VersionIdsToStages"])
+    assert source_result["ARN"] == secret["ARN"]
+    assert source_result["Name"] == secret["Name"]
+    assert source_result["VersionIdsToStages"] == secret["VersionIdsToStages"]
 
 
 @mock_secretsmanager
@@ -44,8 +45,8 @@ def test_get_value_from_secrets_manager__without_decryption():
     with pytest.raises(ClientError) as exc:
         ssm.get_parameter(Name="/aws/reference/secretsmanager/sth")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.equal(
+    assert err["Code"] == "ValidationException"
+    assert err["Message"] == (
         "WithDecryption flag must be True for retrieving a Secret Manager secret."
     )
 
@@ -60,8 +61,8 @@ def test_get_value_from_secrets_manager__with_decryption_false():
             Name="/aws/reference/secretsmanager/sth", WithDecryption=False
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ValidationException")
-    err["Message"].should.equal(
+    assert err["Code"] == "ValidationException"
+    assert err["Message"] == (
         "WithDecryption flag must be True for retrieving a Secret Manager secret."
     )
 
@@ -86,15 +87,15 @@ def test_get_value_from_secrets_manager__by_id():
     # then
     full_name = f"/aws/reference/secretsmanager/{name}:{version_id1}"
     param = ssm.get_parameter(Name=full_name, WithDecryption=True)["Parameter"]
-    param.should.have.key("Value").equals("1st")
+    assert param["Value"] == "1st"
 
     full_name = f"/aws/reference/secretsmanager/{name}"
     param = ssm.get_parameter(Name=full_name, WithDecryption=True)["Parameter"]
-    param.should.have.key("Value").equals("2nd")
+    assert param["Value"] == "2nd"
 
     full_name = f"/aws/reference/secretsmanager/{name}:{version_id3}"
     param = ssm.get_parameter(Name=full_name, WithDecryption=True)["Parameter"]
-    param.should.have.key("Value").equals("3rd")
+    assert param["Value"] == "3rd"
 
 
 @mock_secretsmanager
@@ -112,7 +113,7 @@ def test_get_value_from_secrets_manager__by_version():
     # then
     full_name = f"/aws/reference/secretsmanager/{name}:AWSPREVIOUS"
     param = ssm.get_parameter(Name=full_name, WithDecryption=True)["Parameter"]
-    param.should.have.key("Value").equals("1st")
+    assert param["Value"] == "1st"
 
 
 @mock_secretsmanager
@@ -124,7 +125,8 @@ def test_get_value_from_secrets_manager__param_does_not_exist():
             Name="/aws/reference/secretsmanager/test", WithDecryption=True
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ParameterNotFound")
-    err["Message"].should.equal(
-        "An error occurred (ParameterNotFound) when referencing Secrets Manager: Secret /aws/reference/secretsmanager/test not found."
+    assert err["Code"] == "ParameterNotFound"
+    assert err["Message"] == (
+        "An error occurred (ParameterNotFound) when referencing Secrets "
+        "Manager: Secret /aws/reference/secretsmanager/test not found."
     )
diff --git a/tests/test_ssm/test_ssm_utils.py b/tests/test_ssm/test_ssm_utils.py
index 040c79525..2c18cd9a9 100644
--- a/tests/test_ssm/test_ssm_utils.py
+++ b/tests/test_ssm/test_ssm_utils.py
@@ -1,11 +1,11 @@
-import sure  # noqa # pylint: disable=unused-import
-
-
 from moto.ssm.utils import convert_to_tree, convert_to_params
 
 SOURCE_PARAMS = [
     {
-        "ARN": "arn:aws:ssm:us-west-1::parameter/aws/service/global-infrastructure/regions/af-south-1",
+        "ARN": (
+            "arn:aws:ssm:us-west-1::parameter/aws/service"
+            "/global-infrastructure/regions/af-south-1"
+        ),
         "DataType": "text",
         "Name": "/aws/service/global-infrastructure/regions/af-south-1",
         "Type": "String",
@@ -13,7 +13,10 @@ SOURCE_PARAMS = [
         "Version": 1,
     },
     {
-        "ARN": "arn:aws:ssm:us-west-1::parameter/aws/service/global-infrastructure/regions/ap-northeast-2",
+        "ARN": (
+            "arn:aws:ssm:us-west-1::parameter/aws/service"
+            "/global-infrastructure/regions/ap-northeast-2"
+        ),
         "DataType": "text",
         "Name": "/aws/service/global-infrastructure/regions/ap-northeast-2",
         "Type": "String",
@@ -21,7 +24,10 @@ SOURCE_PARAMS = [
         "Version": 1,
     },
     {
-        "ARN": "arn:aws:ssm:us-west-1::parameter/aws/service/global-infrastructure/regions/cn-north-1",
+        "ARN": (
+            "arn:aws:ssm:us-west-1::parameter/aws/service"
+            "/global-infrastructure/regions/cn-north-1"
+        ),
         "DataType": "text",
         "Name": "/aws/service/global-infrastructure/regions/cn-north-1",
         "Type": "String",
@@ -29,9 +35,16 @@ SOURCE_PARAMS = [
         "Version": 1,
     },
     {
-        "ARN": "arn:aws:ssm:us-west-1::parameter/aws/service/global-infrastructure/regions/ap-northeast-2/services/codestar-notifications",
+        "ARN": (
+            "arn:aws:ssm:us-west-1::parameter/aws/service"
+            "/global-infrastructure/regions/ap-northeast-2/services"
+            "/codestar-notifications"
+        ),
         "DataType": "text",
-        "Name": "/aws/service/global-infrastructure/regions/ap-northeast-2/services/codestar-notifications",
+        "Name": (
+            "/aws/service/global-infrastructure/regions"
+            "/ap-northeast-2/services/codestar-notifications"
+        ),
         "Type": "String",
         "Value": "codestar-notifications",
         "Version": 1,
@@ -73,7 +86,10 @@ CONVERTED_PARAMS = [
         "Value": "ap-northeast-2",
     },
     {
-        "Name": "/aws/service/global-infrastructure/regions/ap-northeast-2/services/codestar-notifications",
+        "Name": (
+            "/aws/service/global-infrastructure/regions/ap-northeast-2"
+            "/services/codestar-notifications"
+        ),
         "Value": "codestar-notifications",
     },
 ]
@@ -82,20 +98,18 @@ CONVERTED_PARAMS = [
 def test_convert_to_tree():
     tree = convert_to_tree(SOURCE_PARAMS)
 
-    tree.should.equal(EXPECTED_TREE)
+    assert tree == EXPECTED_TREE
 
 
 def test_convert_to_params():
     actual = convert_to_params(EXPECTED_TREE)
-    actual.should.have.length_of(len(CONVERTED_PARAMS))
+    assert len(actual) == len(CONVERTED_PARAMS)
     for param in CONVERTED_PARAMS:
-        actual.should.contain(param)
+        assert param in actual
 
 
 def test_input_is_correct():
-    """
-    Test input should match
-    """
+    """Test input should match."""
     for src in SOURCE_PARAMS:
         minimized_src = {"Name": src["Name"], "Value": src["Value"]}
-        CONVERTED_PARAMS.should.contain(minimized_src)
+        assert minimized_src in CONVERTED_PARAMS
diff --git a/tests/test_timestreamwrite/test_server.py b/tests/test_timestreamwrite/test_server.py
index c1c907268..f2ceb65d6 100644
--- a/tests/test_timestreamwrite/test_server.py
+++ b/tests/test_timestreamwrite/test_server.py
@@ -1,5 +1,4 @@
 import json
-import sure  # noqa # pylint: disable=unused-import
 
 import moto.server as server
 from moto import mock_timestreamwrite
@@ -12,5 +11,5 @@ def test_timestreamwrite_list():
 
     headers = {"X-Amz-Target": "Timestream_20181101.ListDatabases"}
     resp = test_client.post("/", headers=headers, json={})
-    resp.status_code.should.equal(200)
-    json.loads(resp.data).should.equal({"Databases": []})
+    assert resp.status_code == 200
+    assert json.loads(resp.data) == {"Databases": []}
diff --git a/tests/test_timestreamwrite/test_timestreamwrite_database.py b/tests/test_timestreamwrite/test_timestreamwrite_database.py
index 55c8ca6bf..e49453e9d 100644
--- a/tests/test_timestreamwrite/test_timestreamwrite_database.py
+++ b/tests/test_timestreamwrite/test_timestreamwrite_database.py
@@ -1,8 +1,7 @@
 import boto3
+from botocore.exceptions import ClientError
 import pytest
-import sure  # noqa # pylint: disable=unused-import
 
-from botocore.exceptions import ClientError
 from moto import mock_timestreamwrite
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
 
@@ -13,14 +12,12 @@ def test_create_database_simple():
     resp = ts.create_database(DatabaseName="mydatabase")
     database = resp["Database"]
 
-    database.should.have.key("Arn").equals(
+    assert database["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase"
     )
-    database.should.have.key("DatabaseName").equals("mydatabase")
-    database.should.have.key("TableCount").equals(0)
-    database.should.have.key("KmsKeyId").equals(
-        f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key"
-    )
+    assert database["DatabaseName"] == "mydatabase"
+    assert database["TableCount"] == 0
+    assert database["KmsKeyId"] == f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key"
 
 
 @mock_timestreamwrite
@@ -33,12 +30,12 @@ def test_create_database_advanced():
     )
     database = resp["Database"]
 
-    database.should.have.key("Arn").equals(
+    assert database["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase"
     )
-    database.should.have.key("DatabaseName").equals("mydatabase")
-    database.should.have.key("TableCount").equals(0)
-    database.should.have.key("KmsKeyId").equal("mykey")
+    assert database["DatabaseName"] == "mydatabase"
+    assert database["TableCount"] == 0
+    assert database["KmsKeyId"] == "mykey"
 
 
 @mock_timestreamwrite
@@ -48,12 +45,12 @@ def test_describe_database():
 
     database = ts.describe_database(DatabaseName="mydatabase")["Database"]
 
-    database.should.have.key("Arn").equals(
+    assert database["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase"
     )
-    database.should.have.key("DatabaseName").equals("mydatabase")
-    database.should.have.key("TableCount").equals(0)
-    database.should.have.key("KmsKeyId").equal("mykey")
+    assert database["DatabaseName"] == "mydatabase"
+    assert database["TableCount"] == 0
+    assert database["KmsKeyId"] == "mykey"
 
 
 @mock_timestreamwrite
@@ -62,8 +59,8 @@ def test_describe_unknown_database():
     with pytest.raises(ClientError) as exc:
         ts.describe_database(DatabaseName="unknown")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
-    err["Message"].should.equal("The database unknown does not exist.")
+    assert err["Code"] == "ResourceNotFoundException"
+    assert err["Message"] == "The database unknown does not exist."
 
 
 @mock_timestreamwrite
@@ -74,23 +71,19 @@ def test_list_databases():
 
     resp = ts.list_databases()
     databases = resp["Databases"]
-    databases.should.have.length_of(2)
-    databases.should.contain(
-        {
-            "Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_with",
-            "DatabaseName": "db_with",
-            "TableCount": 0,
-            "KmsKeyId": "mykey",
-        }
-    )
-    databases.should.contain(
-        {
-            "Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_without",
-            "DatabaseName": "db_without",
-            "TableCount": 0,
-            "KmsKeyId": f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key",
-        }
-    )
+    assert len(databases) == 2
+    assert {
+        "Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_with",
+        "DatabaseName": "db_with",
+        "TableCount": 0,
+        "KmsKeyId": "mykey",
+    } in databases
+    assert {
+        "Arn": f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/db_without",
+        "DatabaseName": "db_without",
+        "TableCount": 0,
+        "KmsKeyId": f"arn:aws:kms:us-east-1:{ACCOUNT_ID}:key/default_key",
+    } in databases
 
 
 @mock_timestreamwrite
@@ -100,13 +93,13 @@ def test_delete_database():
     ts.create_database(DatabaseName="db_2")
     ts.create_database(DatabaseName="db_3", KmsKeyId="mysecondkey")
 
-    ts.list_databases()["Databases"].should.have.length_of(3)
+    assert len(ts.list_databases()["Databases"]) == 3
 
     ts.delete_database(DatabaseName="db_2")
 
     databases = ts.list_databases()["Databases"]
-    databases.should.have.length_of(2)
-    [db["DatabaseName"] for db in databases].should.equal(["db_1", "db_3"])
+    assert len(databases) == 2
+    assert [db["DatabaseName"] for db in databases] == ["db_1", "db_3"]
 
 
 @mock_timestreamwrite
@@ -114,10 +107,10 @@ def test_update_database():
     ts = boto3.client("timestream-write", region_name="us-east-1")
     ts.create_database(DatabaseName="mydatabase", KmsKeyId="mykey")
     resp = ts.update_database(DatabaseName="mydatabase", KmsKeyId="updatedkey")
-    resp.should.have.key("Database")
+    assert "Database" in resp
     database = resp["Database"]
-    database.should.have.key("Arn")
-    database.should.have.key("KmsKeyId").equal("updatedkey")
+    assert "Arn" in database
+    assert database["KmsKeyId"] == "updatedkey"
 
     database = ts.describe_database(DatabaseName="mydatabase")["Database"]
-    database.should.have.key("KmsKeyId").equal("updatedkey")
+    assert database["KmsKeyId"] == "updatedkey"
diff --git a/tests/test_timestreamwrite/test_timestreamwrite_table.py b/tests/test_timestreamwrite/test_timestreamwrite_table.py
index 83738b658..33fa936e5 100644
--- a/tests/test_timestreamwrite/test_timestreamwrite_table.py
+++ b/tests/test_timestreamwrite/test_timestreamwrite_table.py
@@ -1,9 +1,9 @@
 import time
+
 import boto3
+from botocore.exceptions import ClientError
 import pytest
-import sure  # noqa # pylint: disable=unused-import
 
-from botocore.exceptions import ClientError
 from moto import mock_timestreamwrite, settings
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
 
@@ -22,18 +22,16 @@ def test_create_table():
         },
     )
     table = resp["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
-    table.should.have.key("DatabaseName").equal("mydatabase")
-    table.should.have.key("TableStatus").equal("ACTIVE")
-    table.should.have.key("RetentionProperties").should.equal(
-        {
-            "MemoryStoreRetentionPeriodInHours": 7,
-            "MagneticStoreRetentionPeriodInDays": 42,
-        }
-    )
+    assert table["TableName"] == "mytable"
+    assert table["DatabaseName"] == "mydatabase"
+    assert table["TableStatus"] == "ACTIVE"
+    assert table["RetentionProperties"] == {
+        "MemoryStoreRetentionPeriodInHours": 7,
+        "MagneticStoreRetentionPeriodInDays": 42,
+    }
 
 
 @mock_timestreamwrite
@@ -52,20 +50,18 @@ def test_create_table__with_magnetic_store_write_properties():
         },
     )
     table = resp["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
-    table.should.have.key("DatabaseName").equal("mydatabase")
-    table.should.have.key("TableStatus").equal("ACTIVE")
-    table.should.have.key("MagneticStoreWriteProperties").should.equal(
-        {
-            "EnableMagneticStoreWrites": True,
-            "MagneticStoreRejectedDataLocation": {
-                "S3Configuration": {"BucketName": "hithere"}
-            },
-        }
-    )
+    assert table["TableName"] == "mytable"
+    assert table["DatabaseName"] == "mydatabase"
+    assert table["TableStatus"] == "ACTIVE"
+    assert table["MagneticStoreWriteProperties"] == {
+        "EnableMagneticStoreWrites": True,
+        "MagneticStoreRejectedDataLocation": {
+            "S3Configuration": {"BucketName": "hithere"}
+        },
+    }
 
 
 @mock_timestreamwrite
@@ -75,18 +71,16 @@ def test_create_table_without_retention_properties():
 
     resp = ts.create_table(DatabaseName="mydatabase", TableName="mytable")
     table = resp["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
-    table.should.have.key("DatabaseName").equal("mydatabase")
-    table.should.have.key("TableStatus").equal("ACTIVE")
-    table.should.have.key("RetentionProperties").equals(
-        {
-            "MemoryStoreRetentionPeriodInHours": 123,
-            "MagneticStoreRetentionPeriodInDays": 123,
-        }
-    )
+    assert table["TableName"] == "mytable"
+    assert table["DatabaseName"] == "mydatabase"
+    assert table["TableStatus"] == "ACTIVE"
+    assert table["RetentionProperties"] == {
+        "MemoryStoreRetentionPeriodInHours": 123,
+        "MagneticStoreRetentionPeriodInDays": 123,
+    }
 
 
 @mock_timestreamwrite
@@ -104,18 +98,16 @@ def test_describe_table():
     )
 
     table = ts.describe_table(DatabaseName="mydatabase", TableName="mytable")["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
-    table.should.have.key("DatabaseName").equal("mydatabase")
-    table.should.have.key("TableStatus").equal("ACTIVE")
-    table.should.have.key("RetentionProperties").should.equal(
-        {
-            "MemoryStoreRetentionPeriodInHours": 10,
-            "MagneticStoreRetentionPeriodInDays": 12,
-        }
-    )
+    assert table["TableName"] == "mytable"
+    assert table["DatabaseName"] == "mydatabase"
+    assert table["TableStatus"] == "ACTIVE"
+    assert table["RetentionProperties"] == {
+        "MemoryStoreRetentionPeriodInHours": 10,
+        "MagneticStoreRetentionPeriodInDays": 12,
+    }
 
 
 @mock_timestreamwrite
@@ -126,8 +118,8 @@ def test_describe_unknown_database():
     with pytest.raises(ClientError) as exc:
         ts.describe_table(DatabaseName="mydatabase", TableName="unknown")
     err = exc.value.response["Error"]
-    err["Code"].should.equal("ResourceNotFoundException")
-    err["Message"].should.equal("The table unknown does not exist.")
+    assert err["Code"] == "ResourceNotFoundException"
+    assert err["Message"] == "The table unknown does not exist."
 
 
 @mock_timestreamwrite
@@ -147,15 +139,19 @@ def test_create_multiple_tables():
 
     database = ts.describe_database(DatabaseName="mydatabase")["Database"]
 
-    database.should.have.key("TableCount").equals(5)
+    assert database["TableCount"] == 5
 
     tables = ts.list_tables(DatabaseName="mydatabase")["Tables"]
-    tables.should.have.length_of(5)
-    set([t["DatabaseName"] for t in tables]).should.equal({"mydatabase"})
-    set([t["TableName"] for t in tables]).should.equal(
-        {"mytable_0", "mytable_1", "mytable_2", "mytable_3", "mytable_4"}
-    )
-    set([t["TableStatus"] for t in tables]).should.equal({"ACTIVE"})
+    assert len(tables) == 5
+    assert {t["DatabaseName"] for t in tables} == {"mydatabase"}
+    assert {t["TableName"] for t in tables} == {
+        "mytable_0",
+        "mytable_1",
+        "mytable_2",
+        "mytable_3",
+        "mytable_4",
+    }
+    assert {t["TableStatus"] for t in tables} == {"ACTIVE"}
 
 
 @mock_timestreamwrite
@@ -174,13 +170,13 @@ def test_delete_table():
         )
 
     tables = ts.list_tables(DatabaseName="mydatabase")["Tables"]
-    tables.should.have.length_of(3)
+    assert len(tables) == 3
 
     ts.delete_table(DatabaseName="mydatabase", TableName="mytable_1")
 
     tables = ts.list_tables(DatabaseName="mydatabase")["Tables"]
-    tables.should.have.length_of(2)
-    set([t["TableName"] for t in tables]).should.equal({"mytable_0", "mytable_2"})
+    assert len(tables) == 2
+    assert {t["TableName"] for t in tables} == {"mytable_0", "mytable_2"}
 
 
 @mock_timestreamwrite
@@ -198,26 +194,22 @@ def test_update_table():
         },
     )
     table = resp["Table"]
-    table.should.have.key("RetentionProperties").equals(
-        {
-            "MagneticStoreRetentionPeriodInDays": 2,
-            "MemoryStoreRetentionPeriodInHours": 1,
-        }
-    )
+    assert table["RetentionProperties"] == {
+        "MagneticStoreRetentionPeriodInDays": 2,
+        "MemoryStoreRetentionPeriodInHours": 1,
+    }
 
     table = ts.describe_table(DatabaseName="mydatabase", TableName="mytable")["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
-    table.should.have.key("DatabaseName").equal("mydatabase")
-    table.should.have.key("TableStatus").equal("ACTIVE")
-    table.should.have.key("RetentionProperties").equals(
-        {
-            "MagneticStoreRetentionPeriodInDays": 2,
-            "MemoryStoreRetentionPeriodInHours": 1,
-        }
-    )
+    assert table["TableName"] == "mytable"
+    assert table["DatabaseName"] == "mydatabase"
+    assert table["TableStatus"] == "ACTIVE"
+    assert table["RetentionProperties"] == {
+        "MagneticStoreRetentionPeriodInDays": 2,
+        "MemoryStoreRetentionPeriodInHours": 1,
+    }
 
 
 @mock_timestreamwrite
@@ -238,20 +230,18 @@ def test_update_table__with_magnetic_store_write_properties():
         },
     )
     table = resp["Table"]
-    table.should.have.key("Arn").equal(
+    assert table["Arn"] == (
         f"arn:aws:timestream:us-east-1:{ACCOUNT_ID}:database/mydatabase/table/mytable"
     )
-    table.should.have.key("TableName").equal("mytable")
-    table.should.have.key("DatabaseName").equal("mydatabase")
-    table.should.have.key("TableStatus").equal("ACTIVE")
-    table.should.have.key("MagneticStoreWriteProperties").should.equal(
-        {
-            "EnableMagneticStoreWrites": True,
-            "MagneticStoreRejectedDataLocation": {
-                "S3Configuration": {"BucketName": "hithere"}
-            },
-        }
-    )
+    assert table["TableName"] == "mytable"
+    assert table["DatabaseName"] == "mydatabase"
+    assert table["TableStatus"] == "ACTIVE"
+    assert table["MagneticStoreWriteProperties"] == {
+        "EnableMagneticStoreWrites": True,
+        "MagneticStoreRejectedDataLocation": {
+            "S3Configuration": {"BucketName": "hithere"}
+        },
+    }
 
 
 @mock_timestreamwrite
@@ -263,7 +253,8 @@ def test_write_records():
     ts.create_database(DatabaseName="mydatabase")
     ts.create_table(DatabaseName="mydatabase", TableName="mytable")
 
-    # Sample records from https://docs.aws.amazon.com/timestream/latest/developerguide/code-samples.write.html
+    # Sample records from:
+    # https://docs.aws.amazon.com/timestream/latest/developerguide/code-samples.write.html
     dimensions = [
         {"Name": "region", "Value": "us-east-1"},
         {"Name": "az", "Value": "az1"},
@@ -293,15 +284,15 @@ def test_write_records():
         TableName="mytable",
         Records=sample_records,
     ).get("RecordsIngested", {})
-    resp["Total"].should.equal(len(sample_records))
-    (resp["MemoryStore"] + resp["MagneticStore"]).should.equal(resp["Total"])
+    assert resp["Total"] == len(sample_records)
+    assert (resp["MemoryStore"] + resp["MagneticStore"]) == resp["Total"]
 
     if not settings.TEST_SERVER_MODE:
         from moto.timestreamwrite.models import timestreamwrite_backends
 
         backend = timestreamwrite_backends[ACCOUNT_ID]["us-east-1"]
         records = backend.databases["mydatabase"].tables["mytable"].records
-        records.should.equal(sample_records)
+        assert records == sample_records
 
         disk_utilization = {
             "Dimensions": dimensions,
@@ -317,4 +308,4 @@ def test_write_records():
             TableName="mytable",
             Records=[disk_utilization],
         )
-        records.should.equal(sample_records)
+        assert records == sample_records
diff --git a/tests/test_timestreamwrite/test_timestreamwrite_tagging.py b/tests/test_timestreamwrite/test_timestreamwrite_tagging.py
index a18ce8f22..584c360af 100644
--- a/tests/test_timestreamwrite/test_timestreamwrite_tagging.py
+++ b/tests/test_timestreamwrite/test_timestreamwrite_tagging.py
@@ -19,7 +19,7 @@ def test_list_tagging_for_table_without_tags():
     table_arn = resp["Table"]["Arn"]
 
     resp = ts.list_tags_for_resource(ResourceARN=table_arn)
-    resp.should.have.key("Tags").equals([])
+    assert resp["Tags"] == []
 
 
 @mock_timestreamwrite
@@ -39,7 +39,7 @@ def test_list_tagging_for_table_with_tags():
     table_arn = resp["Table"]["Arn"]
 
     resp = ts.list_tags_for_resource(ResourceARN=table_arn)
-    resp.should.have.key("Tags").equals([{"Key": "k1", "Value": "v1"}])
+    assert resp["Tags"] == [{"Key": "k1", "Value": "v1"}]
 
 
 @mock_timestreamwrite
@@ -48,7 +48,7 @@ def test_list_tagging_for_database_without_tags():
     db_arn = ts.create_database(DatabaseName="mydatabase")["Database"]["Arn"]
 
     resp = ts.list_tags_for_resource(ResourceARN=db_arn)
-    resp.should.have.key("Tags").equals([])
+    assert resp["Tags"] == []
 
 
 @mock_timestreamwrite
@@ -59,7 +59,7 @@ def test_list_tagging_for_database_with_tags():
     )["Database"]["Arn"]
 
     resp = ts.list_tags_for_resource(ResourceARN=db_arn)
-    resp.should.have.key("Tags").equals([{"Key": "k1", "Value": "v1"}])
+    assert resp["Tags"] == [{"Key": "k1", "Value": "v1"}]
 
 
 @mock_timestreamwrite
@@ -75,17 +75,13 @@ def test_tag_and_untag_database():
     )
 
     resp = ts.list_tags_for_resource(ResourceARN=db_arn)
-    resp.should.have.key("Tags").equals(
-        [
-            {"Key": "k1", "Value": "v1"},
-            {"Key": "k2", "Value": "v2"},
-            {"Key": "k3", "Value": "v3"},
-        ]
-    )
+    assert resp["Tags"] == [
+        {"Key": "k1", "Value": "v1"},
+        {"Key": "k2", "Value": "v2"},
+        {"Key": "k3", "Value": "v3"},
+    ]
 
     ts.untag_resource(ResourceARN=db_arn, TagKeys=["k2"])
 
     resp = ts.list_tags_for_resource(ResourceARN=db_arn)
-    resp.should.have.key("Tags").equals(
-        [{"Key": "k1", "Value": "v1"}, {"Key": "k3", "Value": "v3"}]
-    )
+    assert resp["Tags"] == [{"Key": "k1", "Value": "v1"}, {"Key": "k3", "Value": "v3"}]
diff --git a/tests/test_wafv2/test_server.py b/tests/test_wafv2/test_server.py
index 867dc6b2d..cf308d6e7 100644
--- a/tests/test_wafv2/test_server.py
+++ b/tests/test_wafv2/test_server.py
@@ -1,9 +1,7 @@
-import sure  # noqa # pylint: disable=unused-import
-
-import moto.server as server
 from moto import mock_wafv2
-from .test_helper_functions import CREATE_WEB_ACL_BODY, LIST_WEB_ACL_BODY
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
+import moto.server as server
+from .test_helper_functions import CREATE_WEB_ACL_BODY, LIST_WEB_ACL_BODY
 
 CREATE_WEB_ACL_HEADERS = {
     "X-Amz-Target": "AWSWAF_20190729.CreateWebACL",
@@ -43,9 +41,9 @@ def test_create_web_acl():
     )
     assert res.status_code == 400
     assert (
-        b"AWS WAF could not perform the operation because some resource in your request is a duplicate of an existing one."
-        in res.data
-    )
+        b"AWS WAF could not perform the operation because some resource "
+        b"in your request is a duplicate of an existing one."
+    ) in res.data
     assert b"WafV2DuplicateItem" in res.data
 
     res = test_client.post(
diff --git a/tests/test_wafv2/test_wafv2.py b/tests/test_wafv2/test_wafv2.py
index 202a0db1f..f1a4c3393 100644
--- a/tests/test_wafv2/test_wafv2.py
+++ b/tests/test_wafv2/test_wafv2.py
@@ -1,11 +1,10 @@
-import pytest
-
-import sure  # noqa # pylint: disable=unused-import
 import boto3
 from botocore.exceptions import ClientError
+import pytest
+
 from moto import mock_wafv2
-from .test_helper_functions import CREATE_WEB_ACL_BODY, LIST_WEB_ACL_BODY
 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
+from .test_helper_functions import CREATE_WEB_ACL_BODY, LIST_WEB_ACL_BODY
 
 
 @mock_wafv2
@@ -22,10 +21,11 @@ def test_create_web_acl():
     with pytest.raises(ClientError) as ex:
         conn.create_web_acl(**CREATE_WEB_ACL_BODY("John", "REGIONAL"))
     err = ex.value.response["Error"]
-    err["Message"].should.contain(
-        "AWS WAF could not perform the operation because some resource in your request is a duplicate of an existing one."
-    )
-    err["Code"].should.equal("WafV2DuplicateItem")
+    assert (
+        "AWS WAF could not perform the operation because some resource "
+        "in your request is a duplicate of an existing one."
+    ) in err["Message"]
+    assert err["Code"] == "WafV2DuplicateItem"
 
     res = conn.create_web_acl(**CREATE_WEB_ACL_BODY("Carl", "CLOUDFRONT"))
     web_acl = res["Summary"]
@@ -84,16 +84,14 @@ def test_create_web_acl_with_all_arguments():
     )["Summary"]["Id"]
 
     wacl = client.get_web_acl(Name="test", Scope="CLOUDFRONT", Id=web_acl_id)["WebACL"]
-    wacl.should.have.key("Description").equals("test desc")
-    wacl.should.have.key("DefaultAction").equals({"Allow": {}})
-    wacl.should.have.key("VisibilityConfig").equals(
-        {
-            "SampledRequestsEnabled": False,
-            "CloudWatchMetricsEnabled": False,
-            "MetricName": "idk",
-        }
-    )
-    wacl.should.have.key("Rules").length_of(2)
+    assert wacl["Description"] == "test desc"
+    assert wacl["DefaultAction"] == {"Allow": {}}
+    assert wacl["VisibilityConfig"] == {
+        "SampledRequestsEnabled": False,
+        "CloudWatchMetricsEnabled": False,
+        "MetricName": "idk",
+    }
+    assert len(wacl["Rules"]) == 2
 
 
 @mock_wafv2
@@ -102,8 +100,8 @@ def test_get_web_acl():
     body = CREATE_WEB_ACL_BODY("John", "REGIONAL")
     web_acl_id = conn.create_web_acl(**body)["Summary"]["Id"]
     wacl = conn.get_web_acl(Name="John", Scope="REGIONAL", Id=web_acl_id)["WebACL"]
-    wacl.should.have.key("Name").equals("John")
-    wacl.should.have.key("Id").equals(web_acl_id)
+    assert wacl["Name"] == "John"
+    assert wacl["Id"] == web_acl_id
 
 
 @mock_wafv2
@@ -134,13 +132,13 @@ def test_delete_web_acl():
     conn.delete_web_acl(Name="Daphne", Id=wacl_id, Scope="REGIONAL", LockToken="n/a")
 
     res = conn.list_web_acls(**LIST_WEB_ACL_BODY("REGIONAL"))
-    res["WebACLs"].should.have.length_of(0)
+    assert len(res["WebACLs"]) == 0
 
     with pytest.raises(ClientError) as exc:
         conn.get_web_acl(Name="Daphne", Scope="REGIONAL", Id=wacl_id)
     err = exc.value.response["Error"]
-    err["Code"].should.equal("WAFNonexistentItemException")
-    err["Message"].should.equal(
+    assert err["Code"] == "WAFNonexistentItemException"
+    assert err["Message"] == (
         "AWS WAF couldn’t perform the operation because your resource doesn’t exist."
     )
 
@@ -177,31 +175,25 @@ def test_update_web_acl():
             "MetricName": "updated",
         },
     )
-    resp.should.have.key("NextLockToken")
+    assert "NextLockToken" in resp
 
     acl = conn.get_web_acl(Name="Daphne", Scope="REGIONAL", Id=wacl_id)["WebACL"]
-    acl.should.have.key("Description").equals("updated_desc")
-    acl.should.have.key("DefaultAction").equals(
-        {"Block": {"CustomResponse": {"ResponseCode": 412}}}
-    )
-    acl.should.have.key("Rules").equals(
-        [
-            {
-                "Name": "rule1",
-                "Priority": 456,
-                "Statement": {},
-                "VisibilityConfig": {
-                    "SampledRequestsEnabled": True,
-                    "CloudWatchMetricsEnabled": True,
-                    "MetricName": "updated",
-                },
-            }
-        ]
-    )
-    acl.should.have.key("VisibilityConfig").equals(
+    assert acl["Description"] == "updated_desc"
+    assert acl["DefaultAction"] == {"Block": {"CustomResponse": {"ResponseCode": 412}}}
+    assert acl["Rules"] == [
         {
-            "SampledRequestsEnabled": True,
-            "CloudWatchMetricsEnabled": True,
-            "MetricName": "updated",
+            "Name": "rule1",
+            "Priority": 456,
+            "Statement": {},
+            "VisibilityConfig": {
+                "SampledRequestsEnabled": True,
+                "CloudWatchMetricsEnabled": True,
+                "MetricName": "updated",
+            },
         }
-    )
+    ]
+    assert acl["VisibilityConfig"] == {
+        "SampledRequestsEnabled": True,
+        "CloudWatchMetricsEnabled": True,
+        "MetricName": "updated",
+    }
diff --git a/tests/test_wafv2/test_wafv2_integration.py b/tests/test_wafv2/test_wafv2_integration.py
index 4430c6787..eff2862c5 100644
--- a/tests/test_wafv2/test_wafv2_integration.py
+++ b/tests/test_wafv2/test_wafv2_integration.py
@@ -1,11 +1,10 @@
-import pytest
-
-import sure  # noqa # pylint: disable=unused-import
 import boto3
 from botocore.exceptions import ClientError
+import pytest
+
 from moto import mock_apigateway, mock_wafv2
-from .test_helper_functions import CREATE_WEB_ACL_BODY
 from tests.test_apigateway.test_apigateway_stage import create_method_integration
+from .test_helper_functions import CREATE_WEB_ACL_BODY
 
 
 @mock_wafv2
@@ -28,8 +27,8 @@ def test_associate_with_unknown_resource():
             WebACLArn=f"{wacl_arn}2", ResourceArn="unknownarnwithminlength20"
         )
     err = exc.value.response["Error"]
-    err["Code"].should.equal("WAFNonexistentItemException")
-    err["Message"].should.equal(
+    assert err["Code"] == "WAFNonexistentItemException"
+    assert err["Message"] == (
         "AWS WAF couldn’t perform the operation because your resource doesn’t exist."
     )
 
@@ -48,12 +47,12 @@ def test_associate_with_apigateway_stage():
     conn.associate_web_acl(WebACLArn=wacl_arn, ResourceArn=stage_arn)
 
     stage = apigw.get_stage(restApiId=api_id, stageName="test")
-    stage.should.have.key("webAclArn").equals(wacl_arn)
+    assert stage["webAclArn"] == wacl_arn
 
     conn.disassociate_web_acl(ResourceArn=stage_arn)
 
     stage = apigw.get_stage(restApiId=api_id, stageName="test")
-    stage.shouldnt.have.key("webAclArn")
+    assert "webAclArn" not in stage
 
 
 @mock_apigateway
@@ -68,14 +67,14 @@ def test_get_web_acl_for_resource():
     _, stage_arn = create_apigateway_stage(client=apigw)
 
     resp = conn.get_web_acl_for_resource(ResourceArn=stage_arn)
-    resp.shouldnt.have.key("WebACL")
+    assert "WebACL" not in resp
 
     conn.associate_web_acl(WebACLArn=wacl_arn, ResourceArn=stage_arn)
 
     resp = conn.get_web_acl_for_resource(ResourceArn=stage_arn)
-    resp.should.have.key("WebACL")
-    resp["WebACL"].should.have.key("Name").equals("John")
-    resp["WebACL"].should.have.key("ARN").equals(wacl_arn)
+    assert "WebACL" in resp
+    assert resp["WebACL"]["Name"] == "John"
+    assert resp["WebACL"]["ARN"] == wacl_arn
 
 
 @mock_wafv2
diff --git a/tests/test_wafv2/test_wafv2_rules.py b/tests/test_wafv2/test_wafv2_rules.py
index 98329d4fc..5273cb73b 100644
--- a/tests/test_wafv2/test_wafv2_rules.py
+++ b/tests/test_wafv2/test_wafv2_rules.py
@@ -6,4 +6,4 @@ from moto import mock_wafv2
 def test_list_rule_groups():
     client = boto3.client("wafv2", region_name="us-east-2")
     resp = client.list_rule_groups(Scope="CLOUDFRONT")
-    resp.should.have.key("RuleGroups").equals([])
+    assert resp["RuleGroups"] == []
diff --git a/tests/test_wafv2/test_wafv2_tags.py b/tests/test_wafv2/test_wafv2_tags.py
index 093418bf7..36c9700e7 100644
--- a/tests/test_wafv2/test_wafv2_tags.py
+++ b/tests/test_wafv2/test_wafv2_tags.py
@@ -1,5 +1,5 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
+
 from moto import mock_wafv2
 from .test_helper_functions import CREATE_WEB_ACL_BODY
 
@@ -12,7 +12,7 @@ def test_list_tags_for_resource__none_supplied():
     ]
 
     tag_info = conn.list_tags_for_resource(ResourceARN=arn)["TagInfoForResource"]
-    tag_info.should.have.key("TagList").equals([])
+    assert tag_info["TagList"] == []
 
 
 @mock_wafv2
@@ -31,7 +31,7 @@ def test_list_tags_for_resource():
     )["Summary"]["ARN"]
 
     tag_info = conn.list_tags_for_resource(ResourceARN=arn)["TagInfoForResource"]
-    tag_info.should.have.key("TagList").equals([{"Key": "k1", "Value": "v1"}])
+    assert tag_info["TagList"] == [{"Key": "k1", "Value": "v1"}]
 
 
 @mock_wafv2
@@ -57,9 +57,10 @@ def test_tag_resource():
     )
 
     tag_info = conn.list_tags_for_resource(ResourceARN=arn)["TagInfoForResource"]
-    tag_info.should.have.key("TagList").equals(
-        [{"Key": "k1", "Value": "v1"}, {"Key": "k2", "Value": "v2"}]
-    )
+    assert tag_info["TagList"] == [
+        {"Key": "k1", "Value": "v1"},
+        {"Key": "k2", "Value": "v2"},
+    ]
 
 
 @mock_wafv2
@@ -80,4 +81,4 @@ def test_untag_resource():
     conn.untag_resource(ResourceARN=arn, TagKeys=["k1"])
 
     tag_info = conn.list_tags_for_resource(ResourceARN=arn)["TagInfoForResource"]
-    tag_info.should.have.key("TagList").equals([{"Key": "k2", "Value": "v2"}])
+    assert tag_info["TagList"] == [{"Key": "k2", "Value": "v2"}]
diff --git a/tests/test_xray/test_xray_boto3.py b/tests/test_xray/test_xray_boto3.py
index 80c2629d9..69d22a982 100644
--- a/tests/test_xray/test_xray_boto3.py
+++ b/tests/test_xray/test_xray_boto3.py
@@ -1,11 +1,9 @@
-import boto3
+import datetime
 import json
-import sure  # noqa # pylint: disable=unused-import
+import boto3
 
 from moto import mock_xray
 
-import datetime
-
 
 @mock_xray
 def test_put_telemetry():
@@ -119,8 +117,8 @@ def test_batch_get_trace():
             "1-581cf772-b006649127e371903a2de979",
         ]
     )
-    len(resp["UnprocessedTraceIds"]).should.equal(1)
-    len(resp["Traces"]).should.equal(1)
+    assert len(resp["UnprocessedTraceIds"]) == 1
+    assert len(resp["Traces"]) == 1
 
 
 # Following are not implemented, just testing it returns what boto expects
diff --git a/tests/test_xray/test_xray_client.py b/tests/test_xray/test_xray_client.py
index 5fe679b67..80f4ca0db 100644
--- a/tests/test_xray/test_xray_client.py
+++ b/tests/test_xray/test_xray_client.py
@@ -1,23 +1,21 @@
 import os
-
-from moto import mock_xray_client, XRaySegment, mock_dynamodb
-from moto.utilities.distutils_version import LooseVersion
-from unittest import SkipTest
-import sure  # noqa # pylint: disable=unused-import
-import boto3
+import requests  # noqa # pylint: disable=all
 import sys
+from unittest import SkipTest
 
-from moto.xray.mock_client import MockEmitter
 import aws_xray_sdk.core as xray_core
 import aws_xray_sdk.core.patcher as xray_core_patcher
-
+import boto3
 import botocore.client
 import botocore.endpoint
 
+from moto import mock_xray_client, XRaySegment, mock_dynamodb
+from moto.utilities.distutils_version import LooseVersion
+from moto.xray.mock_client import MockEmitter
+
 original_make_api_call = botocore.client.BaseClient._make_api_call
 original_encode_headers = botocore.endpoint.Endpoint._encode_headers
 
-import requests  # noqa # pylint: disable=all
 
 original_session_request = requests.Session.request
 original_session_prep_request = requests.Session.prepare_request
@@ -52,7 +50,7 @@ def test_xray_dynamo_request_id():
 
     with XRaySegment():
         resp = client.list_tables()
-        resp["ResponseMetadata"].should.contain("RequestId")
+        assert "RequestId" in resp["ResponseMetadata"]
         id1 = resp["ResponseMetadata"]["RequestId"]
 
     with XRaySegment():
@@ -60,7 +58,7 @@ def test_xray_dynamo_request_id():
         resp = client.list_tables()
         id2 = resp["ResponseMetadata"]["RequestId"]
 
-    id1.should_not.equal(id2)
+    assert id1 != id2
 
     setattr(botocore.client.BaseClient, "_make_api_call", original_make_api_call)
     setattr(botocore.endpoint.Endpoint, "_encode_headers", original_encode_headers)
@@ -82,7 +80,7 @@ def test_xray_dynamo_request_id_with_context_mgr():
 
             with XRaySegment():
                 resp = client.list_tables()
-                resp["ResponseMetadata"].should.contain("RequestId")
+                assert "RequestId" in resp["ResponseMetadata"]
                 id1 = resp["ResponseMetadata"]["RequestId"]
 
             with XRaySegment():
@@ -90,7 +88,7 @@ def test_xray_dynamo_request_id_with_context_mgr():
                 resp = client.list_tables()
                 id2 = resp["ResponseMetadata"]["RequestId"]
 
-            id1.should_not.equal(id2)
+            assert id1 != id2
 
             setattr(
                 botocore.client.BaseClient, "_make_api_call", original_make_api_call
@@ -129,7 +127,7 @@ def test_xray_context_patched():
     xray_core_patcher._PATCHED_MODULES = set()
     xray_core.patch_all()
 
-    xray_core.xray_recorder._context.context_missing.should.equal("LOG_ERROR")
+    assert xray_core.xray_recorder._context.context_missing == "LOG_ERROR"
 
     setattr(botocore.client.BaseClient, "_make_api_call", original_make_api_call)
     setattr(botocore.endpoint.Endpoint, "_encode_headers", original_encode_headers)