Repository: getmoto/moto
Pull request #8462 (2025-01-03 12:01:37)

Feat: Add KMS methods for Key Rotations and MACs
Implemented New Methods for KMS:

- `generate_mac`
- `rotate_key_on_demand`
- `list_key_rotations`
- `verify_mac`

Added these already implemented methods as dummies to the Backend so they show up in the coverage:

- `list_key_policies`
- `generate_random`

(When I ran `scripts/implementation_coverage.py` it also updated a bunch of other rst-files (>50) with new methods, I'm not sure if I should commit those as well, as most are unrelated to KMS)

codecov[bot]: ## [Codecov](https://app.codecov.io/gh/getmoto/moto/pull/8462?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto) Report
Attention: Patch coverage is `94.87179%` with `2 lines` in your changes missing coverage. Please review.
> Project coverage is 92.62%. Comparing base [(`ec277aa`)](https://app.codecov.io/gh/getmoto/moto/commit/ec277aa25294839f5b9ce5cd346955050a4bbe8d?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto) to head [(`e7584ce`)](https://app.codecov.io/gh/getmoto/moto/commit/e7584cef310d28588a6baa8d9fc9232efd9ec354?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto).

| [Files with missing lines](https://app.codecov.io/gh/getmoto/moto/pull/8462?dropdown=coverage&src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto) | Patch % | Lines |
|---|---|---|
| [moto/kms/models.py](https://app.codecov.io/gh/getmoto/moto/pull/8462?src=pr&el=tree&filepath=moto%2Fkms%2Fmodels.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto#diff-bW90by9rbXMvbW9kZWxzLnB5) | 91.66% | [2 Missing :warning: ](https://app.codecov.io/gh/getmoto/moto/pull/8462?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto) |

<details><summary>Additional details and impacted files</summary>


```diff
@@           Coverage Diff           @@
##           master    #8462   +/-   ##
=======================================
  Coverage   92.62%   92.62%           
=======================================
  Files        1225     1225           
  Lines      105655   105693   +38     
=======================================
+ Hits        97865    97901   +36     
- Misses       7790     7792    +2     
```

| [Flag](https://app.codecov.io/gh/getmoto/moto/pull/8462/flags?src=pr&el=flags&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto) | Coverage Δ | |
|---|---|---|
| [servertests](https://app.codecov.io/gh/getmoto/moto/pull/8462/flags?src=pr&el=flag&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto) | `27.75% <20.51%> (-0.01%)` | :arrow_down: |
| [unittests](https://app.codecov.io/gh/getmoto/moto/pull/8462/flags?src=pr&el=flag&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto) | `92.60% <94.87%> (+<0.01%)` | :arrow_up: |

Flags with carried forward coverage won't be shown. [Click here](https://docs.codecov.io/docs/carryforward-flags?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto#carryforward-flags-in-the-pull-request-comment) to find out more.

</details>

[:umbrella: View full report in Codecov by Sentry](https://app.codecov.io/gh/getmoto/moto/pull/8462?dropdown=coverage&src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto).   
:loudspeaker: Have feedback on the report? [Share it here](https://about.codecov.io/codecov-pr-comment-feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=getmoto).

MauriceBrg: The two lines missing coverage are for the dummy methods to include `list_key_policies` and `generate_random` in the implementation coverage. Should I write some dummy tests or call them from the responses?
bblommers: Hi @MauriceBrg, thanks for the PR! Just left two comments.

> (When I ran scripts/implementation_coverage.py it also updated a bunch of other rst-files (>50) with new methods, I'm not sure if I should commit those as well, as most are unrelated to KMS)

That will be either because Moto hasn't been updated in a while, or you're running the script with an outdated version of `botocore`. Either way, it's not necessary - the implementation docs will always be updated when we release a new version.

> The two lines missing coverage are for the dummy methods to include list_key_policies and generate_random in the implementation coverage. Should I write some dummy tests or call them from the responses?

I'm OK with the current approach. Having 100% coverage is a nice to have, but in the end, it doesn't functionally change anything. We have an implementation, and we have tests for it - that's all I care about.

Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index bc31b4a78..9c2e55841 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,24 @@
 Moto Changelog
 ==============
 
+5.0.26
+-----
+Docker Digest for 5.0.26: _sha256:1cae28be97cc87151ecabb531d1507b8dd3d52d3636b86143a16cccf4b5fcf43_
+
+    New Services:
+        * Kinesis:
+            * delete_resource_policy()
+            * get_resource_policy()
+            * put_resource_policy()
+
+    Miscellaneous:
+        * DynamoDB: transact_write_items() now validates empty ExpressionAttributeValues
+        * Logs: describe_log_groups() now returns the logStreamArn-property
+        * Organizations now has additional validation around creation and deletion of organizations and accounts
+        * SecretsManager: list_secrets() now properly splits words when filtering
+        * StepFunctions: describe_state_machine() now takes Version ARN's
+        * StepFunctions: describe_state_machine() now returns the versionDescription
+
 5.0.25
 -----
 Docker Digest for 5.0.25: _sha256:1ac2d89ce8c79a6cdfebffb37678a5bd8bb54a39dcbced069f6ac5e29e4cc752_
diff --git a/IMPLEMENTATION_COVERAGE.md b/IMPLEMENTATION_COVERAGE.md
index a71dc75e9..e4f7ac646 100644
--- a/IMPLEMENTATION_COVERAGE.md
+++ b/IMPLEMENTATION_COVERAGE.md
@@ -685,6 +685,7 @@
 - [ ] get_backup_vault_access_policy
 - [ ] get_backup_vault_notifications
 - [ ] get_legal_hold
+- [ ] get_recovery_point_index_details
 - [ ] get_recovery_point_restore_metadata
 - [ ] get_restore_job_metadata
 - [ ] get_restore_testing_inferred_metadata
@@ -701,6 +702,7 @@
 - [ ] list_copy_job_summaries
 - [ ] list_copy_jobs
 - [ ] list_frameworks
+- [ ] list_indexed_recovery_points
 - [ ] list_legal_holds
 - [ ] list_protected_resources
 - [ ] list_protected_resources_by_backup_vault
@@ -729,6 +731,7 @@
 - [ ] update_backup_plan
 - [ ] update_framework
 - [ ] update_global_settings
+- [ ] update_recovery_point_index_settings
 - [ ] update_recovery_point_lifecycle
 - [ ] update_region_settings
 - [ ] update_report_plan
@@ -1922,7 +1925,7 @@
 
 ## datasync
 <details>
-<summary>10% implemented</summary>
+<summary>9% implemented</summary>
 
 - [ ] add_storage_system
 - [X] cancel_task_execution
@@ -1977,9 +1980,15 @@
 - [ ] update_agent
 - [ ] update_discovery_job
 - [ ] update_location_azure_blob
+- [ ] update_location_efs
+- [ ] update_location_fsx_lustre
+- [ ] update_location_fsx_ontap
+- [ ] update_location_fsx_open_zfs
+- [ ] update_location_fsx_windows
 - [ ] update_location_hdfs
 - [ ] update_location_nfs
 - [ ] update_location_object_storage
+- [ ] update_location_s3
 - [ ] update_location_smb
 - [ ] update_storage_system
 - [X] update_task
@@ -2276,6 +2285,22 @@
 - [ ] verify_trust
 </details>
 
+## dsql
+<details>
+<summary>20% implemented</summary>
+
+- [X] create_cluster
+- [ ] create_multi_region_clusters
+- [ ] delete_cluster
+- [ ] delete_multi_region_clusters
+- [X] get_cluster
+- [ ] list_clusters
+- [ ] list_tags_for_resource
+- [ ] tag_resource
+- [ ] untag_resource
+- [ ] update_cluster
+</details>
+
 ## dynamodb
 <details>
 <summary>68% implemented</summary>
@@ -3217,6 +3242,7 @@
 - [ ] describe_addon_configuration
 - [ ] describe_addon_versions
 - [X] describe_cluster
+- [ ] describe_cluster_versions
 - [ ] describe_eks_anywhere_subscription
 - [X] describe_fargate_profile
 - [ ] describe_identity_provider_config
@@ -4756,6 +4782,7 @@
 - [X] get_policy_version
 - [X] get_registration_code
 - [ ] get_statistics
+- [ ] get_thing_connectivity_data
 - [X] get_topic_rule
 - [ ] get_topic_rule_destination
 - [ ] get_v2_logging_options
@@ -4996,12 +5023,12 @@
 
 ## kinesis
 <details>
-<summary>84% implemented</summary>
+<summary>93% implemented</summary>
 
 - [X] add_tags_to_stream
 - [X] create_stream
 - [X] decrease_stream_retention_period
-- [ ] delete_resource_policy
+- [X] delete_resource_policy
 - [X] delete_stream
 - [X] deregister_stream_consumer
 - [ ] describe_limits
@@ -5011,7 +5038,7 @@
 - [X] disable_enhanced_monitoring
 - [X] enable_enhanced_monitoring
 - [X] get_records
-- [ ] get_resource_policy
+- [X] get_resource_policy
 - [X] get_shard_iterator
 - [X] increase_stream_retention_period
 - [X] list_shards
@@ -5021,7 +5048,7 @@
 - [X] merge_shards
 - [X] put_record
 - [X] put_records
-- [ ] put_resource_policy
+- [X] put_resource_policy
 - [X] register_stream_consumer
 - [X] remove_tags_from_stream
 - [X] split_shard
@@ -5550,6 +5577,7 @@
 - [ ] list_reservations
 - [ ] list_signal_maps
 - [ ] list_tags_for_resource
+- [ ] list_versions
 - [ ] purchase_offering
 - [ ] reboot_input_device
 - [ ] reject_input_device_transfer
@@ -9362,6 +9390,7 @@
 - autoscaling-plans
 - b2bi
 - backup-gateway
+- backupsearch
 - bcm-data-exports
 - bcm-pricing-calculator
 - bedrock-agent-runtime
@@ -9424,7 +9453,6 @@
 - docdb-elastic
 - drs
 - ds-data
-- dsql
 - ecr-public
 - eks-auth
 - elastic-inference
diff --git a/docs/docs/services/backup.rst b/docs/docs/services/backup.rst
index aa5502ff2..b86289703 100644
--- a/docs/docs/services/backup.rst
+++ b/docs/docs/services/backup.rst
@@ -58,6 +58,7 @@ backup
 - [ ] get_backup_vault_access_policy
 - [ ] get_backup_vault_notifications
 - [ ] get_legal_hold
+- [ ] get_recovery_point_index_details
 - [ ] get_recovery_point_restore_metadata
 - [ ] get_restore_job_metadata
 - [ ] get_restore_testing_inferred_metadata
@@ -82,6 +83,7 @@ backup
 - [ ] list_copy_job_summaries
 - [ ] list_copy_jobs
 - [ ] list_frameworks
+- [ ] list_indexed_recovery_points
 - [ ] list_legal_holds
 - [ ] list_protected_resources
 - [ ] list_protected_resources_by_backup_vault
@@ -114,6 +116,7 @@ backup
 - [ ] update_backup_plan
 - [ ] update_framework
 - [ ] update_global_settings
+- [ ] update_recovery_point_index_settings
 - [ ] update_recovery_point_lifecycle
 - [ ] update_region_settings
 - [ ] update_report_plan
diff --git a/docs/docs/services/datasync.rst b/docs/docs/services/datasync.rst
index 44eeed11c..1e6a37f47 100644
--- a/docs/docs/services/datasync.rst
+++ b/docs/docs/services/datasync.rst
@@ -67,9 +67,15 @@ datasync
 - [ ] update_agent
 - [ ] update_discovery_job
 - [ ] update_location_azure_blob
+- [ ] update_location_efs
+- [ ] update_location_fsx_lustre
+- [ ] update_location_fsx_ontap
+- [ ] update_location_fsx_open_zfs
+- [ ] update_location_fsx_windows
 - [ ] update_location_hdfs
 - [ ] update_location_nfs
 - [ ] update_location_object_storage
+- [ ] update_location_s3
 - [ ] update_location_smb
 - [ ] update_storage_system
 - [X] update_task
diff --git a/docs/docs/services/dsql.rst b/docs/docs/services/dsql.rst
new file mode 100644
index 000000000..02bdadf65
--- /dev/null
+++ b/docs/docs/services/dsql.rst
@@ -0,0 +1,29 @@
+.. _implementedservice_dsql:
+
+.. |start-h3| raw:: html
+
+    <h3>
+
+.. |end-h3| raw:: html
+
+    </h3>
+
+====
+dsql
+====
+
+.. autoclass:: moto.dsql.models.AuroraDSQLBackend
+
+|start-h3| Implemented features for this service |end-h3|
+
+- [X] create_cluster
+- [ ] create_multi_region_clusters
+- [ ] delete_cluster
+- [ ] delete_multi_region_clusters
+- [X] get_cluster
+- [ ] list_clusters
+- [ ] list_tags_for_resource
+- [ ] tag_resource
+- [ ] untag_resource
+- [ ] update_cluster
+
diff --git a/docs/docs/services/eks.rst b/docs/docs/services/eks.rst
index 410409e9e..859bebe4b 100644
--- a/docs/docs/services/eks.rst
+++ b/docs/docs/services/eks.rst
@@ -37,6 +37,7 @@ eks
 - [ ] describe_addon_configuration
 - [ ] describe_addon_versions
 - [X] describe_cluster
+- [ ] describe_cluster_versions
 - [ ] describe_eks_anywhere_subscription
 - [X] describe_fargate_profile
 - [ ] describe_identity_provider_config
diff --git a/docs/docs/services/iot.rst b/docs/docs/services/iot.rst
index 5e9b3a3d0..9e6134838 100644
--- a/docs/docs/services/iot.rst
+++ b/docs/docs/services/iot.rst
@@ -175,6 +175,7 @@ iot
 - [X] get_policy_version
 - [X] get_registration_code
 - [ ] get_statistics
+- [ ] get_thing_connectivity_data
 - [X] get_topic_rule
 - [ ] get_topic_rule_destination
 - [ ] get_v2_logging_options
diff --git a/docs/docs/services/kinesis.rst b/docs/docs/services/kinesis.rst
index 84a1d3fc8..cae31fc63 100644
--- a/docs/docs/services/kinesis.rst
+++ b/docs/docs/services/kinesis.rst
@@ -17,7 +17,11 @@ kinesis
 - [X] add_tags_to_stream
 - [X] create_stream
 - [X] decrease_stream_retention_period
-- [ ] delete_resource_policy
+- [X] delete_resource_policy
+  
+        Remove resource policy with a matching given resource arn.
+        
+
 - [X] delete_stream
 - [X] deregister_stream_consumer
 - [ ] describe_limits
@@ -27,7 +31,11 @@ kinesis
 - [X] disable_enhanced_monitoring
 - [X] enable_enhanced_monitoring
 - [X] get_records
-- [ ] get_resource_policy
+- [X] get_resource_policy
+  
+        Get resource policy with a matching given resource arn.
+        
+
 - [X] get_shard_iterator
 - [X] increase_stream_retention_period
 - [X] list_shards
@@ -41,7 +49,11 @@ kinesis
 - [X] merge_shards
 - [X] put_record
 - [X] put_records
-- [ ] put_resource_policy
+- [X] put_resource_policy
+  
+        Creates/updates resource policy and return policy object
+        
+
 - [X] register_stream_consumer
 - [X] remove_tags_from_stream
 - [X] split_shard
diff --git a/docs/docs/services/medialive.rst b/docs/docs/services/medialive.rst
index be7400cc1..80eb2e390 100644
--- a/docs/docs/services/medialive.rst
+++ b/docs/docs/services/medialive.rst
@@ -103,6 +103,7 @@ medialive
 - [ ] list_reservations
 - [ ] list_signal_maps
 - [ ] list_tags_for_resource
+- [ ] list_versions
 - [ ] purchase_offering
 - [ ] reboot_input_device
 - [ ] reject_input_device_transfer
diff --git a/moto/__init__.py b/moto/__init__.py
index 813bad530..fc4217cd6 100644
--- a/moto/__init__.py
+++ b/moto/__init__.py
@@ -1,4 +1,4 @@
 from moto.core.decorator import mock_aws as mock_aws
 
 __title__ = "moto"
-__version__ = "5.0.26.dev"
+__version__ = "5.0.27.dev"
diff --git a/moto/ec2/resources/instance_types.json b/moto/ec2/resources/instance_types.json
index ffc86d5b4..ddb149095 100644
--- a/moto/ec2/resources/instance_types.json
+++ b/moto/ec2/resources/instance_types.json
@@ -93339,11 +93339,11 @@
    "MaximumNetworkInterfaces": 8,
    "NetworkCards": [
     {
-     "BaselineBandwidthInGbps": 12.0,
+     "BaselineBandwidthInGbps": 10.0,
      "MaximumNetworkInterfaces": 8,
      "NetworkCardIndex": 0,
      "NetworkPerformance": "10 Gigabit",
-     "PeakBandwidthInGbps": 12.0
+     "PeakBandwidthInGbps": 10.0
     }
    ],
    "NetworkPerformance": "10 Gigabit"
@@ -93579,11 +93579,11 @@
    "MaximumNetworkInterfaces": 8,
    "NetworkCards": [
     {
-     "BaselineBandwidthInGbps": 12.0,
+     "BaselineBandwidthInGbps": 10.0,
      "MaximumNetworkInterfaces": 8,
      "NetworkCardIndex": 0,
      "NetworkPerformance": "10 Gigabit",
-     "PeakBandwidthInGbps": 12.0
+     "PeakBandwidthInGbps": 10.0
     }
    ],
    "NetworkPerformance": "10 Gigabit"
@@ -94543,7 +94543,7 @@
    "NvmeSupport": "required"
   },
   "FreeTierEligible": false,
-  "HibernationSupported": false,
+  "HibernationSupported": true,
   "Hypervisor": "nitro",
   "InstanceStorageInfo": {
    "Disks": [
@@ -94905,7 +94905,7 @@
    "NvmeSupport": "required"
   },
   "FreeTierEligible": false,
-  "HibernationSupported": false,
+  "HibernationSupported": true,
   "Hypervisor": "nitro",
   "InstanceStorageInfo": {
    "Disks": [
@@ -95009,7 +95009,7 @@
    "NvmeSupport": "required"
   },
   "FreeTierEligible": false,
-  "HibernationSupported": false,
+  "HibernationSupported": true,
   "Hypervisor": "nitro",
   "InstanceStorageInfo": {
    "Disks": [
@@ -95202,7 +95202,7 @@
    "NvmeSupport": "required"
   },
   "FreeTierEligible": false,
-  "HibernationSupported": false,
+  "HibernationSupported": true,
   "Hypervisor": "nitro",
   "InstanceStorageInfo": {
    "Disks": [
diff --git a/moto/kinesis/models.py b/moto/kinesis/models.py
index 51a4a21e0..f3492006b 100644
--- a/moto/kinesis/models.py
+++ b/moto/kinesis/models.py
@@ -585,6 +585,7 @@ class KinesisBackend(BaseBackend):
     def __init__(self, region_name: str, account_id: str):
         super().__init__(region_name, account_id)
         self.streams: Dict[str, Stream] = OrderedDict()
+        self.resource_policies: Dict[str, str] = {}
 
     @staticmethod
     def default_vpc_endpoint_service(
@@ -1025,5 +1026,35 @@ class KinesisBackend(BaseBackend):
             explicit_hash_key="",
         )
 
+    def put_resource_policy(self, resource_arn: str, policy_doc: str) -> None:
+        """
+        Creates/updates resource policy and return policy object
+        """
+        self.resource_policies[resource_arn] = policy_doc
+
+    def delete_resource_policy(self, resource_arn: str) -> None:
+        """
+        Remove resource policy with a matching given resource arn.
+        """
+        stream_name = resource_arn.split("/")[-1]
+        if stream_name not in self.streams:
+            raise StreamNotFoundError(resource_arn, self.account_id)
+        if resource_arn not in self.resource_policies:
+            raise ResourceNotFoundError(
+                message=f"No resource policy found for resource ARN {resource_arn}."
+            )
+        del self.resource_policies[resource_arn]
+
+    def get_resource_policy(self, resource_arn: str) -> str:
+        """
+        Get resource policy with a matching given resource arn.
+        """
+        stream_name = resource_arn.split("/")[-1]
+        if stream_name not in self.streams:
+            raise StreamNotFoundError(resource_arn, self.account_id)
+        if resource_arn not in self.resource_policies:
+            return "{}"
+        return self.resource_policies[resource_arn]
+
 
 kinesis_backends = BackendDict(KinesisBackend, "kinesis")
diff --git a/moto/kinesis/responses.py b/moto/kinesis/responses.py
index ba873a7ff..e4d46410a 100644
--- a/moto/kinesis/responses.py
+++ b/moto/kinesis/responses.py
@@ -325,3 +325,24 @@ class KinesisResponse(BaseResponse):
         stream_mode = self._get_param("StreamModeDetails")
         self.kinesis_backend.update_stream_mode(stream_arn, stream_mode)
         return "{}"
+
+    def put_resource_policy(self) -> str:
+        resource_arn = self._get_param("ResourceARN")
+        policy = self._get_param("Policy")
+        self.kinesis_backend.put_resource_policy(
+            resource_arn=resource_arn,
+            policy_doc=policy,
+        )
+        return json.dumps(dict())
+
+    def get_resource_policy(self) -> str:
+        resource_arn = self._get_param("ResourceARN")
+        policy = self.kinesis_backend.get_resource_policy(resource_arn=resource_arn)
+        return json.dumps({"Policy": policy})
+
+    def delete_resource_policy(self) -> str:
+        resource_arn = self._get_param("ResourceARN")
+        self.kinesis_backend.delete_resource_policy(
+            resource_arn=resource_arn,
+        )
+        return json.dumps(dict())
diff --git a/moto/kms/exceptions.py b/moto/kms/exceptions.py
index 1ebf0d123..5a8ad4fc3 100644
--- a/moto/kms/exceptions.py
+++ b/moto/kms/exceptions.py
@@ -47,3 +47,21 @@ class InvalidCiphertextException(JsonRESTError):
         super().__init__("InvalidCiphertextException", "")
 
         self.description = '{"__type":"InvalidCiphertextException"}'
+
+
+class InvalidKeyUsageException(JsonRESTError):
+    code = 400
+
+    def __init__(self) -> None:
+        super().__init__("InvalidKeyUsageException", "")
+
+        self.description = '{"__type":"InvalidKeyUsageException"}'
+
+
+class KMSInvalidMacException(JsonRESTError):
+    code = 400
+
+    def __init__(self) -> None:
+        super().__init__("KMSInvalidMacException", "")
+
+        self.description = '{"__type":"KMSInvalidMacException"}'
diff --git a/moto/kms/models.py b/moto/kms/models.py
index 5e9f3f6f0..03b834c37 100644
--- a/moto/kms/models.py
+++ b/moto/kms/models.py
@@ -4,23 +4,29 @@ import typing
 from collections import defaultdict
 from copy import copy
 from datetime import datetime, timedelta
-from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
+from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, Union
 
 from moto.core.base_backend import BackendDict, BaseBackend
 from moto.core.common_models import BaseModel, CloudFormationModel
 from moto.core.exceptions import JsonRESTError
 from moto.core.utils import unix_time
 from moto.moto_api._internal import mock_random
+from moto.utilities.paginator import paginate
 from moto.utilities.tagging_service import TaggingService
 from moto.utilities.utils import get_partition
 
-from .exceptions import ValidationException
+from .exceptions import (
+    InvalidKeyUsageException,
+    KMSInvalidMacException,
+    ValidationException,
+)
 from .utils import (
     RESERVED_ALIASES,
     KeySpec,
     SigningAlgorithm,
     decrypt,
     encrypt,
+    generate_hmac,
     generate_key_id,
     generate_master_key,
     generate_private_key,
@@ -100,6 +106,8 @@ class Key(CloudFormationModel):
         )
         self.grants: Dict[str, Grant] = dict()
 
+        self.rotations: List[Dict[str, Any]] = []
+
     def add_grant(
         self,
         name: str,
@@ -272,6 +280,15 @@ class Key(CloudFormationModel):
 
 
 class KmsBackend(BaseBackend):
+    PAGINATION_MODEL = {
+        "list_key_rotations": {
+            "input_token": "next_marker",
+            "limit_key": "limit",
+            "limit_default": 1000,
+            "unique_attribute": "RotationDate",
+        }
+    }
+
     def __init__(self, region_name: str, account_id: Optional[str] = None):
         super().__init__(region_name=region_name, account_id=account_id)  # type: ignore
         self.keys: Dict[str, Key] = {}
@@ -460,6 +477,11 @@ class KmsBackend(BaseBackend):
     def get_key_policy(self, key_id: str) -> str:
         return self.keys[self.get_key_id(key_id)].policy
 
+    def list_key_policies(self) -> None:
+        # Marker to indicate this is implemented
+        # Responses uses 'describe_key'
+        pass
+
     def disable_key(self, key_id: str) -> None:
         self.keys[key_id].enabled = False
         self.keys[key_id].key_state = "Disabled"
@@ -526,6 +548,11 @@ class KmsBackend(BaseBackend):
         )
         return new_ciphertext_blob, decrypting_arn, encrypting_arn
 
+    def generate_random(self) -> None:
+        # Marker to indicate this is implemented
+        # Responses uses 'os.urandom'
+        pass
+
     def generate_data_key(
         self,
         key_id: str,
@@ -714,5 +741,68 @@ class KmsBackend(BaseBackend):
         key = self.describe_key(key_id)
         return key, key.private_key.public_key()
 
+    def rotate_key_on_demand(self, key_id: str) -> str:
+        key: Key = self.keys[self.get_key_id(key_id)]
+
+        rotation = {
+            "KeyId": key_id,
+            "RotationDate": datetime.now().timestamp(),
+            "RotationType": "ON_DEMAND",
+        }
+
+        # Add to key rotations
+        key.rotations.append(rotation)
+
+        return key_id
+
+    @paginate(PAGINATION_MODEL)
+    def list_key_rotations(
+        self, key_id: str, limit: int, next_marker: str
+    ) -> List[Dict[str, Union[str, float]]]:
+        key: Key = self.keys[self.get_key_id(key_id)]
+
+        return key.rotations
+
+    def generate_mac(
+        self,
+        message: bytes,
+        key_id: str,
+        mac_algorithm: str,
+        grant_tokens: List[str],
+        dry_run: bool,
+    ) -> Tuple[str, str, str]:
+        key = self.keys[key_id]
+
+        if (
+            key.key_usage != "GENERATE_VERIFY_MAC"
+            or key.key_spec not in KeySpec.hmac_key_specs()
+        ):
+            raise InvalidKeyUsageException()
+
+        mac = generate_hmac(
+            key=key.key_material, message=message, mac_algorithm=mac_algorithm
+        )
+        return mac, mac_algorithm, key_id
+
+    def verify_mac(
+        self,
+        message: bytes,
+        key_id: str,
+        mac_algorithm: str,
+        mac: str,
+        grant_tokens: List[str],
+        dry_run: bool,
+    ) -> None:
+        regenerated_mac, _, _ = self.generate_mac(
+            message=message,
+            key_id=key_id,
+            mac_algorithm=mac_algorithm,
+            grant_tokens=grant_tokens,
+            dry_run=dry_run,
+        )
+
+        if mac != regenerated_mac:
+            raise KMSInvalidMacException()
+
 
 kms_backends = BackendDict(KmsBackend, "kms")
diff --git a/moto/kms/responses.py b/moto/kms/responses.py
index 7f5b9b674..a5c90a268 100644
--- a/moto/kms/responses.py
+++ b/moto/kms/responses.py
@@ -604,6 +604,36 @@ class KmsResponse(BaseResponse):
 
         return json.dumps(result)
 
+    def generate_mac(self) -> str:
+        message = self._get_param("Message")
+        key_id = self._get_param("KeyId")
+        mac_algorithm = self._get_param("MacAlgorithm")
+        grant_tokens = self._get_param("GrantTokens")
+        dry_run = self._get_param("DryRun")
+
+        self._validate_key_id(key_id)
+
+        mac_algorithms = {
+            "HMAC_SHA_224",
+            "HMAC_SHA_256",
+            "HMAC_SHA_384",
+            "HMAC_SHA_512",
+        }
+        if mac_algorithm and mac_algorithm not in mac_algorithms:
+            raise ValidationException(
+                f"MacAlgorithm must be one of {', '.join(mac_algorithms)}"
+            )
+
+        mac, mac_algorithm, key_id = self.kms_backend.generate_mac(
+            message=message,
+            key_id=key_id,
+            mac_algorithm=mac_algorithm,
+            grant_tokens=grant_tokens,
+            dry_run=dry_run,
+        )
+
+        return json.dumps(dict(Mac=mac, MacAlgorithm=mac_algorithm, KeyId=key_id))
+
     def generate_random(self) -> str:
         """https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateRandom.html"""
         number_of_bytes = self._get_param("NumberOfBytes")
@@ -703,6 +733,38 @@ class KmsResponse(BaseResponse):
             }
         )
 
+    def verify_mac(self) -> str:
+        message = self._get_param("Message")
+        mac = self._get_param("Mac")
+        key_id = self._get_param("KeyId")
+        mac_algorithm = self._get_param("MacAlgorithm")
+        grant_tokens = self._get_param("GrantTokens")
+        dry_run = self._get_param("DryRun")
+
+        self._validate_key_id(key_id)
+
+        mac_algorithms = {
+            "HMAC_SHA_224",
+            "HMAC_SHA_256",
+            "HMAC_SHA_384",
+            "HMAC_SHA_512",
+        }
+        if mac_algorithm and mac_algorithm not in mac_algorithms:
+            raise ValidationException(
+                f"MacAlgorithm must be one of {', '.join(mac_algorithms)}"
+            )
+
+        self.kms_backend.verify_mac(
+            message=message,
+            key_id=key_id,
+            mac_algorithm=mac_algorithm,
+            mac=mac,
+            grant_tokens=grant_tokens,
+            dry_run=dry_run,
+        )
+
+        return json.dumps(dict(KeyId=key_id, MacValid=True, MacAlgorithm=mac_algorithm))
+
     def get_public_key(self) -> str:
         key_id = self._get_param("KeyId")
 
@@ -719,6 +781,35 @@ class KmsResponse(BaseResponse):
             }
         )
 
+    def rotate_key_on_demand(self) -> str:
+        key_id = self._get_param("KeyId")
+
+        self._validate_key_id(key_id)
+
+        key_id = self.kms_backend.rotate_key_on_demand(
+            key_id=key_id,
+        )
+        return json.dumps(dict(KeyId=key_id))
+
+    def list_key_rotations(self) -> str:
+        key_id = self._get_param("KeyId")
+        limit = self._get_param("Limit", 1000)
+        marker = self._get_param("Marker")
+
+        self._validate_key_id(key_id)
+
+        rotations, next_marker = self.kms_backend.list_key_rotations(
+            key_id=key_id, limit=limit, next_marker=marker
+        )
+        is_truncated = next_marker is not None
+
+        response = {"Rotations": rotations, "Truncated": is_truncated}
+
+        if is_truncated:
+            response["NextMarker"] = next_marker
+
+        return json.dumps(response)
+
 
 def _assert_default_policy(policy_name: str) -> None:
     if policy_name != "default":
diff --git a/moto/kms/utils.py b/moto/kms/utils.py
index 0d63d052c..d1d510972 100644
--- a/moto/kms/utils.py
+++ b/moto/kms/utils.py
@@ -1,3 +1,6 @@
+import base64
+import hashlib
+import hmac
 import io
 import os
 import struct
@@ -443,3 +446,28 @@ def decrypt(
         raise InvalidCiphertextException()
 
     return plaintext, ciphertext.key_id
+
+
+def generate_hmac(
+    key: bytes,
+    message: bytes,
+    mac_algorithm: str,
+) -> str:
+    """
+    Returns a base64 encoded HMAC
+    """
+
+    algos = {
+        "HMAC_SHA_224": hashlib.sha224,
+        "HMAC_SHA_256": hashlib.sha256,
+        "HMAC_SHA_384": hashlib.sha384,
+        "HMAC_SHA_512": hashlib.sha512,
+    }
+
+    hmac_val = hmac.new(
+        key=key,
+        msg=message,
+        digestmod=algos[mac_algorithm],
+    )
+
+    return base64.b64encode(hmac_val.digest()).decode("utf-8")
diff --git a/moto/secretsmanager/list_secrets/filters.py b/moto/secretsmanager/list_secrets/filters.py
index 5a863b01a..2d0a5b828 100644
--- a/moto/secretsmanager/list_secrets/filters.py
+++ b/moto/secretsmanager/list_secrets/filters.py
@@ -1,3 +1,4 @@
+import re
 from typing import TYPE_CHECKING, List
 
 if TYPE_CHECKING:
@@ -9,7 +10,14 @@ def name_filter(secret: "FakeSecret", names: List[str]) -> bool:
 
 
 def description_filter(secret: "FakeSecret", descriptions: List[str]) -> bool:
-    return _matcher(descriptions, [secret.description], match_prefix=False)  # type: ignore
+    if not secret.description:
+        return False
+    # The documentation states that this search uses `Prefix match`
+    # But actual testing determines that it uses the same approach to the `all_filter`:
+    # 'Breaks the filter value string into words and then searches all attributes for matches.'
+    return _matcher(
+        descriptions, [secret.description], match_prefix=False, case_sensitive=False
+    )
 
 
 def tag_key(secret: "FakeSecret", tag_keys: List[str]) -> bool:
@@ -25,36 +33,53 @@ def tag_value(secret: "FakeSecret", tag_values: List[str]) -> bool:
 
 
 def filter_all(secret: "FakeSecret", values: List[str]) -> bool:
-    attributes = [secret.name, secret.description]
+    attributes = [secret.name]
+    if secret.description:
+        attributes.append(secret.description)
     if secret.tags:
         attributes += [tag["Key"] for tag in secret.tags] + [
             tag["Value"] for tag in secret.tags
         ]
 
-    return _matcher(values, attributes)  # type: ignore
+    return _matcher(values, attributes, match_prefix=False, case_sensitive=False)
 
 
 def _matcher(
-    patterns: List[str], strings: List[str], match_prefix: bool = True
+    patterns: List[str],
+    strings: List[str],
+    match_prefix: bool = True,
+    case_sensitive: bool = True,
 ) -> bool:
     for pattern in [p for p in patterns if p.startswith("!")]:
         for string in strings:
-            if not _match_pattern(pattern[1:], string, match_prefix):
+            if not _match_pattern(
+                pattern[1:], string, match_prefix, case_sensitive=case_sensitive
+            ):
                 return True
 
     for pattern in [p for p in patterns if not p.startswith("!")]:
         for string in strings:
-            if _match_pattern(pattern, string, match_prefix):
+            if _match_pattern(
+                pattern, string, match_prefix, case_sensitive=case_sensitive
+            ):
                 return True
     return False
 
 
-def _match_pattern(pattern: str, value: str, match_prefix: bool = True) -> bool:
+def _match_pattern(
+    pattern: str, value: str, match_prefix: bool = True, case_sensitive: bool = True
+) -> bool:
     if match_prefix:
-        return value.startswith(pattern)
+        if not case_sensitive:
+            return value.lower().startswith(pattern.lower())
+        else:
+            return value.startswith(pattern)
     else:
-        pattern_words = pattern.split(" ")
-        value_words = value.split(" ")
+        pattern_words = split_words(pattern)
+        value_words = split_words(value)
+        if not case_sensitive:
+            pattern_words = [p.lower() for p in pattern_words]
+            value_words = [v.lower() for v in value_words]
         for pattern_word in pattern_words:
             # all words in value must start with pattern_word
             if not any(
@@ -62,3 +87,12 @@ def _match_pattern(pattern: str, value: str, match_prefix: bool = True) -> bool:
             ):
                 return False
     return True
+
+
+def split_words(s: str) -> List[str]:
+    """
+    Split a string into words. Words are recognized by upper case letters, i.e.:
+    test   -> [test]
+    MyTest -> [My, Test]
+    """
+    return [x.strip() for x in re.split(r"([^a-z][a-z]+)", s) if x]
diff --git a/moto/ssm/resources/regions.json b/moto/ssm/resources/regions.json
index 2e3782e1d..c507a5cf5 100644
--- a/moto/ssm/resources/regions.json
+++ b/moto/ssm/resources/regions.json
@@ -23055,6 +23055,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "fsx": {
+                "Value": "fsx",
+                "endpoint": {
+                  "Value": "fsx.ap-southeast-5.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "glue": {
                 "Value": "glue",
                 "endpoint": {
@@ -23307,6 +23316,15 @@
                   "Value": "HTTPS, HTTP"
                 }
               },
+              "sagemaker-metrics": {
+                "Value": "sagemaker-metrics",
+                "endpoint": {
+                  "Value": "metrics.sagemaker.ap-southeast-5.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "savingsplans": {
                 "Value": "savingsplans",
                 "endpoint": {
diff --git a/moto/ssm/resources/services.json b/moto/ssm/resources/services.json
index 7c7028241..5f3099223 100644
--- a/moto/ssm/resources/services.json
+++ b/moto/ssm/resources/services.json
@@ -27620,6 +27620,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "ap-southeast-5": {
+                "Value": "ap-southeast-5",
+                "endpoint": {
+                  "Value": "fsx.ap-southeast-5.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "ca-central-1": {
                 "Value": "ca-central-1",
                 "endpoint": {
@@ -56922,6 +56931,15 @@
                   "Value": "HTTPS"
                 }
               },
+              "ap-southeast-5": {
+                "Value": "ap-southeast-5",
+                "endpoint": {
+                  "Value": "metrics.sagemaker.ap-southeast-5.amazonaws.com"
+                },
+                "protocols": {
+                  "Value": "HTTPS"
+                }
+              },
               "ca-central-1": {
                 "Value": "ca-central-1",
                 "endpoint": {
diff --git a/moto/stepfunctions/models.py b/moto/stepfunctions/models.py
index c432b9bd0..fd91fcf7c 100644
--- a/moto/stepfunctions/models.py
+++ b/moto/stepfunctions/models.py
@@ -51,10 +51,13 @@ class StateMachineInstance:
         self.loggingConfiguration = loggingConfiguration or {"level": "OFF"}
         self.tracingConfiguration = tracingConfiguration or {"enabled": False}
         self.sm_type = "STANDARD"  # or express
+        self.description: Optional[str] = None
 
 
 class StateMachineVersion(StateMachineInstance, CloudFormationModel):
-    def __init__(self, source: StateMachineInstance, version: int):
+    def __init__(
+        self, source: StateMachineInstance, version: int, description: Optional[str]
+    ):
         version_arn = f"{source.arn}:{version}"
         StateMachineInstance.__init__(
             self,
@@ -68,6 +71,7 @@ class StateMachineVersion(StateMachineInstance, CloudFormationModel):
         )
         self.source_arn = source.arn
         self.version = version
+        self.description = description
 
 
 class StateMachine(StateMachineInstance, CloudFormationModel):
@@ -100,9 +104,11 @@ class StateMachine(StateMachineInstance, CloudFormationModel):
         self.versions: Dict[int, StateMachineVersion] = {}
         self.latest_version: Optional[StateMachineVersion] = None
 
-    def publish(self) -> None:
+    def publish(self, description: Optional[str]) -> None:
         new_version_number = self.latest_version_number + 1
-        new_version = StateMachineVersion(source=self, version=new_version_number)
+        new_version = StateMachineVersion(
+            source=self, version=new_version_number, description=description
+        )
         self.versions[new_version_number] = new_version
         self.latest_version = new_version
         self.latest_version_number = new_version_number
@@ -586,6 +592,7 @@ class StepFunctionBackend(BaseBackend):
         loggingConfiguration: Optional[Dict[str, Any]] = None,
         tracingConfiguration: Optional[Dict[str, Any]] = None,
         encryptionConfiguration: Optional[Dict[str, Any]] = None,
+        version_description: Optional[str] = None,
     ) -> StateMachine:
         self._validate_name(name)
         self._validate_role_arn(roleArn)
@@ -604,7 +611,7 @@ class StepFunctionBackend(BaseBackend):
                 tracingConfiguration,
             )
             if publish:
-                state_machine.publish()
+                state_machine.publish(description=version_description)
             self.state_machines.append(state_machine)
             return state_machine
 
@@ -647,6 +654,7 @@ class StepFunctionBackend(BaseBackend):
         tracing_configuration: Optional[Dict[str, bool]] = None,
         encryption_configuration: Optional[Dict[str, Any]] = None,
         publish: Optional[bool] = None,
+        version_description: Optional[str] = None,
     ) -> StateMachine:
         sm = self.describe_state_machine(arn)
         updates: Dict[str, Any] = {
@@ -661,7 +669,7 @@ class StepFunctionBackend(BaseBackend):
             updates["tracingConfiguration"] = tracing_configuration
         sm.update(**updates)
         if publish:
-            sm.publish()
+            sm.publish(version_description)
         return sm
 
     def start_execution(
diff --git a/moto/stepfunctions/parser/models.py b/moto/stepfunctions/parser/models.py
index bebe334c5..2dee9dfda 100644
--- a/moto/stepfunctions/parser/models.py
+++ b/moto/stepfunctions/parser/models.py
@@ -28,7 +28,6 @@ from moto.stepfunctions.parser.api import (
     TaskToken,
     TraceHeader,
     TracingConfiguration,
-    VersionDescription,
 )
 from moto.stepfunctions.parser.asl.component.state.exec.state_map.iteration.itemprocessor.map_run_record import (
     MapRunRecord,
@@ -86,6 +85,7 @@ class StepFunctionsParserBackend(StepFunctionBackend):
         loggingConfiguration: Optional[LoggingConfiguration] = None,
         tracingConfiguration: Optional[TracingConfiguration] = None,
         encryptionConfiguration: Optional[EncryptionConfiguration] = None,
+        version_description: Optional[str] = None,
     ) -> StateMachine:
         StepFunctionsParserBackend._validate_definition(definition=definition)
 
@@ -98,6 +98,7 @@ class StepFunctionsParserBackend(StepFunctionBackend):
             loggingConfiguration=loggingConfiguration,
             tracingConfiguration=tracingConfiguration,
             encryptionConfiguration=encryptionConfiguration,
+            version_description=version_description,
         )
 
     def send_task_heartbeat(self, task_token: TaskToken) -> SendTaskHeartbeatOutput:
@@ -216,7 +217,7 @@ class StepFunctionsParserBackend(StepFunctionBackend):
         tracing_configuration: TracingConfiguration = None,
         encryption_configuration: EncryptionConfiguration = None,
         publish: Optional[bool] = None,
-        version_description: VersionDescription = None,
+        version_description: str = None,
     ) -> StateMachine:
         if not any(
             [
@@ -242,6 +243,7 @@ class StepFunctionsParserBackend(StepFunctionBackend):
             tracing_configuration=tracing_configuration,
             encryption_configuration=encryption_configuration,
             publish=publish,
+            version_description=version_description,
         )
 
     def describe_map_run(self, map_run_arn: str) -> Dict[str, Any]:
diff --git a/moto/stepfunctions/responses.py b/moto/stepfunctions/responses.py
index fd2e7bbfb..effaca54e 100644
--- a/moto/stepfunctions/responses.py
+++ b/moto/stepfunctions/responses.py
@@ -5,6 +5,7 @@ from moto.core.config import default_user_config
 from moto.core.responses import BaseResponse
 from moto.core.utils import iso_8601_datetime_with_milliseconds
 
+from .exceptions import ValidationException
 from .models import StepFunctionBackend, stepfunctions_backends
 from .parser.api import ExecutionStatus
 
@@ -33,6 +34,13 @@ class StepFunctionResponse(BaseResponse):
         encryptionConfiguration = self._get_param("encryptionConfiguration")
         loggingConfiguration = self._get_param("loggingConfiguration")
         tracingConfiguration = self._get_param("tracingConfiguration")
+        version_description = self._get_param("versionDescription")
+
+        if version_description and not publish:
+            raise ValidationException(
+                "Version description can only be set when publish is true"
+            )
+
         state_machine = self.stepfunction_backend.create_state_machine(
             name=name,
             definition=definition,
@@ -42,6 +50,7 @@ class StepFunctionResponse(BaseResponse):
             loggingConfiguration=loggingConfiguration,
             tracingConfiguration=tracingConfiguration,
             encryptionConfiguration=encryptionConfiguration,
+            version_description=version_description,
         )
         response = {
             "creationDate": state_machine.creation_date,
@@ -90,6 +99,8 @@ class StepFunctionResponse(BaseResponse):
             "tracingConfiguration": state_machine.tracingConfiguration,
             "loggingConfiguration": state_machine.loggingConfiguration,
         }
+        if state_machine.description:
+            response["description"] = state_machine.description
         return 200, {}, json.dumps(response)
 
     def delete_state_machine(self) -> TYPE_RESPONSE:
@@ -105,6 +116,13 @@ class StepFunctionResponse(BaseResponse):
         encryption_config = self._get_param("encryptionConfiguration")
         logging_config = self._get_param("loggingConfiguration")
         publish = self._get_param("publish")
+        version_description = self._get_param("versionDescription")
+
+        if version_description and not publish:
+            raise ValidationException(
+                "Version description can only be set when publish is true"
+            )
+
         state_machine = self.stepfunction_backend.update_state_machine(
             arn=arn,
             definition=definition,
@@ -113,6 +131,7 @@ class StepFunctionResponse(BaseResponse):
             encryption_configuration=encryption_config,
             logging_configuration=logging_config,
             publish=publish,
+            version_description=version_description,
         )
         response = {"updateDate": state_machine.update_date}
         if publish:
diff --git a/setup.cfg b/setup.cfg
index 0697fdd58..3524c32bd 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,6 +1,6 @@
 [metadata]
 name = moto
-version = 5.0.26.dev
+version = 5.0.27.dev
 description = A library that allows you to easily mock out tests based on AWS infrastructure
 long_description = file:README.md
 long_description_content_type = text/markdown


Test patch:
diff --git a/tests/test_kinesis/test_kinesis_resource_policy.py b/tests/test_kinesis/test_kinesis_resource_policy.py
new file mode 100644
index 000000000..d7c4e6fe4
--- /dev/null
+++ b/tests/test_kinesis/test_kinesis_resource_policy.py
@@ -0,0 +1,109 @@
+import json
+
+import boto3
+import pytest
+from botocore.exceptions import ClientError
+
+from moto import mock_aws
+
+
+def get_policy_doc(action, stream_arn):
+    sts = boto3.client("sts", "us-east-1")
+    account_id = sts.get_caller_identity()["Account"]
+
+    policy_doc = {
+        "Version": "2012-10-17",
+        "Statement": [
+            {
+                "Principal": {"AWS": account_id},
+                "Effect": "Allow",
+                "Action": [action],
+                "Resource": f"{stream_arn}",
+            }
+        ],
+    }
+    return json.dumps(policy_doc)
+
+
+@mock_aws
+def test_put_resource_policy():
+    client = boto3.client("kinesis", region_name="us-west-2")
+    client.create_stream(StreamName="my-stream", ShardCount=2)
+    resp = client.describe_stream(StreamName="my-stream")
+    desc = resp["StreamDescription"]
+    stream_arn = desc["StreamARN"]
+
+    action = "kinesis:*"
+    json_policy_doc = get_policy_doc(action, stream_arn)
+    client.put_resource_policy(ResourceARN=stream_arn, Policy=json_policy_doc)
+    response = client.get_resource_policy(ResourceARN=stream_arn)
+
+    assert response["Policy"] == json_policy_doc
+
+
+@mock_aws
+def test_delete_resource_policy():
+    client = boto3.client("kinesis", region_name="us-west-2")
+    client.create_stream(StreamName="my-stream", ShardCount=2)
+    resp = client.describe_stream(StreamName="my-stream")
+    desc = resp["StreamDescription"]
+    stream_arn = desc["StreamARN"]
+    action = "kinesis:*"
+    json_policy_doc = get_policy_doc(action, stream_arn)
+    client.put_resource_policy(ResourceARN=stream_arn, Policy=json_policy_doc)
+    response = client.get_resource_policy(ResourceARN=stream_arn)
+    assert response["Policy"] == json_policy_doc
+
+    client.delete_resource_policy(ResourceARN=stream_arn)
+    response = client.get_resource_policy(ResourceARN=stream_arn)
+    assert response["Policy"] == "{}"
+
+
+@mock_aws
+def test_get_resource_policy_from_unknown_resource():
+    client = boto3.client("kinesis", region_name="us-west-2")
+    client.create_stream(StreamName="my-stream", ShardCount=2)
+    resp = client.describe_stream(StreamName="my-stream")
+    desc = resp["StreamDescription"]
+    stream_arn = desc["StreamARN"] + "unknown"
+    sts = boto3.client("sts", "us-east-1")
+    account_id = sts.get_caller_identity()["Account"]
+    with pytest.raises(ClientError) as exc:
+        client.get_resource_policy(ResourceARN=stream_arn)
+    err = exc.value.response["Error"]
+    assert err["Code"] == "ResourceNotFoundException"
+    assert (
+        err["Message"] == f"Stream {stream_arn} under account {account_id} not found."
+    )
+
+
+@mock_aws
+def test_delete_resource_policy_from_unknown_resource():
+    client = boto3.client("kinesis", region_name="us-west-2")
+    client.create_stream(StreamName="my-stream", ShardCount=2)
+    resp = client.describe_stream(StreamName="my-stream")
+    desc = resp["StreamDescription"]
+    stream_arn = desc["StreamARN"] + "unknown"
+    sts = boto3.client("sts", "us-east-1")
+    account_id = sts.get_caller_identity()["Account"]
+    with pytest.raises(ClientError) as exc:
+        client.delete_resource_policy(ResourceARN=stream_arn)
+    err = exc.value.response["Error"]
+    assert err["Code"] == "ResourceNotFoundException"
+    assert (
+        err["Message"] == f"Stream {stream_arn} under account {account_id} not found."
+    )
+
+
+@mock_aws
+def test_delete_resource_policy_from_resource_without_policy():
+    client = boto3.client("kinesis", region_name="us-west-2")
+    client.create_stream(StreamName="my-stream", ShardCount=2)
+    resp = client.describe_stream(StreamName="my-stream")
+    desc = resp["StreamDescription"]
+    stream_arn = desc["StreamARN"]
+    with pytest.raises(ClientError) as exc:
+        client.delete_resource_policy(ResourceARN=stream_arn)
+    err = exc.value.response["Error"]
+    assert err["Code"] == "ResourceNotFoundException"
+    assert err["Message"] == f"No resource policy found for resource ARN {stream_arn}."
diff --git a/tests/test_kms/test_kms_key_rotation.py b/tests/test_kms/test_kms_key_rotation.py
new file mode 100644
index 000000000..f809a78b3
--- /dev/null
+++ b/tests/test_kms/test_kms_key_rotation.py
@@ -0,0 +1,106 @@
+"""Unit tests for kms-supported APIs."""
+
+import boto3
+import pytest
+
+from moto import mock_aws
+
+# See our Development Tips on writing tests for hints on how to write good tests:
+# http://docs.getmoto.org/en/latest/docs/contributing/development_tips/tests.html
+
+
+@mock_aws
+def test_rotate_key_on_demand_with_existing_key():
+    client = boto3.client("kms", region_name="us-east-2")
+
+    key_id = client.create_key(Policy="my policy")["KeyMetadata"]["KeyId"]
+
+    resp = client.rotate_key_on_demand(KeyId=key_id)
+
+    assert resp["KeyId"] == key_id
+
+
+@mock_aws
+def test_rotate_key_on_demand_with_non_existing_key_fails():
+    client = boto3.client("kms", region_name="us-east-2")
+
+    with pytest.raises(client.exceptions.NotFoundException):
+        client.rotate_key_on_demand(KeyId="some-id")
+
+
+@mock_aws
+def test_list_key_rotations_with_non_existing_key_fails():
+    client = boto3.client("kms", region_name="us-east-2")
+
+    with pytest.raises(client.exceptions.NotFoundException):
+        client.list_key_rotations(KeyId="some-id")
+
+
+@mock_aws
+def test_list_key_rotations_are_empty_on_new_key():
+    client = boto3.client("kms", region_name="us-east-2")
+
+    key_id = client.create_key(Policy="my policy")["KeyMetadata"]["KeyId"]
+
+    resp = client.list_key_rotations(KeyId=key_id)
+
+    assert len(resp["Rotations"]) == 0
+    assert resp["Truncated"] is False
+    assert "NextMarker" not in resp
+
+
+@mock_aws
+def test_list_key_rotations_returns_one_rotation():
+    # Arrange
+    client = boto3.client("kms", region_name="us-east-2")
+    key_id = client.create_key(Policy="my policy")["KeyMetadata"]["KeyId"]
+    client.rotate_key_on_demand(KeyId=key_id)
+
+    # Act
+    resp = client.list_key_rotations(KeyId=key_id)
+
+    # Assert
+    assert len(resp["Rotations"]) == 1
+    assert resp["Truncated"] is False
+    assert "NextMarker" not in resp
+    assert resp["Rotations"][0]["RotationType"] == "ON_DEMAND"
+
+
+@mock_aws
+def test_list_key_rotations_returns_truncated_and_next_marker():
+    # Arrange
+    client = boto3.client("kms", region_name="us-east-2")
+    key_id = client.create_key(Policy="my policy")["KeyMetadata"]["KeyId"]
+    client.rotate_key_on_demand(KeyId=key_id)
+    client.rotate_key_on_demand(KeyId=key_id)
+    client.rotate_key_on_demand(KeyId=key_id)
+
+    # Act
+    resp = client.list_key_rotations(KeyId=key_id, Limit=1)
+
+    # Assert
+    assert len(resp["Rotations"]) == 1
+    assert resp["Truncated"] is True
+    assert "NextMarker" in resp
+
+
+@mock_aws
+def test_list_key_rotations_pagination():
+    # Arrange
+    client = boto3.client("kms", region_name="us-east-2")
+    key_id = client.create_key(Policy="my policy")["KeyMetadata"]["KeyId"]
+    client.rotate_key_on_demand(KeyId=key_id)
+    client.rotate_key_on_demand(KeyId=key_id)
+    client.rotate_key_on_demand(KeyId=key_id)
+    initial_page = client.list_key_rotations(KeyId=key_id, Limit=1)
+
+    # Act
+
+    final_page = client.list_key_rotations(
+        KeyId=key_id, Limit=2, Marker=initial_page["NextMarker"]
+    )
+
+    # Assert
+    assert len(final_page["Rotations"]) == 2
+    assert final_page["Truncated"] is False
+    assert "NextMarker" not in final_page
diff --git a/tests/test_kms/test_kms_mac.py b/tests/test_kms/test_kms_mac.py
new file mode 100644
index 000000000..cf209f9a7
--- /dev/null
+++ b/tests/test_kms/test_kms_mac.py
@@ -0,0 +1,135 @@
+"""Unit tests for kms-supported APIs."""
+
+import base64
+
+import boto3
+import pytest
+
+from moto import mock_aws
+
+# See our Development Tips on writing tests for hints on how to write good tests:
+# http://docs.getmoto.org/en/latest/docs/contributing/development_tips/tests.html
+
+
+def create_hmac_key() -> str:
+    client = boto3.client("kms", region_name="eu-central-1")
+
+    key_id = client.create_key(
+        KeyUsage="GENERATE_VERIFY_MAC", KeySpec="HMAC_512", Policy="My Policy"
+    )["KeyMetadata"]["KeyId"]
+
+    return key_id
+
+
+@mock_aws
+def test_generate_mac():
+    # Arrange
+    key_id = create_hmac_key()
+    client = boto3.client("kms", region_name="eu-central-1")
+
+    # Act
+    resp = client.generate_mac(
+        KeyId=key_id,
+        MacAlgorithm="HMAC_SHA_512",
+        Message=base64.b64encode("Hello World".encode("utf-8")),
+    )
+
+    # Assert
+    assert "Mac" in resp
+    assert resp["KeyId"] == key_id
+    assert resp["MacAlgorithm"] == "HMAC_SHA_512"
+
+
+@mock_aws
+def test_generate_fails_for_non_existent_key():
+    # Arrange
+    client = boto3.client("kms", region_name="eu-central-1")
+
+    # Act + Assert
+    with pytest.raises(client.exceptions.NotFoundException):
+        client.generate_mac(
+            KeyId="some-key",
+            MacAlgorithm="HMAC_SHA_512",
+            Message=base64.b64encode("Hello World".encode("utf-8")),
+        )
+
+
+@mock_aws
+def test_generate_fails_for_invalid_key_usage():
+    # Arrange
+    client = boto3.client("kms", region_name="eu-central-1")
+    key_id = client.create_key(
+        KeyUsage="ENCRYPT_DECRYPT", KeySpec="HMAC_512", Policy="My Policy"
+    )["KeyMetadata"]["KeyId"]
+
+    # Act + Assert
+    with pytest.raises(client.exceptions.InvalidKeyUsageException):
+        client.generate_mac(
+            KeyId=key_id,
+            MacAlgorithm="HMAC_SHA_512",
+            Message=base64.b64encode("Hello World".encode("utf-8")),
+        )
+
+
+@mock_aws
+def test_generate_fails_for_invalid_key_spec():
+    # Arrange
+    client = boto3.client("kms", region_name="eu-central-1")
+    key_id = client.create_key(
+        KeyUsage="GENERATE_VERIFY_MAC", KeySpec="RSA_2048", Policy="My Policy"
+    )["KeyMetadata"]["KeyId"]
+
+    # Act + Assert
+    with pytest.raises(client.exceptions.InvalidKeyUsageException):
+        client.generate_mac(
+            KeyId=key_id,
+            MacAlgorithm="HMAC_SHA_512",
+            Message=base64.b64encode("Hello World".encode("utf-8")),
+        )
+
+
+@mock_aws
+def test_verify_mac():
+    # Arrange
+    key_id = create_hmac_key()
+    client = boto3.client("kms", region_name="eu-central-1")
+    mac = client.generate_mac(
+        KeyId=key_id,
+        MacAlgorithm="HMAC_SHA_512",
+        Message=base64.b64encode("Hello World".encode("utf-8")),
+    )["Mac"]
+
+    # Act
+    resp = client.verify_mac(
+        KeyId=key_id,
+        MacAlgorithm="HMAC_SHA_512",
+        Message=base64.b64encode("Hello World".encode("utf-8")),
+        Mac=mac,
+    )
+
+    # Assert
+    assert resp["KeyId"] == key_id
+    assert resp["MacAlgorithm"] == "HMAC_SHA_512"
+    assert resp["MacValid"] is True
+
+
+@mock_aws
+def test_verify_mac_fails_for_another_key_id():
+    # Arrange
+    key_id = create_hmac_key()
+    other_key_id = create_hmac_key()
+    client = boto3.client("kms", region_name="eu-central-1")
+    mac = client.generate_mac(
+        KeyId=key_id,
+        MacAlgorithm="HMAC_SHA_512",
+        Message=base64.b64encode("Hello World".encode("utf-8")),
+    )["Mac"]
+
+    # Act + Assert
+    with pytest.raises(client.exceptions.KMSInvalidMacException):
+        client.verify_mac(
+            KeyId=other_key_id,
+            MacAlgorithm="HMAC_SHA_512",
+            Message=base64.b64encode("Hello World".encode("utf-8")),
+            Mac=mac,
+        )
diff --git a/tests/test_rds/test_rds.py b/tests/test_rds/test_rds.py
index 9003cccc7..1a6f415af 100644
--- a/tests/test_rds/test_rds.py
+++ b/tests/test_rds/test_rds.py
@@ -14,10 +14,27 @@ from tests import aws_verified
 DEFAULT_REGION = "us-west-2"
 
 
+@pytest.fixture(name="client")
 @mock_aws
-def test_create_database():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
+def get_rds_client():
+    return boto3.client("rds", region_name=DEFAULT_REGION)
+
+
+def create_db_instance(**extra_kwargs):
+    client = boto3.client("rds", region_name=DEFAULT_REGION)
+    kwargs = {
+        "DBInstanceIdentifier": "db-master-1",
+        "Engine": "postgres",
+        "DBName": "staging-postgres",
+        "DBInstanceClass": "db.m1.small",
+    }
+    kwargs.update(extra_kwargs)
+    return client.create_db_instance(**kwargs)["DBInstance"]
+
+
+@mock_aws
+def test_create_database(client):
+    database = client.create_db_instance(
         DBInstanceIdentifier="db-master-1",
         AllocatedStorage=10,
         Engine="postgres",
@@ -56,30 +73,14 @@ def test_create_database():
 
 @mock_aws
 def test_database_with_deletion_protection_cannot_be_deleted():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        DeletionProtection=True,
-    )
-    db_instance = database["DBInstance"]
+    db_instance = create_db_instance(DeletionProtection=True)
     assert db_instance["DBInstanceClass"] == "db.m1.small"
     assert db_instance["DeletionProtection"] is True
 
 
 @mock_aws
 def test_create_database_no_allocated_storage():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-    )
-    db_instance = database["DBInstance"]
+    db_instance = create_db_instance()
     assert db_instance["Engine"] == "postgres"
     assert db_instance["StorageType"] == "gp2"
     assert db_instance["AllocatedStorage"] == 20
@@ -88,15 +89,8 @@ def test_create_database_no_allocated_storage():
 
 @mock_aws
 def test_create_database_invalid_preferred_maintenance_window_more_24_hours():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
     with pytest.raises(ClientError) as ex:
-        conn.create_db_instance(
-            DBInstanceIdentifier="db-master-1",
-            Engine="postgres",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
-            PreferredMaintenanceWindow="mon:16:00-tue:17:00",
-        )
+        create_db_instance(PreferredMaintenanceWindow="mon:16:00-tue:17:00")
     err = ex.value.response["Error"]
     assert err["Code"] == "InvalidParameterValue"
     assert err["Message"] == "Maintenance window must be less than 24 hours."
@@ -104,15 +98,8 @@ def test_create_database_invalid_preferred_maintenance_window_more_24_hours():
 
 @mock_aws
 def test_create_database_invalid_preferred_maintenance_window_less_30_mins():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
     with pytest.raises(ClientError) as ex:
-        conn.create_db_instance(
-            DBInstanceIdentifier="db-master-1",
-            Engine="postgres",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
-            PreferredMaintenanceWindow="mon:16:00-mon:16:05",
-        )
+        create_db_instance(PreferredMaintenanceWindow="mon:16:00-mon:16:05")
     err = ex.value.response["Error"]
     assert err["Code"] == "InvalidParameterValue"
     assert err["Message"] == "The maintenance window must be at least 30 minutes."
@@ -120,15 +107,8 @@ def test_create_database_invalid_preferred_maintenance_window_less_30_mins():
 
 @mock_aws
 def test_create_database_invalid_preferred_maintenance_window_value():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
     with pytest.raises(ClientError) as ex:
-        conn.create_db_instance(
-            DBInstanceIdentifier="db-master-1",
-            Engine="postgres",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
-            PreferredMaintenanceWindow="sim:16:00-mon:16:30",
-        )
+        create_db_instance(PreferredMaintenanceWindow="sim:16:00-mon:16:30")
     err = ex.value.response["Error"]
     assert err["Code"] == "InvalidParameterValue"
     assert "Invalid day:hour:minute" in err["Message"]
@@ -136,15 +116,8 @@ def test_create_database_invalid_preferred_maintenance_window_value():
 
 @mock_aws
 def test_create_database_invalid_preferred_maintenance_window_format():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
     with pytest.raises(ClientError) as ex:
-        conn.create_db_instance(
-            DBInstanceIdentifier="db-master-1",
-            Engine="postgres",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
-            PreferredMaintenanceWindow="mon:16tue:17:00",
-        )
+        create_db_instance(PreferredMaintenanceWindow="mon:16tue:17:00")
     err = ex.value.response["Error"]
     assert err["Code"] == "InvalidParameterValue"
     assert (
@@ -155,13 +128,8 @@ def test_create_database_invalid_preferred_maintenance_window_format():
 
 @mock_aws
 def test_create_database_preferred_backup_window_overlap_no_spill():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
     with pytest.raises(ClientError) as ex:
-        conn.create_db_instance(
-            DBInstanceIdentifier="db-master-1",
-            Engine="postgres",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
+        create_db_instance(
             PreferredMaintenanceWindow="wed:18:00-wed:22:00",
             PreferredBackupWindow="20:00-20:30",
         )
@@ -174,13 +142,8 @@ def test_create_database_preferred_backup_window_overlap_no_spill():
 
 @mock_aws
 def test_create_database_preferred_backup_window_overlap_maintenance_window_spill():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
     with pytest.raises(ClientError) as ex:
-        conn.create_db_instance(
-            DBInstanceIdentifier="db-master-1",
-            Engine="postgres",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
+        create_db_instance(
             PreferredMaintenanceWindow="wed:18:00-thu:01:00",
             PreferredBackupWindow="00:00-00:30",
         )
@@ -193,13 +156,8 @@ def test_create_database_preferred_backup_window_overlap_maintenance_window_spil
 
 @mock_aws
 def test_create_database_preferred_backup_window_overlap_backup_window_spill():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
     with pytest.raises(ClientError) as ex:
-        conn.create_db_instance(
-            DBInstanceIdentifier="db-master-1",
-            Engine="postgres",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
+        create_db_instance(
             PreferredMaintenanceWindow="thu:00:00-thu:14:00",
             PreferredBackupWindow="23:50-00:20",
         )
@@ -212,13 +170,8 @@ def test_create_database_preferred_backup_window_overlap_backup_window_spill():
 
 @mock_aws
 def test_create_database_preferred_backup_window_overlap_both_spill():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
     with pytest.raises(ClientError) as ex:
-        conn.create_db_instance(
-            DBInstanceIdentifier="db-master-1",
-            Engine="postgres",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
+        create_db_instance(
             PreferredMaintenanceWindow="wed:18:00-thu:01:00",
             PreferredBackupWindow="23:50-00:20",
         )
@@ -231,66 +184,33 @@ def test_create_database_preferred_backup_window_overlap_both_spill():
 
 @mock_aws
 def test_create_database_valid_preferred_maintenance_window_format():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        PreferredMaintenanceWindow="sun:16:00-sun:16:30",
-    )
-    db_instance = database["DBInstance"]
+    db_instance = create_db_instance(PreferredMaintenanceWindow="sun:16:00-sun:16:30")
     assert db_instance["DBInstanceClass"] == "db.m1.small"
     assert db_instance["PreferredMaintenanceWindow"] == "sun:16:00-sun:16:30"
 
 
 @mock_aws
 def test_create_database_valid_preferred_maintenance_window_uppercase_format():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        PreferredMaintenanceWindow="MON:16:00-TUE:01:30",
-    )
-    db_instance = database["DBInstance"]
+    db_instance = create_db_instance(PreferredMaintenanceWindow="MON:16:00-TUE:01:30")
     assert db_instance["DBInstanceClass"] == "db.m1.small"
     assert db_instance["PreferredMaintenanceWindow"] == "mon:16:00-tue:01:30"
 
 
 @mock_aws
 def test_create_database_non_existing_option_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
     with pytest.raises(ClientError):
-        conn.create_db_instance(
-            DBInstanceIdentifier="db-master-1",
-            AllocatedStorage=10,
-            Engine="postgres",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
-            OptionGroupName="non-existing",
-        )
+        create_db_instance(OptionGroupName="non-existing")
 
 
 @mock_aws
-def test_create_database_with_option_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_option_group(
+def test_create_database_with_option_group(client):
+    client.create_option_group(
         OptionGroupName="my-og",
         EngineName="mysql",
         MajorEngineVersion="5.6",
         OptionGroupDescription="test option group",
     )
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        OptionGroupName="my-og",
-    )
-    db_instance = database["DBInstance"]
+    db_instance = create_db_instance(AllocatedStorage=10, OptionGroupName="my-og")
     assert db_instance["AllocatedStorage"] == 10
     assert db_instance["DBInstanceClass"] == "db.m1.small"
     assert db_instance["DBName"] == "staging-postgres"
@@ -298,294 +218,212 @@ def test_create_database_with_option_group():
 
 
 @mock_aws
-def test_stop_database():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        LicenseModel="license-included",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    mydb = conn.describe_db_instances(
-        DBInstanceIdentifier=database["DBInstance"]["DBInstanceIdentifier"]
+def test_stop_database(client):
+    db_instance = create_db_instance()
+    mydb = client.describe_db_instances(
+        DBInstanceIdentifier=db_instance["DBInstanceIdentifier"]
     )["DBInstances"][0]
     assert mydb["DBInstanceStatus"] == "available"
     # test stopping database should shutdown
-    response = conn.stop_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
+    response = client.stop_db_instance(
+        DBInstanceIdentifier=mydb["DBInstanceIdentifier"]
+    )
     assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
     assert response["DBInstance"]["DBInstanceStatus"] == "stopped"
     # test rdsclient error when trying to stop an already stopped database
     with pytest.raises(ClientError):
-        conn.stop_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
+        client.stop_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
     # test stopping a stopped database with snapshot should error and no
     # snapshot should exist for that call
     with pytest.raises(ClientError):
-        conn.stop_db_instance(
+        client.stop_db_instance(
             DBInstanceIdentifier=mydb["DBInstanceIdentifier"],
             DBSnapshotIdentifier="rocky4570-rds-snap",
         )
-    response = conn.describe_db_snapshots()
+    response = client.describe_db_snapshots()
     assert response["DBSnapshots"] == []
 
 
 @mock_aws
-def test_start_database():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        LicenseModel="license-included",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    mydb = conn.describe_db_instances(
-        DBInstanceIdentifier=database["DBInstance"]["DBInstanceIdentifier"]
+def test_start_database(client):
+    db_instance = create_db_instance()
+    mydb = client.describe_db_instances(
+        DBInstanceIdentifier=db_instance["DBInstanceIdentifier"]
     )["DBInstances"][0]
     assert mydb["DBInstanceStatus"] == "available"
     # test starting an already started database should error
     with pytest.raises(ClientError):
-        conn.start_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
+        client.start_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
     # stop and test start - should go from stopped to available, create
     # snapshot and check snapshot
-    response = conn.stop_db_instance(
+    response = client.stop_db_instance(
         DBInstanceIdentifier=mydb["DBInstanceIdentifier"],
         DBSnapshotIdentifier="rocky4570-rds-snap",
     )
     assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
     assert response["DBInstance"]["DBInstanceStatus"] == "stopped"
-    response = conn.describe_db_snapshots()
+    response = client.describe_db_snapshots()
     assert response["DBSnapshots"][0]["DBSnapshotIdentifier"] == "rocky4570-rds-snap"
-    response = conn.start_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
+    response = client.start_db_instance(
+        DBInstanceIdentifier=mydb["DBInstanceIdentifier"]
+    )
     assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
     assert response["DBInstance"]["DBInstanceStatus"] == "available"
     # starting database should not remove snapshot
-    response = conn.describe_db_snapshots()
+    response = client.describe_db_snapshots()
     assert response["DBSnapshots"][0]["DBSnapshotIdentifier"] == "rocky4570-rds-snap"
     # test stopping database, create snapshot with existing snapshot already
     # created should throw error
     with pytest.raises(ClientError):
-        conn.stop_db_instance(
+        client.stop_db_instance(
             DBInstanceIdentifier=mydb["DBInstanceIdentifier"],
             DBSnapshotIdentifier="rocky4570-rds-snap",
         )
     # test stopping database not invoking snapshot should succeed.
-    response = conn.stop_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
+    response = client.stop_db_instance(
+        DBInstanceIdentifier=mydb["DBInstanceIdentifier"]
+    )
     assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
     assert response["DBInstance"]["DBInstanceStatus"] == "stopped"
 
 
 @mock_aws
-def test_fail_to_stop_multi_az_and_sqlserver():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
+def test_fail_to_stop_multi_az_and_sqlserver(client):
+    db_instance = create_db_instance(
         Engine="sqlserver-ee",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
         LicenseModel="license-included",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
         MultiAZ=True,
     )
 
-    mydb = conn.describe_db_instances(
-        DBInstanceIdentifier=database["DBInstance"]["DBInstanceIdentifier"]
+    mydb = client.describe_db_instances(
+        DBInstanceIdentifier=db_instance["DBInstanceIdentifier"]
     )["DBInstances"][0]
     assert mydb["DBInstanceStatus"] == "available"
     # multi-az databases arent allowed to be shutdown at this time.
     with pytest.raises(ClientError):
-        conn.stop_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
+        client.stop_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
     # multi-az databases arent allowed to be started up at this time.
     with pytest.raises(ClientError):
-        conn.start_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
+        client.start_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
 
 
 @mock_aws
-def test_stop_multi_az_postgres():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        LicenseModel="license-included",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-        MultiAZ=True,
-    )
+def test_stop_multi_az_postgres(client):
+    db_instance = create_db_instance(MultiAZ=True)
 
-    mydb = conn.describe_db_instances(
-        DBInstanceIdentifier=database["DBInstance"]["DBInstanceIdentifier"]
+    mydb = client.describe_db_instances(
+        DBInstanceIdentifier=db_instance["DBInstanceIdentifier"]
     )["DBInstances"][0]
     assert mydb["DBInstanceStatus"] == "available"
 
-    response = conn.stop_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
+    response = client.stop_db_instance(
+        DBInstanceIdentifier=mydb["DBInstanceIdentifier"]
+    )
     assert response["ResponseMetadata"]["HTTPStatusCode"] == 200
     assert response["DBInstance"]["DBInstanceStatus"] == "stopped"
 
 
 @mock_aws
-def test_fail_to_stop_readreplica():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        LicenseModel="license-included",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_fail_to_stop_readreplica(client):
+    db_instance = create_db_instance()
 
-    replica = conn.create_db_instance_read_replica(
+    replica = client.create_db_instance_read_replica(
         DBInstanceIdentifier="db-replica-1",
-        SourceDBInstanceIdentifier="db-master-1",
+        SourceDBInstanceIdentifier=db_instance["DBInstanceIdentifier"],
         DBInstanceClass="db.m1.small",
     )
 
-    mydb = conn.describe_db_instances(
+    mydb = client.describe_db_instances(
         DBInstanceIdentifier=replica["DBInstance"]["DBInstanceIdentifier"]
     )["DBInstances"][0]
     assert mydb["DBInstanceStatus"] == "available"
     # read-replicas are not allowed to be stopped at this time.
     with pytest.raises(ClientError):
-        conn.stop_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
+        client.stop_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
     # read-replicas are not allowed to be started at this time.
     with pytest.raises(ClientError):
-        conn.start_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
+        client.start_db_instance(DBInstanceIdentifier=mydb["DBInstanceIdentifier"])
 
 
 @mock_aws
-def test_get_databases():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
-    instances = conn.describe_db_instances()
-    assert len(list(instances["DBInstances"])) == 0
+def test_get_databases(client):
+    instances = client.describe_db_instances()
+    assert len(instances["DBInstances"]) == 0
 
-    conn.create_db_instance(
+    create_db_instance(
         DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
     )
-    conn.create_db_instance(
+    create_db_instance(
         DBInstanceIdentifier="db-master-2",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
         Port=1234,
-        DBSecurityGroups=["my_sg"],
         DeletionProtection=True,
     )
-    instances = conn.describe_db_instances()
-    assert len(list(instances["DBInstances"])) == 2
+    instances = client.describe_db_instances()
+    assert len(instances["DBInstances"]) == 2
 
-    instances = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
-    assert len(list(instances["DBInstances"])) == 1
+    instances = client.describe_db_instances(DBInstanceIdentifier="db-master-1")
+    assert len(instances["DBInstances"]) == 1
     assert instances["DBInstances"][0]["DBInstanceIdentifier"] == "db-master-1"
     assert instances["DBInstances"][0]["DeletionProtection"] is False
     assert instances["DBInstances"][0]["DBInstanceArn"] == (
-        f"arn:aws:rds:us-west-2:{ACCOUNT_ID}:db:db-master-1"
+        f"arn:aws:rds:{DEFAULT_REGION}:{ACCOUNT_ID}:db:db-master-1"
     )
 
-    instances = conn.describe_db_instances(DBInstanceIdentifier="db-master-2")
+    instances = client.describe_db_instances(DBInstanceIdentifier="db-master-2")
     assert instances["DBInstances"][0]["DeletionProtection"] is True
     assert instances["DBInstances"][0]["Endpoint"]["Port"] == 1234
     assert instances["DBInstances"][0]["DbInstancePort"] == 1234
 
 
 @mock_aws
-def test_get_databases_paginated():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
+def test_get_databases_paginated(client):
     for i in range(51):
-        conn.create_db_instance(
-            AllocatedStorage=5,
-            Port=5432,
-            DBInstanceIdentifier=f"rds{i}",
-            DBInstanceClass="db.t1.micro",
-            Engine="postgres",
-        )
+        create_db_instance(DBInstanceIdentifier=f"rds{i}")
 
-    resp = conn.describe_db_instances()
+    resp = client.describe_db_instances()
     assert len(resp["DBInstances"]) == 50
     assert resp["Marker"] == resp["DBInstances"][-1]["DBInstanceIdentifier"]
 
-    resp2 = conn.describe_db_instances(Marker=resp["Marker"])
+    resp2 = client.describe_db_instances(Marker=resp["Marker"])
     assert len(resp2["DBInstances"]) == 1
 
-    resp3 = conn.describe_db_instances(MaxRecords=100)
+    resp3 = client.describe_db_instances(MaxRecords=100)
     assert len(resp3["DBInstances"]) == 51
 
 
 @mock_aws
-def test_describe_non_existent_database():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_describe_non_existent_database(client):
     with pytest.raises(ClientError):
-        conn.describe_db_instances(DBInstanceIdentifier="not-a-db")
+        client.describe_db_instances(DBInstanceIdentifier="not-a-db")
 
 
 @pytest.mark.parametrize(
     "custom_db_subnet_group", [True, False], ids=("custom_subnet", "default_subnet")
 )
 @mock_aws
-def test_modify_db_instance(custom_db_subnet_group: bool):
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
+def test_modify_db_instance(custom_db_subnet_group: bool, client):
     if custom_db_subnet_group:
         extra_kwargs = {"DBSubnetGroupName": create_db_subnet_group()}
     else:
         extra_kwargs = {}
 
-    conn.create_db_instance(
+    create_db_instance(
         DBInstanceIdentifier="db-id",
         AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
         **extra_kwargs,
     )
-    inst = conn.describe_db_instances(DBInstanceIdentifier="db-id")["DBInstances"][0]
+    inst = client.describe_db_instances(DBInstanceIdentifier="db-id")["DBInstances"][0]
     assert inst["AllocatedStorage"] == 10
     assert inst["EnabledCloudwatchLogsExports"] == []
 
-    conn.modify_db_instance(
+    client.modify_db_instance(
         DBInstanceIdentifier="db-id",
         AllocatedStorage=20,
         ApplyImmediately=True,
         VpcSecurityGroupIds=["sg-123456"],
         CloudwatchLogsExportConfiguration={"EnableLogTypes": ["error"]},
     )
-    inst = conn.describe_db_instances(DBInstanceIdentifier="db-id")["DBInstances"][0]
+    inst = client.describe_db_instances(DBInstanceIdentifier="db-id")["DBInstances"][0]
     assert inst["AllocatedStorage"] == 20
     assert inst["PreferredMaintenanceWindow"] == "wed:06:38-wed:07:08"
     assert inst["VpcSecurityGroups"][0]["VpcSecurityGroupId"] == "sg-123456"
@@ -594,8 +432,9 @@ def test_modify_db_instance(custom_db_subnet_group: bool):
 
 @pytest.mark.parametrize("with_custom_kms_key", [True, False])
 @mock_aws
-def test_modify_db_instance_manage_master_user_password(with_custom_kms_key: bool):
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_modify_db_instance_manage_master_user_password(
+    with_custom_kms_key: bool, client
+):
     db_id = "db-id"
 
     custom_kms_key = f"arn:aws:kms:{DEFAULT_REGION}:123456789012:key/abcd1234-56ef-78gh-90ij-klmnopqrstuv"
@@ -603,28 +442,22 @@ def test_modify_db_instance_manage_master_user_password(with_custom_kms_key: boo
         {"MasterUserSecretKmsKeyId": custom_kms_key} if with_custom_kms_key else {}
     )
 
-    create_response = conn.create_db_instance(
+    db_instance = create_db_instance(
         DBInstanceIdentifier=db_id,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter21",
         ManageMasterUserPassword=False,
     )
 
-    modify_response = conn.modify_db_instance(
+    modify_response = client.modify_db_instance(
         DBInstanceIdentifier=db_id, ManageMasterUserPassword=True, **custom_kms_key_args
     )
 
-    describe_response = conn.describe_db_instances(
-        DBInstanceIdentifier=db_id,
-    )
+    describe_response = client.describe_db_instances(DBInstanceIdentifier=db_id)
 
-    revert_modification_response = conn.modify_db_instance(
+    revert_modification_response = client.modify_db_instance(
         DBInstanceIdentifier=db_id, ManageMasterUserPassword=False
     )
 
-    assert create_response["DBInstance"].get("MasterUserSecret") is None
+    assert db_instance.get("MasterUserSecret") is None
     master_user_secret = modify_response["DBInstance"]["MasterUserSecret"]
     assert len(master_user_secret.keys()) == 3
     assert (
@@ -649,27 +482,21 @@ def test_modify_db_instance_manage_master_user_password(with_custom_kms_key: boo
 
 @pytest.mark.parametrize("with_apply_immediately", [True, False])
 @mock_aws
-def test_modify_db_instance_rotate_master_user_password(with_apply_immediately):
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_modify_db_instance_rotate_master_user_password(with_apply_immediately, client):
     db_id = "db-id"
-
-    conn.create_db_instance(
+    create_db_instance(
         DBInstanceIdentifier=db_id,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter21",
         ManageMasterUserPassword=True,
     )
 
     if with_apply_immediately:
-        modify_response = conn.modify_db_instance(
+        modify_response = client.modify_db_instance(
             DBInstanceIdentifier=db_id,
             RotateMasterUserPassword=True,
             ApplyImmediately=True,
         )
 
-        describe_response = conn.describe_db_instances(
+        describe_response = client.describe_db_instances(
             DBInstanceIdentifier=db_id,
         )
 
@@ -684,97 +511,55 @@ def test_modify_db_instance_rotate_master_user_password(with_apply_immediately):
 
     else:
         with pytest.raises(ClientError):
-            conn.modify_db_instance(
+            client.modify_db_instance(
                 DBInstanceIdentifier=db_id,
                 RotateMasterUserPassword=True,
             )
 
 
 @mock_aws
-def test_modify_db_instance_not_existent_db_parameter_group_name():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    instances = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
-    assert instances["DBInstances"][0]["AllocatedStorage"] == 10
+def test_modify_db_instance_not_existent_db_parameter_group_name(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
     with pytest.raises(ClientError):
-        conn.modify_db_instance(
+        client.modify_db_instance(
             DBInstanceIdentifier="db-master-1",
             DBParameterGroupName="test-sqlserver-se-2017",
         )
 
 
 @mock_aws
-def test_modify_db_instance_valid_preferred_maintenance_window():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    instances = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
-    conn.modify_db_instance(
+def test_modify_db_instance_valid_preferred_maintenance_window(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
+    client.modify_db_instance(
         DBInstanceIdentifier="db-master-1",
         PreferredMaintenanceWindow="sun:16:00-sun:16:30",
     )
-    instances = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
+    instances = client.describe_db_instances(DBInstanceIdentifier="db-master-1")
     assert instances["DBInstances"][0]["PreferredMaintenanceWindow"] == (
         "sun:16:00-sun:16:30"
     )
 
 
 @mock_aws
-def test_modify_db_instance_valid_preferred_maintenance_window_uppercase():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    instances = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
-    conn.modify_db_instance(
+def test_modify_db_instance_valid_preferred_maintenance_window_uppercase(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
+    client.modify_db_instance(
         DBInstanceIdentifier="db-master-1",
         PreferredMaintenanceWindow="SUN:16:00-SUN:16:30",
     )
-    instances = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
+    instances = client.describe_db_instances(DBInstanceIdentifier="db-master-1")
     assert instances["DBInstances"][0]["PreferredMaintenanceWindow"] == (
         "sun:16:00-sun:16:30"
     )
 
 
 @mock_aws
-def test_modify_db_instance_invalid_preferred_maintenance_window_more_than_24_hours():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_modify_db_instance_invalid_preferred_maintenance_window_more_than_24_hours(
+    client,
+):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
     with pytest.raises(ClientError) as ex:
-        conn.modify_db_instance(
+        client.modify_db_instance(
             DBInstanceIdentifier="db-master-1",
             PreferredMaintenanceWindow="sun:16:00-sat:16:30",
         )
@@ -784,20 +569,12 @@ def test_modify_db_instance_invalid_preferred_maintenance_window_more_than_24_ho
 
 
 @mock_aws
-def test_modify_db_instance_invalid_preferred_maintenance_window_less_than_30_mins():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_modify_db_instance_invalid_preferred_maintenance_window_less_than_30_mins(
+    client,
+):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
     with pytest.raises(ClientError) as ex:
-        conn.modify_db_instance(
+        client.modify_db_instance(
             DBInstanceIdentifier="db-master-1",
             PreferredMaintenanceWindow="sun:16:00-sun:16:10",
         )
@@ -807,20 +584,10 @@ def test_modify_db_instance_invalid_preferred_maintenance_window_less_than_30_mi
 
 
 @mock_aws
-def test_modify_db_instance_invalid_preferred_maintenance_window_value():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_modify_db_instance_invalid_preferred_maintenance_window_value(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
     with pytest.raises(ClientError) as ex:
-        conn.modify_db_instance(
+        client.modify_db_instance(
             DBInstanceIdentifier="db-master-1",
             PreferredMaintenanceWindow="sin:16:00-sun:16:30",
         )
@@ -830,20 +597,10 @@ def test_modify_db_instance_invalid_preferred_maintenance_window_value():
 
 
 @mock_aws
-def test_modify_db_instance_invalid_preferred_maintenance_window_format():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_modify_db_instance_invalid_preferred_maintenance_window_format(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
     with pytest.raises(ClientError) as ex:
-        conn.modify_db_instance(
+        client.modify_db_instance(
             DBInstanceIdentifier="db-master-1",
             PreferredMaintenanceWindow="sun:16:00sun:16:30",
         )
@@ -856,20 +613,10 @@ def test_modify_db_instance_invalid_preferred_maintenance_window_format():
 
 
 @mock_aws
-def test_modify_db_instance_maintenance_backup_window_no_spill():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_modify_db_instance_maintenance_backup_window_no_spill(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
     with pytest.raises(ClientError) as ex:
-        conn.modify_db_instance(
+        client.modify_db_instance(
             DBInstanceIdentifier="db-master-1",
             PreferredMaintenanceWindow="sun:16:00-sun:16:30",
             PreferredBackupWindow="15:50-16:20",
@@ -882,20 +629,10 @@ def test_modify_db_instance_maintenance_backup_window_no_spill():
 
 
 @mock_aws
-def test_modify_db_instance_maintenance_backup_window_maintenance_spill():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_modify_db_instance_maintenance_backup_window_maintenance_spill(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
     with pytest.raises(ClientError) as ex:
-        conn.modify_db_instance(
+        client.modify_db_instance(
             DBInstanceIdentifier="db-master-1",
             PreferredMaintenanceWindow="sun:16:00-mon:15:00",
             PreferredBackupWindow="00:00-00:30",
@@ -908,20 +645,10 @@ def test_modify_db_instance_maintenance_backup_window_maintenance_spill():
 
 
 @mock_aws
-def test_modify_db_instance_maintenance_backup_window_backup_spill():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_modify_db_instance_maintenance_backup_window_backup_spill(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
     with pytest.raises(ClientError) as ex:
-        conn.modify_db_instance(
+        client.modify_db_instance(
             DBInstanceIdentifier="db-master-1",
             PreferredMaintenanceWindow="mon:00:00-mon:15:00",
             PreferredBackupWindow="23:50-00:20",
@@ -934,20 +661,10 @@ def test_modify_db_instance_maintenance_backup_window_backup_spill():
 
 
 @mock_aws
-def test_modify_db_instance_maintenance_backup_window_both_spill():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_modify_db_instance_maintenance_backup_window_both_spill(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
     with pytest.raises(ClientError) as ex:
-        conn.modify_db_instance(
+        client.modify_db_instance(
             DBInstanceIdentifier="db-master-1",
             PreferredMaintenanceWindow="sun:16:00-mon:15:00",
             PreferredBackupWindow="23:20-00:20",
@@ -960,159 +677,109 @@ def test_modify_db_instance_maintenance_backup_window_both_spill():
 
 
 @mock_aws
-def test_rename_db_instance():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    instances = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
-    assert len(list(instances["DBInstances"])) == 1
+def test_rename_db_instance(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
+    instances = client.describe_db_instances(DBInstanceIdentifier="db-master-1")
+    assert len(instances["DBInstances"]) == 1
     with pytest.raises(ClientError):
-        conn.describe_db_instances(DBInstanceIdentifier="db-master-2")
-    conn.modify_db_instance(
+        client.describe_db_instances(DBInstanceIdentifier="db-master-2")
+    client.modify_db_instance(
         DBInstanceIdentifier="db-master-1",
         NewDBInstanceIdentifier="db-master-2",
         ApplyImmediately=True,
     )
     with pytest.raises(ClientError):
-        conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
-    instances = conn.describe_db_instances(DBInstanceIdentifier="db-master-2")
-    assert len(list(instances["DBInstances"])) == 1
+        client.describe_db_instances(DBInstanceIdentifier="db-master-1")
+    instances = client.describe_db_instances(DBInstanceIdentifier="db-master-2")
+    assert len(instances["DBInstances"]) == 1
 
 
 @mock_aws
-def test_modify_non_existent_database():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_modify_non_existent_database(client):
     with pytest.raises(ClientError):
-        conn.modify_db_instance(
+        client.modify_db_instance(
             DBInstanceIdentifier="not-a-db", AllocatedStorage=20, ApplyImmediately=True
         )
 
 
 @mock_aws
-def test_reboot_db_instance():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    database = conn.reboot_db_instance(DBInstanceIdentifier="db-master-1")
+def test_reboot_db_instance(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
+    database = client.reboot_db_instance(DBInstanceIdentifier="db-master-1")
     assert database["DBInstance"]["DBInstanceIdentifier"] == "db-master-1"
 
 
 @mock_aws
-def test_reboot_non_existent_database():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_reboot_non_existent_database(client):
     with pytest.raises(ClientError):
-        conn.reboot_db_instance(DBInstanceIdentifier="not-a-db")
+        client.reboot_db_instance(DBInstanceIdentifier="not-a-db")
 
 
 @mock_aws
-def test_delete_database():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    instances = conn.describe_db_instances()
-    assert len(list(instances["DBInstances"])) == 0
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    instances = conn.describe_db_instances()
-    assert len(list(instances["DBInstances"])) == 1
+def test_delete_database(client):
+    instances = client.describe_db_instances()
+    assert len(instances["DBInstances"]) == 0
+    create_db_instance(DBInstanceIdentifier="db-1")
+    instances = client.describe_db_instances()
+    assert len(instances["DBInstances"]) == 1
 
-    conn.delete_db_instance(
+    client.delete_db_instance(
         DBInstanceIdentifier="db-1",
         FinalDBSnapshotIdentifier="primary-1-snapshot",
     )
 
-    instances = conn.describe_db_instances()
-    assert len(list(instances["DBInstances"])) == 0
+    instances = client.describe_db_instances()
+    assert len(instances["DBInstances"]) == 0
 
     # Saved the snapshot
-    snapshot = conn.describe_db_snapshots(DBInstanceIdentifier="db-1")["DBSnapshots"][0]
+    snapshot = client.describe_db_snapshots(DBInstanceIdentifier="db-1")["DBSnapshots"][
+        0
+    ]
     assert snapshot["Engine"] == "postgres"
     assert snapshot["SnapshotType"] == "automated"
 
 
 @mock_aws
-def test_create_db_snapshots():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_create_db_snapshots(client):
     with pytest.raises(ClientError):
-        conn.create_db_snapshot(
+        client.create_db_snapshot(
             DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-1"
         )
 
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
 
-    snapshot = conn.create_db_snapshot(
+    snapshot = client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="g-1"
-    ).get("DBSnapshot")
+    )["DBSnapshot"]
 
-    assert snapshot.get("Engine") == "postgres"
-    assert snapshot.get("DBInstanceIdentifier") == "db-primary-1"
-    assert snapshot.get("DBSnapshotIdentifier") == "g-1"
-    result = conn.list_tags_for_resource(ResourceName=snapshot["DBSnapshotArn"])
+    assert snapshot["Engine"] == "postgres"
+    assert snapshot["DBInstanceIdentifier"] == "db-primary-1"
+    assert snapshot["DBSnapshotIdentifier"] == "g-1"
+    result = client.list_tags_for_resource(ResourceName=snapshot["DBSnapshotArn"])
     assert result["TagList"] == []
 
 
 @mock_aws
-def test_create_db_snapshots_copy_tags():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_create_db_snapshots_copy_tags(client):
     with pytest.raises(ClientError):
-        conn.create_db_snapshot(
+        client.create_db_snapshot(
             DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-1"
         )
 
-    conn.create_db_instance(
+    create_db_instance(
         DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
         CopyTagsToSnapshot=True,
         Tags=[{"Key": "foo", "Value": "bar"}, {"Key": "foo1", "Value": "bar1"}],
     )
 
-    snapshot = conn.create_db_snapshot(
+    snapshot = client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="g-1"
-    ).get("DBSnapshot")
+    )["DBSnapshot"]
 
-    assert snapshot.get("Engine") == "postgres"
-    assert snapshot.get("DBInstanceIdentifier") == "db-primary-1"
-    assert snapshot.get("DBSnapshotIdentifier") == "g-1"
-    result = conn.list_tags_for_resource(ResourceName=snapshot["DBSnapshotArn"])
+    assert snapshot["Engine"] == "postgres"
+    assert snapshot["DBInstanceIdentifier"] == "db-primary-1"
+    assert snapshot["DBSnapshotIdentifier"] == "g-1"
+    result = client.list_tags_for_resource(ResourceName=snapshot["DBSnapshotArn"])
     assert result["TagList"] == [
         {"Value": "bar", "Key": "foo"},
         {"Value": "bar1", "Key": "foo1"},
@@ -1120,31 +787,20 @@ def test_create_db_snapshots_copy_tags():
 
 
 @mock_aws
-def test_create_db_snapshots_with_tags():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_create_db_snapshots_with_tags(client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
 
-    conn.create_db_snapshot(
+    client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1",
         DBSnapshotIdentifier="g-1",
         Tags=[{"Key": "foo", "Value": "bar"}, {"Key": "foo1", "Value": "bar1"}],
     )
 
-    snapshots = conn.describe_db_snapshots(DBInstanceIdentifier="db-primary-1").get(
+    snapshots = client.describe_db_snapshots(DBInstanceIdentifier="db-primary-1")[
         "DBSnapshots"
-    )
-    assert snapshots[0].get("DBSnapshotIdentifier") == "g-1"
-    assert snapshots[0].get("TagList") == [
+    ]
+    assert snapshots[0]["DBSnapshotIdentifier"] == "g-1"
+    assert snapshots[0]["TagList"] == [
         {"Value": "bar", "Key": "foo"},
         {"Value": "bar1", "Key": "foo1"},
     ]
@@ -1157,50 +813,40 @@ def test_create_db_snapshots_with_tags():
     ids=("by_name", "by_arn"),
 )
 @mock_aws
-def test_copy_db_snapshots(delete_db_instance: bool, db_snapshot_identifier: str):
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_copy_db_snapshots(
+    delete_db_instance: bool, db_snapshot_identifier: str, client
+):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
 
-    conn.create_db_snapshot(
+    client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-1"
-    ).get("DBSnapshot")
+    )
 
     if delete_db_instance:
         # Delete the original instance, but the copy snapshot operation should still succeed.
-        conn.delete_db_instance(DBInstanceIdentifier="db-primary-1")
+        client.delete_db_instance(DBInstanceIdentifier="db-primary-1")
 
-    target_snapshot = conn.copy_db_snapshot(
+    target_snapshot = client.copy_db_snapshot(
         SourceDBSnapshotIdentifier=db_snapshot_identifier,
         TargetDBSnapshotIdentifier="snapshot-2",
-    ).get("DBSnapshot")
+    )["DBSnapshot"]
 
-    assert target_snapshot.get("Engine") == "postgres"
-    assert target_snapshot.get("DBInstanceIdentifier") == "db-primary-1"
-    assert target_snapshot.get("DBSnapshotIdentifier") == "snapshot-2"
-    result = conn.list_tags_for_resource(ResourceName=target_snapshot["DBSnapshotArn"])
+    assert target_snapshot["Engine"] == "postgres"
+    assert target_snapshot["DBInstanceIdentifier"] == "db-primary-1"
+    assert target_snapshot["DBSnapshotIdentifier"] == "snapshot-2"
+    result = client.list_tags_for_resource(
+        ResourceName=target_snapshot["DBSnapshotArn"]
+    )
     assert result["TagList"] == []
 
 
 @mock_aws
-def test_copy_db_snapshot_invalid_arns():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
+def test_copy_db_snapshot_invalid_arns(client):
     invalid_arn = (
         f"arn:aws:rds:{DEFAULT_REGION}:123456789012:this-is-not-a-snapshot:snapshot-1"
     )
     with pytest.raises(ClientError) as ex:
-        conn.copy_db_snapshot(
+        client.copy_db_snapshot(
             SourceDBSnapshotIdentifier=invalid_arn,
             TargetDBSnapshotIdentifier="snapshot-2",
         )
@@ -1234,122 +880,80 @@ new_snapshot_tags = [{"Key": "new", "Value": "tag"}]
     ),
 )
 @mock_aws
-def test_copy_db_snapshots_copytags_and_tags(kwargs, expected_tags):
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        Engine="postgres",
-        DBInstanceClass="db.m1.small",
-    )
-    conn.create_db_snapshot(
+def test_copy_db_snapshots_copytags_and_tags(kwargs, expected_tags, client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
+    client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1",
         DBSnapshotIdentifier="snapshot",
         Tags=original_snapshot_tags,
     )
 
-    target_snapshot = conn.copy_db_snapshot(
+    target_snapshot = client.copy_db_snapshot(
         SourceDBSnapshotIdentifier="snapshot",
         TargetDBSnapshotIdentifier="snapshot-copy",
         **kwargs,
-    ).get("DBSnapshot")
-    result = conn.list_tags_for_resource(ResourceName=target_snapshot["DBSnapshotArn"])
+    )["DBSnapshot"]
+    result = client.list_tags_for_resource(
+        ResourceName=target_snapshot["DBSnapshotArn"]
+    )
     assert result["TagList"] == expected_tags
 
 
 @mock_aws
-def test_describe_db_snapshots():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_describe_db_snapshots(client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
 
-    created = conn.create_db_snapshot(
+    created = client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-1"
-    ).get("DBSnapshot")
+    )["DBSnapshot"]
 
     assert created["Engine"] == "postgres"
     assert created["SnapshotType"] == "manual"
 
-    by_database_id = conn.describe_db_snapshots(
-        DBInstanceIdentifier="db-primary-1"
-    ).get("DBSnapshots")
-    by_snapshot_id = conn.describe_db_snapshots(DBSnapshotIdentifier="snapshot-1").get(
-        "DBSnapshots"
-    )
-    assert by_snapshot_id == by_database_id
+    by_database_id = client.describe_db_snapshots(DBInstanceIdentifier="db-primary-1")
+    by_snapshot_id = client.describe_db_snapshots(DBSnapshotIdentifier="snapshot-1")
+    assert by_snapshot_id["DBSnapshots"] == by_database_id["DBSnapshots"]
 
-    snapshot = by_snapshot_id[0]
+    snapshot = by_snapshot_id["DBSnapshots"][0]
     assert snapshot == created
 
-    conn.create_db_snapshot(
+    client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-2"
     )
-    snapshots = conn.describe_db_snapshots(DBInstanceIdentifier="db-primary-1").get(
+    snapshots = client.describe_db_snapshots(DBInstanceIdentifier="db-primary-1")[
         "DBSnapshots"
-    )
-    assert len(snapshots) == 2
-
-
-@mock_aws
-def test_promote_read_replica():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+    ]
+    assert len(snapshots) == 2
+
+
+@mock_aws
+def test_promote_read_replica(client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
 
-    conn.create_db_instance_read_replica(
+    client.create_db_instance_read_replica(
         DBInstanceIdentifier="db-replica-1",
         SourceDBInstanceIdentifier="db-primary-1",
         DBInstanceClass="db.m1.small",
     )
-    conn.promote_read_replica(DBInstanceIdentifier="db-replica-1")
+    client.promote_read_replica(DBInstanceIdentifier="db-replica-1")
 
-    replicas = conn.describe_db_instances(DBInstanceIdentifier="db-primary-1").get(
+    replicas = client.describe_db_instances(DBInstanceIdentifier="db-primary-1").get(
         "ReadReplicaDBInstanceIdentifiers"
     )
     assert replicas is None
 
 
 @mock_aws
-def test_delete_db_snapshot():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    conn.create_db_snapshot(
+def test_delete_db_snapshot(client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
+    client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-1"
     )
 
-    _ = conn.describe_db_snapshots(DBSnapshotIdentifier="snapshot-1").get(
-        "DBSnapshots"
-    )[0]
-    conn.delete_db_snapshot(DBSnapshotIdentifier="snapshot-1")
+    client.describe_db_snapshots(DBSnapshotIdentifier="snapshot-1")["DBSnapshots"][0]
+    client.delete_db_snapshot(DBSnapshotIdentifier="snapshot-1")
     with pytest.raises(ClientError):
-        conn.describe_db_snapshots(DBSnapshotIdentifier="snapshot-1")
+        client.describe_db_snapshots(DBSnapshotIdentifier="snapshot-1")
 
 
 @pytest.mark.parametrize(
@@ -1362,22 +966,18 @@ def test_delete_db_snapshot():
 )
 @mock_aws
 def test_restore_db_instance_from_db_snapshot(
-    db_snapshot_identifier: str, custom_db_subnet_group: bool
+    db_snapshot_identifier: str, custom_db_subnet_group: bool, client
 ):
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
+    create_db_instance(
         DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
         Engine="postgres",
         DBName="staging-postgres",
         DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
         DBSecurityGroups=["my_sg"],
     )
-    assert len(conn.describe_db_instances()["DBInstances"]) == 1
+    assert len(client.describe_db_instances()["DBInstances"]) == 1
 
-    conn.create_db_snapshot(
+    client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-1"
     )
 
@@ -1385,7 +985,7 @@ def test_restore_db_instance_from_db_snapshot(
         db_subnet_group_name = create_db_subnet_group()
 
     # restore
-    new_instance = conn.restore_db_instance_from_db_snapshot(
+    new_instance = client.restore_db_instance_from_db_snapshot(
         DBInstanceIdentifier="db-restore-1", DBSnapshotIdentifier=db_snapshot_identifier
     )["DBInstance"]
     kwargs = {
@@ -1394,7 +994,7 @@ def test_restore_db_instance_from_db_snapshot(
     }
     if custom_db_subnet_group:
         kwargs["DBSubnetGroupName"] = db_subnet_group_name
-    new_instance = conn.restore_db_instance_from_db_snapshot(**kwargs)["DBInstance"]
+    new_instance = client.restore_db_instance_from_db_snapshot(**kwargs)["DBInstance"]
     if custom_db_subnet_group:
         assert (
             new_instance["DBSubnetGroup"]["DBSubnetGroupName"] == db_subnet_group_name
@@ -1413,10 +1013,10 @@ def test_restore_db_instance_from_db_snapshot(
     assert new_instance["Endpoint"]["Port"] == 5432
 
     # Verify it exists
-    assert len(conn.describe_db_instances()["DBInstances"]) == 2
+    assert len(client.describe_db_instances()["DBInstances"]) == 2
     assert (
         len(
-            conn.describe_db_instances(DBInstanceIdentifier="db-restore-1")[
+            client.describe_db_instances(DBInstanceIdentifier="db-restore-1")[
                 "DBInstances"
             ]
         )
@@ -1428,29 +1028,24 @@ def test_restore_db_instance_from_db_snapshot(
     "custom_db_subnet_group", [True, False], ids=("custom_subnet", "default_subnet")
 )
 @mock_aws
-def test_restore_db_instance_to_point_in_time(custom_db_subnet_group: bool):
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
+def test_restore_db_instance_to_point_in_time(custom_db_subnet_group: bool, client):
     if custom_db_subnet_group:
         extra_kwargs = {"DBSubnetGroupName": create_db_subnet_group()}
     else:
         extra_kwargs = {}
 
-    conn.create_db_instance(
+    create_db_instance(
         DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
         Engine="postgres",
         DBName="staging-postgres",
         DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
         DBSecurityGroups=["my_sg"],
         **extra_kwargs,
     )
-    assert len(conn.describe_db_instances()["DBInstances"]) == 1
+    assert len(client.describe_db_instances()["DBInstances"]) == 1
 
     # restore
-    new_instance = conn.restore_db_instance_to_point_in_time(
+    new_instance = client.restore_db_instance_to_point_in_time(
         SourceDBInstanceIdentifier="db-primary-1",
         TargetDBInstanceIdentifier="db-restore-1",
     )["DBInstance"]
@@ -1468,17 +1063,17 @@ def test_restore_db_instance_to_point_in_time(custom_db_subnet_group: bool):
     assert new_instance["Endpoint"]["Port"] == 5432
 
     # Verify it exists
-    assert len(conn.describe_db_instances()["DBInstances"]) == 2
+    assert len(client.describe_db_instances()["DBInstances"]) == 2
     assert (
         len(
-            conn.describe_db_instances(DBInstanceIdentifier="db-restore-1")[
+            client.describe_db_instances(DBInstanceIdentifier="db-restore-1")[
                 "DBInstances"
             ]
         )
         == 1
     )
     # ensure another pit restore can be made
-    new_instance = conn.restore_db_instance_to_point_in_time(
+    new_instance = client.restore_db_instance_to_point_in_time(
         SourceDBInstanceIdentifier="db-primary-1",
         TargetDBInstanceIdentifier="db-restore-2",
     )["DBInstance"]
@@ -1496,10 +1091,10 @@ def test_restore_db_instance_to_point_in_time(custom_db_subnet_group: bool):
     assert new_instance["Endpoint"]["Port"] == 5432
 
     # Verify it exists
-    assert len(conn.describe_db_instances()["DBInstances"]) == 3
+    assert len(client.describe_db_instances()["DBInstances"]) == 3
     assert (
         len(
-            conn.describe_db_instances(DBInstanceIdentifier="db-restore-2")[
+            client.describe_db_instances(DBInstanceIdentifier="db-restore-2")[
                 "DBInstances"
             ]
         )
@@ -1508,26 +1103,22 @@ def test_restore_db_instance_to_point_in_time(custom_db_subnet_group: bool):
 
 
 @mock_aws
-def test_restore_db_instance_from_db_snapshot_and_override_params():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
+def test_restore_db_instance_from_db_snapshot_and_override_params(client):
+    create_db_instance(
         DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
         Engine="postgres",
         DBName="staging-postgres",
         DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
         Port=1234,
         DBSecurityGroups=["my_sg"],
     )
-    assert len(conn.describe_db_instances()["DBInstances"]) == 1
-    conn.create_db_snapshot(
+    assert len(client.describe_db_instances()["DBInstances"]) == 1
+    client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-1"
     )
 
     # restore with some updated attributes
-    new_instance = conn.restore_db_instance_from_db_snapshot(
+    new_instance = client.restore_db_instance_from_db_snapshot(
         DBInstanceIdentifier="db-restore-1",
         DBSnapshotIdentifier="snapshot-1",
         Port=10000,
@@ -1547,30 +1138,26 @@ def test_restore_db_instance_from_db_snapshot_and_override_params():
 
 
 @mock_aws
-def test_create_option_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    option_group = conn.create_option_group(
+def test_create_option_group(client):
+    option_group = client.create_option_group(
         OptionGroupName="test",
         EngineName="mysql",
         MajorEngineVersion="5.6",
         OptionGroupDescription="test option group",
-    )
-    assert option_group["OptionGroup"]["OptionGroupName"] == "test"
-    assert option_group["OptionGroup"]["EngineName"] == "mysql"
-    assert option_group["OptionGroup"]["OptionGroupDescription"] == (
-        "test option group"
-    )
-    assert option_group["OptionGroup"]["MajorEngineVersion"] == "5.6"
-    assert option_group["OptionGroup"]["OptionGroupArn"] == (
-        f"arn:aws:rds:us-west-2:{ACCOUNT_ID}:og:test"
+    )["OptionGroup"]
+    assert option_group["OptionGroupName"] == "test"
+    assert option_group["EngineName"] == "mysql"
+    assert option_group["OptionGroupDescription"] == "test option group"
+    assert option_group["MajorEngineVersion"] == "5.6"
+    assert (
+        option_group["OptionGroupArn"] == f"arn:aws:rds:us-west-2:{ACCOUNT_ID}:og:test"
     )
 
 
 @mock_aws
-def test_create_option_group_bad_engine_name():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_create_option_group_bad_engine_name(client):
     with pytest.raises(ClientError):
-        conn.create_option_group(
+        client.create_option_group(
             OptionGroupName="test",
             EngineName="invalid_engine",
             MajorEngineVersion="5.6",
@@ -1579,10 +1166,9 @@ def test_create_option_group_bad_engine_name():
 
 
 @mock_aws
-def test_create_option_group_bad_engine_major_version():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_create_option_group_bad_engine_major_version(client):
     with pytest.raises(ClientError):
-        conn.create_option_group(
+        client.create_option_group(
             OptionGroupName="test",
             EngineName="mysql",
             MajorEngineVersion="6.6.6",
@@ -1591,10 +1177,9 @@ def test_create_option_group_bad_engine_major_version():
 
 
 @mock_aws
-def test_create_option_group_empty_description():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_create_option_group_empty_description(client):
     with pytest.raises(ClientError):
-        conn.create_option_group(
+        client.create_option_group(
             OptionGroupName="test",
             EngineName="mysql",
             MajorEngineVersion="5.6",
@@ -1603,16 +1188,15 @@ def test_create_option_group_empty_description():
 
 
 @mock_aws
-def test_create_option_group_duplicate():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_option_group(
+def test_create_option_group_duplicate(client):
+    client.create_option_group(
         OptionGroupName="test",
         EngineName="mysql",
         MajorEngineVersion="5.6",
         OptionGroupDescription="test option group",
     )
     with pytest.raises(ClientError):
-        conn.create_option_group(
+        client.create_option_group(
             OptionGroupName="test",
             EngineName="mysql",
             MajorEngineVersion="5.6",
@@ -1621,75 +1205,71 @@ def test_create_option_group_duplicate():
 
 
 @mock_aws
-def test_describe_option_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_option_group(
+def test_describe_option_group(client):
+    client.create_option_group(
         OptionGroupName="test",
         EngineName="mysql",
         MajorEngineVersion="5.6",
         OptionGroupDescription="test option group",
     )
-    option_groups = conn.describe_option_groups(OptionGroupName="test")
+    option_groups = client.describe_option_groups(OptionGroupName="test")
     assert option_groups["OptionGroupsList"][0]["OptionGroupName"] == "test"
 
 
 @mock_aws
-def test_describe_non_existent_option_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_describe_non_existent_option_group(client):
     with pytest.raises(ClientError):
-        conn.describe_option_groups(OptionGroupName="not-a-option-group")
+        client.describe_option_groups(OptionGroupName="not-a-option-group")
 
 
 @mock_aws
-def test_delete_option_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_option_group(
+def test_delete_option_group(client):
+    client.create_option_group(
         OptionGroupName="test",
         EngineName="mysql",
         MajorEngineVersion="5.6",
         OptionGroupDescription="test option group",
     )
-    option_groups = conn.describe_option_groups(OptionGroupName="test")
+    option_groups = client.describe_option_groups(OptionGroupName="test")
     assert option_groups["OptionGroupsList"][0]["OptionGroupName"] == "test"
-    conn.delete_option_group(OptionGroupName="test")
+    client.delete_option_group(OptionGroupName="test")
     with pytest.raises(ClientError):
-        conn.describe_option_groups(OptionGroupName="test")
+        client.describe_option_groups(OptionGroupName="test")
 
 
 @mock_aws
-def test_delete_non_existent_option_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_delete_non_existent_option_group(client):
     with pytest.raises(ClientError):
-        conn.delete_option_group(OptionGroupName="non-existent")
+        client.delete_option_group(OptionGroupName="non-existent")
 
 
 @mock_aws
-def test_describe_option_group_options():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    option_group_options = conn.describe_option_group_options(EngineName="sqlserver-ee")
+def test_describe_option_group_options(client):
+    option_group_options = client.describe_option_group_options(
+        EngineName="sqlserver-ee"
+    )
     assert len(option_group_options["OptionGroupOptions"]) == 4
-    option_group_options = conn.describe_option_group_options(
+    option_group_options = client.describe_option_group_options(
         EngineName="sqlserver-ee", MajorEngineVersion="11.00"
     )
     assert len(option_group_options["OptionGroupOptions"]) == 2
-    option_group_options = conn.describe_option_group_options(
+    option_group_options = client.describe_option_group_options(
         EngineName="mysql", MajorEngineVersion="5.6"
     )
     assert len(option_group_options["OptionGroupOptions"]) == 1
     with pytest.raises(ClientError):
-        conn.describe_option_group_options(EngineName="non-existent")
+        client.describe_option_group_options(EngineName="non-existent")
     with pytest.raises(ClientError):
-        conn.describe_option_group_options(
+        client.describe_option_group_options(
             EngineName="mysql", MajorEngineVersion="non-existent"
         )
 
 
 @pytest.mark.aws_verified
 @aws_verified
-def test_modify_option_group():
-    conn = boto3.client("rds", region_name="us-east-1")
+def test_modify_option_group(client):
     option_group_name = f"og-{str(uuid4())[0:6]}"
-    conn.create_option_group(
+    client.create_option_group(
         OptionGroupName=option_group_name,
         EngineName="mysql",
         MajorEngineVersion="5.6",
@@ -1698,7 +1278,7 @@ def test_modify_option_group():
 
     try:
         # Verify OptionsToRemove do not have to exist
-        option_group = conn.modify_option_group(
+        option_group = client.modify_option_group(
             OptionGroupName=option_group_name,
             OptionsToInclude=[],
             OptionsToRemove=["MEMCACHED"],
@@ -1708,14 +1288,14 @@ def test_modify_option_group():
         assert option_group["Options"] == []
         assert option_group["OptionGroupName"] == option_group_name
 
-        option_groups = conn.describe_option_groups(OptionGroupName=option_group_name)[
-            "OptionGroupsList"
-        ]
+        option_groups = client.describe_option_groups(
+            OptionGroupName=option_group_name
+        )["OptionGroupsList"]
         assert option_groups[0]["Options"] == []
 
         # Include option
         # https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.MySQL.Options.AuditPlugin.html
-        conn.modify_option_group(
+        client.modify_option_group(
             OptionGroupName=option_group_name,
             OptionsToInclude=[{"OptionName": "MARIADB_AUDIT_PLUGIN"}],
             OptionsToRemove=[],
@@ -1723,9 +1303,9 @@ def test_modify_option_group():
         )["OptionGroup"]
 
         # Verify it was added successfully
-        option_groups = conn.describe_option_groups(OptionGroupName=option_group_name)[
-            "OptionGroupsList"
-        ]
+        option_groups = client.describe_option_groups(
+            OptionGroupName=option_group_name
+        )["OptionGroupsList"]
 
         options = option_groups[0]["Options"]
         assert len(options) == 1
@@ -1733,7 +1313,7 @@ def test_modify_option_group():
         # AWS automatically adds a description + default option settings, but Moto does not support that yet
 
         # Change setting for an existing option
-        conn.modify_option_group(
+        client.modify_option_group(
             OptionGroupName=option_group_name,
             OptionsToInclude=[
                 {
@@ -1747,9 +1327,9 @@ def test_modify_option_group():
         )["OptionGroup"]
 
         # Verify it was added successfully
-        option_groups = conn.describe_option_groups(OptionGroupName=option_group_name)[
-            "OptionGroupsList"
-        ]
+        option_groups = client.describe_option_groups(
+            OptionGroupName=option_group_name
+        )["OptionGroupsList"]
 
         options = option_groups[0]["Options"]
         assert len(options) == 1
@@ -1763,37 +1343,35 @@ def test_modify_option_group():
         audit_plugin["Value"] == "1000"
 
         # Verify option can be deleted
-        conn.modify_option_group(
+        client.modify_option_group(
             OptionGroupName=option_group_name,
             OptionsToRemove=["MARIADB_AUDIT_PLUGIN"],
             ApplyImmediately=True,
         )
-        option_groups = conn.describe_option_groups(OptionGroupName=option_group_name)[
-            "OptionGroupsList"
-        ]
+        option_groups = client.describe_option_groups(
+            OptionGroupName=option_group_name
+        )["OptionGroupsList"]
         assert option_groups[0]["Options"] == []
     finally:
-        conn.delete_option_group(OptionGroupName=option_group_name)
+        client.delete_option_group(OptionGroupName=option_group_name)
 
 
 @mock_aws
-def test_modify_option_group_no_options():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_option_group(
+def test_modify_option_group_no_options(client):
+    client.create_option_group(
         OptionGroupName="test",
         EngineName="mysql",
         MajorEngineVersion="5.6",
         OptionGroupDescription="test option group",
     )
     with pytest.raises(ClientError):
-        conn.modify_option_group(OptionGroupName="test")
+        client.modify_option_group(OptionGroupName="test")
 
 
 @mock_aws
-def test_modify_non_existent_option_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_modify_non_existent_option_group(client):
     with pytest.raises(ClientError) as client_err:
-        conn.modify_option_group(
+        client.modify_option_group(
             OptionGroupName="non-existent",
             OptionsToInclude=[{"OptionName": "test-option"}],
         )
@@ -1803,59 +1381,39 @@ def test_modify_non_existent_option_group():
 
 
 @mock_aws
-def test_delete_database_with_protection():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBInstanceClass="db.m1.small",
-        DeletionProtection=True,
-    )
+def test_delete_database_with_protection(client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1", DeletionProtection=True)
 
     with pytest.raises(ClientError) as exc:
-        conn.delete_db_instance(DBInstanceIdentifier="db-primary-1")
+        client.delete_db_instance(DBInstanceIdentifier="db-primary-1")
     err = exc.value.response["Error"]
     assert err["Message"] == "Can't delete Instance with protection enabled"
 
 
 @mock_aws
-def test_delete_non_existent_database():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_delete_non_existent_database(client):
     with pytest.raises(ClientError) as ex:
-        conn.delete_db_instance(DBInstanceIdentifier="non-existent")
+        client.delete_db_instance(DBInstanceIdentifier="non-existent")
     assert ex.value.response["Error"]["Code"] == "DBInstanceNotFound"
     assert ex.value.response["Error"]["Message"] == "DBInstance non-existent not found."
 
 
 @mock_aws
-def test_list_tags_invalid_arn():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_list_tags_invalid_arn(client):
     with pytest.raises(ClientError):
-        conn.list_tags_for_resource(ResourceName="arn:aws:rds:bad-arn")
+        client.list_tags_for_resource(ResourceName="arn:aws:rds:bad-arn")
 
 
 @mock_aws
-def test_list_tags_db():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    result = conn.list_tags_for_resource(
+def test_list_tags_db(client):
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:db:foo"
     )
     assert result["TagList"] == []
-    test_instance = conn.create_db_instance(
-        DBInstanceIdentifier="db-with-tags",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
+    test_instance = create_db_instance(
         Tags=[{"Key": "foo", "Value": "bar"}, {"Key": "foo1", "Value": "bar1"}],
     )
-    result = conn.list_tags_for_resource(
-        ResourceName=test_instance["DBInstance"]["DBInstanceArn"]
-    )
+    result = client.list_tags_for_resource(ResourceName=test_instance["DBInstanceArn"])
     assert result["TagList"] == [
         {"Value": "bar", "Key": "foo"},
         {"Value": "bar1", "Key": "foo1"},
@@ -1863,84 +1421,57 @@ def test_list_tags_db():
 
 
 @mock_aws
-def test_add_tags_db():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
+def test_add_tags_db(client):
+    create_db_instance(
         DBInstanceIdentifier="db-without-tags",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
         Tags=[{"Key": "foo", "Value": "bar"}, {"Key": "foo1", "Value": "bar1"}],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:db:db-without-tags"
     )
-    assert len(list(result["TagList"])) == 2
-    conn.add_tags_to_resource(
+    assert len(result["TagList"]) == 2
+    client.add_tags_to_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:db:db-without-tags",
         Tags=[{"Key": "foo", "Value": "fish"}, {"Key": "foo2", "Value": "bar2"}],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:db:db-without-tags"
     )
-    assert len(list(result["TagList"])) == 3
+    assert len(result["TagList"]) == 3
 
 
 @mock_aws
-def test_remove_tags_db():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
+def test_remove_tags_db(client):
+    create_db_instance(
         DBInstanceIdentifier="db-with-tags",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
         Tags=[{"Key": "foo", "Value": "bar"}, {"Key": "foo1", "Value": "bar1"}],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:db:db-with-tags"
     )
-    assert len(list(result["TagList"])) == 2
-    conn.remove_tags_from_resource(
+    assert len(result["TagList"]) == 2
+    client.remove_tags_from_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:db:db-with-tags", TagKeys=["foo"]
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:db:db-with-tags"
     )
     assert len(result["TagList"]) == 1
 
 
 @mock_aws
-def test_list_tags_snapshot():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    result = conn.list_tags_for_resource(
+def test_list_tags_snapshot(client):
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:snapshot:foo"
     )
     assert result["TagList"] == []
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    snapshot = conn.create_db_snapshot(
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
+    snapshot = client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1",
         DBSnapshotIdentifier="snapshot-with-tags",
         Tags=[{"Key": "foo", "Value": "bar"}, {"Key": "foo1", "Value": "bar1"}],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName=snapshot["DBSnapshot"]["DBSnapshotArn"]
     )
     assert result["TagList"] == [
@@ -1950,128 +1481,102 @@ def test_list_tags_snapshot():
 
 
 @mock_aws
-def test_add_tags_snapshot():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    conn.create_db_snapshot(
+def test_add_tags_snapshot(client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
+    client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1",
         DBSnapshotIdentifier="snapshot-without-tags",
         Tags=[{"Key": "foo", "Value": "bar"}, {"Key": "foo1", "Value": "bar1"}],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:snapshot:snapshot-without-tags"
     )
-    assert len(list(result["TagList"])) == 2
-    conn.add_tags_to_resource(
+    assert len(result["TagList"]) == 2
+    client.add_tags_to_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:snapshot:snapshot-without-tags",
         Tags=[{"Key": "foo", "Value": "fish"}, {"Key": "foo2", "Value": "bar2"}],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:snapshot:snapshot-without-tags"
     )
-    assert len(list(result["TagList"])) == 3
+    assert len(result["TagList"]) == 3
 
 
 @mock_aws
-def test_remove_tags_snapshot():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-    conn.create_db_snapshot(
+def test_remove_tags_snapshot(client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
+    client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1",
         DBSnapshotIdentifier="snapshot-with-tags",
         Tags=[{"Key": "foo", "Value": "bar"}, {"Key": "foo1", "Value": "bar1"}],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:snapshot:snapshot-with-tags"
     )
-    assert len(list(result["TagList"])) == 2
-    conn.remove_tags_from_resource(
+    assert len(result["TagList"]) == 2
+    client.remove_tags_from_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:snapshot:snapshot-with-tags",
         TagKeys=["foo"],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:snapshot:snapshot-with-tags"
     )
     assert len(result["TagList"]) == 1
 
 
 @mock_aws
-def test_add_tags_option_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_option_group(
+def test_add_tags_option_group(client):
+    client.create_option_group(
         OptionGroupName="test",
         EngineName="mysql",
         MajorEngineVersion="5.6",
         OptionGroupDescription="test option group",
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:og:test"
     )
-    assert len(list(result["TagList"])) == 0
-    conn.add_tags_to_resource(
+    assert len(result["TagList"]) == 0
+    client.add_tags_to_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:og:test",
         Tags=[{"Key": "foo", "Value": "fish"}, {"Key": "foo2", "Value": "bar2"}],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:og:test"
     )
-    assert len(list(result["TagList"])) == 2
+    assert len(result["TagList"]) == 2
 
 
 @mock_aws
-def test_remove_tags_option_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_option_group(
+def test_remove_tags_option_group(client):
+    client.create_option_group(
         OptionGroupName="test",
         EngineName="mysql",
         MajorEngineVersion="5.6",
         OptionGroupDescription="test option group",
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:og:test"
     )
-    conn.add_tags_to_resource(
+    client.add_tags_to_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:og:test",
         Tags=[{"Key": "foo", "Value": "fish"}, {"Key": "foo2", "Value": "bar2"}],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:og:test"
     )
-    assert len(list(result["TagList"])) == 2
-    conn.remove_tags_from_resource(
+    assert len(result["TagList"]) == 2
+    client.remove_tags_from_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:og:test", TagKeys=["foo"]
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:og:test"
     )
-    assert len(list(result["TagList"])) == 1
+    assert len(result["TagList"]) == 1
 
 
 @mock_aws
-def test_create_database_security_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
-    result = conn.create_db_security_group(
+def test_create_database_security_group(client):
+    result = client.create_db_security_group(
         DBSecurityGroupName="db_sg", DBSecurityGroupDescription="DB Security Group"
     )
     assert result["DBSecurityGroup"]["DBSecurityGroupName"] == "db_sg"
@@ -2082,78 +1587,72 @@ def test_create_database_security_group():
 
 
 @mock_aws
-def test_get_security_groups():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
-    result = conn.describe_db_security_groups()
+def test_get_security_groups(client):
+    result = client.describe_db_security_groups()
     assert len(result["DBSecurityGroups"]) == 0
 
-    conn.create_db_security_group(
+    client.create_db_security_group(
         DBSecurityGroupName="db_sg1", DBSecurityGroupDescription="DB Security Group"
     )
-    conn.create_db_security_group(
+    client.create_db_security_group(
         DBSecurityGroupName="db_sg2", DBSecurityGroupDescription="DB Security Group"
     )
 
-    result = conn.describe_db_security_groups()
+    result = client.describe_db_security_groups()
     assert len(result["DBSecurityGroups"]) == 2
 
-    result = conn.describe_db_security_groups(DBSecurityGroupName="db_sg1")
+    result = client.describe_db_security_groups(DBSecurityGroupName="db_sg1")
     assert len(result["DBSecurityGroups"]) == 1
     assert result["DBSecurityGroups"][0]["DBSecurityGroupName"] == "db_sg1"
 
 
 @mock_aws
-def test_get_non_existent_security_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_get_non_existent_security_group(client):
     with pytest.raises(ClientError):
-        conn.describe_db_security_groups(DBSecurityGroupName="not-a-sg")
+        client.describe_db_security_groups(DBSecurityGroupName="not-a-sg")
 
 
 @mock_aws
-def test_delete_database_security_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_security_group(
+def test_delete_database_security_group(client):
+    client.create_db_security_group(
         DBSecurityGroupName="db_sg", DBSecurityGroupDescription="DB Security Group"
     )
 
-    result = conn.describe_db_security_groups()
+    result = client.describe_db_security_groups()
     assert len(result["DBSecurityGroups"]) == 1
 
-    conn.delete_db_security_group(DBSecurityGroupName="db_sg")
-    result = conn.describe_db_security_groups()
+    client.delete_db_security_group(DBSecurityGroupName="db_sg")
+    result = client.describe_db_security_groups()
     assert len(result["DBSecurityGroups"]) == 0
 
 
 @mock_aws
-def test_delete_non_existent_security_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_delete_non_existent_security_group(client):
     with pytest.raises(ClientError):
-        conn.delete_db_security_group(DBSecurityGroupName="not-a-db")
+        client.delete_db_security_group(DBSecurityGroupName="not-a-db")
 
 
 @mock_aws
-def test_security_group_authorize():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    security_group = conn.create_db_security_group(
+def test_security_group_authorize(client):
+    security_group = client.create_db_security_group(
         DBSecurityGroupName="db_sg", DBSecurityGroupDescription="DB Security Group"
     )
     assert security_group["DBSecurityGroup"]["IPRanges"] == []
 
-    conn.authorize_db_security_group_ingress(
+    client.authorize_db_security_group_ingress(
         DBSecurityGroupName="db_sg", CIDRIP="10.3.2.45/32"
     )
 
-    result = conn.describe_db_security_groups(DBSecurityGroupName="db_sg")
+    result = client.describe_db_security_groups(DBSecurityGroupName="db_sg")
     assert len(result["DBSecurityGroups"][0]["IPRanges"]) == 1
     assert result["DBSecurityGroups"][0]["IPRanges"] == [
         {"Status": "authorized", "CIDRIP": "10.3.2.45/32"}
     ]
 
-    conn.authorize_db_security_group_ingress(
+    client.authorize_db_security_group_ingress(
         DBSecurityGroupName="db_sg", CIDRIP="10.3.2.46/32"
     )
-    result = conn.describe_db_security_groups(DBSecurityGroupName="db_sg")
+    result = client.describe_db_security_groups(DBSecurityGroupName="db_sg")
     assert len(result["DBSecurityGroups"][0]["IPRanges"]) == 2
     assert result["DBSecurityGroups"][0]["IPRanges"] == [
         {"Status": "authorized", "CIDRIP": "10.3.2.45/32"},
@@ -2162,28 +1661,18 @@ def test_security_group_authorize():
 
 
 @mock_aws
-def test_add_security_group_to_database():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        DBInstanceClass="postgres",
-        Engine="postgres",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-    )
+def test_add_security_group_to_database(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
 
-    result = conn.describe_db_instances()
+    result = client.describe_db_instances()
     assert result["DBInstances"][0]["DBSecurityGroups"] == []
-    conn.create_db_security_group(
+    client.create_db_security_group(
         DBSecurityGroupName="db_sg", DBSecurityGroupDescription="DB Security Group"
     )
-    conn.modify_db_instance(
+    client.modify_db_instance(
         DBInstanceIdentifier="db-master-1", DBSecurityGroups=["db_sg"]
     )
-    result = conn.describe_db_instances()
+    result = client.describe_db_instances()
     assert (
         result["DBInstances"][0]["DBSecurityGroups"][0]["DBSecurityGroupName"]
         == "db_sg"
@@ -2191,18 +1680,17 @@ def test_add_security_group_to_database():
 
 
 @mock_aws
-def test_list_tags_security_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    result = conn.describe_db_subnet_groups()
+def test_list_tags_security_group(client):
+    result = client.describe_db_subnet_groups()
     assert len(result["DBSubnetGroups"]) == 0
 
-    security_group = conn.create_db_security_group(
+    security_group = client.create_db_security_group(
         DBSecurityGroupName="db_sg",
         DBSecurityGroupDescription="DB Security Group",
         Tags=[{"Value": "bar", "Key": "foo"}, {"Value": "bar1", "Key": "foo1"}],
     )["DBSecurityGroup"]["DBSecurityGroupName"]
     resource = f"arn:aws:rds:us-west-2:1234567890:secgrp:{security_group}"
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == [
         {"Value": "bar", "Key": "foo"},
         {"Value": "bar1", "Key": "foo1"},
@@ -2210,22 +1698,21 @@ def test_list_tags_security_group():
 
 
 @mock_aws
-def test_add_tags_security_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    result = conn.describe_db_subnet_groups()
+def test_add_tags_security_group(client):
+    result = client.describe_db_subnet_groups()
     assert len(result["DBSubnetGroups"]) == 0
 
-    security_group = conn.create_db_security_group(
+    security_group = client.create_db_security_group(
         DBSecurityGroupName="db_sg", DBSecurityGroupDescription="DB Security Group"
     )["DBSecurityGroup"]["DBSecurityGroupName"]
 
     resource = f"arn:aws:rds:us-west-2:1234567890:secgrp:{security_group}"
-    conn.add_tags_to_resource(
+    client.add_tags_to_resource(
         ResourceName=resource,
         Tags=[{"Value": "bar", "Key": "foo"}, {"Value": "bar1", "Key": "foo1"}],
     )
 
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == [
         {"Value": "bar", "Key": "foo"},
         {"Value": "bar1", "Key": "foo1"},
@@ -2233,26 +1720,25 @@ def test_add_tags_security_group():
 
 
 @mock_aws
-def test_remove_tags_security_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    result = conn.describe_db_subnet_groups()
+def test_remove_tags_security_group(client):
+    result = client.describe_db_subnet_groups()
     assert len(result["DBSubnetGroups"]) == 0
 
-    security_group = conn.create_db_security_group(
+    security_group = client.create_db_security_group(
         DBSecurityGroupName="db_sg",
         DBSecurityGroupDescription="DB Security Group",
         Tags=[{"Value": "bar", "Key": "foo"}, {"Value": "bar1", "Key": "foo1"}],
     )["DBSecurityGroup"]["DBSecurityGroupName"]
 
     resource = f"arn:aws:rds:us-west-2:1234567890:secgrp:{security_group}"
-    conn.remove_tags_from_resource(ResourceName=resource, TagKeys=["foo"])
+    client.remove_tags_from_resource(ResourceName=resource, TagKeys=["foo"])
 
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == [{"Value": "bar1", "Key": "foo1"}]
 
 
 @mock_aws
-def test_create_database_subnet_group():
+def test_create_database_subnet_group(client):
     vpc_conn = boto3.client("ec2", DEFAULT_REGION)
     vpc = vpc_conn.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
     subnet1 = vpc_conn.create_subnet(VpcId=vpc["VpcId"], CidrBlock="10.0.1.0/24")[
@@ -2263,21 +1749,20 @@ def test_create_database_subnet_group():
     ]
 
     subnet_ids = [subnet1["SubnetId"], subnet2["SubnetId"]]
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    result = conn.create_db_subnet_group(
+    subnet_group = client.create_db_subnet_group(
         DBSubnetGroupName="db_subnet",
         DBSubnetGroupDescription="my db subnet",
         SubnetIds=subnet_ids,
-    )
-    assert result["DBSubnetGroup"]["DBSubnetGroupName"] == "db_subnet"
-    assert result["DBSubnetGroup"]["DBSubnetGroupDescription"] == "my db subnet"
-    subnets = result["DBSubnetGroup"]["Subnets"]
+    )["DBSubnetGroup"]
+    assert subnet_group["DBSubnetGroupName"] == "db_subnet"
+    assert subnet_group["DBSubnetGroupDescription"] == "my db subnet"
+    subnets = subnet_group["Subnets"]
     subnet_group_ids = [subnets[0]["SubnetIdentifier"], subnets[1]["SubnetIdentifier"]]
-    assert list(subnet_group_ids) == subnet_ids
+    assert subnet_group_ids == subnet_ids
 
 
 @mock_aws
-def test_modify_database_subnet_group():
+def test_modify_database_subnet_group(client):
     vpc_conn = boto3.client("ec2", DEFAULT_REGION)
     vpc = vpc_conn.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
     subnet1 = vpc_conn.create_subnet(VpcId=vpc["VpcId"], CidrBlock="10.0.1.0/24")[
@@ -2287,49 +1772,36 @@ def test_modify_database_subnet_group():
         "Subnet"
     ]
 
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_subnet_group(
+    client.create_db_subnet_group(
         DBSubnetGroupName="db_subnet",
         DBSubnetGroupDescription="my db subnet",
         SubnetIds=[subnet1["SubnetId"]],
     )
 
-    conn.modify_db_subnet_group(
+    client.modify_db_subnet_group(
         DBSubnetGroupName="db_subnet",
         DBSubnetGroupDescription="my updated desc",
         SubnetIds=[subnet1["SubnetId"], subnet2["SubnetId"]],
     )
 
-    _ = conn.describe_db_subnet_groups()["DBSubnetGroups"]
+    _ = client.describe_db_subnet_groups()["DBSubnetGroups"]
     # FIXME: Group is deleted atm
     # TODO: we should check whether all attrs are persisted
 
 
 @mock_aws
-def test_create_database_in_subnet_group():
-    vpc_conn = boto3.client("ec2", DEFAULT_REGION)
-    vpc = vpc_conn.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
-    subnet = vpc_conn.create_subnet(VpcId=vpc["VpcId"], CidrBlock="10.0.1.0/24")[
-        "Subnet"
-    ]
-
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_subnet_group(
+def test_create_database_in_subnet_group(client):
+    subnet_id = create_subnet()
+    client.create_db_subnet_group(
         DBSubnetGroupName="db_subnet1",
         DBSubnetGroupDescription="my db subnet",
-        SubnetIds=[subnet["SubnetId"]],
+        SubnetIds=[subnet_id],
     )
-    conn.create_db_instance(
+    create_db_instance(
         DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
         DBSubnetGroupName="db_subnet1",
     )
-    result = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
+    result = client.describe_db_instances(DBInstanceIdentifier="db-master-1")
     assert result["DBInstances"][0]["DBSubnetGroup"]["DBSubnetGroupName"] == (
         "db_subnet1"
     )
@@ -2349,26 +1821,20 @@ def create_db_subnet_group(db_subnet_group_name: str = "custom_db_subnet") -> st
 
 
 @mock_aws
-def test_describe_database_subnet_group():
-    vpc_conn = boto3.client("ec2", DEFAULT_REGION)
-    vpc = vpc_conn.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
-    subnet = vpc_conn.create_subnet(VpcId=vpc["VpcId"], CidrBlock="10.0.1.0/24")[
-        "Subnet"
-    ]
-
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_subnet_group(
+def test_describe_database_subnet_group(client):
+    subnet_id = create_subnet()
+    client.create_db_subnet_group(
         DBSubnetGroupName="db_subnet1",
         DBSubnetGroupDescription="my db subnet",
-        SubnetIds=[subnet["SubnetId"]],
+        SubnetIds=[subnet_id],
     )
-    conn.create_db_subnet_group(
+    client.create_db_subnet_group(
         DBSubnetGroupName="db_subnet2",
         DBSubnetGroupDescription="my db subnet",
-        SubnetIds=[subnet["SubnetId"]],
+        SubnetIds=[subnet_id],
     )
 
-    resp = conn.describe_db_subnet_groups()
+    resp = client.describe_db_subnet_groups()
     assert len(resp["DBSubnetGroups"]) == 2
 
     subnets = resp["DBSubnetGroups"][0]["Subnets"]
@@ -2376,66 +1842,59 @@ def test_describe_database_subnet_group():
 
     assert (
         len(
-            list(
-                conn.describe_db_subnet_groups(DBSubnetGroupName="db_subnet1")[
-                    "DBSubnetGroups"
-                ]
-            )
+            client.describe_db_subnet_groups(DBSubnetGroupName="db_subnet1")[
+                "DBSubnetGroups"
+            ]
         )
         == 1
     )
 
     with pytest.raises(ClientError):
-        conn.describe_db_subnet_groups(DBSubnetGroupName="not-a-subnet")
+        client.describe_db_subnet_groups(DBSubnetGroupName="not-a-subnet")
 
 
 @mock_aws
-def test_delete_database_subnet_group():
-    vpc_conn = boto3.client("ec2", DEFAULT_REGION)
-    vpc = vpc_conn.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
-    subnet = vpc_conn.create_subnet(VpcId=vpc["VpcId"], CidrBlock="10.0.1.0/24")[
-        "Subnet"
-    ]
-
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    result = conn.describe_db_subnet_groups()
+def test_delete_database_subnet_group(client):
+    result = client.describe_db_subnet_groups()
     assert len(result["DBSubnetGroups"]) == 0
 
-    conn.create_db_subnet_group(
+    subnet_id = create_subnet()
+    client.create_db_subnet_group(
         DBSubnetGroupName="db_subnet1",
         DBSubnetGroupDescription="my db subnet",
-        SubnetIds=[subnet["SubnetId"]],
+        SubnetIds=[subnet_id],
     )
-    result = conn.describe_db_subnet_groups()
+    result = client.describe_db_subnet_groups()
     assert len(result["DBSubnetGroups"]) == 1
 
-    conn.delete_db_subnet_group(DBSubnetGroupName="db_subnet1")
-    result = conn.describe_db_subnet_groups()
+    client.delete_db_subnet_group(DBSubnetGroupName="db_subnet1")
+    result = client.describe_db_subnet_groups()
     assert len(result["DBSubnetGroups"]) == 0
 
     with pytest.raises(ClientError):
-        conn.delete_db_subnet_group(DBSubnetGroupName="db_subnet1")
+        client.delete_db_subnet_group(DBSubnetGroupName="db_subnet1")
 
 
-@mock_aws
-def test_list_tags_database_subnet_group():
-    vpc_conn = boto3.client("ec2", DEFAULT_REGION)
-    vpc = vpc_conn.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
-    subnet = vpc_conn.create_subnet(VpcId=vpc["VpcId"], CidrBlock="10.0.1.0/24")[
-        "Subnet"
-    ]
+def create_subnet() -> str:
+    ec2_client = boto3.client("ec2", DEFAULT_REGION)
+    vpc = ec2_client.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
+    response = ec2_client.create_subnet(VpcId=vpc["VpcId"], CidrBlock="10.0.1.0/24")
+    return response["Subnet"]["SubnetId"]
 
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    result = conn.describe_db_subnet_groups()
+
+@mock_aws
+def test_list_tags_database_subnet_group(client):
+    result = client.describe_db_subnet_groups()
     assert len(result["DBSubnetGroups"]) == 0
 
-    subnet = conn.create_db_subnet_group(
+    subnet_id = create_subnet()
+    subnet = client.create_db_subnet_group(
         DBSubnetGroupName="db_subnet1",
         DBSubnetGroupDescription="my db subnet",
-        SubnetIds=[subnet["SubnetId"]],
+        SubnetIds=[subnet_id],
         Tags=[{"Value": "bar", "Key": "foo"}, {"Value": "bar1", "Key": "foo1"}],
     )["DBSubnetGroup"]["DBSubnetGroupName"]
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName=f"arn:aws:rds:us-west-2:1234567890:subgrp:{subnet}"
     )
     assert result["TagList"] == [
@@ -2445,36 +1904,34 @@ def test_list_tags_database_subnet_group():
 
 
 @mock_aws
-def test_modify_tags_parameter_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_modify_tags_parameter_group(client):
     client_tags = [{"Key": "character_set_client", "Value": "utf-8"}]
-    result = conn.create_db_parameter_group(
+    result = client.create_db_parameter_group(
         DBParameterGroupName="test-sqlserver-2017",
         DBParameterGroupFamily="mysql5.6",
         Description="MySQL Group",
         Tags=client_tags,
     )
     resource = result["DBParameterGroup"]["DBParameterGroupArn"]
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == client_tags
     server_tags = [{"Key": "character_set_server", "Value": "utf-8"}]
-    conn.add_tags_to_resource(ResourceName=resource, Tags=server_tags)
+    client.add_tags_to_resource(ResourceName=resource, Tags=server_tags)
     combined_tags = client_tags + server_tags
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == combined_tags
 
-    conn.remove_tags_from_resource(
+    client.remove_tags_from_resource(
         ResourceName=resource, TagKeys=["character_set_client"]
     )
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == server_tags
 
 
 @mock_aws
-def test_modify_tags_event_subscription():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_modify_tags_event_subscription(client):
     tags = [{"Key": "hello", "Value": "world"}]
-    result = conn.create_event_subscription(
+    result = client.create_event_subscription(
         SubscriptionName="my-instance-events",
         SourceType="db-instance",
         EventCategories=["backup", "recovery"],
@@ -2482,45 +1939,39 @@ def test_modify_tags_event_subscription():
         Tags=tags,
     )
     resource = result["EventSubscription"]["EventSubscriptionArn"]
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == tags
     new_tags = [{"Key": "new_key", "Value": "new_value"}]
-    conn.add_tags_to_resource(ResourceName=resource, Tags=new_tags)
+    client.add_tags_to_resource(ResourceName=resource, Tags=new_tags)
     combined_tags = tags + new_tags
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == combined_tags
 
-    conn.remove_tags_from_resource(ResourceName=resource, TagKeys=["new_key"])
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    client.remove_tags_from_resource(ResourceName=resource, TagKeys=["new_key"])
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == tags
 
 
 @mock_aws
-def test_add_tags_database_subnet_group():
-    vpc_conn = boto3.client("ec2", DEFAULT_REGION)
-    vpc = vpc_conn.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
-    subnet = vpc_conn.create_subnet(VpcId=vpc["VpcId"], CidrBlock="10.0.1.0/24")[
-        "Subnet"
-    ]
-
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    result = conn.describe_db_subnet_groups()
+def test_add_tags_database_subnet_group(client):
+    result = client.describe_db_subnet_groups()
     assert len(result["DBSubnetGroups"]) == 0
 
-    subnet = conn.create_db_subnet_group(
+    subnet_id = create_subnet()
+    subnet = client.create_db_subnet_group(
         DBSubnetGroupName="db_subnet1",
         DBSubnetGroupDescription="my db subnet",
-        SubnetIds=[subnet["SubnetId"]],
+        SubnetIds=[subnet_id],
         Tags=[],
     )["DBSubnetGroup"]["DBSubnetGroupName"]
     resource = f"arn:aws:rds:us-west-2:1234567890:subgrp:{subnet}"
 
-    conn.add_tags_to_resource(
+    client.add_tags_to_resource(
         ResourceName=resource,
         Tags=[{"Value": "bar", "Key": "foo"}, {"Value": "bar1", "Key": "foo1"}],
     )
 
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == [
         {"Value": "bar", "Key": "foo"},
         {"Value": "bar1", "Key": "foo1"},
@@ -2528,47 +1979,30 @@ def test_add_tags_database_subnet_group():
 
 
 @mock_aws
-def test_remove_tags_database_subnet_group():
-    vpc_conn = boto3.client("ec2", DEFAULT_REGION)
-    vpc = vpc_conn.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
-    subnet = vpc_conn.create_subnet(VpcId=vpc["VpcId"], CidrBlock="10.0.1.0/24")[
-        "Subnet"
-    ]
-
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    result = conn.describe_db_subnet_groups()
+def test_remove_tags_database_subnet_group(client):
+    result = client.describe_db_subnet_groups()
     assert len(result["DBSubnetGroups"]) == 0
 
-    subnet = conn.create_db_subnet_group(
+    subnet_id = create_subnet()
+    subnet = client.create_db_subnet_group(
         DBSubnetGroupName="db_subnet1",
         DBSubnetGroupDescription="my db subnet",
-        SubnetIds=[subnet["SubnetId"]],
+        SubnetIds=[subnet_id],
         Tags=[{"Value": "bar", "Key": "foo"}, {"Value": "bar1", "Key": "foo1"}],
     )["DBSubnetGroup"]["DBSubnetGroupName"]
     resource = f"arn:aws:rds:us-west-2:1234567890:subgrp:{subnet}"
 
-    conn.remove_tags_from_resource(ResourceName=resource, TagKeys=["foo"])
+    client.remove_tags_from_resource(ResourceName=resource, TagKeys=["foo"])
 
-    result = conn.list_tags_for_resource(ResourceName=resource)
+    result = client.list_tags_for_resource(ResourceName=resource)
     assert result["TagList"] == [{"Value": "bar1", "Key": "foo1"}]
 
 
 @mock_aws
-def test_create_database_replica():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
-    conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_create_database_replica(client):
+    create_db_instance(DBInstanceIdentifier="db-master-1")
 
-    replica = conn.create_db_instance_read_replica(
+    replica = client.create_db_instance_read_replica(
         DBInstanceIdentifier="db-replica-1",
         SourceDBInstanceIdentifier="db-master-1",
         DBInstanceClass="db.m1.small",
@@ -2579,18 +2013,20 @@ def test_create_database_replica():
     assert replica["DBInstance"]["DBInstanceClass"] == "db.m1.small"
     assert replica["DBInstance"]["DBInstanceIdentifier"] == "db-replica-1"
 
-    master = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
+    master = client.describe_db_instances(DBInstanceIdentifier="db-master-1")
     assert master["DBInstances"][0]["ReadReplicaDBInstanceIdentifiers"] == (
         ["db-replica-1"]
     )
-    replica = conn.describe_db_instances(DBInstanceIdentifier="db-replica-1")[
+    replica = client.describe_db_instances(DBInstanceIdentifier="db-replica-1")[
         "DBInstances"
     ][0]
     assert replica["ReadReplicaSourceDBInstanceIdentifier"] == "db-master-1"
 
-    conn.delete_db_instance(DBInstanceIdentifier="db-replica-1", SkipFinalSnapshot=True)
+    client.delete_db_instance(
+        DBInstanceIdentifier="db-replica-1", SkipFinalSnapshot=True
+    )
 
-    master = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")
+    master = client.describe_db_instances(DBInstanceIdentifier="db-master-1")
     assert master["DBInstances"][0]["ReadReplicaDBInstanceIdentifiers"] == []
 
 
@@ -2602,7 +2038,6 @@ def test_create_database_replica_cross_region():
     source_id = "db-master-1"
     source_arn = us1.create_db_instance(
         DBInstanceIdentifier=source_id,
-        AllocatedStorage=10,
         Engine="postgres",
         DBInstanceClass="db.m1.small",
     )["DBInstance"]["DBInstanceArn"]
@@ -2626,7 +2061,7 @@ def test_create_database_replica_cross_region():
 
 
 @mock_aws
-def test_create_database_with_encrypted_storage():
+def test_create_database_with_encrypted_storage(client):
     kms_conn = boto3.client("kms", region_name=DEFAULT_REGION)
     key = kms_conn.create_key(
         Policy="my RDS encryption policy",
@@ -2634,30 +2069,19 @@ def test_create_database_with_encrypted_storage():
         KeyUsage="ENCRYPT_DECRYPT",
     )
 
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
+    db_instance = create_db_instance(
         StorageEncrypted=True,
         KmsKeyId=key["KeyMetadata"]["KeyId"],
     )
 
-    assert database["DBInstance"]["StorageEncrypted"] is True
-    assert database["DBInstance"]["KmsKeyId"] == key["KeyMetadata"]["KeyId"]
+    assert db_instance["StorageEncrypted"] is True
+    assert db_instance["KmsKeyId"] == key["KeyMetadata"]["KeyId"]
 
 
 @mock_aws
-def test_create_db_parameter_group():
-    region = DEFAULT_REGION
+def test_create_db_parameter_group(client):
     pg_name = "test"
-    conn = boto3.client("rds", region_name=region)
-    db_parameter_group = conn.create_db_parameter_group(
+    db_parameter_group = client.create_db_parameter_group(
         DBParameterGroupName="test",
         DBParameterGroupFamily="mysql5.6",
         Description="test parameter group",
@@ -2671,58 +2095,34 @@ def test_create_db_parameter_group():
         "test parameter group"
     )
     assert db_parameter_group["DBParameterGroup"]["DBParameterGroupArn"] == (
-        f"arn:aws:rds:{region}:{ACCOUNT_ID}:pg:{pg_name}"
+        f"arn:aws:rds:{DEFAULT_REGION}:{ACCOUNT_ID}:pg:{pg_name}"
     )
 
 
 @mock_aws
-def test_create_db_instance_with_parameter_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_parameter_group(
+def test_create_db_instance_with_parameter_group(client):
+    client.create_db_parameter_group(
         DBParameterGroupName="test",
         DBParameterGroupFamily="mysql5.6",
         Description="test parameter group",
     )
 
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="mysql",
-        DBInstanceClass="db.m1.small",
-        DBParameterGroupName="test",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-    )
+    db_instance = create_db_instance(DBParameterGroupName="test")
 
-    assert len(database["DBInstance"]["DBParameterGroups"]) == 1
-    assert database["DBInstance"]["DBParameterGroups"][0]["DBParameterGroupName"] == (
-        "test"
-    )
-    assert database["DBInstance"]["DBParameterGroups"][0]["ParameterApplyStatus"] == (
-        "in-sync"
-    )
+    assert len(db_instance["DBParameterGroups"]) == 1
+    assert db_instance["DBParameterGroups"][0]["DBParameterGroupName"] == "test"
+    assert db_instance["DBParameterGroups"][0]["ParameterApplyStatus"] == "in-sync"
 
 
 @mock_aws
-def test_create_database_with_default_port():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
-        DBInstanceIdentifier="db-master-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        DBSecurityGroups=["my_sg"],
-    )
-    assert database["DBInstance"]["Endpoint"]["Port"] == 5432
+def test_create_database_with_default_port(client):
+    db_instance = create_db_instance()
+    assert db_instance["Endpoint"]["Port"] == 5432
 
 
 @mock_aws
-def test_modify_db_instance_with_parameter_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    database = conn.create_db_instance(
+def test_modify_db_instance_with_parameter_group(client):
+    db_instance = create_db_instance(
         DBInstanceIdentifier="db-master-1",
         AllocatedStorage=10,
         Engine="mysql",
@@ -2732,26 +2132,23 @@ def test_modify_db_instance_with_parameter_group():
         Port=1234,
     )
 
-    assert len(database["DBInstance"]["DBParameterGroups"]) == 1
-    assert database["DBInstance"]["DBParameterGroups"][0]["DBParameterGroupName"] == (
-        "default.mysql5.6"
-    )
-    assert database["DBInstance"]["DBParameterGroups"][0]["ParameterApplyStatus"] == (
-        "in-sync"
-    )
+    assert len(db_instance["DBParameterGroups"]) == 1
+    parameter_group = db_instance["DBParameterGroups"][0]
+    assert parameter_group["DBParameterGroupName"] == "default.mysql5.6"
+    assert parameter_group["ParameterApplyStatus"] == "in-sync"
 
-    conn.create_db_parameter_group(
+    client.create_db_parameter_group(
         DBParameterGroupName="test",
         DBParameterGroupFamily="mysql5.6",
         Description="test parameter group",
     )
-    conn.modify_db_instance(
+    client.modify_db_instance(
         DBInstanceIdentifier="db-master-1",
         DBParameterGroupName="test",
         ApplyImmediately=True,
     )
 
-    database = conn.describe_db_instances(DBInstanceIdentifier="db-master-1")[
+    database = client.describe_db_instances(DBInstanceIdentifier="db-master-1")[
         "DBInstances"
     ][0]
     assert len(database["DBParameterGroups"]) == 1
@@ -2760,10 +2157,9 @@ def test_modify_db_instance_with_parameter_group():
 
 
 @mock_aws
-def test_create_db_parameter_group_empty_description():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_create_db_parameter_group_empty_description(client):
     with pytest.raises(ClientError):
-        conn.create_db_parameter_group(
+        client.create_db_parameter_group(
             DBParameterGroupName="test",
             DBParameterGroupFamily="mysql5.6",
             Description="",
@@ -2771,15 +2167,14 @@ def test_create_db_parameter_group_empty_description():
 
 
 @mock_aws
-def test_create_db_parameter_group_duplicate():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_parameter_group(
+def test_create_db_parameter_group_duplicate(client):
+    client.create_db_parameter_group(
         DBParameterGroupName="test",
         DBParameterGroupFamily="mysql5.6",
         Description="test parameter group",
     )
     with pytest.raises(ClientError):
-        conn.create_db_parameter_group(
+        client.create_db_parameter_group(
             DBParameterGroupName="test",
             DBParameterGroupFamily="mysql5.6",
             Description="test parameter group",
@@ -2787,58 +2182,61 @@ def test_create_db_parameter_group_duplicate():
 
 
 @mock_aws
-def test_describe_db_parameter_group():
-    region = DEFAULT_REGION
+def test_describe_db_parameter_group(client):
     pg_name = "test"
-    conn = boto3.client("rds", region_name=region)
-    conn.create_db_parameter_group(
+    client.create_db_parameter_group(
         DBParameterGroupName=pg_name,
         DBParameterGroupFamily="mysql5.6",
         Description="test parameter group",
     )
-    db_parameter_groups = conn.describe_db_parameter_groups(DBParameterGroupName="test")
+    db_parameter_groups = client.describe_db_parameter_groups(
+        DBParameterGroupName="test"
+    )
     assert db_parameter_groups["DBParameterGroups"][0]["DBParameterGroupName"] == (
         "test"
     )
     assert db_parameter_groups["DBParameterGroups"][0]["DBParameterGroupArn"] == (
-        f"arn:aws:rds:{region}:{ACCOUNT_ID}:pg:{pg_name}"
+        f"arn:aws:rds:{DEFAULT_REGION}:{ACCOUNT_ID}:pg:{pg_name}"
     )
 
 
 @mock_aws
-def test_describe_non_existent_db_parameter_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    db_parameter_groups = conn.describe_db_parameter_groups(DBParameterGroupName="test")
+def test_describe_non_existent_db_parameter_group(client):
+    db_parameter_groups = client.describe_db_parameter_groups(
+        DBParameterGroupName="test"
+    )
     assert len(db_parameter_groups["DBParameterGroups"]) == 0
 
 
 @mock_aws
-def test_delete_db_parameter_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_parameter_group(
+def test_delete_db_parameter_group(client):
+    client.create_db_parameter_group(
         DBParameterGroupName="test",
         DBParameterGroupFamily="mysql5.6",
         Description="test parameter group",
     )
-    db_parameter_groups = conn.describe_db_parameter_groups(DBParameterGroupName="test")
+    db_parameter_groups = client.describe_db_parameter_groups(
+        DBParameterGroupName="test"
+    )
     assert db_parameter_groups["DBParameterGroups"][0]["DBParameterGroupName"] == (
         "test"
     )
-    conn.delete_db_parameter_group(DBParameterGroupName="test")
-    db_parameter_groups = conn.describe_db_parameter_groups(DBParameterGroupName="test")
+    client.delete_db_parameter_group(DBParameterGroupName="test")
+    db_parameter_groups = client.describe_db_parameter_groups(
+        DBParameterGroupName="test"
+    )
     assert len(db_parameter_groups["DBParameterGroups"]) == 0
 
 
 @mock_aws
-def test_modify_db_parameter_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_parameter_group(
+def test_modify_db_parameter_group(client):
+    client.create_db_parameter_group(
         DBParameterGroupName="test",
         DBParameterGroupFamily="mysql5.6",
         Description="test parameter group",
     )
 
-    modify_result = conn.modify_db_parameter_group(
+    modify_result = client.modify_db_parameter_group(
         DBParameterGroupName="test",
         Parameters=[
             {
@@ -2852,7 +2250,7 @@ def test_modify_db_parameter_group():
 
     assert modify_result["DBParameterGroupName"] == "test"
 
-    db_parameters = conn.describe_db_parameters(DBParameterGroupName="test")
+    db_parameters = client.describe_db_parameters(DBParameterGroupName="test")
     assert db_parameters["Parameters"][0]["ParameterName"] == "foo"
     assert db_parameters["Parameters"][0]["ParameterValue"] == "foo_val"
     assert db_parameters["Parameters"][0]["Description"] == "test param"
@@ -2860,61 +2258,50 @@ def test_modify_db_parameter_group():
 
 
 @mock_aws
-def test_delete_non_existent_db_parameter_group():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_delete_non_existent_db_parameter_group(client):
     with pytest.raises(ClientError):
-        conn.delete_db_parameter_group(DBParameterGroupName="non-existent")
+        client.delete_db_parameter_group(DBParameterGroupName="non-existent")
 
 
 @mock_aws
-def test_create_parameter_group_with_tags():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-    conn.create_db_parameter_group(
+def test_create_parameter_group_with_tags(client):
+    client.create_db_parameter_group(
         DBParameterGroupName="test",
         DBParameterGroupFamily="mysql5.6",
         Description="test parameter group",
         Tags=[{"Key": "foo", "Value": "bar"}],
     )
-    result = conn.list_tags_for_resource(
+    result = client.list_tags_for_resource(
         ResourceName="arn:aws:rds:us-west-2:1234567890:pg:test"
     )
     assert result["TagList"] == [{"Value": "bar", "Key": "foo"}]
 
 
 @mock_aws
-def test_create_db_with_iam_authentication():
-    conn = boto3.client("rds", region_name=DEFAULT_REGION)
-
-    database = conn.create_db_instance(
+def test_create_db_with_iam_authentication(client):
+    db_instance = create_db_instance(
         DBInstanceIdentifier="rds",
-        DBInstanceClass="db.t1.micro",
-        Engine="postgres",
         EnableIAMDatabaseAuthentication=True,
     )
 
-    db_instance = database["DBInstance"]
     assert db_instance["IAMDatabaseAuthenticationEnabled"] is True
 
-    snapshot = conn.create_db_snapshot(
+    snapshot = client.create_db_snapshot(
         DBInstanceIdentifier="rds", DBSnapshotIdentifier="snapshot"
-    ).get("DBSnapshot")
+    )["DBSnapshot"]
 
-    assert snapshot.get("IAMDatabaseAuthenticationEnabled") is True
+    assert snapshot["IAMDatabaseAuthenticationEnabled"] is True
 
 
 @mock_aws
-def test_create_db_instance_with_tags():
-    client = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_create_db_instance_with_tags(client):
     tags = [{"Key": "foo", "Value": "bar"}, {"Key": "foo1", "Value": "bar1"}]
     db_instance_identifier = "test-db-instance"
-    resp = client.create_db_instance(
+    db_instance = create_db_instance(
         DBInstanceIdentifier=db_instance_identifier,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
         Tags=tags,
     )
-    assert resp["DBInstance"]["TagList"] == tags
+    assert db_instance["TagList"] == tags
 
     resp = client.describe_db_instances(DBInstanceIdentifier=db_instance_identifier)
     assert resp["DBInstances"][0]["TagList"] == tags
@@ -2997,17 +2384,11 @@ def test_validate_db_snapshot_identifier_backend_valid(valid_db_snapshot_identif
 
 
 @mock_aws
-def test_validate_db_identifier():
-    client = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_validate_db_identifier(client):
     invalid_db_instance_identifier = "arn:aws:rds:eu-west-1:123456789012:db:mydb"
 
     with pytest.raises(ClientError) as exc:
-        client.create_db_instance(
-            DBInstanceIdentifier=invalid_db_instance_identifier,
-            Engine="postgres",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
-        )
+        create_db_instance(DBInstanceIdentifier=invalid_db_instance_identifier)
     validation_helper(exc)
 
     with pytest.raises(ClientError) as exc:
@@ -3036,18 +2417,12 @@ def test_validate_db_identifier():
 
 
 @mock_aws
-def test_validate_db_snapshot_identifier_different_operations():
-    client = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_validate_db_snapshot_identifier_different_operations(client):
     db_instance_identifier = "valid-identifier"
     valid_db_snapshot_identifier = "valid"
     invalid_db_snapshot_identifier = "--invalid--"
 
-    client.create_db_instance(
-        DBInstanceIdentifier=db_instance_identifier,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-    )
+    create_db_instance(DBInstanceIdentifier=db_instance_identifier)
 
     expected_message = f"Invalid snapshot identifier:  {invalid_db_snapshot_identifier}"
     with pytest.raises(ClientError) as exc:
@@ -3107,16 +2482,10 @@ snapshot_identifier_data = (
 )
 @mock_aws
 def test_validate_db_snapshot_identifier_different_error_messages(
-    invalid_db_snapshot_identifier, expected_message
+    invalid_db_snapshot_identifier, expected_message, client
 ):
-    client = boto3.client("rds", region_name=DEFAULT_REGION)
     db_instance_identifier = "valid-identifier"
-    client.create_db_instance(
-        DBInstanceIdentifier=db_instance_identifier,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-    )
+    create_db_instance(DBInstanceIdentifier=db_instance_identifier)
 
     with pytest.raises(ClientError) as exc:
         client.create_db_snapshot(
@@ -3127,15 +2496,9 @@ def test_validate_db_snapshot_identifier_different_error_messages(
 
 
 @mock_aws
-def test_createdb_instance_engine_with_invalid_value():
-    client = boto3.client("rds", region_name=DEFAULT_REGION)
+def test_createdb_instance_engine_with_invalid_value(client):
     with pytest.raises(ClientError) as exc:
-        client.create_db_instance(
-            DBInstanceIdentifier="test-db-instance",
-            Engine="invalid-engine",
-            DBName="staging-postgres",
-            DBInstanceClass="db.m1.small",
-        )
+        create_db_instance(Engine="invalid-engine")
 
     err = exc.value.response["Error"]
 
@@ -3147,23 +2510,11 @@ def test_createdb_instance_engine_with_invalid_value():
 
 
 @mock_aws
-def test_describe_db_snapshot_attributes_default():
-    client = boto3.client("rds", region_name="us-east-2")
-    client.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-
+def test_describe_db_snapshot_attributes_default(client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
     client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-1"
-    ).get("DBSnapshot")
+    )
 
     resp = client.describe_db_snapshot_attributes(DBSnapshotIdentifier="snapshot-1")
 
@@ -3172,23 +2523,11 @@ def test_describe_db_snapshot_attributes_default():
 
 
 @mock_aws
-def test_describe_db_snapshot_attributes():
-    client = boto3.client("rds", region_name="us-east-2")
-    client.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
-
+def test_describe_db_snapshot_attributes(client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
     client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-1"
-    ).get("DBSnapshot")
+    )
 
     resp = client.modify_db_snapshot_attribute(
         DBSnapshotIdentifier="snapshot-1",
@@ -3197,58 +2536,38 @@ def test_describe_db_snapshot_attributes():
     )
 
     resp = client.describe_db_snapshot_attributes(DBSnapshotIdentifier="snapshot-1")
+    snapshot_attributes = resp["DBSnapshotAttributesResult"]["DBSnapshotAttributes"]
 
-    assert (
-        resp["DBSnapshotAttributesResult"]["DBSnapshotAttributes"][0]["AttributeName"]
-        == "restore"
-    )
-    assert resp["DBSnapshotAttributesResult"]["DBSnapshotAttributes"][0][
-        "AttributeValues"
-    ] == ["Test", "Test2"]
+    assert snapshot_attributes[0]["AttributeName"] == "restore"
+    assert snapshot_attributes[0]["AttributeValues"] == ["Test", "Test2"]
 
 
 @mock_aws
-def test_modify_db_snapshot_attribute():
-    client = boto3.client("rds", region_name="us-east-2")
-    client.create_db_instance(
-        DBInstanceIdentifier="db-primary-1",
-        AllocatedStorage=10,
-        Engine="postgres",
-        DBName="staging-postgres",
-        DBInstanceClass="db.m1.small",
-        MasterUsername="root",
-        MasterUserPassword="hunter2",
-        Port=1234,
-        DBSecurityGroups=["my_sg"],
-    )
+def test_modify_db_snapshot_attribute(client):
+    create_db_instance(DBInstanceIdentifier="db-primary-1")
 
     client.create_db_snapshot(
         DBInstanceIdentifier="db-primary-1", DBSnapshotIdentifier="snapshot-1"
-    ).get("DBSnapshot")
+    )
 
-    resp = client.modify_db_snapshot_attribute(
+    client.modify_db_snapshot_attribute(
         DBSnapshotIdentifier="snapshot-1",
         AttributeName="restore",
         ValuesToAdd=["Test", "Test2"],
     )
-    resp = client.modify_db_snapshot_attribute(
+    client.modify_db_snapshot_attribute(
         DBSnapshotIdentifier="snapshot-1",
         AttributeName="restore",
         ValuesToRemove=["Test"],
     )
-    resp = client.modify_db_snapshot_attribute(
+    snapshot_attributes = client.modify_db_snapshot_attribute(
         DBSnapshotIdentifier="snapshot-1",
         AttributeName="restore",
         ValuesToAdd=["Test3"],
-    )
+    )["DBSnapshotAttributesResult"]["DBSnapshotAttributes"]
 
-    assert (
-        resp["DBSnapshotAttributesResult"]["DBSnapshotAttributes"][0]["AttributeName"]
-        == "restore"
-    )
-    assert resp["DBSnapshotAttributesResult"]["DBSnapshotAttributes"][0][
-        "AttributeValues"
-    ] == ["Test2", "Test3"]
+    assert snapshot_attributes[0]["AttributeName"] == "restore"
+    assert snapshot_attributes[0]["AttributeValues"] == ["Test2", "Test3"]
 
 
 def validation_helper(exc):
diff --git a/tests/test_secretsmanager/test_list_secrets.py b/tests/test_secretsmanager/test_list_secrets.py
index 37de56a78..ba26bba7c 100644
--- a/tests/test_secretsmanager/test_list_secrets.py
+++ b/tests/test_secretsmanager/test_list_secrets.py
@@ -1,4 +1,5 @@
 from datetime import datetime
+from uuid import uuid4
 
 import boto3
 import pytest
@@ -6,6 +7,8 @@ from botocore.exceptions import ClientError
 from dateutil.tz import tzlocal
 
 from moto import mock_aws
+from moto.secretsmanager.list_secrets.filters import split_words
+from tests import aws_verified
 
 
 def boto_client():
@@ -104,30 +107,111 @@ def test_with_description_filter():
     assert secret_names == ["foo"]
 
 
-@mock_aws
+@aws_verified
+# Verified, but not marked because it's flaky - AWS can take up to 5 minutes before secrets are listed
 def test_with_all_filter():
     # The 'all' filter will match a secret that contains ANY field with
     # the criteria. In other words an implicit OR.
+    unique_name = str(uuid4())[0:6]
+
+    first_secret = f"SecretOne{unique_name}"
+    second_secret = f"SecretTwo{unique_name}"
+    third_secret = f"Thirdsecret{unique_name}"
+    foo_tag_key = f"SecretFTag{unique_name}"
+    foo_tag_val = f"SecretFValue{unique_name}"
+    no_match = f"none{unique_name}"
 
     conn = boto_client()
 
-    conn.create_secret(Name="foo", SecretString="secret")
-    conn.create_secret(Name="bar", SecretString="secret", Description="foo")
-    conn.create_secret(
-        Name="baz", SecretString="secret", Tags=[{"Key": "foo", "Value": "1"}]
-    )
+    conn.create_secret(Name=first_secret, SecretString="s")
+    conn.create_secret(Name=second_secret, SecretString="s", Description="DescTwo")
+    conn.create_secret(Name=third_secret, SecretString="s")
     conn.create_secret(
-        Name="qux", SecretString="secret", Tags=[{"Key": "1", "Value": "foo"}]
+        Name=foo_tag_key, SecretString="s", Tags=[{"Key": "1", "Value": "foo"}]
     )
     conn.create_secret(
-        Name="multi", SecretString="secret", Tags=[{"Key": "foo", "Value": "foo"}]
+        Name=foo_tag_val, SecretString="s", Tags=[{"Key": "foo", "Value": "v"}]
     )
-    conn.create_secret(Name="none", SecretString="secret")
+    conn.create_secret(Name=no_match, SecretString="s")
 
-    secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["foo"]}])
+    try:
+        # Full Match
+        secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["SecretOne"]}])[
+            "SecretList"
+        ]
+        secret_names = [s["Name"] for s in secrets]
+        assert secret_names == [first_secret]
 
-    secret_names = list(map(lambda s: s["Name"], secrets["SecretList"]))
-    assert sorted(secret_names) == ["bar", "baz", "foo", "multi", "qux"]
+        # Search in tags
+        secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["foo"]}])[
+            "SecretList"
+        ]
+        secret_names = [s["Name"] for s in secrets]
+        assert secret_names == [foo_tag_key, foo_tag_val]
+
+        # StartsWith - full word
+        secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["Secret"]}])[
+            "SecretList"
+        ]
+        secret_names = [s["Name"] for s in secrets]
+        assert secret_names == [first_secret, second_secret, foo_tag_key, foo_tag_val]
+
+        # Partial Match - full word - lowercase
+        secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["secret"]}])[
+            "SecretList"
+        ]
+        secret_names = [s["Name"] for s in secrets]
+        assert secret_names == [first_secret, second_secret, foo_tag_key, foo_tag_val]
+
+        # Partial Match - partial word
+        secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["ret"]}])[
+            "SecretList"
+        ]
+        secret_names = [s["Name"] for s in secrets]
+        assert not secret_names
+
+        # Partial Match - partial word
+        secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["sec"]}])[
+            "SecretList"
+        ]
+        secret_names = [s["Name"] for s in secrets]
+        assert secret_names == [first_secret, second_secret, foo_tag_key, foo_tag_val]
+
+        # Unknown Match
+        secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["SomeSecret"]}])[
+            "SecretList"
+        ]
+        assert not secrets
+
+        # Single value
+        # Only matches description that contains a d
+        secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["d"]}])[
+            "SecretList"
+        ]
+        secret_names = [s["Name"] for s in secrets]
+        assert secret_names == [second_secret]
+
+        # Multiple values
+        # Only matches description that contains a d and t (DescTwo)
+        secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["d t"]}])[
+            "SecretList"
+        ]
+        secret_names = [s["Name"] for s in secrets]
+        assert secret_names == [second_secret]
+
+        # Name parts that start with a t (DescTwo)
+        secrets = conn.list_secrets(Filters=[{"Key": "all", "Values": ["t"]}])[
+            "SecretList"
+        ]
+        secret_names = [s["Name"] for s in secrets]
+        assert secret_names == [second_secret, third_secret, foo_tag_key]
+    finally:
+        conn.delete_secret(SecretId=first_secret, ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId=second_secret, ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId=third_secret, ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId=foo_tag_key, ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId=foo_tag_val, ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId=no_match, ForceDeleteWithoutRecovery=True)
 
 
 @mock_aws
@@ -171,7 +255,8 @@ def test_with_invalid_filter_key():
     )
 
 
-@mock_aws
+@aws_verified
+# Verified, but not marked because it's flaky - AWS can take up to 5 minutes before secrets are listed
 def test_with_duplicate_filter_keys():
     # Multiple filters with the same key combine with an implicit AND operator
 
@@ -182,15 +267,21 @@ def test_with_duplicate_filter_keys():
     conn.create_secret(Name="baz", SecretString="secret", Description="two")
     conn.create_secret(Name="qux", SecretString="secret", Description="unrelated")
 
-    secrets = conn.list_secrets(
-        Filters=[
-            {"Key": "description", "Values": ["one"]},
-            {"Key": "description", "Values": ["two"]},
-        ]
-    )
+    try:
+        secrets = conn.list_secrets(
+            Filters=[
+                {"Key": "description", "Values": ["one"]},
+                {"Key": "description", "Values": ["two"]},
+            ]
+        )
 
-    secret_names = list(map(lambda s: s["Name"], secrets["SecretList"]))
-    assert secret_names == ["foo"]
+        secret_names = list(map(lambda s: s["Name"], secrets["SecretList"]))
+        assert secret_names == ["foo"]
+    finally:
+        conn.delete_secret(SecretId="foo", ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId="bar", ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId="baz", ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId="qux", ForceDeleteWithoutRecovery=True)
 
 
 @mock_aws
@@ -237,7 +328,8 @@ def test_with_filter_with_multiple_values():
     assert secret_names == ["foo", "bar"]
 
 
-@mock_aws
+@aws_verified
+# Verified, but not marked because it's flaky - AWS can take up to 5 minutes before secrets are listed
 def test_with_filter_with_value_with_multiple_words():
     conn = boto_client()
 
@@ -247,10 +339,29 @@ def test_with_filter_with_value_with_multiple_words():
     conn.create_secret(Name="qux", SecretString="secret", Description="two")
     conn.create_secret(Name="none", SecretString="secret", Description="unrelated")
 
-    secrets = conn.list_secrets(Filters=[{"Key": "description", "Values": ["one two"]}])
-
-    secret_names = list(map(lambda s: s["Name"], secrets["SecretList"]))
-    assert secret_names == ["foo", "bar"]
+    try:
+        # All values that contain one and two
+        secrets = conn.list_secrets(
+            Filters=[{"Key": "description", "Values": ["one two"]}]
+        )
+        secret_names = list(map(lambda s: s["Name"], secrets["SecretList"]))
+        assert secret_names == ["foo", "bar"]
+
+        # All values that start with o and t
+        secrets = conn.list_secrets(Filters=[{"Key": "description", "Values": ["o t"]}])
+        secret_names = list(map(lambda s: s["Name"], secrets["SecretList"]))
+        assert secret_names == ["foo", "bar"]
+
+        # All values that contain t
+        secrets = conn.list_secrets(Filters=[{"Key": "description", "Values": ["t"]}])
+        secret_names = list(map(lambda s: s["Name"], secrets["SecretList"]))
+        assert secret_names == ["foo", "bar", "qux"]
+    finally:
+        conn.delete_secret(SecretId="foo", ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId="bar", ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId="baz", ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId="qux", ForceDeleteWithoutRecovery=True)
+        conn.delete_secret(SecretId="none", ForceDeleteWithoutRecovery=True)
 
 
 @mock_aws
@@ -318,3 +429,19 @@ def test_with_include_planned_deleted_secrets():
     assert secrets["SecretList"][0]["ARN"] is not None
     assert secrets["SecretList"][0]["Name"] == "foo"
     assert secrets["SecretList"][0]["SecretVersionsToStages"] is not None
+
+
+@pytest.mark.parametrize(
+    "input,output",
+    [
+        ("test", ["test"]),
+        ("my test", ["my", "test"]),
+        ("Mytest", ["Mytest"]),
+        ("MyTest", ["My", "Test"]),
+        ("MyTestPhrase", ["My", "Test", "Phrase"]),
+        ("myTest", ["my", "Test"]),
+        ("my test", ["my", "test"]),
+    ],
+)
+def test_word_splitter(input, output):
+    assert split_words(input) == output
diff --git a/tests/test_stepfunctions/test_stepfunctions_versions.py b/tests/test_stepfunctions/test_stepfunctions_versions.py
index 715033cb0..ebd3c9bb0 100644
--- a/tests/test_stepfunctions/test_stepfunctions_versions.py
+++ b/tests/test_stepfunctions/test_stepfunctions_versions.py
@@ -3,8 +3,10 @@ from uuid import uuid4
 
 import boto3
 import pytest
+from botocore.exceptions import ClientError
 
 from moto import mock_aws
+from tests import aws_verified
 from tests.test_stepfunctions.parser import sfn_role_policy
 from tests.test_stepfunctions.test_stepfunctions import simple_definition
 
@@ -22,9 +24,9 @@ def test_describe_state_machine_using_version_arn(use_parser):
 
         client = boto3.client("stepfunctions", region_name="us-east-1")
 
-        name1 = f"sfn_name_{str(uuid4())[0:6]}"
+        name = f"sfn_name_{str(uuid4())[0:6]}"
         response = client.create_state_machine(
-            name=name1, definition=simple_definition, roleArn=sfn_role, publish=True
+            name=name, definition=simple_definition, roleArn=sfn_role, publish=True
         )
         arn = response["stateMachineArn"]
         version_arn1 = response["stateMachineVersionArn"]
@@ -51,3 +53,84 @@ def test_describe_state_machine_using_version_arn(use_parser):
         # Assert that we can still describe the first version of the state machine
         version1 = client.describe_state_machine(stateMachineArn=version_arn1)
         assert version1["loggingConfiguration"] == {"level": "OFF"}
+
+
+@aws_verified
+@pytest.mark.aws_verified
+def test_create_state_machine_with_version_description():
+    iam = boto3.client("iam", region_name="us-east-1")
+    role_name = f"sfn_role_{str(uuid4())[0:6]}"
+    sfn_role = iam.create_role(
+        RoleName=role_name,
+        AssumeRolePolicyDocument=json.dumps(sfn_role_policy),
+        Path="/",
+    )["Role"]["Arn"]
+
+    client = boto3.client("stepfunctions", region_name="us-east-1")
+
+    try:
+        name = f"sfn_name_{str(uuid4())[0:6]}"
+
+        response = client.create_state_machine(
+            name=name,
+            definition=simple_definition,
+            roleArn=sfn_role,
+            versionDescription="first version",
+            publish=True,
+        )
+        arn = response["stateMachineArn"]
+        version_arn1 = response["stateMachineVersionArn"]
+
+        # Use the initial version to describe the state machine
+        sm = client.describe_state_machine(stateMachineArn=arn)
+        assert "description" not in sm
+
+        version = client.describe_state_machine(stateMachineArn=version_arn1)
+        assert version["description"] == "first version"
+
+        update = client.update_state_machine(
+            stateMachineArn=arn,
+            definition=simple_definition,
+            versionDescription="second version",
+            publish=True,
+        )
+        version_arn2 = update["stateMachineVersionArn"]
+
+        version = client.describe_state_machine(stateMachineArn=version_arn2)
+        assert version["description"] == "second version"
+    finally:
+        client.delete_state_machine(stateMachineArn=arn)
+        iam.delete_role(RoleName=role_name)
+
+
+@aws_verified
+@pytest.mark.aws_verified
+def test_create_unpublished_state_machine_with_version_description():
+    iam = boto3.client("iam", region_name="us-east-1")
+    role_name = f"sfn_role_{str(uuid4())[0:6]}"
+    sfn_role = iam.create_role(
+        RoleName=role_name,
+        AssumeRolePolicyDocument=json.dumps(sfn_role_policy),
+        Path="/",
+    )["Role"]["Arn"]
+
+    client = boto3.client("stepfunctions", region_name="us-east-1")
+
+    try:
+        name = f"sfn_name_{str(uuid4())[0:6]}"
+
+        with pytest.raises(ClientError) as exc:
+            client.create_state_machine(
+                name=name,
+                definition=simple_definition,
+                roleArn=sfn_role,
+                versionDescription="first version of statemachine",
+            )
+        err = exc.value.response["Error"]
+        assert err["Code"] == "ValidationException"
+        assert (
+            err["Message"] == "Version description can only be set when publish is true"
+        )
+
+    finally:
+        iam.delete_role(RoleName=role_name)