diff --git a/.gitignore b/.gitignore
index cad5c2103..267e4101b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,7 @@
 *.swo
 *.swp
 *~
+otcextensions-*/
 .coverage
 .idea
 .stestr/
diff --git a/otcextensions/osclient/rds/v3/instance.py b/otcextensions/osclient/rds/v3/instance.py
index b03f0f863..5b1fc6e40 100644
--- a/otcextensions/osclient/rds/v3/instance.py
+++ b/otcextensions/osclient/rds/v3/instance.py
@@ -179,14 +179,15 @@ def get_parser(self, prog_name):
             help=_("Name of the instance.")
         )
         parser.add_argument(
-            'flavor_ref',
-            metavar='<flavor_ref>',
+            'flavor',
+            metavar='<flavor>',
             help=_("Flavor spec_code")
         )
         disk_group = parser.add_argument_group('Disk data')
         disk_group.add_argument(
             '--size',
             metavar='<size>',
+            dest='volume_size',
             type=int,
             required=True,
             help=_("Size of the instance disk volume in GB. ")
@@ -196,6 +197,7 @@ def get_parser(self, prog_name):
             metavar='{' + ','.join(DISK_TYPE_CHOICES) + '}',
             type=lambda s: s.upper(),
             required=True,
+            dest='volume_type',
             choices=[s.upper() for s in DISK_TYPE_CHOICES],
             help=_("Volume type. (COMMON, ULTRAHIGH).")
         )
@@ -224,7 +226,7 @@ def get_parser(self, prog_name):
         )
         parser.add_argument(
             '--configuration',
-            dest='configuration_id',
+            dest='configuration',
             metavar='<configuration_id>',
             default=None,
             help=_("ID of the configuration group to attach to the instance.")
@@ -253,16 +255,18 @@ def get_parser(self, prog_name):
         new_instance_group.add_argument(
             '--router-id',
             metavar='<router_id>',
+            dest='router',
             help=_('ID of a Router the DB should be connected to')
         )
         new_instance_group.add_argument(
             '--network-id',
             metavar='<net_id>',
+            dest='network',
             help=_('ID of a Neutron network the DB should be connected to.')
         )
         new_instance_group.add_argument(
             '--security-group-id',
-            dest='security_group_id',
+            dest='security_group',
             metavar='<security_group_id>',
             help=_('Security group ID')
         )
@@ -301,6 +305,17 @@ def get_parser(self, prog_name):
             metavar='<backup>',
             help=_('Backup ID or Name to create new instance from.')
         )
+        create_from_group.add_argument(
+            '--backup-keepdays',
+            metavar='<backup_keepday>',
+            help=_('Specifies the retention days for specific backup files.')
+        )
+        create_from_group.add_argument(
+            '--backup-timeframe',
+            metavar='<HH:MM-HH:MM>',
+            help=_('Specifies the backup time window. Automated backups will '
+                   'be triggered during the backup time window.')
+        )
         create_from_group.add_argument(
             '--restore-time',
             metavar='<time>',
@@ -321,166 +336,26 @@ def get_parser(self, prog_name):
 
     def take_action(self, parsed_args):
         # Attention: not conform password result in BadRequest with no info
-        client = self.app.client_manager.rds
-
+        client = self.app.client_manager
         attrs = {}
-        args_list = [
-            'name', 'availability_zone', 'configuration_id', 'region',
-            'router_id', 'network_id', 'security_group_id',
-            'disk_encryption_id', 'port', 'password', 'flavor_ref'
-        ]
-        for arg in args_list:
-            if getattr(parsed_args, arg):
-                attrs[arg] = getattr(parsed_args, arg)
-        volume = {}
-        if parsed_args.size:
-            volume = {"size": parsed_args.size}
-            if parsed_args.volume_type:
-                volume['type'] = parsed_args.volume_type
-            attrs['volume'] = volume
-        if parsed_args.datastore_type:
-            datastore = {
-                'type': parsed_args.datastore_type,
-                'version': parsed_args.datastore_version
-            }
-            attrs['datastore'] = datastore
-        if parsed_args.ha_mode:
-            ha = {'mode': 'ha', 'replication_mode': parsed_args.ha_mode}
-            attrs['ha'] = ha
-        if parsed_args.charge_mode:
-            attrs['charge_info'] = {'charge_mode': parsed_args.charge_mode}
-
-        new_instance_required = [
-            parsed_args.router_id,
-            parsed_args.network_id,
-            parsed_args.security_group_id,
-            parsed_args.password
-        ]
-
-        if (not parsed_args.replica_of
-                and not (parsed_args.datastore_type
-                         and parsed_args.datastore_version)):
-            raise exceptions.CommandError(
-                _('`--datastore-type` and `--datastore-version` are '
-                  'required')
-            )
-
-        if parsed_args.replica_of:
-            # Create replica
-            if (parsed_args.password or parsed_args.port
-                    or parsed_args.router_id or parsed_args.security_group_id
-                    or parsed_args.network_id):
-                raise exceptions.CommandError(
-                    _('Setting password/port/router/network/sg is not '
-                      'supported when creating replica')
-                )
-            src = client.find_instance(parsed_args.replica_of,
-                                       ignore_missing=False)
-            parsed_args.datastore_type = src['datastore']['type']
-            parsed_args.datastore_version = src['datastore']['version']
-            attrs['replica_of_id'] = src.id
-            attrs.pop('datastore', None)
-        elif parsed_args.from_instance:
-            source = client.find_instance(parsed_args.from_instance,
-                                          ignore_missing=False)
-            if parsed_args.backup:
-                # Create from backup
-                backup = client.find_backup(
-                    name_or_id=parsed_args.backup,
-                    instance=source,
-                    ignore_missing=False)
-                attrs['restore_point'] = {
-                    'type': 'backup',
-                    'backup_id': backup.id,
-                    'instance_id': backup.instance_id
-                }
-            elif parsed_args.restore_time:
-                attrs['restore_point'] = {
-                    'type': 'timestamp',
-                    'restore_time': parsed_args.restore_time,
-                    'instance_id': source.id
-                }
-        elif parsed_args.backup or parsed_args.restore_time:
-            raise exceptions.CommandError(
-                _('`--from-instance` is required when restoring from '
-                  'backup or using PITR.')
-            )
-        elif not all(new_instance_required):
-            raise exceptions.CommandError(
-                _('`--router-id`, `--subnet-id`, `--security-group-id`, '
-                  '`--password` parameters are required when creating '
-                  'new primary instance.')
-            )
-
-        flavors = list(client.flavors(
-            datastore_name=parsed_args.datastore_type,
-            version_name=parsed_args.datastore_version)
-        )
-        flavor = None
-        for f in flavors:
-            if f.name == parsed_args.flavor_ref:
-                flavor = f
-        if not flavor:
-            raise exceptions.CommandError(
-                _(
-                    'Flavor {flavor} can not be found'.format(
-                        flavor=parsed_args.flavor_ref)
-                )
-            )
-        if flavor.instance_mode == 'ha' and not parsed_args.ha_mode:
-            raise exceptions.CommandError(
-                _('`--ha-mode` is required when using HA enabled flavor')
-            )
-        if flavor.instance_mode != 'ha' and parsed_args.ha_mode:
-            raise exceptions.CommandError(
-                _('`ha` enabled flavor must be '
-                  'chosen when setting ha_mode')
-            )
-        if flavor.instance_mode != 'replica' and parsed_args.replica_of:
-            raise exceptions.CommandError(
-                _('`replica` enabled flavor must be '
-                  'chosen when creating replica')
-            )
-        if parsed_args.ha_mode:
-            if ',' not in parsed_args.availability_zone:
-                raise exceptions.CommandError(
-                    _('List of availability zones must be used when '
-                      'creating ha instance')
-                )
-        if parsed_args.ha_mode:
-            mode = parsed_args.ha_mode
-            if (parsed_args.datastore_type.lower() == 'postgresql'
-                    and mode not in ['async', 'sync']):
-                raise exceptions.CommandError(
-                    _('`async` or `sync` ha_mode can be used for '
-                      'PostgreSQL isntance')
-                )
-            elif (parsed_args.datastore_type.lower() == 'mysql'
-                    and mode not in ['async', 'semisync']):
-                raise exceptions.CommandError(
-                    _('`async` or `semisync` ha_mode can be used for '
-                      'MySQL isntance')
-                )
-            elif (parsed_args.datastore_type.lower() == 'sqlserver'
-                    and mode not in ['sync']):
-                raise exceptions.CommandError(
-                    _('Only `sync` ha_mode can be used for '
-                      'SQLServer isntance')
-                )
-        if parsed_args.wait_interval and not parsed_args.wait:
-            raise exceptions.CommandError(
-                _('`--wait-interval` is only valid with `--wait`')
-            )
-
-        obj = client.create_instance(**attrs)
-
-        if obj.job_id and parsed_args.wait:
-            wait_args = {}
-            if parsed_args.wait_interval:
-                wait_args['interval'] = parsed_args.wait_interval
-
-            client.wait_for_job(obj.job_id, **wait_args)
-            obj = client.get_instance(obj.id)
+        for attr in [
+            'availability_zone', 'backup', 'backup_keepdays',
+            'backup_timeframe', 'charge_mode', 'configuration',
+            'datastore_type', 'datastore_version', 'disk_encryption_id',
+            'flavor', 'from_instance', 'ha_mode', 'name', 'network',
+            'password', 'port', 'region', 'replica_of', 'restore_time',
+            'router', 'security_group', 'volume_size', 'volume_type', 'wait',
+            'wait_interval'
+        ]:
+            if getattr(parsed_args, attr):
+                attrs[attr] = getattr(parsed_args, attr)
+
+        if not parsed_args.wait:
+            attrs['wait'] = False
+
+        obj = client.create_rds_instance(
+            **attrs
+        )
 
         display_columns, columns = _get_columns(obj)
         data = utils.get_item_properties(obj, columns, formatters={})
diff --git a/otcextensions/sdk/__init__.py b/otcextensions/sdk/__init__.py
index 030d22517..7da252974 100644
--- a/otcextensions/sdk/__init__.py
+++ b/otcextensions/sdk/__init__.py
@@ -19,6 +19,8 @@
 from otcextensions.sdk.compute.v2 import server
 from otcextensions.common import exc
 
+from otcextensions.sdk.cloud import rds as _rds
+
 
 _logger = _log.setup_logging('openstack')
 
@@ -127,9 +129,8 @@
     },
     'rds': {
         'service_type': 'rds',
-        # 'additional_headers': {'content-type': 'application/json'},
         'endpoint_service_type': 'rdsv3',
-        'append_project_id': True,
+        'append_project_id': True
     },
     'sdrs': {
         'service_type': 'sdrs'
@@ -243,6 +244,13 @@ def get_ak_sk(conn):
         return(ak, sk)
 
 
+def extend_instance(obj, cls):
+    """Apply mixins to a class instance after creation"""
+    base_cls = obj.__class__
+    base_cls_name = obj.__class__.__name__
+    obj.__class__ = type(base_cls_name, (base_cls, cls), {})
+
+
 def patch_openstack_resources():
     openstack.compute.v2.server.Server._get_tag_struct = \
         server.Server._get_tag_struct
@@ -310,6 +318,8 @@ def load(conn, **kwargs):
 
     patch_openstack_resources()
 
+    extend_instance(conn, _rds.RdsMixin)
+
     return None
 
 
diff --git a/otcextensions/sdk/cloud/__init__.py b/otcextensions/sdk/cloud/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/otcextensions/sdk/cloud/rds.py b/otcextensions/sdk/cloud/rds.py
new file mode 100644
index 000000000..2bad6ab84
--- /dev/null
+++ b/otcextensions/sdk/cloud/rds.py
@@ -0,0 +1,266 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+from openstack import exceptions
+
+
+class RdsMixin:
+    def create_rds_instance(self, name,
+                            wait=True, timeout=180, wait_interval=5,
+                            **kwargs):
+        """Create RDS instance with all the checks
+
+        :param str availability_zone:
+        :param str backup: Name or ID of the backup to create
+            instance from (when from_instance is passed).
+        :param int backup_keepdays:
+        :param str backup_timeframe:
+        :param str charge_mode: Charge mode.
+        :param str configuration: dict(type=str),
+        :param str datastore_type: dict(type=str, default='postgresql'),
+        :param str datastore_version: dict(type=str),
+        :param str disk_encryption_id: dict(type=str),
+        :param str flavor: dict(required=True, type=str),
+        :param str from_instance: Name or ID of the instance to create
+            instance from (requires from_backup of restore_time).
+        :param str ha_mode: HA mode. choices=['async', 'semisync', 'sync']
+        :param str name: dict(required=True, type=str),
+        :param str network: dict(type=str),
+        :param str password: dict(type=str, no_log=True),
+        :param int port: dict(type=int),
+        :param str region: dict(type=str, choices=['eu-de'], default='eu -de'),
+        :param str replica_of: dict(type=str),
+        :param str restore_time: Restoration time.
+        :param str router: dict(type=str),
+        :param str security_group: dict(type=str),
+        :param str volume_type: dict(required=True, type=str),
+        :param int volume_size: dict(required=True, type=int),
+        :param bool wait: dict(type=bool, default=True),
+        :param int timeout: dict(type=int, default=180)
+        :param int wait_interval: Check interval.
+
+        :returns: The results of server creation
+        :rtype: :class:`~otcextensions.sdk.rds.v3.instance.Instance`
+        """
+
+        availability_zone = kwargs.get('availability_zone')
+        backup = kwargs.get('backup')
+        backup_keepdays = kwargs.get('backup_keepdays')
+        backup_timeframe = kwargs.get('backup_timeframe')
+        charge_mode = kwargs.get('charge_mode')
+        configuration = kwargs.get('configuration')
+        datastore_type = kwargs.get('datastore_type')
+        datastore_version = kwargs.get('datastore_version')
+        disk_encryption_id = kwargs.get('disk_encryption_id')
+        flavor = kwargs.get('flavor')
+        from_instance = kwargs.get('from_instance')
+        ha_mode = kwargs.get('ha_mode')
+        network = kwargs.get('network')
+        password = kwargs.get('password')
+        port = kwargs.get('port')
+        region = kwargs.get('region')
+        replica_of = kwargs.get('replica_of')
+        restore_time = kwargs.get('restore_time')
+        router = kwargs.get('router')
+        security_group = kwargs.get('security_group')
+        volume_type = kwargs.get('volume_type')
+        volume_size = kwargs.get('volume_size')
+
+        attrs = {}
+
+        attrs['name'] = name
+
+        if availability_zone:
+            attrs['availability_zone'] = availability_zone
+        if backup_keepdays and backup_timeframe:
+            backup_attrs = {}
+            backup_attrs['keep_days'] = backup_keepdays
+            backup_attrs['start_time'] = backup_timeframe
+            attrs['backup_strategy'] = backup_attrs
+        elif backup_keepdays or backup_timeframe:
+            raise exceptions.SDKException(
+                '`backup_keepdays` and `backup_timeframe` must be passed'
+                'together'
+            )
+        if charge_mode:
+            attrs['charge_info'] = {'charge_mode': charge_mode}
+        if configuration:
+            # TODO(not_gtema): find configuration
+            attrs['configuration_id'] = configuration
+        if datastore_type:
+            datastore = {
+                'type': datastore_type,
+                'version': datastore_version
+            }
+            attrs['datastore'] = datastore
+        if disk_encryption_id:
+            attrs['disk_encryption_id'] = disk_encryption_id
+        if flavor:
+            attrs['flavor_ref'] = flavor
+        if ha_mode:
+            ha = {'mode': 'ha', 'replication_mode': ha_mode}
+            attrs['ha'] = ha
+        if port:
+            attrs['port'] = port
+        if password:
+            attrs['password'] = password
+        if region:
+            attrs['region'] = region
+
+        volume = {}
+        if volume_size:
+            volume = {"size": volume_size}
+            if volume_type:
+                volume['type'] = volume_type
+            attrs['volume'] = volume
+
+        new_instance_required = [
+            router,
+            network,
+            security_group,
+            password
+        ]
+
+        if (not replica_of
+                and not (datastore_type and datastore_version)):
+            raise exceptions.SDKException(
+                '`--datastore-type` and `--datastore-version` are '
+                'required'
+            )
+
+        if replica_of:
+            # Create replica
+            if (
+                password or port
+                or router or security_group
+                or network
+            ):
+                raise exceptions.SDKException(
+                    'Setting password/port/router/network/sg is not '
+                    'supported when creating replica'
+                )
+            src = self.rds.find_instance(replica_of, ignore_missing=False)
+            datastore_type = src['datastore']['type']
+            datastore_version = src['datastore']['version']
+            attrs['replica_of_id'] = src.id
+            attrs.pop('datastore', None)
+        elif from_instance:
+            source = self.rds.find_instance(
+                from_instance, ignore_missing=False)
+            if backup:
+                # Create from backup
+                backup_obj = self.rds.find_backup(
+                    name_or_id=backup,
+                    instance=source,
+                    ignore_missing=False)
+                attrs['restore_point'] = {
+                    'type': 'backup',
+                    'backup_id': backup_obj.id,
+                    'instance_id': backup_obj.instance_id
+                }
+            elif restore_time:
+                attrs['restore_point'] = {
+                    'type': 'timestamp',
+                    'restore_time': restore_time,
+                    'instance_id': source.id
+                }
+        elif backup or restore_time:
+            raise exceptions.SDKException(
+                '`from-instance` is required when restoring from '
+                'backup or using PITR.'
+            )
+        elif not all(new_instance_required):
+            raise exceptions.SDKException(
+                '`router`, `subnet`, `security-group`, '
+                '`password` parameters are required when creating '
+                'new primary instance.'
+            )
+
+        flavors = list(self.rds.flavors(
+            datastore_name=datastore_type,
+            version_name=datastore_version)
+        )
+        flavor_obj = None
+        for f in flavors:
+            if f.name == flavor:
+                flavor_obj = f
+        if not flavor_obj:
+            raise exceptions.SDKException(
+                'Flavor {flavor} can not be found'.format(
+                    flavor=flavor)
+            )
+        if flavor_obj.instance_mode == 'ha' and not ha_mode:
+            raise exceptions.SDKException(
+                '`ha_mode` is required when using HA enabled flavor'
+            )
+        if flavor_obj.instance_mode != 'ha' and ha_mode:
+            raise exceptions.SDKException(
+                '`ha` enabled flavor must be '
+                'chosen when setting ha_mode'
+            )
+        if flavor_obj.instance_mode != 'replica' and replica_of:
+            raise exceptions.SDKException(
+                '`replica` enabled flavor must be '
+                'chosen when creating replica'
+            )
+        if ha_mode:
+            if ',' not in availability_zone:
+                raise exceptions.SDKException(
+                    'List of availability zones must be used when '
+                    'creating ha instance'
+                )
+        if ha_mode:
+            mode = ha_mode
+            if (datastore_type.lower() == 'postgresql'
+                    and mode not in ['async', 'sync']):
+                raise exceptions.SDKException(
+                    '`async` or `sync` ha_mode can be used for '
+                    'PostgreSQL isntance'
+                )
+            elif (datastore_type.lower() == 'mysql'
+                    and mode not in ['async', 'semisync']):
+                raise exceptions.SDKException(
+                    '`async` or `semisync` ha_mode can be used for '
+                    'MySQL isntance'
+                )
+            elif (datastore_type.lower() == 'sqlserver'
+                    and mode not in ['sync']):
+                raise exceptions.SDKException(
+                    'Only `sync` ha_mode can be used for '
+                    'SQLServer isntance'
+                )
+        if wait_interval and not wait:
+            raise exceptions.SDKException(
+                '`wait-interval` is only valid with `wait`'
+            )
+        if network:
+            network_obj = self.network.find_network(
+                network, ignore_missing=False)
+            attrs['network_id'] = network_obj.id
+        if security_group:
+            security_group_obj = self.network.find_security_group(
+                security_group, ignore_missing=False)
+            attrs['security_group_id'] = security_group_obj.id
+        if router:
+            router_obj = self.network.find_router(router, ignore_missing=False)
+            attrs['router_id'] = router_obj.id
+
+        obj = self.rds.create_instance(**attrs)
+
+        if obj.job_id and wait:
+            wait_args = {}
+            if wait_interval:
+                wait_args['interval'] = wait_interval
+
+            self.rds.wait_for_job(obj.job_id, **wait_args)
+            obj = self.rds.get_instance(obj.id)
+
+        return obj
diff --git a/otcextensions/tests/unit/base.py b/otcextensions/tests/unit/base.py
new file mode 100644
index 000000000..bc883f053
--- /dev/null
+++ b/otcextensions/tests/unit/base.py
@@ -0,0 +1,23 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+
+from openstack.tests.unit import base
+
+from otcextensions import sdk
+
+
+class TestCase(base.TestCase):
+
+    def setUp(self):
+        super(TestCase, self).setUp()
+        sdk.load(self.cloud)
diff --git a/otcextensions/tests/unit/osclient/anti_ddos/v1/fakes.py b/otcextensions/tests/unit/osclient/anti_ddos/v1/fakes.py
index 08ca91950..d949a9cc6 100644
--- a/otcextensions/tests/unit/osclient/anti_ddos/v1/fakes.py
+++ b/otcextensions/tests/unit/osclient/anti_ddos/v1/fakes.py
@@ -89,8 +89,8 @@ class FakeFloatingIPEvent(test_base.Fake):
     def generate(cls):
         object_info = {
             'floating_ip_id': uuid.uuid4().hex,
-            'start_time': time.clock() * 1000,
-            'end_time': time.clock() * 1000,
+            'start_time': time.time() * 1000,
+            'end_time': time.time() * 1000,
             'trigger_bps': random.randint(1, 5),
             'trigger_pps': random.randint(1, 5),
             'trigger_http_pps': random.randint(1, 5),
@@ -107,7 +107,7 @@ class FakeFloatingIPStatDay(test_base.Fake):
     def generate(cls):
         object_info = {
             'floating_ip_id': uuid.uuid4().hex,
-            'period_start': time.clock() * 1000,
+            'period_start': time.time() * 1000,
             'bps_in': random.randint(1, 5),
             'bps_attack': random.randint(1, 5),
             'total_bps': random.randint(1, 5),
@@ -126,7 +126,7 @@ class FakeFloatingIPStatWeek(test_base.Fake):
     def generate(cls):
         object_info = {
             'weekdata': [({
-                'period_start': time.clock() * 1000,
+                'period_start': time.time() * 1000,
                 'ddos_intercept_times': random.randint(1, 5),
                 'ddos_blackhole_times': random.randint(1, 5),
                 'max_attack_bps': random.randint(1, 5),
diff --git a/otcextensions/tests/unit/osclient/cts/v1/fakes.py b/otcextensions/tests/unit/osclient/cts/v1/fakes.py
index 221c736ac..a292c664f 100644
--- a/otcextensions/tests/unit/osclient/cts/v1/fakes.py
+++ b/otcextensions/tests/unit/osclient/cts/v1/fakes.py
@@ -44,7 +44,7 @@ def generate(cls):
             'name': uuid.uuid4().hex,
             'level': uuid.uuid4().hex,
             'type': uuid.uuid4().hex,
-            'time': time.clock() * 1000,
+            'time': time.time() * 1000,
             'user': uuid.uuid4().hex,
             'code': random.randint(1, 600),
             'service_type': uuid.uuid4().hex,
@@ -52,7 +52,7 @@ def generate(cls):
             'resource_name': uuid.uuid4().hex,
             'resource_id': uuid.uuid4().hex,
             'source_ip': uuid.uuid4().hex,
-            'record_time': time.clock() * 1000,
+            'record_time': time.time() * 1000,
             'request': uuid.uuid4().hex,
             'response': uuid.uuid4().hex,
         }
diff --git a/otcextensions/tests/unit/osclient/dns/v2/fakes.py b/otcextensions/tests/unit/osclient/dns/v2/fakes.py
index 115533f27..3ca763762 100644
--- a/otcextensions/tests/unit/osclient/dns/v2/fakes.py
+++ b/otcextensions/tests/unit/osclient/dns/v2/fakes.py
@@ -61,7 +61,7 @@ def generate(cls):
             'serial': random.randint(1, 600),
             'status': uuid.uuid4().hex,
             'ttl': random.randint(1, 600),
-            'updated_at': time.clock() * 1000,
+            'updated_at': time.time() * 1000,
             'zone_type': uuid.uuid4().hex,
         }
         obj = zone.Zone.existing(**object_info)
diff --git a/otcextensions/tests/unit/osclient/rds/v3/test_instance.py b/otcextensions/tests/unit/osclient/rds/v3/test_instance.py
index 197bdd11d..ce73900a3 100644
--- a/otcextensions/tests/unit/osclient/rds/v3/test_instance.py
+++ b/otcextensions/tests/unit/osclient/rds/v3/test_instance.py
@@ -12,8 +12,6 @@
 #
 import mock
 
-from osc_lib import exceptions
-
 from otcextensions.osclient.rds.v3 import instance
 from otcextensions.tests.unit.osclient.rds.v3 import fakes
 
@@ -242,8 +240,6 @@ def test_delete_wait(self):
 class TestCreateDatabaseInstance(fakes.TestRds):
 
     _data = fakes.FakeInstance.create_one()
-    other_instance = fakes.FakeInstance.create_one()
-    flavors = fakes.FakeFlavor.create_multiple(10)
 
     columns = ()
 
@@ -254,783 +250,74 @@ def setUp(self):
 
         self.cmd = instance.CreateDatabaseInstance(self.app, None)
 
-        self.client.flavors = mock.Mock(return_value=self.flavors)
-        self.flavor = self.find_flavor('single')
-        self.client.find_instance = mock.Mock(return_value=self.other_instance)
-        self.client.create_instance = mock.Mock(return_value=self._data)
-        self.client.get_instance = mock.Mock(return_value=self._data)
-        self.client.wait_for_job = mock.Mock()
+        self.client = self.app.client_manager
+
+        self.client.create_rds_instance = mock.Mock(return_value=self._data)
 
     def test_create(self):
         arglist = [
             'inst_name',
-            self.flavor.name,
+            'test-flavor',
             '--availability-zone', 'test-az-01',
+            '--backup', 'source_backup',
+            '--backup-keepdays', 'bkd',
+            '--backup-timeframe', 'xxx',
+            '--charge-mode', 'postpaid',
             '--configuration', '123',
             '--datastore-type', 'MySQL',
             '--datastore-version', '5.7',
             '--disk-encryption-id', '234',
-            '--router-id', 'test-vpc-id',
-            '--network-id', 'test-network-id',
-            '--security-group-id', 'test-sec_grp-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
-            '--port', '12345'
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', self.flavor.name),
-            ('availability_zone', 'test-az-01'),
-            ('datastore_type', 'MySQL'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region')]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.cmd.take_action(parsed_args)
-
-        self.client.find_instance.assert_not_called()
-
-        self.client.create_instance.assert_called_with(
-            availability_zone='test-az-01',
-            charge_info={'charge_mode': 'postPaid'},
-            configuration_id='123',
-            datastore={'type': 'MySQL', 'version': '5.7'},
-            disk_encryption_id='234',
-            flavor_ref=self.flavor.name,
-            name='inst_name',
-            password='testtest',
-            port=12345,
-            region='test-region',
-            router_id='test-vpc-id',
-            security_group_id='test-sec_grp-id',
-            volume={'size': 100, 'type': 'ULTRAHIGH'},
-            network_id='test-network-id'
-        )
-
-    def test_create_ha(self):
-        flavor = self.find_flavor('ha')
-        arglist = [
-            'inst_name',
-            flavor.name,
-            '--availability-zone', 'test-az-01,az2',
-            '--configuration', '123',
-            '--datastore-type', 'MySQL',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
+            '--from-instance', 'source_instance',
             '--ha-mode', 'async',
-            '--router-id', 'test-vpc-id',
             '--network-id', 'test-network-id',
-            '--security-group-id', 'test-sec_grp-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
+            '--password', 'CrackMe123',
             '--port', '12345',
-            '--wait'
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', flavor.name),
-            ('ha_mode', 'async'),
-            ('availability_zone', 'test-az-01,az2'),
-            ('datastore_type', 'MySQL'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region'),
-            ('wait', True)
-        ]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.cmd.take_action(parsed_args)
-
-        self.client.find_instance.assert_not_called()
-
-        self.client.create_instance.assert_called_with(
-            availability_zone='test-az-01,az2',
-            charge_info={'charge_mode': 'postPaid'},
-            configuration_id='123',
-            datastore={'type': 'MySQL', 'version': '5.7'},
-            disk_encryption_id='234',
-            flavor_ref=flavor.name,
-            name='inst_name',
-            password='testtest',
-            port=12345,
-            region='test-region',
-            router_id='test-vpc-id',
-            security_group_id='test-sec_grp-id',
-            volume={'size': 100, 'type': 'ULTRAHIGH'},
-            network_id='test-network-id',
-            ha={'mode': 'ha', 'replication_mode': 'async'}
-        )
-
-        self.client.wait_for_job.assert_called_with(self._data.job_id)
-        self.client.get_instance.assert_called_with(self._data.id)
-
-    def test_create_ha_wrong_az(self):
-        flavor = self.find_flavor('ha')
-        arglist = [
-            'inst_name',
-            flavor.name,
-            '--availability-zone', 'test-az-01',
-            '--configuration', '123',
-            '--datastore-type', 'MySQL',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
-            '--ha-mode', 'sync',
-            '--router-id', 'test-vpc-id',
-            '--network-id', 'test-network-id',
-            '--security-group-id', 'test-sec_grp-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
             '--region', 'test-region',
-            '--port', '12345',
-            '--wait'
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', flavor.name),
-            ('ha_mode', 'sync'),
-            ('availability_zone', 'test-az-01'),
-            ('datastore_type', 'MySQL'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region'),
-            ('wait', True)
-        ]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args)
-
-    def test_create_ha_wrong_mode_pg(self):
-        flavor = self.find_flavor('ha')
-        arglist = [
-            'inst_name',
-            flavor.name,
-            '--availability-zone', 'test-az-01,az2',
-            '--configuration', '123',
-            '--datastore-type', 'postgresql',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
-            '--ha-mode', 'semisync',
+            '--replica-of', 'replica_instance',
+            '--restore-time', 'restore_time_123',
             '--router-id', 'test-vpc-id',
-            '--network-id', 'test-network-id',
             '--security-group-id', 'test-sec_grp-id',
             '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
-            '--port', '12345',
-            '--wait'
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', flavor.name),
-            ('ha_mode', 'semisync'),
-            ('availability_zone', 'test-az-01,az2'),
-            ('datastore_type', 'postgresql'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region'),
-            ('wait', True)
-        ]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args)
-
-    def test_create_ha_wrong_mode_mysql(self):
-        flavor = self.find_flavor('ha')
-        arglist = [
-            'inst_name',
-            flavor.name,
-            '--availability-zone', 'test-az-01,az2',
-            '--configuration', '123',
-            '--datastore-type', 'MySQL',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
-            '--ha-mode', 'sync',
-            '--router-id', 'test-vpc-id',
-            '--network-id', 'test-network-id',
-            '--security-group-id', 'test-sec_grp-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
-            '--port', '12345',
-            '--wait'
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', flavor.name),
-            ('ha_mode', 'sync'),
-            ('availability_zone', 'test-az-01,az2'),
-            ('datastore_type', 'MySQL'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region'),
-            ('wait', True)
-        ]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args)
-
-    def test_create_ha_wrong_mode_mssql(self):
-        flavor = self.find_flavor('ha')
-        arglist = [
-            'inst_name',
-            flavor.name,
-            '--availability-zone', 'test-az-01,az2',
-            '--configuration', '123',
-            '--datastore-type', 'sqlserver',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
-            '--ha-mode', 'async',
-            '--router-id', 'test-vpc-id',
-            '--network-id', 'test-network-id',
-            '--security-group-id', 'test-sec_grp-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
-            '--port', '12345',
-            '--wait'
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', flavor.name),
-            ('ha_mode', 'async'),
-            ('availability_zone', 'test-az-01,az2'),
-            ('datastore_type', 'sqlserver'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region'),
-            ('wait', True)
-        ]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args)
-
-        arglist = [
-            'inst_name',
-            flavor.name,
-            '--availability-zone', 'test-az-01,az2',
-            '--configuration', '123',
-            '--datastore-type', 'sqlserver',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
-            '--ha-mode', 'semisync',
-            '--router-id', 'test-vpc-id',
-            '--network-id', 'test-network-id',
-            '--security-group-id', 'test-sec_grp-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
-            '--port', '12345',
-            '--wait'
+            '--size', '100'
         ]
 
         verifylist = [
             ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', flavor.name),
-            ('ha_mode', 'semisync'),
-            ('availability_zone', 'test-az-01,az2'),
-            ('datastore_type', 'sqlserver'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region'),
-            ('wait', True)
-        ]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args)
-
-    def find_flavor(self, instance_mode):
-        flavor = None
-        for f in self.flavors:
-            if f.instance_mode == instance_mode:
-                flavor = f
-        if not flavor:
-            self.flavors[0].instance_mode = instance_mode
-            flavor = self.flavors[0]
-        # For the moment just ensure we have found something
-        self.assertIsNotNone(flavor)
-        return flavor
-
-    def test_create_replica(self):
-        flavor = self.find_flavor('replica')
-        arglist = [
-            'inst_name',
-            flavor.name,
-            '--availability-zone', 'test-az-01',
-            '--configuration', '123',
-            '--disk-encryption-id', '234',
-            '--replica-of', 'fake_name',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--region', 'test-region',
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', flavor.name),
-            ('availability_zone', 'test-az-01'),
-            ('disk_encryption_id', '234'),
-            ('replica_of', 'fake_name'),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('region', 'test-region')]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.cmd.take_action(parsed_args)
-
-        self.client.flavors.assert_called_with(
-            datastore_name=self.other_instance.datastore['type'],
-            version_name=self.other_instance.datastore['version'])
-
-        self.client.find_instance.assert_called_with('fake_name',
-                                                     ignore_missing=False)
-
-        self.client.create_instance.assert_called_with(
-            availability_zone='test-az-01',
-            charge_info={'charge_mode': 'postPaid'},
-            configuration_id='123',
-            disk_encryption_id='234',
-            flavor_ref=flavor.name,
-            name='inst_name',
-            region='test-region',
-            replica_of_id=self.other_instance.id,
-            volume={'size': 100, 'type': 'ULTRAHIGH'},
-        )
-
-    def test_create_replica_exception(self):
-        arglist = [
-            'inst_name',
-            'test-flavor',
-            '--availability-zone', 'test-az-01',
-            '--configuration', '123',
-            '--datastore-type', 'MySQL',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
-            '--ha-mode', 'semisync',
-            '--replica-of', 'fake_name',
-            '--port', '5432',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--region', 'test-region',
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', 'test-flavor'),
-            ('availability_zone', 'test-az-01'),
-            ('datastore_type', 'MySQL'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('ha_mode', 'semisync'),
-            ('replica_of', 'fake_name'),
-            ('port', 5432),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('region', 'test-region')]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.assertRaises(exceptions.CommandError,
-                          self.cmd.take_action, parsed_args)
-
-    def test_create_from_instance_pir(self):
-        arglist = [
-            'inst_name',
-            self.flavor.name,
-            '--availability-zone', 'test-az-01',
-            '--configuration', '123',
-            '--datastore-type', 'MySQL',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
-            '--router-id', 'test-vpc-id',
-            '--network-id', 'test-network-id',
-            '--security-group-id', 'test-sec_grp-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
-            '--port', '12345',
-            '--from-instance', 'source_instance',
-            '--restore-time', 'abcde'
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', self.flavor.name),
-            ('availability_zone', 'test-az-01'),
-            ('datastore_type', 'MySQL'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region'),
-            ('from_instance', 'source_instance'),
-            ('restore_time', 'abcde')
-        ]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.cmd.take_action(parsed_args)
-
-        self.client.find_instance.assert_called_with('source_instance',
-                                                     ignore_missing=False)
-
-        self.client.create_instance.assert_called_with(
-            availability_zone='test-az-01',
-            charge_info={'charge_mode': 'postPaid'},
-            configuration_id='123',
-            datastore={'type': 'MySQL', 'version': '5.7'},
-            disk_encryption_id='234',
-            flavor_ref=self.flavor.name,
-            name='inst_name',
-            password='testtest',
-            port=12345,
-            region='test-region',
-            router_id='test-vpc-id',
-            security_group_id='test-sec_grp-id',
-            volume={'size': 100, 'type': 'ULTRAHIGH'},
-            network_id='test-network-id',
-            restore_point={
-                'type': 'timestamp',
-                'restore_time': 'abcde',
-                'instance_id': self.other_instance.id}
-        )
-
-        self.client.find_instance.assert_called_with('source_instance',
-                                                     ignore_missing=False)
-
-    def test_create_from_backup(self):
-        arglist = [
-            'inst_name',
-            self.flavor.name,
-            '--availability-zone', 'test-az-01',
-            '--configuration', '123',
-            '--datastore-type', 'MySQL',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
-            '--router-id', 'test-vpc-id',
-            '--network-id', 'test-network-id',
-            '--security-group-id', 'test-sec_grp-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
-            '--port', '12345',
-            '--backup', 'source_backup',
-            '--from-instance', 'source_instance'
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', self.flavor.name),
+            ('configuration', '123'),
+            ('flavor', 'test-flavor'),
             ('availability_zone', 'test-az-01'),
             ('datastore_type', 'MySQL'),
             ('datastore_version', '5.7'),
             ('disk_encryption_id', '234'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
+            ('router', 'test-vpc-id'),
+            ('network', 'test-network-id'),
+            ('security_group', 'test-sec_grp-id'),
             ('port', 12345),
             ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region'),
-            ('backup', 'source_backup'),
-            ('from_instance', 'source_instance')
-        ]
+            ('volume_size', 100),
+            ('password', 'CrackMe123'),
+            ('region', 'test-region')]
 
         # Verify cm is triggered with default parameters
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        backup = self.backup_mock.create_one()
-        self.client.find_backup = mock.Mock(return_value=backup)
-
         # Trigger the action
         self.cmd.take_action(parsed_args)
 
-        self.client.create_instance.assert_called_with(
-            availability_zone='test-az-01',
-            charge_info={'charge_mode': 'postPaid'},
-            configuration_id='123',
-            datastore={'type': 'MySQL', 'version': '5.7'},
-            disk_encryption_id='234',
-            flavor_ref=self.flavor.name,
-            name='inst_name',
-            password='testtest',
-            port=12345,
-            region='test-region',
-            router_id='test-vpc-id',
-            security_group_id='test-sec_grp-id',
-            volume={'size': 100, 'type': 'ULTRAHIGH'},
-            network_id='test-network-id',
-            restore_point={
-                'type': 'backup',
-                'backup_id': backup.id,
-                'instance_id': backup.instance_id}
-        )
-
-        self.client.find_instance.assert_called_with('source_instance',
-                                                     ignore_missing=False)
-        self.client.find_backup.assert_called_with(
-            instance=self.other_instance,
-            name_or_id='source_backup',
-            ignore_missing=False)
-
-    def test_create_from_backup_no_instance(self):
-        arglist = [
-            'inst_name',
-            'test-flavor',
-            '--availability-zone', 'test-az-01',
-            '--configuration', '123',
-            '--datastore-type', 'MySQL',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
-            '--ha-mode', 'semisync',
-            '--router-id', 'test-vpc-id',
-            '--network-id', 'test-network-id',
-            '--security-group-id', 'test-sec_grp-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
-            '--port', '12345',
-            '--backup', 'source_backup',
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', 'test-flavor'),
-            ('availability_zone', 'test-az-01'),
-            ('datastore_type', 'MySQL'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('ha_mode', 'semisync'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region'),
-            ('backup', 'source_backup'),
-        ]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.assertRaises(
-            exceptions.CommandError,
-            self.cmd.take_action,
-            parsed_args
+        self.client.create_rds_instance.assert_called_with(
+            availability_zone='test-az-01', backup='source_backup',
+            backup_keepdays='bkd', backup_timeframe='xxx',
+            charge_mode='postpaid', configuration='123',
+            datastore_type='MySQL', datastore_version='5.7',
+            disk_encryption_id='234', flavor='test-flavor',
+            from_instance='source_instance', ha_mode='async', name='inst_name',
+            network='test-network-id', password='CrackMe123', port=12345,
+            region='test-region', replica_of='replica_instance',
+            restore_time='restore_time_123', router='test-vpc-id',
+            security_group='test-sec_grp-id', volume_size=100,
+            volume_type='ULTRAHIGH', wait=False
         )
 
-    def test_create_primary_missing_params(self):
-        arglist = [
-            'inst_name',
-            'test-flavor',
-            '--availability-zone', 'test-az-01',
-            '--configuration', '123',
-            '--datastore-type', 'MySQL',
-            '--datastore-version', '5.7',
-            '--disk-encryption-id', '234',
-            '--ha-mode', 'semisync',
-            '--router-id', 'test-vpc-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
-            '--port', '12345'
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', 'test-flavor'),
-            ('availability_zone', 'test-az-01'),
-            ('datastore_type', 'MySQL'),
-            ('datastore_version', '5.7'),
-            ('disk_encryption_id', '234'),
-            ('ha_mode', 'semisync'),
-            ('router_id', 'test-vpc-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region')]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        # Trigger the action
-        self.assertRaises(exceptions.CommandError,
-                          self.cmd.take_action,
-                          parsed_args)
-
-    def test_create_missing_datastore(self):
-        arglist = [
-            'inst_name',
-            self.flavor.name,
-            '--availability-zone', 'test-az-01',
-            '--configuration', '123',
-            '--disk-encryption-id', '234',
-            '--router-id', 'test-vpc-id',
-            '--network-id', 'test-network-id',
-            '--security-group-id', 'test-sec_grp-id',
-            '--volume-type', 'ULTRAHIGH',
-            '--size', '100',
-            '--password', 'testtest',
-            '--region', 'test-region',
-            '--port', '12345'
-        ]
-
-        verifylist = [
-            ('name', 'inst_name'),
-            ('configuration_id', '123'),
-            ('flavor_ref', self.flavor.name),
-            ('availability_zone', 'test-az-01'),
-            ('disk_encryption_id', '234'),
-            ('router_id', 'test-vpc-id'),
-            ('network_id', 'test-network-id'),
-            ('security_group_id', 'test-sec_grp-id'),
-            ('port', 12345),
-            ('volume_type', 'ULTRAHIGH'),
-            ('size', 100),
-            ('password', 'testtest'),
-            ('region', 'test-region')]
-
-        # Verify cm is triggered with default parameters
-        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-
-        self.assertRaises(exceptions.CommandError,
-                          self.cmd.take_action,
-                          parsed_args)
-
 
 class TestRestoreDatabaseInstance(fakes.TestRds):
 
diff --git a/otcextensions/tests/unit/sdk/base.py b/otcextensions/tests/unit/sdk/base.py
new file mode 100644
index 000000000..a5b6e12ce
--- /dev/null
+++ b/otcextensions/tests/unit/sdk/base.py
@@ -0,0 +1,46 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+
+from openstack.tests.unit import base
+
+from otcextensions import sdk
+
+
+class TestCase(base.TestCase):
+
+    def setUp(self):
+        super(TestCase, self).setUp()
+        sdk.load(self.cloud)
+        self.cloud.config.config['rdsv3_api_version'] = '3'
+
+    def get_keystone_v3_token(
+            self,
+            project_name='admin',
+    ):
+        ets = self.os_fixture._get_endpoint_templates('rdsv3')
+        svc = self.os_fixture.v3_token.add_service('rdsv3', name='rdsv3')
+        svc.add_standard_endpoints(region='RegionOne', **ets)
+
+        return super(TestCase, self).get_keystone_v3_token()
+
+    def get_rds_url(self, resource=None,
+                    append=None, base_url_append=None,
+                    qs_elements=None):
+        url = self.get_mock_url(
+            'rdsv3', resource=resource,
+            append=append, base_url_append=base_url_append,
+            qs_elements=qs_elements)
+
+        url = url % {'project_id': self.cloud.current_project_id}
+
+        return url
diff --git a/otcextensions/tests/unit/sdk/cloud/__init__.py b/otcextensions/tests/unit/sdk/cloud/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/otcextensions/tests/unit/sdk/cloud/test_rds.py b/otcextensions/tests/unit/sdk/cloud/test_rds.py
new file mode 100644
index 000000000..254f1420f
--- /dev/null
+++ b/otcextensions/tests/unit/sdk/cloud/test_rds.py
@@ -0,0 +1,885 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+
+from openstack import exceptions
+
+from otcextensions.tests.unit.sdk import base
+
+
+class TestRdsMixin(base.TestCase):
+
+    flavor = {'id': 1, 'name': 'test'}
+
+    def setUp(self):
+        super(TestRdsMixin, self).setUp()
+
+    def test_create_rds_instance(self):
+        self.register_uris([
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    base_url_append='flavors/MySQL',
+                    qs_elements=['version_name=5.7']
+                ),
+                status_code=200,
+                json={"flavors": [
+                     {
+                         "vcpus": "2",
+                         "ram": 8,
+                         "id": "1",
+                         "spec_code": "rds.mysql.s1.large",
+                         "instance_mode": "single",
+                         "az_status": {
+                             "eu-de-02": "normal",
+                             "eu-de-01": "normal",
+                             "eu-de-03": "normal"},
+                         "version_name": ["5.7"]}]}),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='networks',
+                    base_url_append='v2.0',
+                    append=['test-network-id']
+                ),
+                json={'id': 'fake'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='security-groups',
+                    base_url_append='v2.0',
+                    append=['test-sec_grp-id']
+                ),
+                json={'id': 'fake'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='routers',
+                    base_url_append='v2.0',
+                    append=['test-vpc-id']
+                ),
+                json={'id': 'fake'}
+            ),
+            dict(
+                method='POST',
+                uri=self.get_rds_url(
+                    resource='instances'
+                ),
+                status_code=200,
+                json={
+                    'instance': {'id': 123987},
+                    'job_id': '15'
+                }
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='jobs',
+                    qs_elements=['id=15']
+                ),
+                status_code=200,
+                json={'status': 'completed'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='instances',
+                    qs_elements=['id=123987']
+                ),
+                status_code=200,
+                json={'instances': [{'id': 123987, 'name': 'inst_name'}]}
+            )
+        ])
+
+        obj = self.cloud.create_rds_instance(
+            availability_zone='test-az-01',
+            charge_info={'charge_mode': 'postPaid'},
+            configuration='123',
+            datastore_type='MySQL',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            flavor='rds.mysql.s1.large',
+            name='inst_name',
+            password='testtest',
+            port=12345,
+            region='test-region',
+            router='test-vpc-id',
+            security_group='test-sec_grp-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH',
+            network='test-network-id'
+        )
+
+        self.assert_calls()
+
+        self.assertEqual('inst_name', obj.name)
+
+    def test_create_rds_instance_ha(self):
+        self.register_uris([
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    base_url_append='flavors/MySQL',
+                    qs_elements=['version_name=5.7']
+                ),
+                status_code=200,
+                json={"flavors": [
+                     {
+                         "vcpus": "2",
+                         "ram": 8,
+                         "id": "1",
+                         "spec_code": "rds.mysql.s1.large.ha",
+                         "instance_mode": "ha",
+                         "az_status": {
+                             "eu-de-02": "normal",
+                             "eu-de-01": "normal",
+                             "eu-de-03": "normal"},
+                         "version_name": ["5.7"]}]}),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='networks',
+                    base_url_append='v2.0',
+                    append=['test-network-id']
+                ),
+                json={'id': 'fake'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='security-groups',
+                    base_url_append='v2.0',
+                    append=['test-sec_grp-id']
+                ),
+                json={'id': 'fake'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='routers',
+                    base_url_append='v2.0',
+                    append=['test-vpc-id']
+                ),
+                json={'id': 'fake'}
+            ),
+            dict(
+                method='POST',
+                uri=self.get_rds_url(
+                    resource='instances'
+                ),
+                status_code=200,
+                json={
+                    'instance': {'id': 123987},
+                    'job_id': '15'
+                }
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='jobs',
+                    qs_elements=['id=15']
+                ),
+                status_code=200,
+                json={'status': 'completed'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='instances',
+                    qs_elements=['id=123987']
+                ),
+                status_code=200,
+                json={'instances': [{'id': 123987, 'name': 'inst_name'}]}
+            )
+        ])
+
+        obj = self.cloud.create_rds_instance(
+            availability_zone='test-az-01,az2',
+            charge_info={'charge_mode': 'postPaid'},
+            configuration='123',
+            datastore_type='MySQL',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            flavor='rds.mysql.s1.large.ha',
+            ha_mode='async',
+            name='inst_name',
+            password='testtest',
+            port=12345,
+            region='test-region',
+            router='test-vpc-id',
+            security_group='test-sec_grp-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH',
+            network='test-network-id'
+        )
+
+        self.assert_calls()
+
+        self.assertEqual('inst_name', obj.name)
+
+    def test_create_rds_instance_ha_wrong_az(self):
+        self.register_uris([
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    base_url_append='flavors/MySQL',
+                    qs_elements=['version_name=5.7']
+                ),
+                status_code=200,
+                json={"flavors": [
+                     {
+                         "vcpus": "2",
+                         "ram": 8,
+                         "id": "1",
+                         "spec_code": "rds.mysql.s1.large.ha",
+                         "instance_mode": "ha",
+                         "az_status": {
+                             "eu-de-02": "normal",
+                             "eu-de-01": "normal",
+                             "eu-de-03": "normal"},
+                         "version_name": ["5.7"]}]})
+        ])
+
+        self.assertRaises(
+            exceptions.SDKException,
+            self.cloud.create_rds_instance,
+            availability_zone='test-az-01',
+            charge_info={'charge_mode': 'postPaid'},
+            configuration='123',
+            datastore_type='MySQL',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            flavor='rds.mysql.s1.large.ha',
+            ha_mode='async',
+            name='inst_name',
+            password='testtest',
+            port=12345,
+            region='test-region',
+            router='test-vpc-id',
+            security_group='test-sec_grp-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH',
+            network='test-network-id'
+        )
+
+        self.assert_calls()
+
+    def test_create_rds_instance_ha_wrong_mode_pg(self):
+        self.register_uris([
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    base_url_append='flavors/postgresql',
+                    qs_elements=['version_name=5.7']
+                ),
+                status_code=200,
+                json={"flavors": [
+                     {
+                         "vcpus": "2",
+                         "ram": 8,
+                         "id": "1",
+                         "spec_code": "rds.pg.s1.large.ha",
+                         "instance_mode": "ha",
+                         "az_status": {
+                             "eu-de-02": "normal",
+                             "eu-de-01": "normal",
+                             "eu-de-03": "normal"},
+                         "version_name": ["5.7"]}]})
+        ])
+
+        self.assertRaises(
+            exceptions.SDKException,
+            self.cloud.create_rds_instance,
+            availability_zone='test-az-01,az2',
+            charge_info={'charge_mode': 'postPaid'},
+            configuration='123',
+            datastore_type='postgresql',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            flavor='rds.mysql.s1.large.ha',
+            ha_mode='semisync',
+            name='inst_name',
+            password='testtest',
+            port=12345,
+            region='test-region',
+            router='test-vpc-id',
+            security_group='test-sec_grp-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH',
+            network='test-network-id'
+        )
+
+        self.assert_calls()
+
+    def test_create_rds_instance_ha_wrong_mode_mysql(self):
+        self.register_uris([
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    base_url_append='flavors/MySQL',
+                    qs_elements=['version_name=5.7']
+                ),
+                status_code=200,
+                json={"flavors": [
+                     {
+                         "vcpus": "2",
+                         "ram": 8,
+                         "id": "1",
+                         "spec_code": "rds.pg.s1.large.ha",
+                         "instance_mode": "ha",
+                         "az_status": {
+                             "eu-de-02": "normal",
+                             "eu-de-01": "normal",
+                             "eu-de-03": "normal"},
+                         "version_name": ["5.7"]}]})
+        ])
+
+        self.assertRaises(
+            exceptions.SDKException,
+            self.cloud.create_rds_instance,
+            availability_zone='test-az-01,az2',
+            charge_info={'charge_mode': 'postPaid'},
+            configuration='123',
+            datastore_type='MySQL',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            flavor='rds.mysql.s1.large.ha',
+            ha_mode='sync',
+            name='inst_name',
+            password='testtest',
+            port=12345,
+            region='test-region',
+            router='test-vpc-id',
+            security_group='test-sec_grp-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH',
+            network='test-network-id'
+        )
+
+        self.assert_calls()
+
+    def test_create_rds_instance_ha_wrong_mode_mssql(self):
+        self.register_uris([
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    base_url_append='flavors/sqlserver',
+                    qs_elements=['version_name=5.7']
+                ),
+                status_code=200,
+                json={"flavors": [
+                     {
+                         "vcpus": "2",
+                         "ram": 8,
+                         "id": "1",
+                         "spec_code": "rds.pg.s1.large.ha",
+                         "instance_mode": "ha",
+                         "az_status": {
+                             "eu-de-02": "normal",
+                             "eu-de-01": "normal",
+                             "eu-de-03": "normal"},
+                         "version_name": ["5.7"]}]})
+        ])
+
+        self.assertRaises(
+            exceptions.SDKException,
+            self.cloud.create_rds_instance,
+            availability_zone='test-az-01,az2',
+            charge_info={'charge_mode': 'postPaid'},
+            configuration='123',
+            datastore_type='sqlserver',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            flavor='rds.mysql.s1.large.ha',
+            ha_mode='async',
+            name='inst_name',
+            password='testtest',
+            port=12345,
+            region='test-region',
+            router='test-vpc-id',
+            security_group='test-sec_grp-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH',
+            network='test-network-id'
+        )
+
+        self.assert_calls()
+
+    def test_rds_create_replica(self):
+        self.register_uris([
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='instances',
+                    qs_elements=['id=fake_name']
+                ),
+                status_code=200,
+                json={'instances': [{
+                    'id': 123987,
+                    'name': 'fake_name',
+                    'datastore': {'type': 'MySQL', 'version': '5.7'}}]}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    base_url_append='flavors/MySQL',
+                    qs_elements=['version_name=5.7']
+                ),
+                status_code=200,
+                json={"flavors": [
+                     {
+                         "vcpus": "2",
+                         "ram": 8,
+                         "id": "1",
+                         "spec_code": "rds.mysql.s1.large.replica",
+                         "instance_mode": "replica",
+                         "az_status": {
+                             "eu-de-02": "normal",
+                             "eu-de-01": "normal",
+                             "eu-de-03": "normal"},
+                         "version_name": ["5.7"]}]}
+            ),
+            dict(
+                method='POST',
+                uri=self.get_rds_url(
+                    resource='instances'
+                ),
+                status_code=200,
+                json={
+                    'instance': {'id': 1239876},
+                    'job_id': '15'
+                }
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='jobs',
+                    qs_elements=['id=15']
+                ),
+                status_code=200,
+                json={'status': 'completed'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='instances',
+                    qs_elements=['id=1239876']
+                ),
+                status_code=200,
+                json={'instances': [{
+                    'id': 1239876,
+                    'name': 'copy_name'}]}
+            )
+        ])
+
+        obj = self.cloud.create_rds_instance(
+            availability_zone='test-az-01',
+            configuration='123',
+            disk_encryption_id='234',
+            flavor='rds.mysql.s1.large.replica',
+            name='inst_name',
+            replica_of='fake_name',
+            volume_size=100,
+            volume_type='ULTRAHIGH'
+        )
+
+        self.assert_calls()
+
+        self.assertEqual('copy_name', obj.name)
+
+    def test_create_rds_instance_replica_exception(self):
+        """setting port with replica not allowed"""
+
+        self.assertRaises(
+            exceptions.SDKException,
+            self.cloud.create_rds_instance,
+            configuration='123',
+            datastore_type='MySQL',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            flavor='test-flavor',
+            replica_of='fake_name',
+            ha_mode='semisync',
+            name='inst_name',
+            port=5432,
+            region='test-region',
+            volume_size=100,
+            volume_type='ULTRAHIGH',
+        )
+
+        self.assert_calls()
+
+    def test_rds_create_from_instance_pir(self):
+        self.register_uris([
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='instances',
+                    qs_elements=['id=source_instance']
+                ),
+                status_code=200,
+                json={'instances': [{
+                    'id': 123987,
+                    'name': 'source_instance',
+                    'datastore': {'type': 'MySQL', 'version': '5.7'}}]}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    base_url_append='flavors/MySQL',
+                    qs_elements=['version_name=5.7']
+                ),
+                status_code=200,
+                json={"flavors": [
+                     {
+                         "vcpus": "2",
+                         "ram": 8,
+                         "id": "1",
+                         "spec_code": "rds.mysql.s1.large",
+                         "instance_mode": "single",
+                         "az_status": {
+                             "eu-de-02": "normal",
+                             "eu-de-01": "normal",
+                             "eu-de-03": "normal"},
+                         "version_name": ["5.7"]}]}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='networks',
+                    base_url_append='v2.0',
+                    append=['test-network-id']
+                ),
+                json={'id': 'fake'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='security-groups',
+                    base_url_append='v2.0',
+                    append=['test-sec_grp-id']
+                ),
+                json={'id': 'fake'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='routers',
+                    base_url_append='v2.0',
+                    append=['test-vpc-id']
+                ),
+                json={'id': 'fake'}
+            ),
+
+            dict(
+                method='POST',
+                uri=self.get_rds_url(
+                    resource='instances'
+                ),
+                status_code=200,
+                json={
+                    'instance': {'id': 1239876},
+                    'job_id': '15'
+                },
+                validate=dict(
+                    json={
+                        'availability_zone': 'test-az-01',
+                        'configuration_id': '123',
+                        'datastore': {'type': 'MySQL', 'version': '5.7'},
+                        'disk_encryption_id': '234',
+                        'flavor_ref': 'rds.mysql.s1.large',
+                        'name': 'inst_name',
+                        'port': 12345,
+                        'region': 'test-region',
+                        'restore_point': {'instance_id': 123987,
+                                          'restore_time': 'abcde',
+                                          'type': 'timestamp'},
+                        'security_group_id': 'fake',
+                        'subnet_id': 'fake',
+                        'volume': {'size': 100, 'type': 'ULTRAHIGH'},
+                        'vpc_id': 'fake'}
+                )
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='jobs',
+                    qs_elements=['id=15']
+                ),
+                status_code=200,
+                json={'status': 'completed'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='instances',
+                    qs_elements=['id=1239876']
+                ),
+                status_code=200,
+                json={'instances': [{
+                    'id': 1239876,
+                    'name': 'inst_name'}]}
+            )
+        ])
+
+        obj = self.cloud.create_rds_instance(
+            availability_zone='test-az-01',
+            configuration='123',
+            datastore_type='MySQL',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            flavor='rds.mysql.s1.large',
+            from_instance='source_instance',
+            name='inst_name',
+            network='test-network-id',
+            port=12345,
+            region='test-region',
+            restore_time='abcde',
+            router='test-vpc-id',
+            security_group='test-sec_grp-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH'
+        )
+
+        self.assert_calls()
+
+        self.assertEqual('inst_name', obj.name)
+
+    def test_rds_create_from_backup(self):
+        self.register_uris([
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='instances',
+                    qs_elements=['id=source_instance']
+                ),
+                status_code=200,
+                json={'instances': [{
+                    'id': 123987,
+                    'name': 'source_instance',
+                    'datastore': {'type': 'MySQL', 'version': '5.7'}}]}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='backups',
+                    qs_elements=['instance_id=123987',
+                                 'backup_id=source_backup']
+                ),
+                status_code=200,
+                json={'backups': [{
+                    'id': 12,
+                    'name': 'source_backup',
+                    'datastore': {'type': 'MySQL', 'version': '5.7'}}]}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    base_url_append='flavors/MySQL',
+                    qs_elements=['version_name=5.7']
+                ),
+                status_code=200,
+                json={"flavors": [
+                     {
+                         "vcpus": "2",
+                         "ram": 8,
+                         "id": "1",
+                         "spec_code": "rds.mysql.s1.large",
+                         "instance_mode": "single",
+                         "az_status": {
+                             "eu-de-02": "normal",
+                             "eu-de-01": "normal",
+                             "eu-de-03": "normal"},
+                         "version_name": ["5.7"]}]}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='networks',
+                    base_url_append='v2.0',
+                    append=['test-network-id']
+                ),
+                json={'id': 'fake'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='security-groups',
+                    base_url_append='v2.0',
+                    append=['test-sec_grp-id']
+                ),
+                json={'id': 'fake'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_mock_url(
+                    'network',
+                    resource='routers',
+                    base_url_append='v2.0',
+                    append=['test-vpc-id']
+                ),
+                json={'id': 'fake'}
+            ),
+
+            dict(
+                method='POST',
+                uri=self.get_rds_url(
+                    resource='instances'
+                ),
+                status_code=200,
+                json={
+                    'instance': {'id': 1239876},
+                    'job_id': '15'
+                },
+                validate=dict(
+                    json={
+                        'availability_zone': 'test-az-01',
+                        'configuration_id': '123',
+                        'datastore': {'type': 'MySQL', 'version': '5.7'},
+                        'disk_encryption_id': '234',
+                        'flavor_ref': 'rds.mysql.s1.large',
+                        'name': 'inst_name',
+                        'port': 12345,
+                        'region': 'test-region',
+                        'restore_point': {
+                            'backup_id': 12,
+                            'instance_id': 123987,
+                            'type': 'backup'},
+                        'security_group_id': 'fake',
+                        'subnet_id': 'fake',
+                        'volume': {'size': 100, 'type': 'ULTRAHIGH'},
+                        'vpc_id': 'fake'}
+                )
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='jobs',
+                    qs_elements=['id=15']
+                ),
+                status_code=200,
+                json={'status': 'completed'}
+            ),
+            dict(
+                method='GET',
+                uri=self.get_rds_url(
+                    resource='instances',
+                    qs_elements=['id=1239876']
+                ),
+                status_code=200,
+                json={'instances': [{
+                    'id': 1239876,
+                    'name': 'inst_name'}]}
+            )
+        ])
+
+        obj = self.cloud.create_rds_instance(
+            availability_zone='test-az-01',
+            backup='source_backup',
+            configuration='123',
+            datastore_type='MySQL',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            flavor='rds.mysql.s1.large',
+            from_instance='source_instance',
+            name='inst_name',
+            network='test-network-id',
+            port=12345,
+            region='test-region',
+            router='test-vpc-id',
+            security_group='test-sec_grp-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH'
+        )
+
+        self.assert_calls()
+
+        self.assertEqual('inst_name', obj.name)
+
+    def test_rds_create_from_backup_no_instance(self):
+        self.assertRaises(
+            exceptions.SDKException,
+            self.cloud.create_rds_instance,
+            availability_zone='test-az-01',
+            backup='source_backup',
+            configuration='123',
+            datastore_type='MySQL',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            ha_mode='semisync',
+            flavor='rds.mysql.s1.large',
+            name='inst_name',
+            network='test-network-id',
+            port=12345,
+            region='test-region',
+            router='test-vpc-id',
+            security_group='test-sec_grp-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH'
+        )
+
+        self.assert_calls()
+
+    def test_rds_create_primary_missing_params(self):
+        self.assertRaises(
+            exceptions.SDKException,
+            self.cloud.create_rds_instance,
+            availability_zone='test-az-01',
+            configuration='123',
+            datastore_type='MySQL',
+            datastore_version='5.7',
+            disk_encryption_id='234',
+            ha_mode='semisync',
+            flavor='rds.mysql.s1.large',
+            name='inst_name',
+            port=12345,
+            region='test-region',
+            router='test-vpc-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH'
+        )
+
+        self.assert_calls()
+
+    def test_rds_create_primary_missing_datastore(self):
+        self.assertRaises(
+            exceptions.SDKException,
+            self.cloud.create_rds_instance,
+            availability_zone='test-az-01',
+            configuration='123',
+            disk_encryption_id='234',
+            ha_mode='semisync',
+            flavor='rds.mysql.s1.large',
+            name='inst_name',
+            network='test-network-id',
+            port=12345,
+            region='test-region',
+            router='test-vpc-id',
+            security_group='test-sec_grp-id',
+            volume_size=100,
+            volume_type='ULTRAHIGH'
+        )
+
+        self.assert_calls()
diff --git a/requirements.txt b/requirements.txt
index 831e89211..1e9fdb979 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,5 +2,5 @@
 # of appearance. Changing the order has an impact on the overall integration
 # process, which may cause wedges in the gate later.
 
-openstacksdk>=0.36.0,<0.43.0 # Apache-2.0
+openstacksdk>=0.36.0 # Apache-2.0
 oslo.i18n>3.15.3 # Apache-2.0