From 0b0939b87c9bc598f72ca702372762edd6323763 Mon Sep 17 00:00:00 2001
From: Vineet Pruthi <48789821+vineet-pruthi@users.noreply.github.com>
Date: Fri, 11 Oct 2019 15:34:47 +0200
Subject: [PATCH] Rds v3 (#50)

* Adding RDS v3 implementation
---
 doc/source/enforcer.py                        |    1 +
 .../user/proxies/{rds.rst => rds_v1.rst}      |    0
 doc/source/user/proxies/rds_v3.rst            |   55 +
 doc/source/user/resources/rds/index.rst       |    3 +
 .../user/resources/rds/v3/configuration.rst   |   13 +
 doc/source/user/resources/rds/v3/flavor.rst   |   13 +
 doc/source/user/resources/rds/v3/instance.rst |   13 +
 otcextensions/osclient/rds/client.py          |   14 +-
 otcextensions/osclient/rds/v3/__init__.py     |    0
 otcextensions/osclient/rds/v3/backup.py       |  211 +++
 .../osclient/rds/v3/configuration.py          |  300 ++++
 otcextensions/osclient/rds/v3/datastore.py    |   69 +
 otcextensions/osclient/rds/v3/flavor.py       |   63 +
 otcextensions/osclient/rds/v3/instance.py     |  663 +++++++++
 otcextensions/sdk/__init__.py                 |    1 +
 otcextensions/sdk/job.py                      |   99 ++
 otcextensions/sdk/rds/rds_service.py          |    6 +-
 otcextensions/sdk/rds/v3/__init__.py          |    0
 otcextensions/sdk/rds/v3/_base.py             |  146 ++
 otcextensions/sdk/rds/v3/_proxy.py            |  402 ++++++
 otcextensions/sdk/rds/v3/backup.py            |   97 ++
 otcextensions/sdk/rds/v3/configuration.py     |  104 ++
 otcextensions/sdk/rds/v3/datastore.py         |   30 +
 otcextensions/sdk/rds/v3/flavor.py            |   39 +
 otcextensions/sdk/rds/v3/instance.py          |  314 +++++
 .../tests/functional/osclient/rds/__init__.py |    0
 .../functional/osclient/rds/v3/__init__.py    |    0
 .../osclient/rds/v3/test_configuration.py     |  148 ++
 .../osclient/rds/v3/test_datastore.py         |   35 +
 .../functional/osclient/rds/v3/test_flavor.py |   36 +
 .../osclient/rds/v3/test_instance.py          |   39 +
 .../tests/unit/osclient/dns/v2/fakes.py       |   21 +-
 .../tests/unit/osclient/rds/v3/__init__.py    |    0
 .../tests/unit/osclient/rds/v3/fakes.py       |  204 +++
 .../tests/unit/osclient/rds/v3/test_backup.py |  280 ++++
 .../osclient/rds/v3/test_configuration.py     |  412 ++++++
 .../unit/osclient/rds/v3/test_datastore.py    |   96 ++
 .../tests/unit/osclient/rds/v3/test_flavor.py |   61 +
 .../unit/osclient/rds/v3/test_instance.py     | 1212 +++++++++++++++++
 otcextensions/tests/unit/sdk/rds/__init__.py  |    0
 .../tests/unit/sdk/rds/v3/__init__.py         |    0
 .../tests/unit/sdk/rds/v3/test_backup.py      |   83 ++
 .../tests/unit/sdk/rds/v3/test_config.py      |  131 ++
 .../tests/unit/sdk/rds/v3/test_datastore.py   |   43 +
 .../tests/unit/sdk/rds/v3/test_flavor.py      |   50 +
 .../tests/unit/sdk/rds/v3/test_instance.py    |  251 ++++
 .../tests/unit/sdk/rds/v3/test_proxy.py       |  204 +++
 setup.cfg                                     |   38 +-
 48 files changed, 5970 insertions(+), 30 deletions(-)
 rename doc/source/user/proxies/{rds.rst => rds_v1.rst} (100%)
 create mode 100644 doc/source/user/proxies/rds_v3.rst
 create mode 100644 doc/source/user/resources/rds/v3/configuration.rst
 create mode 100644 doc/source/user/resources/rds/v3/flavor.rst
 create mode 100644 doc/source/user/resources/rds/v3/instance.rst
 create mode 100644 otcextensions/osclient/rds/v3/__init__.py
 create mode 100644 otcextensions/osclient/rds/v3/backup.py
 create mode 100644 otcextensions/osclient/rds/v3/configuration.py
 create mode 100644 otcextensions/osclient/rds/v3/datastore.py
 create mode 100644 otcextensions/osclient/rds/v3/flavor.py
 create mode 100644 otcextensions/osclient/rds/v3/instance.py
 create mode 100644 otcextensions/sdk/job.py
 create mode 100644 otcextensions/sdk/rds/v3/__init__.py
 create mode 100644 otcextensions/sdk/rds/v3/_base.py
 create mode 100644 otcextensions/sdk/rds/v3/_proxy.py
 create mode 100644 otcextensions/sdk/rds/v3/backup.py
 create mode 100644 otcextensions/sdk/rds/v3/configuration.py
 create mode 100644 otcextensions/sdk/rds/v3/datastore.py
 create mode 100644 otcextensions/sdk/rds/v3/flavor.py
 create mode 100644 otcextensions/sdk/rds/v3/instance.py
 create mode 100644 otcextensions/tests/functional/osclient/rds/__init__.py
 create mode 100644 otcextensions/tests/functional/osclient/rds/v3/__init__.py
 create mode 100644 otcextensions/tests/functional/osclient/rds/v3/test_configuration.py
 create mode 100644 otcextensions/tests/functional/osclient/rds/v3/test_datastore.py
 create mode 100644 otcextensions/tests/functional/osclient/rds/v3/test_flavor.py
 create mode 100644 otcextensions/tests/functional/osclient/rds/v3/test_instance.py
 create mode 100644 otcextensions/tests/unit/osclient/rds/v3/__init__.py
 create mode 100644 otcextensions/tests/unit/osclient/rds/v3/fakes.py
 create mode 100644 otcextensions/tests/unit/osclient/rds/v3/test_backup.py
 create mode 100644 otcextensions/tests/unit/osclient/rds/v3/test_configuration.py
 create mode 100644 otcextensions/tests/unit/osclient/rds/v3/test_datastore.py
 create mode 100644 otcextensions/tests/unit/osclient/rds/v3/test_flavor.py
 create mode 100644 otcextensions/tests/unit/osclient/rds/v3/test_instance.py
 create mode 100644 otcextensions/tests/unit/sdk/rds/__init__.py
 create mode 100644 otcextensions/tests/unit/sdk/rds/v3/__init__.py
 create mode 100644 otcextensions/tests/unit/sdk/rds/v3/test_backup.py
 create mode 100644 otcextensions/tests/unit/sdk/rds/v3/test_config.py
 create mode 100644 otcextensions/tests/unit/sdk/rds/v3/test_datastore.py
 create mode 100644 otcextensions/tests/unit/sdk/rds/v3/test_flavor.py
 create mode 100644 otcextensions/tests/unit/sdk/rds/v3/test_instance.py
 create mode 100644 otcextensions/tests/unit/sdk/rds/v3/test_proxy.py

diff --git a/doc/source/enforcer.py b/doc/source/enforcer.py
index 80f9db381..ca79b0311 100644
--- a/doc/source/enforcer.py
+++ b/doc/source/enforcer.py
@@ -43,6 +43,7 @@ def get_proxy_methods():
              "otcextensions.sdk.kms.v1._proxy",
              "otcextensions.sdk.obs.v1._proxy",
              "otcextensions.sdk.rds.v1._proxy",
+             "otcextensions.sdk.rds.v3._proxy",
              "otcextensions.sdk.volume_backup.v2._proxy"
              ]
 
diff --git a/doc/source/user/proxies/rds.rst b/doc/source/user/proxies/rds_v1.rst
similarity index 100%
rename from doc/source/user/proxies/rds.rst
rename to doc/source/user/proxies/rds_v1.rst
diff --git a/doc/source/user/proxies/rds_v3.rst b/doc/source/user/proxies/rds_v3.rst
new file mode 100644
index 000000000..2efeddecc
--- /dev/null
+++ b/doc/source/user/proxies/rds_v3.rst
@@ -0,0 +1,55 @@
+Database RDS API
+================
+
+For details on how to use database, see :doc:`/user/guides/rds`
+
+.. automodule:: otcextensions.sdk.rds.v3._proxy
+
+The Database Class
+------------------
+
+The database high-level interface is available through the ``rds`` member of a
+:class:`~openstack.connection.Connection` object.  The ``rds`` member will only
+be added if the ``otcextensions.sdk.register_otc_extensions(conn)`` method is
+called.
+
+Datastore Operations
+^^^^^^^^^^^^^^^^^^^^
+
+.. autoclass:: otcextensions.sdk.rds.v3._proxy.Proxy
+
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.datastore_versions
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.get_datastore_version
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.datastore_types
+
+Flavor Operations
+^^^^^^^^^^^^^^^^^
+
+.. autoclass:: otcextensions.sdk.rds.v3._proxy.Proxy
+
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.get_flavor
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.flavors
+
+Instance Operations
+^^^^^^^^^^^^^^^^^^^
+
+.. autoclass:: otcextensions.sdk.rds.v3._proxy.Proxy
+
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.create_instance
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.update_instance
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.delete_instance
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.get_instance
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.find_instance
+   .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.instances
+
+
+Backup Operations
+^^^^^^^^^^^^^^^^^
+
+.. autoclass:: otcextensions.sdk.rds.v3._proxy.Proxy
+
+  .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.backups
+  .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.create_backup
+  .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.delete_backup
+  .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.get_backup_policy
+  .. automethod:: otcextensions.sdk.rds.v3._proxy.Proxy.set_backup_policy
diff --git a/doc/source/user/resources/rds/index.rst b/doc/source/user/resources/rds/index.rst
index c27641abc..935c168e6 100644
--- a/doc/source/user/resources/rds/index.rst
+++ b/doc/source/user/resources/rds/index.rst
@@ -7,3 +7,6 @@ RDS Resources
    v1/configuration
    v1/flavor
    v1/instance
+   v3/configuration
+   v3/flavor
+   v3/instance
diff --git a/doc/source/user/resources/rds/v3/configuration.rst b/doc/source/user/resources/rds/v3/configuration.rst
new file mode 100644
index 000000000..2952778eb
--- /dev/null
+++ b/doc/source/user/resources/rds/v3/configuration.rst
@@ -0,0 +1,13 @@
+otcextensions.sdk.rds.v3.configuration
+======================================
+
+.. automodule:: otcextensions.sdk.rds.v3.configuration
+
+The Configuration Class
+-----------------------
+
+The ``Configuration`` class inherits from
+:class:`~otcextensions.sdk.sdk_resource.Resource`.
+
+.. autoclass:: otcextensions.sdk.rds.v3.configuration.ConfigurationGroup
+   :members:
diff --git a/doc/source/user/resources/rds/v3/flavor.rst b/doc/source/user/resources/rds/v3/flavor.rst
new file mode 100644
index 000000000..a8806f213
--- /dev/null
+++ b/doc/source/user/resources/rds/v3/flavor.rst
@@ -0,0 +1,13 @@
+otcextensions.sdk.rds.v3.flavor
+===============================
+
+.. automodule:: otcextensions.sdk.rds.v3.flavor
+
+The Flavor Class
+----------------
+
+The ``Flavor`` class inherits from
+:class:`~otcextensions.sdk.sdk_resource.Resource`.
+
+.. autoclass:: otcextensions.sdk.rds.v3.flavor.Flavor
+   :members:
diff --git a/doc/source/user/resources/rds/v3/instance.rst b/doc/source/user/resources/rds/v3/instance.rst
new file mode 100644
index 000000000..d72e7cd4f
--- /dev/null
+++ b/doc/source/user/resources/rds/v3/instance.rst
@@ -0,0 +1,13 @@
+otcextensions.sdk.rds.v3.instance
+=================================
+
+.. automodule:: otcextensions.sdk.rds.v3.instance
+
+The Instance Class
+------------------
+
+The ``Instance`` class inherits from
+:class:`~otcextensions.sdk.sdk_resource.Resource`.
+
+.. autoclass:: otcextensions.sdk.rds.v3.instance.Instance
+   :members:
diff --git a/otcextensions/osclient/rds/client.py b/otcextensions/osclient/rds/client.py
index db8479d9b..eecdfebff 100644
--- a/otcextensions/osclient/rds/client.py
+++ b/otcextensions/osclient/rds/client.py
@@ -12,17 +12,20 @@
 #
 import logging
 
-from otcextensions import sdk
+from osc_lib import utils
 
+from otcextensions import sdk
+from otcextensions.i18n import _
 
 LOG = logging.getLogger(__name__)
 
-DEFAULT_API_VERSION = '1.0'
+DEFAULT_API_VERSION = '3'
 API_VERSION_OPTION = 'os_rds_api_version'
 API_NAME = "rds"
 API_VERSIONS = {
     "1.0": "openstack.connection.Connection",
     "1": "openstack.connection.Connection",
+    "3": "openstack.connection.Connection"
 }
 
 
@@ -42,4 +45,11 @@ def make_client(instance):
 
 def build_option_parser(parser):
     """Hook to add global options"""
+    parser.add_argument(
+        '--os-rds-api-version',
+        metavar='<rds-api-version>',
+        default=utils.env('OS_RDS_API_VERSION'),
+        help=_("RDS API version, default=%s "
+               "(Env: OS_RDS_API_VERSION)") % DEFAULT_API_VERSION
+    )
     return parser
diff --git a/otcextensions/osclient/rds/v3/__init__.py b/otcextensions/osclient/rds/v3/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/otcextensions/osclient/rds/v3/backup.py b/otcextensions/osclient/rds/v3/backup.py
new file mode 100644
index 000000000..77165ad78
--- /dev/null
+++ b/otcextensions/osclient/rds/v3/backup.py
@@ -0,0 +1,211 @@
+# 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.
+#
+"""Backup v3 action implementations"""
+
+from osc_lib import utils
+from osc_lib.command import command
+
+from otcextensions.common import sdk_utils
+from otcextensions.i18n import _
+
+
+BACKUP_TYPE_CHOICES = ['auto', 'manual', 'fragment', 'incremental']
+
+
+_formatters = {
+}
+
+
+def _get_columns(item):
+    column_map = {}
+    hidden = ['location']
+    return sdk_utils.get_osc_show_columns_for_sdk_resource(
+        item, column_map, hidden)
+
+
+class ListBackup(command.Lister):
+    _description = _("List database backups")
+    column_headers = (
+        'ID', 'Name', 'Type', 'Instance Id', 'Size (KB)'
+    )
+
+    columns = (
+        'id', 'name', 'type', 'instance_id', 'size'
+    )
+
+    def get_parser(self, prog_name):
+        parser = super(ListBackup, self).get_parser(prog_name)
+        parser.add_argument(
+            'instance',
+            metavar='<instance>',
+            help=_('Specify instance ID or Name to get backup list'),
+        )
+        parser.add_argument(
+            '--backup-id',
+            metavar='<backup_id>',
+            help=_('Specify the backup ID.'),
+        )
+        parser.add_argument(
+            '--backup-type',
+            metavar='{' + ','.join(BACKUP_TYPE_CHOICES) + '}',
+            choices=BACKUP_TYPE_CHOICES,
+            type=lambda s: s.lower(),
+            help=_('Specify the backup type.'),
+        )
+        parser.add_argument(
+            '--offset',
+            metavar='<offset>',
+            type=int,
+            help=_('Specify the index position.'),
+        )
+        parser.add_argument(
+            '--limit',
+            metavar='<limit>',
+            type=int,
+            help=_('Specify the limit of resources to be queried.'),
+        )
+#         parser.add_argument(
+#             '--begin-time',
+#             metavar='<begin_time>',
+#             help=_('Specify the start time for obtaining the backup list.'),
+#         )
+#         parser.add_argument(
+#             '--end-time',
+#             metavar='<end_time>',
+#             help=_('Specify the end time for obtaining the backup list.'),
+#         )
+
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+        attrs = {}
+        args_list = [
+            'backup_id', 'backup_type', 'offset', 'limit'
+            # , 'begin_time', 'end_time'
+        ]
+        for arg in args_list:
+            if getattr(parsed_args, arg):
+                attrs[arg] = getattr(parsed_args, arg)
+        if parsed_args.limit:
+            attrs['paginated'] = False
+
+        instance = client.find_instance(parsed_args.instance,
+                                        ignore_missing=False)
+
+        data = client.backups(instance=instance, **attrs)
+
+        return (self.column_headers, (utils.get_item_properties(
+            s,
+            self.columns,
+        ) for s in data))
+
+
+class CreateBackup(command.ShowOne):
+    _description = _('Create Database backup')
+
+    def get_parser(self, prog_name):
+        parser = super(CreateBackup, self).get_parser(prog_name)
+        parser.add_argument(
+            'name',
+            metavar='<name>',
+            help=_('Name for the backup'))
+        parser.add_argument(
+            'instance',
+            metavar='<instance>',
+            help=_('ID or Name of the instance to create backup from'))
+        parser.add_argument(
+            '--description',
+            metavar='<description>',
+            help=_('Description for the backup'))
+        parser.add_argument(
+            '--databases',
+            metavar='<databases>',
+            help=_(
+                'Specifies a CSV list of self-built SQL Server'
+                'databases that are partially backed up'
+                '(Only SQL Server support partial backups.)'))
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        attrs = {'name': parsed_args.name}
+        if parsed_args.description:
+            attrs['description'] = parsed_args.description
+
+        instance = client.find_instance(parsed_args.instance,
+                                        ignore_missing=False)
+
+        if (parsed_args.databases
+                and instance.datastore['type'].lower() == 'sqlserver'):
+            attrs['databases'] = []
+            databases = parsed_args.databases
+            databases = databases.split(",")
+            for db_name in databases:
+                attrs['databases'].append({'name': db_name})
+        else:
+            # Do we want to raise error otherwise?
+            pass
+
+        obj = client.create_backup(instance=instance,
+                                   **attrs)
+
+        display_columns, columns = _get_columns(obj)
+        data = utils.get_item_properties(obj, columns,
+                                         formatters=_formatters)
+
+        return (display_columns, data)
+
+
+class DeleteBackup(command.Command):
+    _description = _('Delete Backup')
+
+    def get_parser(self, prog_name):
+        parser = super(DeleteBackup, self).get_parser(prog_name)
+        parser.add_argument('backup',
+                            metavar='<backup_id>',
+                            nargs='+',
+                            help=_('ID of the backup'))
+        return parser
+
+    def take_action(self, parsed_args):
+
+        if parsed_args.backup:
+            client = self.app.client_manager.rds
+            for bck in parsed_args.backup:
+                client.delete_backup(backup=bck, ignore_missing=False)
+
+
+class ListBackupDownloadLinks(command.Lister):
+    _description = _('List Backup Download Links')
+
+    column_headers = ('Size (KB)', 'URL', 'Expires at')
+    columns = ('size', 'download_link', 'expires_at')
+
+    def get_parser(self, prog_name):
+        parser = super(ListBackupDownloadLinks, self).get_parser(prog_name)
+        parser.add_argument('backup_id',
+                            metavar='<backup_id>',
+                            help=_('ID of the backup'))
+        return parser
+
+    def take_action(self, parsed_args):
+
+        client = self.app.client_manager.rds
+        data = client.backup_download_links(backup_id=parsed_args.backup_id)
+        return (self.column_headers, (utils.get_item_properties(
+            s,
+            self.columns,
+            formatters={}
+        ) for s in data))
diff --git a/otcextensions/osclient/rds/v3/configuration.py b/otcextensions/osclient/rds/v3/configuration.py
new file mode 100644
index 000000000..149dcaa9e
--- /dev/null
+++ b/otcextensions/osclient/rds/v3/configuration.py
@@ -0,0 +1,300 @@
+# 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.
+#
+"""Configuration v3 action implementations"""
+
+from osc_lib import utils
+from osc_lib.cli import parseractions
+from osc_lib.command import command
+
+from otcextensions.i18n import _
+from otcextensions.common import sdk_utils
+
+
+DATASTORE_TYPE_CHOICES = ['mysql', 'postgresql', 'sqlserver']
+
+
+_formatters = {
+}
+
+
+def _get_columns(item, skip_values=True):
+    column_map = {}
+    hidden = ['location', 'links']
+    if skip_values:
+        if 'configuration_parameters' in item:
+            hidden.append('configuration_parameters')
+        if 'values' in item:
+            hidden.append('values')
+
+    return sdk_utils.get_osc_show_columns_for_sdk_resource(
+        item, column_map, hidden)
+
+
+class ListConfigurations(command.Lister):
+    _description = _("List Configurations")
+    column_headers = [
+        'ID', 'Name', 'Description', 'Datastore Name',
+        'Datastore Version Name', 'User Defined'
+    ]
+
+    columns = [
+        'id', 'name', 'description', 'datastore_name',
+        'datastore_version_name', 'is_user_defined'
+    ]
+
+    def get_parser(self, prog_name):
+        parser = super(ListConfigurations, self).get_parser(prog_name)
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        data = client.configurations()
+
+        return (self.column_headers, (utils.get_item_properties(
+            s,
+            self.columns,
+        ) for s in data))
+
+
+class ShowConfiguration(command.ShowOne):
+    _description = _("Show details of a database configuration")
+
+    def get_parser(self, prog_name):
+        parser = super(ShowConfiguration, self).get_parser(prog_name)
+        parser.add_argument('configuration',
+                            metavar="<configuration>",
+                            help=_("ID or name of the configuration"))
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        obj = client.find_configuration(parsed_args.configuration,
+                                        ignore_missing=False)
+
+        display_columns, columns = _get_columns(obj, skip_values=True)
+        data = utils.get_item_properties(obj, columns,
+                                         formatters=_formatters)
+
+        return (display_columns, data)
+
+
+class ListConfigurationParameters(command.Lister):
+    _description = _("List Configuration parameters")
+    column_headers = (
+        'Name', 'Value', 'Type', 'Description',
+        'Restart Required', 'Readonly', 'Value Range'
+    )
+    columns = (
+        'name', 'value', 'type', 'description',
+        'restart_required', 'readonly', 'value_range'
+    )
+
+    def get_parser(self, prog_name):
+        parser = super(ListConfigurationParameters, self).get_parser(prog_name)
+        parser.add_argument('configuration',
+                            metavar="<configuration>",
+                            help=_("ID or name of the configuration"))
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        data = client.find_configuration(
+            parsed_args.configuration,
+            ignore_missing=False).configuration_parameters
+
+        return (self.column_headers, (utils.get_dict_properties(
+            s,
+            self.columns,
+        ) for s in data))
+
+
+class CreateConfiguration(command.ShowOne):
+    _description = _("Create new Configuration")
+
+    def get_parser(self, prog_name):
+        parser = super(CreateConfiguration, self).get_parser(prog_name)
+        parser.add_argument(
+            'name',
+            metavar="<name>",
+            help=_("Parameter group name"))
+        parser.add_argument(
+            '--description',
+            metavar="<description>",
+            help=_("Parameter group description"))
+        parser.add_argument(
+            '--datastore-type',
+            metavar='{' + ','.join(DATASTORE_TYPE_CHOICES) + '}',
+            choices=DATASTORE_TYPE_CHOICES,
+            type=lambda s: s.lower(),
+            required=True,
+            help=_("Datastore type"))
+        parser.add_argument(
+            '--datastore-version',
+            metavar="<datastore_version>",
+            required=True,
+            help=_("Datastore version"))
+        parser.add_argument(
+            '--value',
+            dest='values',
+            metavar="<key=value>",
+            action=parseractions.KeyValueAction,
+            help=_("Configuration value"
+                   "(repeat option to set multiple values)")
+        )
+
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        config_attrs = {}
+        config_attrs['datastore'] = {}
+        if parsed_args.name:
+            config_attrs['name'] = parsed_args.name
+        if parsed_args.description:
+            config_attrs['description'] = parsed_args.description
+        if parsed_args.datastore_type and parsed_args.datastore_version:
+            config_attrs['datastore'] = {
+                'type': parsed_args.datastore_type,
+                'version': parsed_args.datastore_version
+            }
+
+        if parsed_args.values:
+            config_attrs['values'] = parsed_args.values
+        obj = client.create_configuration(**config_attrs)
+
+        display_columns, columns = _get_columns(obj)
+        data = utils.get_item_properties(obj, columns)
+
+        return (display_columns, data)
+
+
+class ApplyConfiguration(command.Lister):
+    _description = _("Apply Configuration to the instance(s)")
+
+    columns = (
+        'instance_id', 'instance_name',
+        'restart_required', 'success'
+    )
+
+    column_headers = (
+        'ID', 'Name', 'Restart required', 'success'
+    )
+
+    def get_parser(self, prog_name):
+        parser = super(ApplyConfiguration, self).get_parser(prog_name)
+        parser.add_argument(
+            'configuration',
+            metavar="<configuration>",
+            help=_("Configuration name or id")
+        )
+        parser.add_argument(
+            '--instance',
+            metavar="<instance_id>",
+            dest='instances',
+            action='append',
+            required=True,
+            help=_('ID of the instance the configuration '
+                   'should be applied to. '
+                   '(repeat option to apply to multiple instances).')
+        )
+
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        config = client.find_configuration(parsed_args.configuration,
+                                           ignore_missing=False)
+
+        inst_ids = []
+
+        # Ensure instance_ids are right
+        for inst in parsed_args.instances:
+            inst_ids.append(client.get_instance(inst).id)
+
+        obj = client.apply_configuration(config.id, instances=inst_ids)
+
+        return (self.column_headers, (utils.get_dict_properties(
+            s,
+            self.columns,
+        ) for s in obj.apply_results))
+
+
+class SetConfiguration(command.Command):
+    _description = _("Set values of the Configuration")
+
+    columns = ('id', 'name', 'description', 'datastore_version_id',
+               'datastore_version_name', 'datastore_name', 'created',
+               'updated', 'allowed_updated', 'instance_count', 'values')
+
+    def get_parser(self, prog_name):
+        parser = super(SetConfiguration, self).get_parser(prog_name)
+        parser.add_argument('configuration',
+                            metavar="<configuration>",
+                            help=_("Configuration id"))
+        parser.add_argument('--name',
+                            metavar="<name>",
+                            help=_("New Configuration name"))
+        parser.add_argument('--description',
+                            metavar="<description>",
+                            help=_("New Configuration description"))
+        parser.add_argument(
+            '--value',
+            dest="values",
+            metavar="<key=value>",
+            required=True,
+            action=parseractions.KeyValueAction,
+            help=_("Configuration value"
+                   "(repeat option to set multiple values)."))
+
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        config_attrs = {}
+
+        if parsed_args.name:
+            config_attrs['name'] = parsed_args.name
+        if parsed_args.description:
+            config_attrs['description'] = parsed_args.description
+        if parsed_args.values:
+            config_attrs['values'] = parsed_args.values
+
+        config = client.find_configuration(parsed_args.configuration,
+                                           ignore_missing=False)
+
+        client.update_configuration(config, **config_attrs)
+
+
+class DeleteConfiguration(command.Command):
+    _description = _("Delete a configuration")
+
+    def get_parser(self, prog_name):
+        parser = super(DeleteConfiguration, self).get_parser(prog_name)
+        parser.add_argument('configuration',
+                            metavar='<configuration>',
+                            nargs='+',
+                            help=_('ID or name of the configuration group'))
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+        if parsed_args.configuration:
+            for cnf in parsed_args.configuration:
+                resource = client.find_configuration(cnf, ignore_missing=False)
+                client.delete_configuration(resource)
diff --git a/otcextensions/osclient/rds/v3/datastore.py b/otcextensions/osclient/rds/v3/datastore.py
new file mode 100644
index 000000000..42645af2f
--- /dev/null
+++ b/otcextensions/osclient/rds/v3/datastore.py
@@ -0,0 +1,69 @@
+# 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.
+#
+"""Datastore v3 action implementations"""
+from osc_lib import utils
+from osc_lib.command import command
+
+from otcextensions.i18n import _
+from otcextensions.common import sdk_utils
+
+
+DB_TYPE_CHOICES = ['mysql', 'postgresql', 'sqlserver']
+
+
+def _get_columns(item):
+    column_map = {}
+    return sdk_utils.get_osc_show_columns_for_sdk_resource(item, column_map)
+
+
+class ListDatastoreTypes(command.Lister):
+
+    _description = _("List available datastores.")
+    columns = ('Name', )
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        data = client.datastore_types()
+
+        return (self.columns, (utils.get_item_properties(
+            s,
+            self.columns,
+        ) for s in data))
+
+
+class ListDatastoreVersions(command.Lister):
+    _description = _("Lists available versions for a datastore.")
+    columns = ('ID', 'Name')
+
+    def get_parser(self, prog_name):
+        parser = super(ListDatastoreVersions, self).get_parser(prog_name)
+
+        parser.add_argument(
+            'database',
+            metavar='{' + ','.join(DB_TYPE_CHOICES) + '}',
+            type=lambda s: s.lower(),
+            choices=DB_TYPE_CHOICES,
+            help=_('Name of the datastore Engine.'),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        data = client.datastores(database_name=parsed_args.database)
+
+        return (self.columns, (utils.get_item_properties(
+            s,
+            self.columns,
+        ) for s in data))
diff --git a/otcextensions/osclient/rds/v3/flavor.py b/otcextensions/osclient/rds/v3/flavor.py
new file mode 100644
index 000000000..a9aeaf6c9
--- /dev/null
+++ b/otcextensions/osclient/rds/v3/flavor.py
@@ -0,0 +1,63 @@
+# 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.
+#
+"""Flavor v3 action implementations"""
+import logging
+
+from osc_lib import utils
+from osc_lib.command import command
+
+from otcextensions.i18n import _
+
+LOG = logging.getLogger(__name__)
+
+DB_TYPE_CHOICES = ['mysql', 'postgresql', 'sqlserver']
+
+
+class ListDatabaseFlavors(command.Lister):
+
+    _description = _("List database flavors.")
+    columns = ('name', 'instance_mode', 'vcpus', 'ram')
+
+    def get_parser(self, prog_name):
+        parser = super(ListDatabaseFlavors, self).get_parser(prog_name)
+
+        parser.add_argument(
+            'database',
+            metavar='{' + ','.join(DB_TYPE_CHOICES) + '}',
+            type=lambda s: s.lower(),
+            choices=DB_TYPE_CHOICES,
+            help=_('Name of the datastore Engine.'),
+        )
+
+        parser.add_argument(
+            'version',
+            metavar='<version>',
+            help=_('Specifies the database version.'),
+        )
+
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        data = client.flavors(
+            datastore_name=parsed_args.database,
+            version_name=parsed_args.version)
+
+        return (
+            self.columns,
+            (utils.get_item_properties(
+                s,
+                self.columns,
+            ) for s in data)
+        )
diff --git a/otcextensions/osclient/rds/v3/instance.py b/otcextensions/osclient/rds/v3/instance.py
new file mode 100644
index 000000000..71bfe6a85
--- /dev/null
+++ b/otcextensions/osclient/rds/v3/instance.py
@@ -0,0 +1,663 @@
+# 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.
+#
+'''Instance v1 action implementations'''
+import argparse
+
+from osc_lib import exceptions
+from osc_lib import utils
+from osc_lib.command import command
+
+from otcextensions.common import sdk_utils
+from otcextensions.i18n import _
+
+
+def _get_columns(item):
+    column_map = {}
+    hidden = ['job_id']
+    return sdk_utils.get_osc_show_columns_for_sdk_resource(item, column_map,
+                                                           hidden)
+
+
+def set_attributes_for_print(instances):
+    for instance in instances:
+        if getattr(instance, 'volume', None):
+            setattr(instance, 'size', instance.volume['size'])
+        else:
+            setattr(instance, 'size', '-')
+        datastore = instance.datastore
+        if datastore.get('version'):
+            setattr(instance, 'datastore_version', datastore['version'])
+        if datastore.get('type'):
+            setattr(instance, 'datastore_type', datastore['type'])
+        yield instance
+
+
+HA_MODE_CHOICES = ['sync', 'semisync', 'async']
+DISK_TYPE_CHOICES = ['common', 'ultrahigh']
+HA_TYPE_CHOICES = ['ha', 'replica', 'single']
+DATASTORE_TYPE_CHOICES = ['mysql', 'postgresql', 'sqlserver']
+
+
+class ListDatabaseInstances(command.Lister):
+    _description = _('List database instances')
+    columns = (
+        'ID', 'Name', 'Datastore Type', 'Datastore Version', 'Status',
+        'Flavor_ref', 'Type', 'Size', 'Region'
+    )
+
+    def get_parser(self, prog_name):
+        parser = super(ListDatabaseInstances, self).get_parser(prog_name)
+        parser.add_argument(
+            '--limit',
+            dest='limit',
+            metavar='<limit>',
+            type=int,
+            help=_('Limit the number of results displayed'))
+        parser.add_argument(
+            '--id',
+            dest='id',
+            metavar='<id>',
+            type=str,
+            help=_('Specifies the DB instance ID.'))
+        parser.add_argument(
+            '--name',
+            dest='name',
+            metavar='<name>',
+            type=str,
+            help=_('Specifies the DB instance Name.'))
+        parser.add_argument(
+            '--type',
+            dest='type',
+            metavar='{' + ','.join(HA_TYPE_CHOICES) + '}',
+            type=lambda s: s.lower(),
+            choices=HA_TYPE_CHOICES,
+            help=_(
+                'Specifies the instance type. Values cane be single/ha/replica'
+            ))
+        parser.add_argument(
+            '--datastore-type',
+            metavar='{' + ','.join(DATASTORE_TYPE_CHOICES) + '}',
+            type=lambda s: s.lower(),
+            choices=DATASTORE_TYPE_CHOICES,
+            help=_(
+                'Specifies the database type. '
+                'value is MySQL, PostgreSQL, or SQLServer.'))
+        parser.add_argument(
+            '--router-id',
+            dest='router_id',
+            metavar='<router_id>',
+            type=str,
+            help=_('Specifies the ID of Router to which '
+                   'instance should be connected to.'))
+        parser.add_argument(
+            '--subnet-id',
+            dest='subnet_id',
+            metavar='<subnet_id>',
+            type=str,
+            help=_('Indicates the Subnet ID of DB Instance.'))
+        parser.add_argument(
+            '--offset',
+            dest='offset',
+            metavar='<offset>',
+            type=int,
+            default=None,
+            help=_('Specifies the index position.'))
+
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+        args_list = [
+            'name', 'id', 'router_id', 'subnet_id', 'offset', 'limit'
+        ]
+        attrs = {}
+        for arg in args_list:
+            if getattr(parsed_args, arg):
+                attrs[arg] = getattr(parsed_args, arg)
+        if parsed_args.type:
+            attrs['type'] = parsed_args.type.title()
+        if parsed_args.datastore_type == 'mysql':
+            attrs['datastore_type'] = 'MySQL'
+        elif parsed_args.datastore_type == 'postgresql':
+            attrs['datastore_type'] = 'PostgreSQL'
+        elif parsed_args.datastore_type == 'sqlserver':
+            attrs['datastore_type'] = 'SQLServer'
+        if parsed_args.limit:
+            attrs['paginated'] = False
+
+        data = client.instances(**attrs)
+        if data:
+            data = set_attributes_for_print(data)
+
+        return (self.columns, (utils.get_item_properties(
+            s,
+            self.columns,
+        ) for s in data))
+
+
+class ShowDatabaseInstance(command.ShowOne):
+    _description = _("Show instance details")
+
+    def get_parser(self, prog_name):
+        parser = super(ShowDatabaseInstance, self).get_parser(prog_name)
+        parser.add_argument(
+            'instance',
+            metavar='<instance>',
+            help=_('Instance (name or ID)'),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+        obj = client.find_instance(parsed_args.instance, ignore_missing=False)
+
+        display_columns, columns = _get_columns(obj)
+        data = utils.get_item_properties(obj, columns)
+
+        return (display_columns, data)
+
+
+class CreateDatabaseInstance(command.ShowOne):
+
+    _description = _("Create a new database instance.")
+
+    def get_parser(self, prog_name):
+        parser = super(CreateDatabaseInstance, self).get_parser(prog_name)
+        parser.add_argument(
+            'name',
+            metavar='<name>',
+            help=_("Name of the instance.")
+        )
+        parser.add_argument(
+            'flavor_ref',
+            metavar='<flavor_ref>',
+            help=_("Flavor spec_code")
+        )
+        disk_group = parser.add_argument_group('Disk data')
+        disk_group.add_argument(
+            '--size',
+            metavar='<size>',
+            type=int,
+            required=True,
+            help=_("Size of the instance disk volume in GB. ")
+        )
+        disk_group.add_argument(
+            '--volume-type',
+            metavar='{' + ','.join(DISK_TYPE_CHOICES) + '}',
+            type=lambda s: s.upper(),
+            required=True,
+            choices=[s.upper() for s in DISK_TYPE_CHOICES],
+            help=_("Volume type. (COMMON, ULTRAHIGH).")
+        )
+        parser.add_argument(
+            '--availability-zone',
+            metavar='<availability_zone>',
+            required=True,
+            help=_("The Zone hint to give to Nova.")
+        )
+        parser.add_argument(
+            '--region',
+            metavar='<region>',
+            required=True,
+            help=argparse.SUPPRESS,
+        )
+        ds_group = parser.add_argument_group('Datasoure parameters')
+        ds_group.add_argument(
+            '--datastore-type',
+            metavar='<datastore>',
+            required=True,
+            help=_("Name of the datastore (type).")
+        )
+        ds_group.add_argument(
+            '--datastore-version',
+            required=True,
+            metavar='<datastore_version>',
+            help=_("Datastore version.")
+        )
+        parser.add_argument(
+            '--configuration',
+            dest='configuration_id',
+            metavar='<configuration_id>',
+            default=None,
+            help=_("ID of the configuration group to attach to the instance.")
+        )
+        parser.add_argument(
+            '--disk-encryption-id',
+            metavar='<disk_encryption_id>',
+            default=None,
+            help=_("key ID for disk encryption.")
+        )
+        new_instance_group = parser.add_argument_group(
+            'New instance parameters',
+            'Parameters to be used for the new instance creation (not when '
+            'created as replica or from backup')
+        new_instance_group.add_argument(
+            '--port',
+            metavar='<port>',
+            type=int,
+            help=_("Database Port")
+        )
+        new_instance_group.add_argument(
+            '--password',
+            metavar='<password>',
+            help=_("ID of the configuration group to attach to the instance.")
+        )
+        new_instance_group.add_argument(
+            '--router-id',
+            metavar='<router_id>',
+            help=_('ID of a Router the DB should be connected to')
+        )
+        new_instance_group.add_argument(
+            '--subnet-id',
+            metavar='<subnet_id>',
+            help=_('ID of a subnet the DB should be connected to.')
+        )
+        new_instance_group.add_argument(
+            '--security-group-id',
+            dest='security_group_id',
+            metavar='<security_group_id>',
+            help=_('Security group ID')
+        )
+        parser.add_argument(
+            '--ha-mode',
+            metavar='{' + ','.join(HA_MODE_CHOICES) + '}',
+            type=lambda s: s.lower(),
+            choices=HA_MODE_CHOICES,
+            help=_('replication mode for the standby DB instance. '
+                   'This parameter is required when using `ha`flavors')
+        )
+        parser.add_argument(
+            '--charge-mode',
+            metavar='<charge_mode>',
+            default='postPaid',
+            help=_('Specifies the billing mode')
+        )
+        create_from_group = parser.add_argument_group(
+            'Create FROM group',
+            'Parameters to be used when creating new instance as a '
+            'replica or from backup')
+        create_from_group.add_argument(
+            '--replica-of',
+            metavar='<source_instance>',
+            default=None,
+            help=_("ID or name of an existing instance to replicate from.")
+        )
+        create_from_group.add_argument(
+            '--from-instance',
+            metavar='<source_instance>',
+            help=_('Source instance ID or Name to create from. '
+                   'It is required when recovering from backup or PITR.')
+        )
+        create_from_group.add_argument(
+            '--backup',
+            metavar='<backup>',
+            help=_('Backup ID or Name to create new instance from.')
+        )
+        create_from_group.add_argument(
+            '--restore-time',
+            metavar='<time>',
+            help=_('Time (UNIX timestamp in ms) to create new instance '
+                   'as a PointInTime recovery.')
+        )
+        parser.add_argument(
+            '--wait',
+            action='store_true',
+            help=('Wait for the instance to become active')
+        )
+        parser.add_argument(
+            '--wait-interval',
+            type=int,
+            help=_('Interval for checking status')
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        # Attention: not conform password result in BadRequest with no info
+        client = self.app.client_manager.rds
+
+        attrs = {}
+        args_list = [
+            'name', 'availability_zone', 'configuration_id', 'region',
+            'router_id', 'subnet_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.subnet_id,
+            parsed_args.security_group_id,
+            parsed_args.password
+        ]
+
+        if parsed_args.replica_of:
+            # Create replica
+            if (parsed_args.password or parsed_args.port
+                    or parsed_args.router_id or parsed_args.subnet_id
+                    or parsed_args.subnet_id):
+                raise exceptions.CommandError(
+                    _('Setting password/port/router/subnet/sg is not '
+                      'supported when creating replica')
+                )
+            attrs['replica_of_id'] = \
+                client.find_instance(parsed_args.replica_of,
+                                     ignore_missing=False).id
+        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)
+
+        display_columns, columns = _get_columns(obj)
+        data = utils.get_item_properties(obj, columns, formatters={})
+        return (display_columns, data)
+
+
+class DeleteDatabaseInstance(command.Command):
+
+    _description = _("Deletes an instance.")
+
+    def get_parser(self, prog_name):
+        parser = super(DeleteDatabaseInstance, self).get_parser(prog_name)
+        parser.add_argument(
+            'instance',
+            metavar='<instance>',
+            help=_('ID or name of the Instance'),
+        )
+        parser.add_argument(
+            '--wait',
+            action='store_true',
+            help=_('Wait for the instance to be deleted')
+        )
+        parser.add_argument(
+            '--wait-interval',
+            type=int,
+            help=_('Interval for checking status')
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+        instance = client.find_instance(parsed_args.instance)
+        try:
+            response = client.delete_instance(instance.id)
+            if parsed_args.wait and response.job_id:
+                wait_args = {}
+                if parsed_args.wait_interval:
+                    wait_args['interval'] = parsed_args.wait_interval
+
+                client.wait_for_job(response.job_id, **wait_args)
+        except Exception as e:
+            msg = (_("Failed to delete instance %(instance)s: %(e)s") % {
+                'instance': parsed_args.instance,
+                'e': e
+            })
+            raise exceptions.CommandError(msg)
+
+
+class RestoreDatabaseInstance(command.Command):
+
+    _description = _("Restores an instance from backup.")
+
+    def get_parser(self, prog_name):
+        parser = super(RestoreDatabaseInstance, self).get_parser(prog_name)
+        parser.add_argument(
+            'instance',
+            metavar='<instance>',
+            type=str,
+            help=_('ID or name of the target instance.')
+        )
+        group = parser.add_mutually_exclusive_group(required=True)
+        group.add_argument(
+            '--backup',
+            metavar='<backup>',
+            default=None,
+            type=str,
+            help=_('ID or name of the backup.')
+        )
+        group.add_argument(
+            '--restore_time',
+            metavar='<restore_time>',
+            default=None,
+            type=str,
+            help=_('Specifies the time point of data '
+                   'restoration in the UNIX timestamp')
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        client = self.app.client_manager.rds
+
+        instance = client.find_instance(parsed_args.instance,
+                                        ignore_missing=False)
+        backup = None
+        if parsed_args.backup:
+            backup = client.find_backup(name_or_id=parsed_args.backup,
+                                        instance=instance,
+                                        ignore_missing=False)
+
+        client.restore_instance(instance=instance,
+                                backup=backup,
+                                restore_time=parsed_args.restore_time)
+
+
+class ShowBackupPolicy(command.ShowOne):
+    _description = _('Show Database instance Backup Policy')
+
+    def get_parser(self, prog_name):
+        parser = super(ShowBackupPolicy, self).get_parser(prog_name)
+        parser.add_argument('instance',
+                            metavar='<instance>',
+                            help=_('Instance ID or Name'))
+        return parser
+
+    def take_action(self, parsed_args):
+
+        client = self.app.client_manager.rds
+
+        instance = client.find_instance(parsed_args.instance,
+                                        ignore_missing=False)
+        obj = client.get_instance_backup_policy(instance)
+
+        display_columns, columns = _get_columns(obj)
+        data = utils.get_dict_properties(obj, columns)
+
+        return (display_columns, data)
+
+
+class SetBackupPolicy(command.Command):
+    _description = _('Set Database Backup Policy')
+
+    def get_parser(self, prog_name):
+        parser = super(SetBackupPolicy, self).get_parser(prog_name)
+        parser.add_argument(
+            'instance',
+            metavar='<instance>',
+            help=_('Instance ID or Name'))
+        parser.add_argument(
+            '--keep-days',
+            metavar='<keep_days>',
+            type=int,
+            required=True,
+            help=_('Specifies the number of days to'
+                   'retain the generated backup files.'))
+        parser.add_argument(
+            '--start-time',
+            metavar='<start_time>',
+            help=_('Specifies the backup time window.'
+                   'The value must be a valid value in the'
+                   '"hh:mm-HH:MM" format.'))
+        parser.add_argument(
+            '--period',
+            metavar='<period>',
+            help=_('Specifies the backup cycle'
+                   'configuration. Data will be'
+                   'automatically backed up on the'
+                   'selected days every week.'))
+        return parser
+
+    def take_action(self, parsed_args):
+
+        client = self.app.client_manager.rds
+        args_list = ['keep_days', 'start_time', 'period']
+        attrs = {}
+        for arg in args_list:
+            if getattr(parsed_args, arg):
+                attrs[arg] = getattr(parsed_args, arg)
+
+        instance = client.find_instance(parsed_args.instance,
+                                        ignore_missing=False)
+
+        client.set_instance_backup_policy(instance, **attrs)
+
+
+class ShowAvailableRestoreTime(command.Lister):
+    _description = _('Show Database instance recovery timeframe')
+
+    columns = ('start_time', 'end_time')
+    column_headers = ('Start time', 'End time')
+
+    def get_parser(self, prog_name):
+        parser = super(ShowAvailableRestoreTime, self).get_parser(prog_name)
+        parser.add_argument('instance',
+                            metavar='<instance>',
+                            help=_('Instance ID or Name'))
+        return parser
+
+    def take_action(self, parsed_args):
+
+        client = self.app.client_manager.rds
+
+        instance = client.find_instance(parsed_args.instance,
+                                        ignore_missing=False)
+        data = client.get_instance_restore_time(instance)
+
+        return (self.column_headers, (utils.get_dict_properties(
+            s,
+            self.columns,
+        ) for s in data))
diff --git a/otcextensions/sdk/__init__.py b/otcextensions/sdk/__init__.py
index 12cb54d2b..f9c76b8e2 100644
--- a/otcextensions/sdk/__init__.py
+++ b/otcextensions/sdk/__init__.py
@@ -91,6 +91,7 @@
     'rds': {
         'service_type': 'rds',
         # 'additional_headers': {'content-type': 'application/json'},
+        'endpoint_service_type': 'rdsv3',
         'append_project_id': True,
     },
     'volume_backup': {
diff --git a/otcextensions/sdk/job.py b/otcextensions/sdk/job.py
new file mode 100644
index 000000000..355a82ee4
--- /dev/null
+++ b/otcextensions/sdk/job.py
@@ -0,0 +1,99 @@
+# 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 openstack import resource
+
+
+class Job(resource.Resource):
+
+    base_path = '/jobs'
+
+    # capabilities
+    allow_fetch = True
+
+    # Properties
+    #: Created (RDS)
+    created = resource.Body('created')
+    #: id
+    id = resource.Body('job_id', alternate_id=True)
+    #: Additional sub information
+    entities = resource.Body('entities', type=dict)
+    #: Error code
+    error_code = resource.Body('error_code')
+    #: Fail reason
+    fail_reason = resource.Body('fail_reason')
+    #: Job finish time
+    finish_time = resource.Body('end_time')
+    #: Job start time
+    start_time = resource.Body('begin_time', alias='created')
+    #: Status
+    status = resource.Body('status')
+    #: Job type
+    #: *Type:str*
+    type = resource.Body('job_type')
+
+    def fetch(self, session, requires_id=True,
+              base_path=None, error_message=None, **params):
+        """Get a remote resource based on this instance.
+
+        :param session: The session to use for making this request.
+        :type session: :class:`~keystoneauth1.adapter.Adapter`
+        :param boolean requires_id: A boolean indicating whether resource ID
+                                    should be part of the requested URI.
+        :param str base_path: Base part of the URI for fetching resources, if
+                              different from
+                              :data:`~openstack.resource.Resource.base_path`.
+        :param str error_message: An Error message to be returned if
+                                  requested object does not exist.
+        :param dict params: Additional parameters that can be consumed.
+        :return: This :class:`Resource` instance.
+        :raises: :exc:`~openstack.exceptions.MethodNotSupported` if
+                 :data:`Resource.allow_fetch` is not set to ``True``.
+        :raises: :exc:`~openstack.exceptions.ResourceNotFound` if
+                 the resource was not found.
+        """
+        if not self.allow_fetch:
+            raise exceptions.MethodNotSupported(self, "fetch")
+
+        request = self._prepare_request(requires_id=requires_id,
+                                        base_path=base_path)
+        if session.service_type == 'rdsv3':
+            request.url = self.base_path + '?id=' + self.id
+            self.resource_key = 'job'
+        session = self._get_session(session)
+        microversion = self._get_microversion_for(session, 'fetch')
+        response = session.get(request.url, microversion=microversion,
+                               params=params)
+        kwargs = {}
+        if error_message:
+            kwargs['error_message'] = error_message
+
+        self.microversion = microversion
+        self._translate_response(response, **kwargs)
+        return self
+
+
+class JobProxyMixin(object):
+
+    def wait_for_job(self, job_id, status='success',
+                     failures=None, interval=5, wait=3600,
+                     attribute='status'):
+        if self.service_type == 'rdsv3':
+            status = 'completed'
+            failures = ['failed']
+        else:
+            failures = ['FAIL'] if failures is None else failures
+
+        job = Job.existing(id=job_id).fetch(self)
+        return resource.wait_for_status(
+            self, job, status, failures, interval, wait, attribute='status'
+        )
diff --git a/otcextensions/sdk/rds/rds_service.py b/otcextensions/sdk/rds/rds_service.py
index 555111e71..bb0f0fe9a 100644
--- a/otcextensions/sdk/rds/rds_service.py
+++ b/otcextensions/sdk/rds/rds_service.py
@@ -12,12 +12,14 @@
 
 from openstack import service_description
 
-from otcextensions.sdk.rds.v1 import _proxy
+from otcextensions.sdk.rds.v1 import _proxy as _proxy_v1
+from otcextensions.sdk.rds.v3 import _proxy as _proxy_v3
 
 
 class RdsService(service_description.ServiceDescription):
     """The RDS service."""
 
     supported_versions = {
-        '1': _proxy.Proxy
+        '1': _proxy_v1.Proxy,
+        '3': _proxy_v3.Proxy
     }
diff --git a/otcextensions/sdk/rds/v3/__init__.py b/otcextensions/sdk/rds/v3/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/otcextensions/sdk/rds/v3/_base.py b/otcextensions/sdk/rds/v3/_base.py
new file mode 100644
index 000000000..bec1abdae
--- /dev/null
+++ b/otcextensions/sdk/rds/v3/_base.py
@@ -0,0 +1,146 @@
+# 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 openstack import resource
+
+
+class Resource(resource.Resource):
+
+    query_marker_key = 'offset'
+
+    _query_mapping = resource.QueryParameters(
+        'marker', 'limit',
+        marker='offset'
+    )
+
+    @classmethod
+    def list(cls, session, paginated=True, base_path=None,
+             allow_unknown_params=False, **params):
+
+        if not cls.allow_list:
+            raise exceptions.MethodNotSupported(cls, "list")
+        session = cls._get_session(session)
+        microversion = cls._get_microversion_for_list(session)
+
+        if base_path is None:
+            base_path = cls.base_path
+        params = cls._query_mapping._validate(
+            params, base_path=base_path,
+            allow_unknown_params=allow_unknown_params)
+
+        query_params = cls._query_mapping._transpose(params, cls)
+        uri = base_path % params
+
+        limit = query_params.get('limit')
+
+        # Track the total number of resources yielded so we can paginate
+        # swift objects
+        total_yielded = query_params.get('offset', 0)
+        while uri:
+            # Copy query_params due to weird mock unittest interactions
+            response = session.get(
+                uri,
+                headers={"Accept": "application/json"},
+                params=query_params.copy(),
+                microversion=microversion)
+            exceptions.raise_from_response(response)
+            data = response.json()
+
+            # Discard any existing pagination keys
+            query_params.pop('offset', None)
+            query_params.pop('limit', None)
+
+            if cls.resources_key:
+                resources = data[cls.resources_key]
+            else:
+                resources = data
+
+            if not isinstance(resources, list):
+                resources = [resources]
+
+            marker = None
+            for raw_resource in resources:
+                value = cls.existing(
+                    microversion=microversion,
+                    connection=session._get_connection(),
+                    **raw_resource)
+                marker = total_yielded + 1
+                yield value
+                total_yielded += 1
+
+            if resources and paginated:
+                uri, next_params = cls._get_next_link(
+                    uri, response, data, marker, limit, total_yielded)
+                query_params.update(next_params)
+            else:
+                return
+
+    @classmethod
+    def _get_next_link(cls, uri, response, data, marker, limit, total_yielded):
+        # AS service pagination. Returns query for the next page
+        next_link = None
+        params = {}
+        if 'total_count' in data and total_yielded <= data['total_count']:
+            next_link = uri
+            params['offset'] = marker
+            params['limit'] = limit
+        else:
+            next_link = None
+        query_params = cls._query_mapping._transpose(params, cls)
+        return next_link, query_params
+
+    @classmethod
+    def find(cls, session, name_or_id, ignore_missing=True, **params):
+        """Find a resource by its name or id.
+
+        :param session: The session to use for making this request.
+        :type session: :class:`~keystoneauth1.adapter.Adapter`
+        :param name_or_id: This resource's identifier, if needed by
+                           the request. The default is ``None``.
+        :param bool ignore_missing: When set to ``False``
+                    :class:`~openstack.exceptions.ResourceNotFound` will be
+                    raised when the resource does not exist.
+                    When set to ``True``, None will be returned when
+                    attempting to find a nonexistent resource.
+        :param dict params: Any additional parameters to be passed into
+                            underlying methods, such as to
+                            :meth:`~openstack.resource.Resource.existing`
+                            in order to pass on URI parameters.
+
+        :return: The :class:`Resource` object matching the given name or id
+                 or None if nothing matches.
+        :raises: :class:`openstack.exceptions.DuplicateResource` if more
+                 than one resource is found for this request.
+        :raises: :class:`openstack.exceptions.ResourceNotFound` if nothing
+                 is found and ignore_missing is ``False``.
+        """
+        session = cls._get_session(session)
+        # Try to short-circuit by looking directly for a matching ID.
+        try:
+            match = cls.existing(
+                id=name_or_id,
+                connection=session._get_connection(),
+                **params)
+            return match.fetch(session, **params)
+        except exceptions.SDKException:
+            pass
+
+        data = cls.list(session, **params)
+
+        result = cls._get_one_match(name_or_id, data)
+        if result is not None:
+            return result
+
+        if ignore_missing:
+            return None
+        raise exceptions.ResourceNotFound(
+            "No %s found for %s" % (cls.__name__, name_or_id))
diff --git a/otcextensions/sdk/rds/v3/_proxy.py b/otcextensions/sdk/rds/v3/_proxy.py
new file mode 100644
index 000000000..b9d85b820
--- /dev/null
+++ b/otcextensions/sdk/rds/v3/_proxy.py
@@ -0,0 +1,402 @@
+# 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 proxy
+
+from otcextensions.sdk import job
+from otcextensions.sdk.rds.v3 import backup as _backup
+from otcextensions.sdk.rds.v3 import configuration as _configuration
+from otcextensions.sdk.rds.v3 import datastore as _datastore
+from otcextensions.sdk.rds.v3 import flavor as _flavor
+from otcextensions.sdk.rds.v3 import instance as _instance
+
+
+class Proxy(proxy.Proxy, job.JobProxyMixin):
+
+    skip_discovery = True
+
+    def __init__(self, session, *args, **kwargs):
+        super(Proxy, self).__init__(session=session, *args, **kwargs)
+        self.additional_headers = {
+            'Content-Type': 'application/json',
+            'X-Language': 'en-us'
+        }
+
+    # ======= Datastores =======
+    def datastore_types(self):
+        """List supported datastore types
+
+        :returns: A generator of supported datastore types
+        :rtype object: object with name attribte
+        """
+        for ds in ['MySQL', 'PostgreSQL', 'SQLServer']:
+            obj = type('obj', (object, ), {'name': ds})
+            yield obj
+
+    def datastores(self, database_name):
+        """List datastores
+
+        :param database_name: database store name
+            (MySQL, PostgreSQL, or SQLServer and is case-sensitive.)
+
+        :returns: A generator of supported datastore versions
+        :rtype: :class:`~otcextensions.sdk.rds.v3.datastore.Datastore`
+        """
+        return self._list(
+            _datastore.Datastore,
+            database_name=database_name,
+        )
+
+    # ======= Flavors =======
+
+    def flavors(self, datastore_name, version_name):
+        """List flavors of given datastore_name and datastore_version
+
+        :param datastore_name: datastore_name
+        :param version_name: version_name
+
+        :returns: A generator of flavor
+        :rtype: :class:`~otcextensions.sdk.rds.v3.flavor.Flavor`
+        """
+        return self._list(_flavor.Flavor,
+                          datastore_name=datastore_name,
+                          version_name=version_name)
+
+    # ======= Instance =======
+
+    def create_instance(self, **attrs):
+        """Create a new instance from attributes
+
+        :param dict attrs: Keyword arguments which will be used to create
+                   a :class:`~otcextensions.sdk.rds.v3.instance.Instance`,
+                   comprised of the properties on the Instance class.
+
+        :returns: The results of server creation
+        :rtype: :class:`~otcextensions.sdk.rds.v3.instance.Instance`
+        """
+        return self._create(
+            _instance.Instance,
+            **attrs)
+
+    def delete_instance(self, instance, ignore_missing=True):
+        """Delete an instance
+
+        :param instance: The value can be either the ID of an instance or a
+            :class:`~otcextensions.sdk.rds.v3.instance.Instance` instance.
+        :param bool ignore_missing: When set to ``False``
+            :class:`~openstack.exceptions.ResourceNotFound` will be
+            raised when the instance does not exist.
+            When set to ``True``, no exception will be set when
+            attempting to delete a nonexistent instance.
+
+        :returns:
+            :class:`~otcextensions.sdk.rds.v3.instance.Instance` instance.
+        """
+        return self._delete(
+            _instance.Instance,
+            instance,
+            ignore_missing=ignore_missing,
+        )
+
+    def get_instance(self, instance):
+        """Get a single instance
+
+        :param isntance: The name or ID of a instance.
+        :returns: One :class:`~otcextensions.sdk.rds.v3.instance.Instance`
+        """
+        return self._get(_instance.Instance, instance)
+
+    def find_instance(self, name_or_id, ignore_missing=True):
+        """Find a single instance
+
+        :param name_or_id: The name or ID of a instance.
+        :param bool ignore_missing: When set to ``False``
+                    :class:`~openstack.exceptions.ResourceNotFound` will be
+                    raised when the resource does not exist.
+                    When set to ``True``, None will be returned when
+                    attempting to find a nonexistent resource.
+        :returns: One :class:`~otcextensions.sdk.rds.v3.instance.Instance`
+                  or None
+        """
+        return self._find(_instance.Instance,
+                          name_or_id,
+                          ignore_missing=ignore_missing)
+
+    def instances(self, **params):
+        """Return a generator of instances
+
+        :returns: A generator of instance objects
+        :rtype: :class:`~otcextensions.sdk.rds.v3.instance.Instance`
+        """
+        return self._list(_instance.Instance, **params)
+
+    def restore_instance(self,
+                         instance,
+                         backup=None,
+                         restore_time=None):
+        """Restore instance from backup
+           or Restore using Point in Time Recovery
+
+        :param instance: Either the id of a source target instance or a
+            :class:`~otcextensions.sdk.rds.v3.instance.Instance` instance.
+        :param backup: Either the id of a backup or a
+            :class:`~otcextensions.sdk.rds.v3.backup.Backup` instance.
+
+        :returns: Job ID
+        :rtype:
+        """
+        instance = self._get_resource(_instance.Instance, instance)
+        if backup:
+            backup = self._get_resource(_backup.Backup, backup)
+        return instance.restore(self, backup, restore_time)
+
+    def get_instance_restore_time(self, instance):
+        """Obtaining a restore time of an instance.
+
+        :param instance: This parameter can be either the ID of an instance
+            or a :class:`~openstack.sdk.rds.v3.instance.Instance`
+        :returns: Instance restore time
+        :rtype: list
+
+        """
+        instance = self._get_resource(_instance.Instance, instance)
+        return instance.fetch_restore_times(self)
+
+    def get_instance_backup_policy(self, instance):
+        """Obtaining a backup policy of the instance
+
+        :param instance: This parameter can be either the ID of an instance
+            or a :class:`~openstack.sdk.rds.v3.instance.Instance`
+        :returns: Instance Backup policy
+        :rtype: :class:`~otcextensions.sdk.rds.v3.instance.BackupPolicy`
+
+        """
+        instance = self._get_resource(_instance.Instance, instance)
+        return instance.get_backup_policy(self)
+
+    def set_instance_backup_policy(self, instance, keep_days,
+                                   start_time=None, period=None):
+        """Sets the backup policy of the instance
+
+        :param instance: This parameter can be either the ID of an instance
+            or a :class:`~openstack.sdk.rds.v3.instance.Instance`
+        :param keep_days:
+        :param start_time:
+        :param period:
+
+        :returns: ``None``
+        """
+        instance = self._get_resource(_instance.Instance, instance)
+        return instance.set_backup_policy(self, keep_days=keep_days,
+                                          start_time=start_time, period=period)
+
+#     def get_instance_configuration(self, instance):
+#         """Obtaining a Configuration associated to instance.
+#
+#         :param instance: This parameter can be either the ID of an instance
+#             or a :class:`~openstack.sdk.rds.v3.instance.Instance`
+#         :returns: Configuration Group details associated to instance
+#         :rtype: :class:
+#             `~otcextensions.sdk.rds.v3.instance.InstanceConfiguration`
+#
+#         """
+#         instance = self._get_resource(instance)
+#         return self._get(_instance.InstanceConfiguration,
+#                          requires_id=False,
+#                          instance_id=instance.id)
+#
+#     def update_instance_configuration(self, instance, **attrs):
+#         """Updates the configuration params of the instance.
+#
+#         :param instance: This parameter can be either the ID of an instance
+#             or a :class:`~openstack.sdk.rds.v3.instance.Instance`
+#
+#         :returns: Parameter restart required as bool value
+#         """
+#         instance = self._get_resource(_instance.Instance, instance)
+#         return self._update(_instance.InstanceConfiguration,
+#                             instance_id=instance.id,
+#                             **attrs)
+#
+    # ======= Configurations =======
+    def configurations(self, **attrs):
+        """Obtaining a list of DB Configuration.
+
+        :returns: A generator of Configuration object
+        :rtype:
+            :class:`~otcextensions.sdk.rds.v3.configuration.Configuration`
+        """
+        return self._list(
+            _configuration.Configuration,
+            paginated=False
+        )
+
+    def get_configuration(self, cg):
+        """Obtaining a Configuration.
+
+        :param parameter_group: The value can be the ID of a Configuration
+            or a object of
+            :class:`~otcextensions.sdk.rds.v3.configuration.Configuration`.
+
+        :returns: A Configuration Object
+        :rtype: :class:`~otcextensions.rds.v3.configuration.Configuration`
+        """
+        return self._get(_configuration.Configuration, cg)
+
+    def find_configuration(self, name_or_id, ignore_missing=True):
+        """Find Configuration by name or id.
+
+        :param name_or_id: The name or ID of configuration.
+        :param bool ignore_missing: When set to ``False``
+                    :class:`~openstack.exceptions.ResourceNotFound` will be
+                    raised when the resource does not exist.
+                    When set to ``True``, None will be returned when
+                    attempting to find a nonexistent resource.
+        :returns: One
+        :class:`~otcextensions.sdk.rds.v3.configuration.Configuration`
+                  or None
+        """
+        return self._find(_configuration.Configuration,
+                          name_or_id,
+                          ignore_missing=ignore_missing)
+
+    def create_configuration(self, **attrs):
+        """Create DB Configuration.
+
+        :param dict **attrs: Dict to overwrite Configuration object
+        :returns: A Configuration Object
+        :rtype:
+            :class:`~otcextensions.sdk.rds.v3.configuration.Configuration`
+        """
+        return self._create(_configuration.Configuration,
+                            prepend_key=False,
+                            **attrs)
+
+    def delete_configuration(self, cg, ignore_missing=True):
+        """Delete DB Configuration.
+
+        :param cg: The value can be the ID of a Configuration or a
+            object of
+            :class:`~otcextensions.sdk.rds.v3.configuration.Configuration`.
+        :param bool ignore_missing: When set to ``False``
+            :class:`~openstack.exceptions.ResourceNotFound` will be
+            raised when the Configration does not exist.
+            When set to ``True``, no exception will be set when
+            attempting to delete a nonexistent Configuration.
+
+        :returns: None
+        :rtype: None
+        """
+        self._delete(
+            _configuration.Configuration,
+            cg,
+            ignore_missing=ignore_missing,
+        )
+
+    def update_configuration(self, config, **attrs):
+        """Sets the configuration properties
+
+        :param config: This parameter can be either the ID of a configuration
+            or a :class:`~openstack.sdk.rds.v3.config.Configuration`
+        :param dict attrs: The attributes to update on the configuration.
+
+        :returns: None
+        :rtype:
+            :class:`~otcextensions.rds.v3.configuration.Configuration`.
+        """
+        return self._update(_configuration.Configuration, config,
+                            **attrs)
+
+    def apply_configuration(self, configuration, instances):
+        """Apply configuration to instances.
+
+        :param configuration: The value can be the ID of a Configuration
+            or a object of
+            :class:`~otcextensions.sdk.rds.v3.configuration.Configuration`.
+        :param instances: List of instance ids the configuration should be
+            applied to
+        :returns: Updated Configuration Object
+        :rtype:
+            :class:`~otcextensions.rds.v3.configuration.Configuration`.
+        """
+        cg = self._get_resource(_configuration.Configuration,
+                                configuration)
+        return cg.apply(self, instances)
+
+    # ======= Backups =======
+    def backups(self, instance, **params):
+        """List Backups.
+
+        :param instance: This parameter can be either the ID of an instance
+            or a :class:`~openstack.sdk.rds.v3.instance.Instance`
+        :returns: A generator of backup
+        :rtype: :class:`~otcextensions.sdk.rds.v3.backup.Backup`
+        """
+        instance = self._get_resource(_instance.Instance, instance)
+        return self._list(_backup.Backup, instance_id=instance.id, **params)
+
+    def create_backup(self, instance, **attrs):
+        """Create a backups of instance
+
+        :returns: A new backup object
+        :rtype: :class:`~otcextensions.sdk.rds.v3.backup.Backup`
+        """
+        instance = self._get_resource(_instance.Instance, instance)
+        attrs.update({'instance_id': instance.id})
+        return self._create(_backup.Backup, **attrs)
+
+    def delete_backup(self, backup, ignore_missing=True):
+        """Deletes given backup
+
+        :param instance: The value can be either the ID of an instance or a
+            :class:`~openstack.database.v3.instance.Instance` instance.
+        :param bool ignore_missing: When set to ``False``
+            :class:`~openstack.exceptions.ResourceNotFound` will be
+            raised when the instance does not exist.
+            When set to ``True``, no exception will be set when
+            attempting to delete a nonexistent instance.
+
+        :returns: ``None``
+        """
+        return self._delete(_backup.Backup,
+                            backup,
+                            ignore_missing=ignore_missing)
+
+    def find_backup(self, name_or_id, instance, ignore_missing=True):
+        """Find a single backup
+
+        :param name_or_id: The name or ID of a instance.
+        :param instance: The value can be either the ID of an instance or a
+            :class:`~openstack.database.v3.instance.Instance` instance.
+         :param bool ignore_missing: When set to ``False``
+                    :class:`~openstack.exceptions.ResourceNotFound` will be
+                    raised when the resource does not exist.
+                    When set to ``True``, None will be returned when
+                    attempting to find a nonexistent resource.
+        :returns: One :class:`~otcextensions.sdk.rds.v3.backup.Backup`
+                  or None
+        """
+        instance = self._get_resource(_instance.Instance, instance)
+        return self._find(_backup.Backup,
+                          name_or_id,
+                          ignore_missing=ignore_missing,
+                          instance_id=instance.id)
+
+    def backup_download_links(self, backup_id):
+        """Obtaining a backup file download links.
+
+        :param backup_id
+        :returns: files link
+        :rtype: :class:`~otcextensions.sdk.rds.v3.backup.BackupFile`
+
+        """
+        return self._list(_backup.BackupFile, backup_id=backup_id)
diff --git a/otcextensions/sdk/rds/v3/backup.py b/otcextensions/sdk/rds/v3/backup.py
new file mode 100644
index 000000000..43dba8c29
--- /dev/null
+++ b/otcextensions/sdk/rds/v3/backup.py
@@ -0,0 +1,97 @@
+# 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 resource
+
+from otcextensions.sdk.rds.v3 import _base
+
+
+class Backup(_base.Resource):
+
+    base_path = '/backups'
+    resources_key = 'backups'
+    resource_key = 'backup'
+
+    # capabilities
+    allow_create = True
+    allow_delete = True
+    allow_list = True
+    allow_fetch = False
+
+    _query_mapping = resource.QueryParameters(
+        'offset', 'begin_time', 'instance_id', 'id',
+        'type', 'begin_time', 'end_time', 'offset', 'limit',
+        id='backup_id', type='backup_type')
+
+    #: Backup id
+    #: Type: uuid*
+    id = resource.Body('id')
+    #: Begin time
+    begin_time = resource.Body('begin_time')
+    #: Create back of specific dbs
+    #: *Type:list*
+    databases = resource.Body('databases', type=list)
+    #: Datastore
+    #: *Type:dict*
+    datastore = resource.Body('datastore', type=dict)
+    #: Data backup description
+    description = resource.Body('description')
+    #: Instance id
+    instance_id = resource.Body('instance_id')
+    #: Back file size in GB
+    #: *Type:int*
+    size = resource.Body('size', type=int)
+    #: Backup status
+    status = resource.Body('status')
+    #: Finished time
+    end_time = resource.Body('end_time')
+    #: Backup type
+    #:  `auto`: automated full backup
+    #:  `manual`: manual full backup
+    #:  `fragment`: differential full backup
+    #:  `incremental`: automated incremental backup
+    type = resource.Body('type')
+
+    def create(self, session, prepend_key=False, base_path=None):
+        return super(Backup, self).create(session,
+                                          prepend_key=prepend_key,
+                                          base_path=base_path)
+
+    def commit(self, session, prepend_key=False, **further_attrs):
+        return super(Backup, self).commit(
+            session,
+            prepend_key=prepend_key,
+            **further_attrs)
+
+
+class BackupFile(resource.Resource):
+
+    base_path = '/backup-files'
+    resources_key = 'files'
+
+    # capabilities
+    allow_list = True
+
+    _query_mapping = resource.QueryParameters('backup_id')
+
+    #:  Indicates the file name
+    #:  *Type: string*
+    name = resource.Body('name')
+    #:  Indicates the file size in KB.
+    #:  *Type: long*
+    size = resource.Body('size', type=int)
+    #:  Indicates the link for downloading the backup file.
+    #:  *Type: string*
+    download_link = resource.Body('download_link')
+    #:  Indicates the link expiration time.
+    #:  The format is "yyyy-mmddThh:mm:ssZ".
+    #:  *Type: string*
+    expires_at = resource.Body('link_expired_time')
diff --git a/otcextensions/sdk/rds/v3/configuration.py b/otcextensions/sdk/rds/v3/configuration.py
new file mode 100644
index 000000000..4a3f90722
--- /dev/null
+++ b/otcextensions/sdk/rds/v3/configuration.py
@@ -0,0 +1,104 @@
+# 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 openstack import resource
+from openstack import utils
+
+from otcextensions.sdk.rds.v3 import _base
+
+
+class Configuration(_base.Resource):
+
+    base_path = '/configurations'
+    resources_key = 'configurations'
+    resource_key = 'configuration'
+
+    # capabilities
+    allow_create = True
+    allow_delete = True
+    allow_commit = True
+    allow_fetch = True
+    allow_list = True
+
+    #: Id of the configuration group
+    configuration_id = resource.Body('configuration_id')
+    configuration_name = resource.Body('configuration_name')
+    #: *Type:str*
+    id = resource.Body('id', alias='configuration_id')
+    #: Name of the configuration group
+    #: *Type:str*
+    name = resource.Body('name', alias='configuration_name')
+    #: Data store information
+    #: *Type: dict*
+    datastore = resource.Body('datastore', type=dict)
+    #: Description of the configuration group
+    #: *Type:str*
+    description = resource.Body('description')
+    #: Name of Datastore version
+    #: *Type:str*
+    datastore_version_name = resource.Body('datastore_version_name')
+    #: Name of Datastore
+    #: *Type:str*
+    datastore_name = resource.Body('datastore_name')
+    #: Individual Configuration values
+    #: *Type:dict*
+    configuration_parameters = resource.Body('configuration_parameters',
+                                             type=list)
+    #: Date of created
+    #: *Type:str*
+    created_at = resource.Body('created')
+    #: Date of updated
+    #: *Type:str*
+    updated_at = resource.Body('updated')
+    #: Indicates whether the parameter group is created by users.
+    #: *Type:bool*
+    is_user_defined = resource.Body('user_defined', type=bool)
+    #: parameter group values defined by users
+    #: *Type: dict*
+    values = resource.Body('values', type=dict)
+
+    #: Results of the configuration apply per instance
+    #: *Type:list*
+    apply_results = resource.Body('apply_results', type=list)
+
+    @classmethod
+    def find(cls, session, name_or_id, ignore_missing=True, **params):
+        instance = super(Configuration, cls).find(
+            session, name_or_id,
+            ignore_missing=ignore_missing,
+            **params)
+        if instance:
+            return instance.fetch(session)
+        return
+
+    def create(self, session, prepend_key=False, base_path=None):
+        return super(Configuration, self).create(session,
+                                                 prepend_key=prepend_key,
+                                                 base_path=base_path)
+
+    def commit(self, session, prepend_key=False, **further_attrs):
+        return super(Configuration, self).commit(
+            session,
+            prepend_key=prepend_key,
+            **further_attrs)
+
+    def apply(self, session, instances):
+        """Apply configuration to the given instances
+        """
+        url = utils.urljoin(self.base_path, self.id, 'apply')
+        body = {'instance_ids': instances}
+        response = session.put(
+            url,
+            json=body)
+        exceptions.raise_from_response(response)
+        self._translate_response(response)
+        return self
diff --git a/otcextensions/sdk/rds/v3/datastore.py b/otcextensions/sdk/rds/v3/datastore.py
new file mode 100644
index 000000000..291d4df50
--- /dev/null
+++ b/otcextensions/sdk/rds/v3/datastore.py
@@ -0,0 +1,30 @@
+# 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 resource
+
+
+class Datastore(resource.Resource):
+
+    base_path = '/datastores/%(database_name)s'
+    resources_key = 'dataStores'
+
+    # capabilities
+    allow_list = True
+
+    database_name = resource.URI('database_name')
+
+    # Indicates the database version ID. Its value is unique.
+    # :*Type:string*
+    id = resource.Body('id')
+    # Indicates the database version.
+    # :*Type:string*
+    name = resource.Body('name')
diff --git a/otcextensions/sdk/rds/v3/flavor.py b/otcextensions/sdk/rds/v3/flavor.py
new file mode 100644
index 000000000..586df6417
--- /dev/null
+++ b/otcextensions/sdk/rds/v3/flavor.py
@@ -0,0 +1,39 @@
+# 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 resource
+
+
+class Flavor(resource.Resource):
+
+    base_path = '/flavors/%(datastore_name)s'
+    resources_key = 'flavors'
+
+    # capabilities
+    allow_list = True
+    _query_mapping = resource.QueryParameters('version_name')
+
+    datastore_name = resource.URI('datastore_name')
+    #: Instance Mode (single/ha/replica)
+    #: *Type: int*
+    instance_mode = resource.Body('instance_mode')
+    #: Ram size in MB.
+    #: *Type:int*
+    ram = resource.Body('ram', type=int)
+    #: Flavor name.
+    #: *Type:str*
+    name = resource.Body('name', alias='spec_code')
+    #: Specification code
+    #: *Type: str*
+    spec_code = resource.Body('spec_code')
+    #: Amount of VCPU's
+    #: *Type: str*
+    vcpus = resource.Body('vcpus')
diff --git a/otcextensions/sdk/rds/v3/instance.py b/otcextensions/sdk/rds/v3/instance.py
new file mode 100644
index 000000000..0831b3146
--- /dev/null
+++ b/otcextensions/sdk/rds/v3/instance.py
@@ -0,0 +1,314 @@
+# 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 openstack import resource
+from openstack import utils
+
+from otcextensions.sdk.rds.v3 import _base
+
+
+class Instance(_base.Resource):
+
+    base_path = '/instances'
+    resources_key = 'instances'
+
+    # capabilities
+    allow_create = True
+    allow_delete = True
+    allow_commit = True
+    allow_list = True
+
+    _query_mapping = resource.QueryParameters(
+        'id', 'name', 'type', 'datastore_type', 'router_id',
+        'subnet_id', 'limit', 'offset',
+        router_id='vpc_id')
+
+    #: Availability Zone.
+    #: *Type:str*
+    availability_zone = resource.Body('availability_zone')
+    # TODO(not_gtema): extract backup strategy into separate type
+    #: Backup Strategy.
+    #: *Type: dict*
+    backup_strategy = resource.Body('backup_strategy', type=dict)
+    #: Specifies the billing information, which is pay-per-use.
+    #: *Type: dict*
+    charge_info = resource.Body('charge_info', type=dict)
+    #: Parameter configuration ID.
+    #: *Type:uuid*
+    configuration_id = resource.Body('configuration_id')
+    #: Instance created time.
+    #: *Type:str*
+    created_at = resource.Body('created')
+    #: Data store information.
+    #: *Type: dict*
+    datastore = resource.Body('datastore', type=dict)
+    #: Datastore type information (for querying).
+    datastore_type = resource.Body('datastore_type')
+    #: Disk Encryption Key Id.
+    #: *Type:str*
+    disk_encryption_id = resource.Body('disk_encryption_id')
+    #: Flavor ID
+    #: *Type:uuid*
+    flavor_ref = resource.Body('flavor_ref')
+    #: Async job id
+    job_id = resource.Body('job_id')
+    #: HighAvailability configuration parameters.
+    #: *Type: dict*
+    ha = resource.Body('ha', type=dict)
+    #: Maintenance time window.
+    #: *Type:str*
+    maintenance_window = resource.Body('maintenance_window')
+    #: Node information
+    #:  Indicates the primary/standby DB instance information.
+    #: *Type:list*
+    nodes = resource.Body('nodes', type=list)
+    #: Password of the default user.
+    #: *Type:str*
+    password = resource.Body('password')
+    #: Database listen port number.
+    #: *Type:int*
+    port = resource.Body('port', type=int)
+    #: Private IP address List.
+    #: *Type:list*
+    private_ips = resource.Body('private_ips', type=list)
+    #: Public IP address List,
+    #: *Type:list*
+    public_ips = resource.Body('public_ips', type=list)
+    #: Region where DB is deployed.
+    #: *Type:str*
+    region = resource.Body('region')
+    #: list of associated DB instances.
+    #: *Type:list*
+    related_instances = resource.Body('related_instance', type=list)
+    #: Specifies the DB instance ID, which is used to create a read replica.
+    replica_of_id = resource.Body('replica_of_id')
+    #: Specifies the restoration point for instance recovery.
+    #: *Type: dict*
+    restore_point = resource.Body('restore_point', type=dict)
+    #: Recovery time period for instance.
+    restore_time = resource.Body('restore_time', type=list)
+    #: Neutron router ID.
+    router_id = resource.Body('vpc_id')
+    #: Security Group Id.
+    security_group_id = resource.Body('security_group_id')
+    #: Id of subnet.
+    subnet_id = resource.Body('subnet_id')
+    #: Instance status.
+    status = resource.Body('status')
+    #: Switch Strategy. The value can be reliability or availability,
+    #: indicating the reliability first and availability first, respectively.
+    #: *Type:str*
+    switch_strategy = resource.Body('switch_strategy')
+    #: Time Zone.
+    #: *Type:str*
+    time_zone = resource.Body('time_zone')
+    #: Instance type Single/Ha/Replica.,
+    #: *Type:str*
+    type = resource.Body('type')
+    # datastore: Instance updated time.
+    #: *Type:str*
+    updated_at = resource.Body('updated')
+    #: Default user of the DB
+    user_name = resource.Body('db_user_name')
+    #: Volume information
+    #: *Type: dict*
+    volume = resource.Body('volume', type=dict)
+
+    def _translate_response(self, response, has_body=None, error_message=None):
+        """Given a KSA response, inflate this instance with its data
+
+        DELETE operations don't return a body, so only try to work
+        with a body when has_body is True.
+
+        This method updates attributes that correspond to headers
+        and body on this instance and clears the dirty set.
+        """
+        if has_body is None:
+            has_body = self.has_body
+        exceptions.raise_from_response(response, error_message=error_message)
+        if has_body:
+            try:
+                body = response.json()
+                # Need to merge job_id on the root with other data inside of
+                # 'instance' container
+                job_id = body.get('job_id')
+                if 'instance' in body:
+                    body = body['instance']
+                    if job_id:
+                        body['job_id'] = job_id
+
+                body_attrs = self._consume_body_attrs(body)
+
+                if self._store_unknown_attrs_as_properties:
+                    body_attrs = self._pack_attrs_under_properties(
+                        body_attrs, body)
+
+                self._body.attributes.update(body_attrs)
+                self._body.clean()
+                if self.commit_jsonpatch or self.allow_patch:
+                    # We need the original body to compare against
+                    self._original_body = body_attrs.copy()
+            except ValueError:
+                # Server returned not parse-able response (202, 204, etc)
+                # Do simply nothing
+                pass
+
+        headers = self._consume_header_attrs(response.headers)
+        self._header.attributes.update(headers)
+        self._header.clean()
+        self._update_location()
+        dict.update(self, self.to_dict())
+
+    @classmethod
+    def find(cls, session, name_or_id, ignore_missing=True, **params):
+        """Find a resource by its name or id.
+
+        :param session: The session to use for making this request.
+        :type session: :class:`~keystoneauth1.adapter.Adapter`
+        :param name_or_id: This resource's identifier, if needed by
+                           the request. The default is ``None``.
+        :param bool ignore_missing: When set to ``False``
+                    :class:`~openstack.exceptions.ResourceNotFound` will be
+                    raised when the resource does not exist.
+                    When set to ``True``, None will be returned when
+                    attempting to find a nonexistent resource.
+        :param dict params: Any additional parameters to be passed into
+                            underlying methods, such as to
+                            :meth:`~openstack.resource.Resource.existing`
+                            in order to pass on URI parameters.
+
+        :return: The :class:`Resource` object matching the given name or id
+                 or None if nothing matches.
+        :raises: :class:`openstack.exceptions.DuplicateResource` if more
+                 than one resource is found for this request.
+        :raises: :class:`openstack.exceptions.ResourceNotFound` if nothing
+                 is found and ignore_missing is ``False``.
+        """
+        session = cls._get_session(session)
+
+        result = cls._find(session, name_or_id, id=name_or_id, **params)
+
+        if not result:
+            result = cls._find(session, name_or_id, name=name_or_id, **params)
+
+        if result:
+            return result
+
+        if ignore_missing:
+            return None
+        raise exceptions.ResourceNotFound(
+            "No %s found for %s" % (cls.__name__, name_or_id))
+
+    @classmethod
+    def _find(cls, session, name_or_id, **params):
+        data = cls.list(session, **params)
+
+        result = cls._get_one_match(name_or_id, data)
+        if result is not None:
+            return result
+
+    def fetch(self, session, requires_id=True,
+              base_path=None, error_message=None, **params):
+        """Get a remote resource based on this instance.
+
+        :param session: The session to use for making this request.
+        :type session: :class:`~keystoneauth1.adapter.Adapter`
+        :param boolean requires_id: A boolean indicating whether resource ID
+                                    should be part of the requested URI.
+        :param str base_path: Base part of the URI for fetching resources, if
+                              different from
+                              :data:`~openstack.resource.Resource.base_path`.
+        :param str error_message: An Error message to be returned if
+                                  requested object does not exist.
+        :param dict params: Additional parameters that can be consumed.
+        :return: This :class:`Resource` instance.
+        :raises: :exc:`~openstack.exceptions.MethodNotSupported` if
+                 :data:`Resource.allow_fetch` is not set to ``True``.
+        :raises: :exc:`~openstack.exceptions.ResourceNotFound` if
+                 the resource was not found.
+        """
+        data = self.list(session, paginated=False, id=self.id)
+        result = self._get_one_match(self.id, data)
+        if not result:
+            raise exceptions.ResourceNotFound(
+                "No Instance found for %s" % (self.id))
+
+        self._body.attributes.update(result._body.attributes)
+        self._body.clean()
+
+        return self
+
+    def fetch_restore_times(self, session):
+        """List possible restore times for the instance.
+        """
+        url = utils.urljoin(self.base_path, self.id, 'restore-time')
+        response = session.get(url)
+        self._translate_response(response)
+        return self.restore_time
+
+    def get_instance_configuration(self, session):
+        pass
+
+    def update_instance_configuration(self, session):
+        pass
+
+    def restore(self, session, backup=None, restore_time=None):
+        """Restore instance from the backup of PIR.
+        """
+        url = utils.urljoin(self.base_path, 'recovery')
+
+        body = {
+            'source': None,
+            'target': {'instance_id': self.id}
+        }
+
+        if backup:
+            body['source'] = {'type': 'backup', 'backup_id': backup.id}
+        elif restore_time:
+            body['source'] = {
+                'type': 'timestamp',
+                'restore_time': restore_time
+            }
+
+        body['source']['instance_id'] = self.id
+
+        response = session.post(url, json=body)
+        exceptions.raise_from_response(response)
+        job_id = response.json().get('job_id')
+
+        return job_id
+
+    def get_backup_policy(self, session):
+        """Get instance backup policy
+        """
+        url = utils.urljoin(self.base_path, self.id, 'backups', 'policy')
+        response = session.get(url)
+        exceptions.raise_from_response(response)
+
+        return response.json().get('backup_policy')
+
+    def set_backup_policy(self, session, keep_days, start_time=None,
+                          period=None):
+        """Set instance backup policy
+        """
+        url = utils.urljoin(self.base_path, self.id, 'backups', 'policy')
+        body = {
+            'keep_days': keep_days
+        }
+        if start_time:
+            body['start_time'] = start_time
+        if period:
+            body['period'] = period
+        response = session.put(url, json={'backup_policy': body})
+        exceptions.raise_from_response(response)
+
+        return None
diff --git a/otcextensions/tests/functional/osclient/rds/__init__.py b/otcextensions/tests/functional/osclient/rds/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/otcextensions/tests/functional/osclient/rds/v3/__init__.py b/otcextensions/tests/functional/osclient/rds/v3/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/otcextensions/tests/functional/osclient/rds/v3/test_configuration.py b/otcextensions/tests/functional/osclient/rds/v3/test_configuration.py
new file mode 100644
index 000000000..00b4aa583
--- /dev/null
+++ b/otcextensions/tests/functional/osclient/rds/v3/test_configuration.py
@@ -0,0 +1,148 @@
+#    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.
+
+import json
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class TestRdsConfiguration(base.TestCase):
+    """Functional tests for RDS Configurations. """
+
+    NAME = uuid.uuid4().hex
+
+    def test_list(self):
+        json_output = json.loads(
+            self.openstack('rds configuration list -f json '))
+        self.assertIsNotNone(json_output)
+
+    def test_show(self):
+        json_output = json.loads(
+            self.openstack('rds configuration list -f json'))
+
+        json_output = json.loads(
+            self.openstack(
+                'rds configuration show {cfg} '
+                '-f json'.format(
+                    cfg=json_output[0]['ID']
+                )
+            )
+        )
+
+        self.assertIsNotNone(json_output['id'])
+
+    def test_long(self):
+        json_output = json.loads(
+            self.openstack(
+                'rds configuration create '
+                '--datastore-type postgresql '
+                '--datastore-version 9.6 '
+                '--value max_connections=10 '
+                '{name} -f json'.format(name=self.NAME)
+            )
+        )
+        id = json_output['id']
+        self.addCleanup(self.openstack, 'rds configuration delete ' + id)
+
+        json_output = json.loads(
+            self.openstack(
+                'rds configuration show {id} '
+                '-f json'.format(id=id)
+            )
+        )
+        self.assertTrue(self.NAME, json_output['name'])
+
+        json_output = json.loads(
+            self.openstack(
+                'rds configuration show {id} '
+                '-f json'.format(id=self.NAME)
+            )
+        )
+        self.assertTrue(id, json_output['id'])
+
+        self.openstack(
+            'rds configuration set '
+            '--value max_connections=15 '
+            '{name}'.format(name=self.NAME)
+        )
+
+    def test_create(self):
+        name = uuid.uuid4().hex
+        json_output = json.loads(
+            self.openstack(
+                'rds configuration create '
+                '{name} '
+                '--datastore-type MySQL '
+                '--datastore-version 5.7 '
+                '-f json'.format(name=name)
+            )
+        )
+        self.assertIsNotNone(json_output)
+        id = json_output['id']
+        self.addCleanup(self.openstack, 'rds configuration delete ' + id)
+
+    def test_create_with_value(self):
+        name = uuid.uuid4().hex
+        json_output = json.loads(
+            self.openstack(
+                'rds configuration create '
+                '{name} '
+                '--datastore-type MySQL '
+                '--datastore-version 5.7 '
+                '--value max_connections=10 '
+                '--value autocommit=OFF '
+                '-f json'.format(name=name)
+            )
+        )
+        self.assertIsNotNone(json_output)
+        self.assertEqual(name, json_output['name'])
+        id = json_output['id']
+        self.addCleanup(self.openstack, 'rds configuration delete ' + id)
+
+    def test_config_param_list(self):
+        json_output = json.loads(
+            self.openstack(
+                'rds configuration list -f json'
+            )
+        )
+        json_output = json.loads(
+            self.openstack(
+                'rds configuration parameter list '
+                '{cfg} '
+                '-f json'.format(cfg=json_output[0]['ID'])
+            )
+        )
+        self.assertIsNotNone(json_output)
+
+    def test_config_set(self):
+        name = uuid.uuid4().hex
+        json_output = json.loads(
+            self.openstack(
+                'rds configuration create '
+                '{name} '
+                '--datastore-type MySQL '
+                '--datastore-version 5.7 '
+                '-f json'.format(name=name)
+            )
+        )
+        self.assertIsNotNone(json_output)
+        id = json_output['id']
+        self.addCleanup(self.openstack, 'rds configuration delete ' + id)
+
+        self.openstack(
+            'rds configuration set '
+            '{name} '
+            '--value max_connections=10 '
+            '--value autocommit=OFF'.format(name=name)
+        )
+        self.assertTrue(True)
diff --git a/otcextensions/tests/functional/osclient/rds/v3/test_datastore.py b/otcextensions/tests/functional/osclient/rds/v3/test_datastore.py
new file mode 100644
index 000000000..2d373251a
--- /dev/null
+++ b/otcextensions/tests/functional/osclient/rds/v3/test_datastore.py
@@ -0,0 +1,35 @@
+#    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.
+
+import json
+
+from openstackclient.tests.functional import base
+
+
+class TestRdsDatastore(base.TestCase):
+    """Functional tests for RDS Datastore. """
+
+    def test_datastore_list(self):
+        json_output = json.loads(self.openstack(
+            'rds datastore type list -f json '
+        ))
+        self.assertIn(
+            'PostgreSQL',
+            [ds['Name'] for ds in json_output]
+        )
+
+    def test_datastore_version_list(self):
+        json_output = json.loads(self.openstack(
+            'rds datastore version list PostgreSQL -f json'
+        ))
+
+        self.assertIsNotNone(json_output)
diff --git a/otcextensions/tests/functional/osclient/rds/v3/test_flavor.py b/otcextensions/tests/functional/osclient/rds/v3/test_flavor.py
new file mode 100644
index 000000000..864316543
--- /dev/null
+++ b/otcextensions/tests/functional/osclient/rds/v3/test_flavor.py
@@ -0,0 +1,36 @@
+#    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.
+
+import json
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class TestRdsFlavor(base.TestCase):
+    """Functional tests for RDS Flavor. """
+
+    NAME = uuid.uuid4().hex
+    OTHER_NAME = uuid.uuid4().hex
+
+    def test_flavor_list(self):
+        json_output = json.loads(self.openstack(
+            'rds datastore version list postgresql -f json '
+        ))
+        ver = json_output[0]['Name']
+
+        json_output = json.loads(self.openstack(
+            'rds flavor list postgresql {ver} -f json '.format(
+                ver=ver)
+        ))
+
+        self.assertIsNotNone(json_output)
diff --git a/otcextensions/tests/functional/osclient/rds/v3/test_instance.py b/otcextensions/tests/functional/osclient/rds/v3/test_instance.py
new file mode 100644
index 000000000..8e34fb33c
--- /dev/null
+++ b/otcextensions/tests/functional/osclient/rds/v3/test_instance.py
@@ -0,0 +1,39 @@
+#    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.
+
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class TestRdsInstance(base.TestCase):
+    """Functional tests for RDS Instance. """
+
+    NAME = uuid.uuid4().hex
+    OTHER_NAME = uuid.uuid4().hex
+
+    def test_instance_list(self):
+        self.openstack(
+            'rds instance list -f json '
+        )
+
+    def test_instance_list_filters(self):
+        self.openstack(
+            'rds instance list '
+            '--limit 1 --id 2 '
+            '--name 3 --type Single '
+            '--database PostgreSQL '
+            '--router_id 123asd --subnet_id 123qwe '
+            '--offset 5'
+        )
+
+        self.assertTrue(True)
diff --git a/otcextensions/tests/unit/osclient/dns/v2/fakes.py b/otcextensions/tests/unit/osclient/dns/v2/fakes.py
index de2a931f2..115533f27 100644
--- a/otcextensions/tests/unit/osclient/dns/v2/fakes.py
+++ b/otcextensions/tests/unit/osclient/dns/v2/fakes.py
@@ -1,17 +1,14 @@
-#   Copyright 2013 Nebula Inc.
+# 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
 #
-#   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
 #
-#        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.
-# import datetime
+# 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.
 import random
 import uuid
 import time
diff --git a/otcextensions/tests/unit/osclient/rds/v3/__init__.py b/otcextensions/tests/unit/osclient/rds/v3/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/otcextensions/tests/unit/osclient/rds/v3/fakes.py b/otcextensions/tests/unit/osclient/rds/v3/fakes.py
new file mode 100644
index 000000000..bc4fc66c6
--- /dev/null
+++ b/otcextensions/tests/unit/osclient/rds/v3/fakes.py
@@ -0,0 +1,204 @@
+# 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.
+#
+import random
+import uuid
+
+import mock
+
+from openstackclient.tests.unit import utils
+
+from otcextensions.tests.unit.osclient import test_base
+
+from otcextensions.sdk.rds.v3 import configuration
+from otcextensions.sdk.rds.v3 import datastore
+from otcextensions.sdk.rds.v3 import flavor
+from otcextensions.sdk.rds.v3 import instance
+from otcextensions.sdk.rds.v3 import backup
+
+
+def gen_data(data, columns):
+    """Fill expected data tuple based on columns list
+    """
+    return tuple(getattr(data, attr, '') for attr in columns)
+
+
+def gen_data_dict(data, columns):
+    """Fill expected data tuple based on columns list
+    """
+    return tuple(data.get(attr, '') for attr in columns)
+
+
+class TestRds(utils.TestCommand):
+    def setUp(self):
+        super(TestRds, self).setUp()
+
+        self.app.client_manager.rds = mock.Mock()
+
+        self.client = self.app.client_manager.rds
+
+        self.datastore_mock = FakeDatastore
+        self.flavor_mock = FakeFlavor
+        self.instance_mock = FakeInstance
+        self.backup_mock = FakeBackup
+        self.configuration_mock = FakeConfiguration
+
+
+class FakeDatastore(test_base.Fake):
+    """Fake one or more datastore versions."""
+    @classmethod
+    def generate(cls):
+        """Create a fake datastore.
+
+        :return:
+            A FakeResource object, with id, name, metadata, and so on
+        """
+        # Set default attributes.
+        object_info = {
+            'id': 'id-' + uuid.uuid4().hex,
+            'name': 'name-' + uuid.uuid4().hex
+        }
+
+        return datastore.Datastore(**object_info)
+
+
+class FakeFlavor(test_base.Fake):
+    """Fake one or more VBS Policy"""
+    @classmethod
+    def generate(cls):
+        object_info = {
+            'instance_mode': random.choice(['ha', 'replica', 'single']),
+            'vcpus': str(random.randint(1, 100)),
+            'spec_code': uuid.uuid4().hex,
+            'ram': random.randint(1, 10280),
+        }
+        obj = flavor.Flavor.existing(**object_info)
+        return obj
+
+
+class FakeConfiguration(test_base.Fake):
+    """Fake one or more Configuration."""
+
+    @classmethod
+    def generate(cls):
+        """Create a fake Configuration.
+
+        :param Dictionary attrs:
+            A dictionary with all attributes
+        :param Dictionary methods:
+            A dictionary with all methods
+        :return:
+            A FakeResource object, with id, name, metadata, and so on
+        """
+        object_info = {
+            'id': 'id-' + uuid.uuid4().hex,
+            'name': 'name-' + uuid.uuid4().hex,
+            'description': 'descriptions-' + uuid.uuid4().hex,
+            'datastore_name': uuid.uuid4().hex,
+            'datastore_version_name': uuid.uuid4().hex,
+            'values': {},
+            'configuration_parameters':
+                list({
+                    'name': 'name-' + uuid.uuid4().hex,
+                    'value': 'value-' + uuid.uuid4().hex,
+                    'restart_required': bool(random.getrandbits(1)),
+                    'readonly': bool(random.getrandbits(1)),
+                    'value_range': uuid.uuid4().hex,
+                    'type': 'type-' + uuid.uuid4().hex,
+                    'description': 'descr-' + uuid.uuid4().hex
+
+                } for i in range(3)),
+            'is_user_defined': bool(random.getrandbits(1)),
+            'apply_results': [
+                {
+                    "instance_id": uuid.uuid4().hex,
+                    "instance_name": uuid.uuid4().hex,
+                    "restart_required": bool(random.getrandbits(1)),
+                    "success": bool(random.getrandbits(1))
+                }
+            ]
+
+        }
+
+        obj = configuration.Configuration.existing(**object_info)
+        return obj
+
+
+class FakeInstance(test_base.Fake):
+    """Fake one or more Instance."""
+    @classmethod
+    def generate(cls):
+        """Create a fake Configuration.
+
+        :return:
+            A FakeResource object, with id, name, metadata, and so on
+        """
+
+        # Set default attributes.
+        object_info = {
+            'id': 'id-' + uuid.uuid4().hex,
+            'name': 'name-' + uuid.uuid4().hex,
+            'status': 'status-' + uuid.uuid4().hex,
+            'datastore': {
+                'type': 'datastore-' + uuid.uuid4().hex,
+                'version': 'version-' + uuid.uuid4().hex,
+            },
+            'flavor_ref': {
+                'id': uuid.uuid4().hex
+            },
+            'volume': {
+                'type': 'type' + uuid.uuid4().hex,
+                'size': random.randint(1, 10280),
+            },
+            'region': 'region' + uuid.uuid4().hex,
+            'job_id': 'jobid' + uuid.uuid4().hex
+        }
+
+        return instance.Instance(**object_info)
+
+
+class FakeBackup(test_base.Fake):
+    """Fake one or more Backup"""
+    @classmethod
+    def generate(cls):
+        object_info = {
+            'id': 'id-' + uuid.uuid4().hex,
+            'name': 'name-' + uuid.uuid4().hex,
+            'description': uuid.uuid4().hex,
+            'datastore': {
+                'type': 'datastore-' + uuid.uuid4().hex,
+                'version': 'version-' + uuid.uuid4().hex,
+            },
+            'instance_id': 'instance_id-' + uuid.uuid4().hex,
+            'size': random.randint(0, 100),
+            'status':
+            random.choice(['BUILDING', 'COMPLETED', 'FAILED', 'DELETING']),
+            'type': random.choice(['auto', 'manual']),
+            'begin_time': uuid.uuid4().hex,
+            'end_time': uuid.uuid4().hex
+        }
+        obj = backup.Backup.existing(**object_info)
+        return obj
+
+
+class FakeBackupFile(test_base.Fake):
+    """Fake one or more BackupFile"""
+    @classmethod
+    def generate(cls):
+        object_info = {
+            'size': random.randint(1, 100000),
+            'name': 'name-' + uuid.uuid4().hex,
+            'download_link': uuid.uuid4().hex,
+            'expires_at': 'expires-' + uuid.uuid4().hex
+        }
+        obj = backup.BackupFile.existing(**object_info)
+        return obj
diff --git a/otcextensions/tests/unit/osclient/rds/v3/test_backup.py b/otcextensions/tests/unit/osclient/rds/v3/test_backup.py
new file mode 100644
index 000000000..337cf7d24
--- /dev/null
+++ b/otcextensions/tests/unit/osclient/rds/v3/test_backup.py
@@ -0,0 +1,280 @@
+# 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.
+import mock
+
+from otcextensions.osclient.rds.v3 import backup
+from otcextensions.tests.unit.osclient.rds.v3 import fakes as fakes
+
+
+class TestList(fakes.TestRds):
+
+    _instance = fakes.FakeInstance.create_one()
+
+    _objects = fakes.FakeBackup.create_multiple(3)
+
+    column_headers = ('ID', 'Name', 'Type', 'Instance Id', 'Size (KB)')
+    columns = ('id', 'name', 'type', 'instance_id', 'size')
+
+    data = []
+
+    for s in _objects:
+        data.append(fakes.gen_data(s, columns))
+
+    def setUp(self):
+        super(TestList, self).setUp()
+
+        self.cmd = backup.ListBackup(self.app, None)
+
+        self.client.backups = mock.Mock()
+        self.client.find_instance = mock.Mock(return_value=self._instance)
+
+    def test_list_default(self):
+        arglist = ['test-instance']
+
+        verifylist = [
+            ('instance', 'test-instance'),
+        ]
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.backups.side_effect = [self._objects]
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.find_instance.assert_called_with('test-instance',
+                                                     ignore_missing=False)
+        self.client.backups.assert_called_once_with(instance=self._instance)
+
+        self.assertEqual(self.column_headers, columns)
+        self.assertEqual(self.data, list(data))
+
+    def test_list_params(self):
+        arglist = [
+            'test-instance',
+            '--backup-id', 'bid',
+            '--backup-type', 'manual',
+            '--offset', '1',
+            '--limit', '2',
+            # '--begin-time', '3',
+            # '--end-time', '4'
+        ]
+
+        verifylist = [
+            ('instance', 'test-instance'),
+            ('backup_id', 'bid'),
+            ('backup_type', 'manual'),
+            ('offset', 1),
+            ('limit', 2),
+            # ('begin_time', '3'),
+            # ('end_time', '4')
+        ]
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.backups.side_effect = [self._objects]
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.find_instance.assert_called_with(
+            'test-instance',
+            ignore_missing=False)
+        self.client.backups.assert_called_once_with(
+            instance=self._instance,
+            backup_id='bid',
+            backup_type='manual',
+            offset=1,
+            limit=2,
+            paginated=False,
+            # begin_time='3',
+            # end_time='4'
+        )
+
+        self.assertEqual(self.column_headers, columns)
+        self.assertEqual(self.data, list(data))
+
+
+class TestCreate(fakes.TestRds):
+
+    _data = fakes.FakeBackup.create_one()
+    _instance = fakes.FakeInstance.create_one()
+
+    columns = (
+        'begin_time', 'datastore', 'description',
+        'end_time', 'id', 'instance_id', 'name',
+        'size', 'status', 'type'
+    )
+
+    data = fakes.gen_data(_data, columns)
+
+    def setUp(self):
+        super(TestCreate, self).setUp()
+
+        self.cmd = backup.CreateBackup(self.app, None)
+
+        self.client.create_backup = mock.Mock(return_value=self._data)
+        self.client.find_instance = mock.Mock(return_value=self._instance)
+
+    def test_create(self):
+        arglist = [
+            'test-backup',
+            'test-instance',
+            '--description',
+            'test description',
+        ]
+        verifylist = [
+            ('name', 'test-backup'),
+            ('instance', 'test-instance'),
+            ('description', 'test description'),
+        ]
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.find_instance.assert_called_with('test-instance',
+                                                     ignore_missing=False)
+        self.client.create_backup.assert_called_with(
+            instance=self._instance,
+            description='test description',
+            name='test-backup'
+        )
+        self.assertEqual(self.columns, columns)
+
+    def test_create_sqlserver(self):
+        arglist = [
+            'test-backup',
+            'test-instance',
+            '--description', 'test description',
+            '--databases', 'a,b,c'
+        ]
+        verifylist = [
+            ('name', 'test-backup'),
+            ('instance', 'test-instance'),
+            ('description', 'test description'),
+            ('databases', 'a,b,c')
+        ]
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        self._instance.datastore.update({'type': 'sqlserver'})
+        self.client.find_instance.return_value = self._instance
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.find_instance.assert_called_with('test-instance',
+                                                     ignore_missing=False)
+        self.client.create_backup.assert_called_with(
+            instance=self._instance,
+            description='test description',
+            name='test-backup',
+            databases=[{'name': 'a'}, {'name': 'b'}, {'name': 'c'}]
+        )
+        self.assertEqual(self.columns, columns)
+
+
+class TestDelete(fakes.TestRds):
+    def setUp(self):
+        super(TestDelete, self).setUp()
+
+        self.cmd = backup.DeleteBackup(self.app, None)
+
+        self.client.delete_backup = mock.Mock()
+
+    def test_delete_default(self):
+        arglist = [
+            'bck1',
+        ]
+
+        verifylist = [
+            ('backup', ['bck1']),
+        ]
+
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.delete_backup.side_effect = [{}]
+
+        # Trigger the action
+        self.cmd.take_action(parsed_args)
+
+        self.client.delete_backup.assert_called_once_with(backup='bck1',
+                                                          ignore_missing=False)
+
+    def test_delete_multiple(self):
+        arglist = ['bck1', 'bck2']
+
+        verifylist = [
+            ('backup', ['bck1', 'bck2']),
+        ]
+
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.delete_backup.side_effect = [{}, {}]
+
+        # Trigger the action
+        self.cmd.take_action(parsed_args)
+
+        calls = [
+            mock.call(backup='bck1', ignore_missing=False),
+            mock.call(backup='bck2', ignore_missing=False),
+        ]
+
+        self.client.delete_backup.assert_has_calls(calls)
+        self.assertEqual(2, self.client.delete_backup.call_count)
+
+
+class TestListLinks(fakes.TestRds):
+
+    _objects = fakes.FakeBackupFile.create_multiple(3)
+
+    column_headers = ('Size (KB)', 'URL', 'Expires at')
+    columns = ('size', 'download_link', 'expires_at')
+
+    data = []
+
+    for s in _objects:
+        data.append(fakes.gen_data(s, columns))
+
+    def setUp(self):
+        super(TestListLinks, self).setUp()
+
+        self.cmd = backup.ListBackupDownloadLinks(self.app, None)
+
+        self.client.backup_download_links = mock.Mock(
+            return_value=self._objects)
+
+    def test_list_default(self):
+        arglist = ['test-backup']
+
+        verifylist = [
+            ('backup_id', 'test-backup'),
+        ]
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.backup_download_links.assert_called_once_with(
+            backup_id='test-backup')
+
+        self.assertEqual(self.column_headers, columns)
+        self.assertEqual(self.data, list(data))
diff --git a/otcextensions/tests/unit/osclient/rds/v3/test_configuration.py b/otcextensions/tests/unit/osclient/rds/v3/test_configuration.py
new file mode 100644
index 000000000..3093e604a
--- /dev/null
+++ b/otcextensions/tests/unit/osclient/rds/v3/test_configuration.py
@@ -0,0 +1,412 @@
+# 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.
+#
+import mock
+
+from otcextensions.osclient.rds.v3 import configuration
+from otcextensions.tests.unit.osclient.rds.v3 import fakes
+
+
+class TestListConfiguration(fakes.TestRds):
+
+    objects = fakes.FakeConfiguration.create_multiple(3)
+
+    column_list_headers = [
+        'ID',
+        'Name',
+        'Description',
+        'Datastore Name',
+        'Datastore Version Name',
+        'User Defined'
+    ]
+
+    columns = ('id', 'name', 'description', 'datastore_name',
+               'datastore_version_name', 'is_user_defined')
+
+    data = []
+
+    for s in objects:
+        data.append(fakes.gen_data(s, columns))
+
+    def setUp(self):
+        super(TestListConfiguration, self).setUp()
+
+        self.cmd = configuration.ListConfigurations(self.app, None)
+
+        self.client.configurations = mock.Mock()
+        self.client.api_mock = self.client.configurations
+
+    def test_list(self):
+        arglist = []
+
+        verifylist = []
+
+        # Verify cm is triggered with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.api_mock.side_effect = [self.objects]
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.api_mock.assert_called_with()
+
+        self.assertEqual(self.column_list_headers, columns)
+        self.assertEqual(self.data, list(data))
+
+
+class TestShowConfiguration(fakes.TestRds):
+
+    _data = fakes.FakeConfiguration.create_one()
+
+    columns = (
+        'apply_results', 'datastore_name', 'datastore_version_name',
+        'description', 'id', 'is_user_defined', 'name'
+    )
+
+    data = fakes.gen_data(_data, columns)
+
+    def setUp(self):
+        super(TestShowConfiguration, self).setUp()
+
+        self.cmd = configuration.ShowConfiguration(self.app, None)
+
+        self.client.find_configuration = mock.Mock(return_value=self._data)
+
+    def test_show(self):
+        arglist = [
+            'test',
+        ]
+
+        verifylist = [
+            ('configuration', 'test'),
+        ]
+
+        # Verify cm is triggered with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+        self.client.find_configuration.assert_called_with('test',
+                                                          ignore_missing=False)
+
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+
+class TestListConfigurationParameters(fakes.TestRds):
+
+    config = fakes.FakeConfiguration.create_one()
+
+    objects = config.configuration_parameters
+
+    column_list_headers = (
+        'Name', 'Value', 'Type', 'Description',
+        'Restart Required', 'Readonly', 'Value Range'
+    )
+
+    columns = (
+        'name', 'value', 'type', 'description',
+        'restart_required', 'readonly', 'value_range'
+    )
+
+    data = []
+
+    for s in objects:
+        # NOTE: please fix this. For some reason comprehension doesn't work
+        # here
+        values = []
+        for attr in columns:
+            values.append(s.get(attr, ''))
+        data.append(tuple(values))
+
+    def setUp(self):
+        super(TestListConfigurationParameters, self).setUp()
+
+        self.cmd = configuration.ListConfigurationParameters(self.app, None)
+
+        self.client.find_configuration = mock.Mock(return_value=self.config)
+        self.client.api_mock = self.client.find_configuration
+
+    def test_list(self):
+        arglist = ['test_config']
+
+        verifylist = [
+            ('configuration', 'test_config')
+        ]
+
+        # Verify cm is triggered with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.api_mock.assert_called_with('test_config',
+                                                ignore_missing=False)
+
+        self.assertEqual(self.column_list_headers, columns)
+        self.assertEqual(self.data, list(data))
+
+
+class TestCreateConfiguration(fakes.TestRds):
+
+    _data = fakes.FakeConfiguration.create_one()
+
+    columns = (
+        'apply_results', 'datastore_name', 'datastore_version_name',
+        'description', 'id', 'is_user_defined', 'name'
+    )
+
+    data = fakes.gen_data(_data, columns)
+
+    def setUp(self):
+        super(TestCreateConfiguration, self).setUp()
+
+        self.cmd = configuration.CreateConfiguration(self.app, None)
+
+        self.client.create_configuration = mock.Mock()
+        self.client.api_mock = self.client.create_configuration
+
+    def test_create(self):
+        arglist = [
+            'cfg',
+            '--datastore-type', 'postgresql',
+            '--datastore-version', '-9.6',
+            '--description', 'descr',
+            '--value', 'a=b',
+            '--value', 'c=d'
+        ]
+
+        verifylist = [
+            ('name', 'cfg'),
+            ('datastore_type', 'postgresql'),
+            ('datastore_version', '-9.6'),
+            ('description', 'descr'),
+            ('values', {'a': 'b', 'c': 'd'})
+        ]
+
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.api_mock.side_effect = [
+            self._data
+        ]
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.api_mock.assert_called_once_with(
+            datastore={'type': 'postgresql', 'version': '-9.6'},
+            description='descr',
+            name='cfg',
+            values={'a': 'b', 'c': 'd'}
+        )
+
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+    def test_create2(self):
+        arglist = [
+            'cfg',
+            '--datastore-type', 'MySQL',
+            '--datastore-version', '-9.6',
+        ]
+
+        verifylist = [
+            ('name', 'cfg'),
+            ('datastore_type', 'mysql'),
+            ('datastore_version', '-9.6'),
+        ]
+
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.api_mock.side_effect = [
+            self._data
+        ]
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.api_mock.assert_called_once_with(
+            datastore={'type': 'mysql', 'version': '-9.6'},
+            name='cfg'
+        )
+
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+
+class TestSetConfiguration(fakes.TestRds):
+
+    def setUp(self):
+        super(TestSetConfiguration, self).setUp()
+
+        self.cmd = configuration.SetConfiguration(self.app, None)
+
+        self.client.update_configuration = mock.Mock()
+        self.client.api_mock = self.client.update_configuration
+        self.client.find_configuration = mock.Mock()
+
+    def test_action(self):
+        arglist = [
+            't1',
+            '--name', 'new_name',
+            '--description', 'new_descr',
+            '--value', 'q=z',
+            '--value', 'w=u'
+        ]
+        verifylist = [
+            ('configuration', 't1'),
+            ('name', 'new_name'),
+            ('description', 'new_descr'),
+            ('values', {'q': 'z', 'w': 'u'})
+        ]
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.find_configuration.return_value = 't1'
+
+        # Trigger the action
+        resp = self.cmd.take_action(parsed_args)
+
+        self.client.find_configuration.assert_called_with('t1',
+                                                          ignore_missing=False)
+        self.client.api_mock.assert_called_with(
+            't1',
+            description='new_descr',
+            name='new_name',
+            values={'q': 'z', 'w': 'u'}
+        )
+        self.assertIsNone(resp)
+
+
+class TestDeleteConfiguration(fakes.TestRds):
+
+    def setUp(self):
+        super(TestDeleteConfiguration, self).setUp()
+
+        self.cmd = configuration.DeleteConfiguration(self.app, None)
+
+        self.client.delete_configuration = mock.Mock()
+        self.client.api_mock = self.client.delete_configuration
+        self.client.find_configuration = mock.Mock()
+
+    def test_delete_multiple(self):
+        arglist = [
+            't1',
+            't2',
+        ]
+        verifylist = [
+            ('configuration', ['t1', 't2'])
+        ]
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.api_mock.side_effect = [{}, {}]
+        self.client.find_configuration.side_effect = ['t1', 't2']
+
+        # Trigger the action
+        self.cmd.take_action(parsed_args)
+
+        find_calls = [
+            mock.call('t1', ignore_missing=False),
+            mock.call('t2', ignore_missing=False)
+        ]
+
+        delete_calls = [
+            mock.call('t1'),
+            mock.call('t2')
+        ]
+
+        self.client.find_configuration.assert_has_calls(find_calls)
+        self.client.api_mock.assert_has_calls(delete_calls)
+
+
+class TestApplyConfiguration(fakes.TestRds):
+
+    _data = fakes.FakeConfiguration.create_one()
+
+    columns = (
+        'instance_id', 'instance_name',
+        'restart_required', 'success'
+    )
+
+    column_headers = (
+        'ID', 'Name', 'Restart required', 'success'
+    )
+
+    data = []
+    for s in _data.apply_results:
+        values = []
+        for attr in columns:
+            values.append(s.get(attr, ''))
+        data.append(tuple(values))
+
+    def setUp(self):
+        super(TestApplyConfiguration, self).setUp()
+
+        self.cmd = configuration.ApplyConfiguration(self.app, None)
+
+        self.client.find_configuration = mock.Mock()
+        self.client.apply_configuration = mock.Mock(return_value=self._data)
+        self.client.get_instance = mock.Mock()
+
+    def test_apply(self):
+        arglist = [
+            'cfg',
+            '--instance', 'i1',
+            '--instance', 'i2',
+        ]
+
+        verifylist = [
+            ('configuration', 'cfg'),
+            ('instances', ['i1', 'i2']),
+        ]
+
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.find_configuration.return_value = self._data
+        self.client.apply_configuration.return_value = self._data
+
+        class Inst(object):
+            def __init__(self, id):
+                self.id = id
+
+        self.client.get_instance.side_effect = lambda s: Inst(s)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        get_calls = [
+            mock.call('i1'),
+            mock.call('i2')
+        ]
+
+        self.client.get_instance.assert_has_calls(get_calls)
+        self.client.find_configuration.assert_called_with('cfg',
+                                                          ignore_missing=False)
+
+        self.client.apply_configuration.assert_called_once_with(
+            self._data.id,
+            instances=['i1', 'i2']
+        )
+
+        self.assertEqual(self.column_headers, columns)
+        self.assertEqual(self.data, list(data))
diff --git a/otcextensions/tests/unit/osclient/rds/v3/test_datastore.py b/otcextensions/tests/unit/osclient/rds/v3/test_datastore.py
new file mode 100644
index 000000000..0c26ddc0c
--- /dev/null
+++ b/otcextensions/tests/unit/osclient/rds/v3/test_datastore.py
@@ -0,0 +1,96 @@
+# 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.
+import mock
+
+from otcextensions.osclient.rds.v3 import datastore
+from otcextensions.tests.unit.osclient.rds.v3 import fakes
+
+
+class TestListDatastores(fakes.TestRds):
+
+    columns_datastore_type = ('Name', )
+
+    def setUp(self):
+        super(TestListDatastores, self).setUp()
+
+        self.cmd = datastore.ListDatastoreTypes(self.app, None)
+
+        self.app.client_manager.rds.datastore_types = mock.Mock()
+
+        self.datastore_types = []
+        self.datastore_type_data = []
+        for ds in ['MySQL', 'PostgreSQL', 'SQLServer']:
+            obj = type('obj', (object,), {'name': ds})
+            self.datastore_types.append(obj)
+            # Since only one field is there leave a comma at the end
+            self.datastore_type_data.append((ds,))
+
+    def test_list_datastore_types(self):
+        arglist = [
+        ]
+
+        verifylist = [
+        ]
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.app.client_manager.rds.datastore_types.side_effect = [
+            self.datastore_types
+        ]
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.app.client_manager.rds.datastore_types.assert_called()
+
+        self.assertEqual(self.columns_datastore_type, columns)
+        self.assertEqual(self.datastore_type_data, list(data))
+
+
+class TestListDatastoreVersions(fakes.TestRds):
+    objects = fakes.FakeDatastore.create_multiple(3)
+
+    column_headers = ('ID', 'Name')
+    columns = ('id', 'name')
+
+    data = []
+
+    for s in objects:
+        data.append(fakes.gen_data(s, columns))
+
+    def setUp(self):
+        super(TestListDatastoreVersions, self).setUp()
+
+        self.cmd = datastore.ListDatastoreVersions(self.app, None)
+
+        self.client.datastores = mock.Mock(return_value=self.objects)
+
+    def test_list_datastore_versions(self):
+        arglist = [
+            'MySQL'
+        ]
+
+        verifylist = [
+            ('database', 'mysql')
+        ]
+
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.datastores.assert_called()
+
+        self.assertEqual(self.column_headers, columns)
+        self.assertEqual(self.data, list(data))
diff --git a/otcextensions/tests/unit/osclient/rds/v3/test_flavor.py b/otcextensions/tests/unit/osclient/rds/v3/test_flavor.py
new file mode 100644
index 000000000..9b37b1b14
--- /dev/null
+++ b/otcextensions/tests/unit/osclient/rds/v3/test_flavor.py
@@ -0,0 +1,61 @@
+# 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.
+import mock
+
+from otcextensions.osclient.rds.v3 import flavor
+from otcextensions.tests.unit.osclient.rds.v3 import fakes
+
+
+class TestListDatabaseFlavors(fakes.TestRds):
+
+    objects = fakes.FakeFlavor.create_multiple(3)
+
+    columns = (
+        'name', 'instance_mode', 'vcpus', 'ram',
+    )
+
+    data = []
+
+    for s in objects:
+        data.append(fakes.gen_data(s, columns))
+
+    def setUp(self):
+        super(TestListDatabaseFlavors, self).setUp()
+
+        self.cmd = flavor.ListDatabaseFlavors(self.app, None)
+
+        self.client.flavors = mock.Mock(return_value=self.objects)
+
+    def test_list_flavors(self):
+        arglist = [
+            'MySQL',
+            '5.7'
+        ]
+
+        verifylist = [
+            ('database', 'mysql'),
+            ('version', '5.7')
+        ]
+
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.flavors.assert_called_with(
+            datastore_name='mysql',
+            version_name='5.7'
+        )
+
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, list(data))
diff --git a/otcextensions/tests/unit/osclient/rds/v3/test_instance.py b/otcextensions/tests/unit/osclient/rds/v3/test_instance.py
new file mode 100644
index 000000000..d1396a76c
--- /dev/null
+++ b/otcextensions/tests/unit/osclient/rds/v3/test_instance.py
@@ -0,0 +1,1212 @@
+# 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.
+#
+import mock
+
+from osc_lib import exceptions
+
+from otcextensions.osclient.rds.v3 import instance
+from otcextensions.tests.unit.osclient.rds.v3 import fakes
+
+
+class TestListDatabaseInstances(fakes.TestRds):
+
+    objects = fakes.FakeInstance.create_multiple(3)
+
+    column_list_headers = (
+        'ID', 'Name', 'Datastore Type', 'Datastore Version', 'Status',
+        'Flavor_ref', 'Type', 'Size', 'Region'
+    )
+
+    columns = (
+        'id', 'name', 'datastore_type', 'datastore_version'
+    )
+
+    data = []
+
+    for s in objects:
+        data.append(
+            (s.id, s.name, s.datastore['type'], s.datastore['version'],
+             s.status, s.flavor_ref, s.type, s.volume['size'], s.region))
+
+    def setUp(self):
+        super(TestListDatabaseInstances, self).setUp()
+
+        self.cmd = instance.ListDatabaseInstances(self.app, None)
+
+        self.client.instances = mock.Mock()
+        self.client.api_mock = self.client.instances
+
+    def test_list(self):
+        arglist = []
+
+        verifylist = []
+
+        # Verify cm is triggered with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.api_mock.side_effect = [self.objects]
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.api_mock.assert_called_with()
+
+        self.assertEqual(self.column_list_headers, columns)
+        self.assertEqual(self.data, list(data))
+
+    def test_list_args(self):
+        arglist = [
+            '--limit', '1',
+            '--id', '2',
+            '--name', '3',
+            '--type', 'ha',
+            '--datastore-type', 'postgreSqL',
+            '--router-id', '6',
+            '--subnet-id', '7',
+            '--offset', '8',
+        ]
+
+        verifylist = [
+            ('limit', 1),
+            ('id', '2'),
+            ('name', '3'),
+            ('type', 'ha'),
+            ('datastore_type', 'postgresql'),
+            ('router_id', '6'),
+            ('subnet_id', '7'),
+            ('offset', 8),
+        ]
+
+        # Verify cm is triggered with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.api_mock.assert_called_with(
+            datastore_type='PostgreSQL',
+            id='2',
+            limit=1,
+            name='3',
+            offset=8,
+            router_id='6',
+            subnet_id='7',
+            type='Ha',
+            paginated=False
+        )
+
+    def test_list_args_paginated(self):
+        arglist = [
+            '--id', '2',
+            '--name', '3',
+            '--type', 'ha',
+            '--datastore-type', 'postgreSqL',
+            '--router-id', '6',
+            '--subnet-id', '7',
+            '--offset', '8',
+        ]
+
+        verifylist = [
+            ('id', '2'),
+            ('name', '3'),
+            ('type', 'ha'),
+            ('datastore_type', 'postgresql'),
+            ('router_id', '6'),
+            ('subnet_id', '7'),
+            ('offset', 8),
+        ]
+
+        # Verify cm is triggered with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.api_mock.assert_called_with(
+            datastore_type='PostgreSQL',
+            id='2',
+            name='3',
+            offset=8,
+            router_id='6',
+            subnet_id='7',
+            type='Ha',
+        )
+
+
+class TestShowDatabaseInstance(fakes.TestRds):
+
+    _data = fakes.FakeInstance.create_one()
+
+    columns = (
+        'datastore', 'flavor_ref', 'id', 'name', 'region', 'status', 'volume'
+    )
+
+    data = fakes.gen_data(_data, columns)
+
+    def setUp(self):
+        super(TestShowDatabaseInstance, self).setUp()
+
+        self.cmd = instance.ShowDatabaseInstance(self.app, None)
+
+        self.client.find_instance = mock.Mock(return_value=self._data)
+
+    def test_show(self):
+        arglist = [
+            'test_instance',
+        ]
+
+        verifylist = [
+            ('instance', 'test_instance'),
+        ]
+
+        # Verify cm is triggered with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+        self.client.find_instance.assert_called_with('test_instance',
+                                                     ignore_missing=False)
+
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+
+class TestDeleteDatabaseInstance(fakes.TestRds):
+
+    data = fakes.FakeInstance.create_one()
+
+    def setUp(self):
+        super(TestDeleteDatabaseInstance, self).setUp()
+
+        self.cmd = instance.DeleteDatabaseInstance(self.app, None)
+
+        self.client.delete_instance = mock.Mock(return_value=self.data)
+        self.client.find_instance = mock.Mock(return_value=self.data)
+        self.client.wait_for_job = mock.Mock()
+
+    def test_delete(self):
+        arglist = [
+            'test_obj',
+        ]
+
+        verifylist = [
+            ('instance', 'test_obj'),
+        ]
+
+        # 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('test_obj')
+
+        self.client.delete_instance.assert_called_with(self.data.id)
+        self.client.wait_for_job.assert_not_called()
+
+    def test_delete_wait(self):
+        arglist = [
+            'test_obj',
+            '--wait'
+        ]
+
+        verifylist = [
+            ('instance', 'test_obj'),
+            ('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_called_with('test_obj')
+
+        self.client.delete_instance.assert_called_with(self.data.id)
+
+        self.client.wait_for_job.assert_called_with(self.data.job_id)
+
+
+class TestCreateDatabaseInstance(fakes.TestRds):
+
+    _data = fakes.FakeInstance.create_one()
+    other_instance = fakes.FakeInstance.create_one()
+    flavors = fakes.FakeFlavor.create_multiple(10)
+
+    columns = ()
+
+    data = fakes.gen_data(_data, columns)
+
+    def setUp(self):
+        super(TestCreateDatabaseInstance, self).setUp()
+
+        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()
+
+    def test_create(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',
+            '--subnet-id', 'test-subnet-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'),
+            ('subnet_id', 'test-subnet-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'},
+            subnet_id='test-subnet-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',
+            '--ha-mode', 'async',
+            '--router-id', 'test-vpc-id',
+            '--subnet-id', 'test-subnet-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', 'MySQL'),
+            ('datastore_version', '5.7'),
+            ('disk_encryption_id', '234'),
+            ('router_id', 'test-vpc-id'),
+            ('subnet_id', 'test-subnet-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'},
+            subnet_id='test-subnet-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',
+            '--subnet-id', 'test-subnet-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'),
+            ('subnet_id', 'test-subnet-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',
+            '--router-id', 'test-vpc-id',
+            '--subnet-id', 'test-subnet-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'),
+            ('subnet_id', 'test-subnet-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',
+            '--subnet-id', 'test-subnet-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'),
+            ('subnet_id', 'test-subnet-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',
+            '--subnet-id', 'test-subnet-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'),
+            ('subnet_id', 'test-subnet-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',
+            '--subnet-id', 'test-subnet-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', 'sqlserver'),
+            ('datastore_version', '5.7'),
+            ('disk_encryption_id', '234'),
+            ('router_id', 'test-vpc-id'),
+            ('subnet_id', 'test-subnet-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',
+            '--datastore-type', 'MySQL',
+            '--datastore-version', '5.7',
+            '--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'),
+            ('datastore_type', 'MySQL'),
+            ('datastore_version', '5.7'),
+            ('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.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=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',
+            '--subnet-id', 'test-subnet-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'),
+            ('subnet_id', 'test-subnet-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'},
+            subnet_id='test-subnet-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',
+            '--subnet-id', 'test-subnet-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),
+            ('availability_zone', 'test-az-01'),
+            ('datastore_type', 'MySQL'),
+            ('datastore_version', '5.7'),
+            ('disk_encryption_id', '234'),
+            ('router_id', 'test-vpc-id'),
+            ('subnet_id', 'test-subnet-id'),
+            ('security_group_id', 'test-sec_grp-id'),
+            ('port', 12345),
+            ('volume_type', 'ULTRAHIGH'),
+            ('size', 100),
+            ('password', 'testtest'),
+            ('region', 'test-region'),
+            ('backup', 'source_backup'),
+            ('from_instance', 'source_instance')
+        ]
+
+        # 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'},
+            subnet_id='test-subnet-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',
+            '--subnet-id', 'test-subnet-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'),
+            ('subnet_id', 'test-subnet-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
+        )
+
+    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)
+
+
+class TestRestoreDatabaseInstance(fakes.TestRds):
+
+    def setUp(self):
+        super(TestRestoreDatabaseInstance, self).setUp()
+
+        self.cmd = instance.RestoreDatabaseInstance(self.app, None)
+
+        self.instance = self.instance_mock.create_one()
+        self.backup = self.backup_mock.create_one()
+
+        self.client.find_instance = mock.Mock(return_value=self.instance)
+        self.client.restore_instance = mock.Mock()
+        self.client.find_backup = mock.Mock(return_value=self.backup)
+
+    def test_action_from_backup(self):
+        arglist = [
+            'inst_name',
+            '--backup', 'backup',
+        ]
+
+        verifylist = [
+            ('instance', 'inst_name'),
+            ('backup', 'backup'),
+        ]
+
+        # 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('inst_name',
+                                                     ignore_missing=False)
+
+        self.client.find_backup.assert_called_with(name_or_id='backup',
+                                                   instance=self.instance,
+                                                   ignore_missing=False)
+
+        self.client.restore_instance.assert_called_with(
+            backup=self.client.find_backup(),
+            instance=self.instance,
+            restore_time=None
+        )
+
+    def test_action_pit(self):
+        arglist = [
+            'inst_name',
+            '--restore_time', 'some_time',
+        ]
+
+        verifylist = [
+            ('instance', 'inst_name'),
+            ('restore_time', 'some_time'),
+        ]
+
+        # 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('inst_name',
+                                                     ignore_missing=False)
+
+        self.client.restore_instance.assert_called_with(
+            backup=None,
+            instance=self.instance,
+            restore_time='some_time'
+        )
+
+
+class TestShowBackupPolicy(fakes.TestRds):
+
+    _instance = fakes.FakeInstance.create_one()
+    _data = {'keep_days': 1, 'period': '2', 'start_time': '3'}
+
+    columns = (
+        'keep_days', 'period', 'start_time'
+    )
+
+    data = (1, '2', '3')
+
+    def setUp(self):
+        super(TestShowBackupPolicy, self).setUp()
+
+        self.cmd = instance.ShowBackupPolicy(self.app, None)
+
+        self.client.find_instance = mock.Mock()
+        self.client.get_instance_backup_policy = mock.Mock()
+
+    def test_action(self):
+        arglist = [
+            'inst'
+        ]
+
+        verifylist = [
+            ('instance', 'inst'),
+        ]
+
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.find_instance.return_value = self._instance
+        self.client.get_instance_backup_policy.return_value = self._data
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.find_instance.assert_called_with('inst',
+                                                     ignore_missing=False)
+
+        self.client.get_instance_backup_policy.assert_called_once_with(
+            self._instance
+        )
+
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+
+class TestSetBackupPolicy(fakes.TestRds):
+
+    _instance = fakes.FakeInstance.create_one()
+
+    def setUp(self):
+        super(TestSetBackupPolicy, self).setUp()
+
+        self.cmd = instance.SetBackupPolicy(self.app, None)
+
+        self.client.find_instance = mock.Mock()
+        self.client.set_instance_backup_policy = mock.Mock()
+
+    def test_action(self):
+        arglist = [
+            'inst',
+            '--keep-days', '1',
+            '--period', '2',
+            '--start-time', '3'
+        ]
+
+        verifylist = [
+            ('instance', 'inst'),
+            ('keep_days', 1),
+            ('period', '2'),
+            ('start_time', '3')
+        ]
+
+        # Verify cm is triggereg with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Set the response
+        self.client.find_instance.return_value = self._instance
+
+        # Trigger the action
+        self.assertIsNone(self.cmd.take_action(parsed_args))
+
+        self.client.find_instance.assert_called_with('inst',
+                                                     ignore_missing=False)
+
+        self.client.set_instance_backup_policy.assert_called_once_with(
+            self._instance,
+            keep_days=1, period='2', start_time='3'
+        )
+
+
+class TestShowAvailableRestoreTime(fakes.TestRds):
+
+    instance = fakes.FakeInstance.create_one()
+
+    objects = [
+        {
+            'start_time': 'some_fake_start',
+            'end_time': 'some_fake_end'
+        }
+    ]
+
+    column_list_headers = (
+        'Start time', 'End time'
+    )
+
+    columns = (
+        'start_time', 'end_time'
+    )
+
+    data = []
+
+    for s in objects:
+        data.append((s['start_time'], s['end_time']))
+
+    def setUp(self):
+        super(TestShowAvailableRestoreTime, self).setUp()
+
+        self.cmd = instance.ShowAvailableRestoreTime(self.app, None)
+
+        self.client.find_instance = mock.Mock(return_value=self.instance)
+        self.client.get_instance_restore_time = mock.Mock(
+            return_value=self.objects)
+
+    def test_action(self):
+        arglist = [
+            'test_inst'
+        ]
+
+        verifylist = [
+            ('instance', 'test_inst')
+        ]
+
+        # Verify cm is triggered with default parameters
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        # Trigger the action
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.client.find_instance.assert_called_with('test_inst',
+                                                     ignore_missing=False)
+        self.client.get_instance_restore_time.assert_called_with(self.instance)
+
+        self.assertEqual(self.column_list_headers, columns)
+        self.assertEqual(self.data, list(data))
diff --git a/otcextensions/tests/unit/sdk/rds/__init__.py b/otcextensions/tests/unit/sdk/rds/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/otcextensions/tests/unit/sdk/rds/v3/__init__.py b/otcextensions/tests/unit/sdk/rds/v3/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/otcextensions/tests/unit/sdk/rds/v3/test_backup.py b/otcextensions/tests/unit/sdk/rds/v3/test_backup.py
new file mode 100644
index 000000000..a066dd5d4
--- /dev/null
+++ b/otcextensions/tests/unit/sdk/rds/v3/test_backup.py
@@ -0,0 +1,83 @@
+# 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.sdk.rds.v3 import backup
+
+IDENTIFIER = 'IDENTIFIER'
+EXAMPLE = {
+    'id': IDENTIFIER,
+    'name': '50deafb3e45d451a9406ca146b71fe9a_rds',
+    'description': '',
+    'begin_time': '2016-08-23T04:01:40',
+    'end_time': '2016-08-23T04:04:40',
+    'status': 'COMPLETED',
+    'instance_id': '4f87d3c4-9e33-482f-b962-e23b30d1a18c',
+    'type': 'manual',
+    'datastore': {}
+}
+
+EXAMPLE_FILE = {
+    'name': '43e4feaab48f11e89039fa163ebaa7e4br01.xxx',
+    'size': 2803,
+    'download_link': 'fake_url',
+    'link_expired_time': '2018-08-016T10:15:14+0800'
+}
+
+
+class TestBackup(base.TestCase):
+
+    def test_basic(self):
+        sot = backup.Backup()
+        self.assertEqual('backup', sot.resource_key)
+        self.assertEqual('backups', sot.resources_key)
+        self.assertEqual('/backups', sot.base_path)
+        self.assertTrue(sot.allow_list)
+        self.assertTrue(sot.allow_create)
+        self.assertFalse(sot.allow_fetch)
+        self.assertFalse(sot.allow_commit)
+        self.assertTrue(sot.allow_delete)
+
+    def test_make_it(self):
+        sot = backup.Backup(**EXAMPLE)
+        self.assertEqual(IDENTIFIER, sot.id)
+        self.assertEqual(EXAMPLE['name'], sot.name)
+        self.assertEqual(EXAMPLE['instance_id'], sot.instance_id)
+        self.assertEqual(EXAMPLE['description'], sot.description)
+        self.assertEqual(EXAMPLE['begin_time'], sot.begin_time)
+        self.assertEqual(EXAMPLE['end_time'], sot.end_time)
+        self.assertEqual(EXAMPLE['type'], sot.type)
+        self.assertEqual(EXAMPLE['status'], sot.status)
+        self.assertEqual(EXAMPLE['datastore'], sot.datastore)
+
+
+class TestBackupFile(base.TestCase):
+
+    def test_basic(self):
+        sot = backup.BackupFile()
+        self.assertEqual('files', sot.resources_key)
+        self.assertEqual('/backup-files', sot.base_path)
+        self.assertTrue(sot.allow_list)
+
+        self.assertDictEqual({
+            'limit': 'limit',
+            'marker': 'marker',
+            'backup_id': 'backup_id'},
+            sot._query_mapping._mapping)
+
+    def test_make_it(self):
+        sot = backup.BackupFile(**EXAMPLE_FILE)
+        self.assertEqual(EXAMPLE_FILE['name'], sot.name)
+        self.assertEqual(EXAMPLE_FILE['size'], sot.size)
+        self.assertEqual(EXAMPLE_FILE['download_link'], sot.download_link)
+        self.assertEqual(EXAMPLE_FILE['link_expired_time'], sot.expires_at)
diff --git a/otcextensions/tests/unit/sdk/rds/v3/test_config.py b/otcextensions/tests/unit/sdk/rds/v3/test_config.py
new file mode 100644
index 000000000..ffc8a3afc
--- /dev/null
+++ b/otcextensions/tests/unit/sdk/rds/v3/test_config.py
@@ -0,0 +1,131 @@
+# 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 keystoneauth1 import adapter
+
+import copy
+import mock
+
+from openstack import resource
+
+from openstack.tests.unit import base
+
+from otcextensions.sdk.rds.v3 import configuration
+
+
+IDENTIFIER = 'ID'
+EXAMPLE = {
+    "id": IDENTIFIER,
+    "name": "paramsGroup-b6d2",
+    "description": "",
+    "datastore": {"type": "PostgreSQL"},
+    "datastore_version_name": "2016_SE",
+    "datastore_name": "sqlserver",
+    "created": "2018-09-15T03:33:07+0800",
+    "updated": "2018-09-15T03:33:07+0800",
+    "user_defined": True,
+    "vcpus": "1",
+    "ram": 2,
+    "spec_code": "rds.mysql.c2.medium.ha",
+    "instance_mode": "ha",
+    "values": {
+        "max_connections": "10",
+        "autocommit": "OFF"
+    }
+}
+
+
+class TestConfiguration(base.TestCase):
+
+    def setUp(self):
+        super(TestConfiguration, self).setUp()
+        self.sess = mock.Mock(spec=adapter.Adapter)
+        self.sess.put = mock.Mock()
+
+    def test_basic(self):
+        sot = configuration.Configuration()
+
+        self.assertEqual('/configurations', sot.base_path)
+        self.assertEqual('configurations', sot.resources_key)
+        self.assertEqual('configuration', sot.resource_key)
+        self.assertTrue(sot.allow_list)
+        self.assertTrue(sot.allow_fetch)
+        self.assertTrue(sot.allow_create)
+        self.assertTrue(sot.allow_delete)
+        self.assertTrue(sot.allow_commit)
+
+    def test_make_it(self):
+        sot = configuration.Configuration(**EXAMPLE)
+        self.assertEqual(IDENTIFIER, sot.id)
+        self.assertEqual(EXAMPLE['name'], sot.name)
+        self.assertEqual(EXAMPLE['datastore'], sot.datastore)
+        self.assertEqual(EXAMPLE['description'], sot.description)
+        self.assertEqual(EXAMPLE['datastore_name'], sot.datastore_name)
+        self.assertEqual(EXAMPLE['datastore_version_name'],
+                         sot.datastore_version_name)
+        self.assertEqual(EXAMPLE['created'], sot.created_at)
+        self.assertEqual(EXAMPLE['updated'], sot.updated_at)
+        self.assertEqual(EXAMPLE['user_defined'], sot.is_user_defined)
+        self.assertEqual(EXAMPLE['values'], sot.values)
+
+    def test_apply(self):
+        sot = configuration.Configuration(id=IDENTIFIER)
+        instances = ['id1', 'id2']
+
+        resp = mock.Mock()
+        resp.body = {
+            "configuration_id": IDENTIFIER,
+            "configuration_name": "paramsGroup-bcf9",
+            "apply_results": [{
+                "instance_id": "fe5f5a07539c431181fc78220713aebein01",
+                "instance_name": "zyy1",
+                "restart_required": False,
+                "success": False
+            }, {
+                "instance_id": "73ea2bf70c73497f89ee0ad4ee008aa2in01",
+                "instance_name": "zyy2",
+                "restart_required": False,
+                "success": False
+            }],
+            "success": False
+        }
+        resp.json = mock.Mock(return_value=copy.deepcopy(resp.body))
+        resp.headers = {}
+        resp.status_code = 200
+        self.sess.put.return_value = resp
+
+        updated = sot.apply(self.sess, instances)
+        self.sess.put.assert_called_with(
+            'configurations/ID/apply',
+            json={'instance_ids': ['id1', 'id2']}
+        )
+
+        self.assertEqual(resp.body['configuration_id'], updated.id)
+        self.assertEqual(resp.body['configuration_name'], updated.name)
+        self.assertEqual(resp.body['apply_results'],
+                         sot.apply_results)
+
+    def test_create(self):
+        sot = configuration.Configuration(id=IDENTIFIER)
+
+        with mock.patch.object(resource.Resource, 'create') as res_mock:
+            sot.create(self.sess)
+            res_mock.assert_called_with(self.sess,
+                                        prepend_key=False,
+                                        base_path=None)
+
+    def test_commit(self):
+        sot = configuration.Configuration(id=IDENTIFIER)
+
+        with mock.patch.object(resource.Resource, 'commit') as res_mock:
+            sot.commit(self.sess)
+            res_mock.assert_called_with(self.sess,
+                                        prepend_key=False)
diff --git a/otcextensions/tests/unit/sdk/rds/v3/test_datastore.py b/otcextensions/tests/unit/sdk/rds/v3/test_datastore.py
new file mode 100644
index 000000000..0da2bd8d0
--- /dev/null
+++ b/otcextensions/tests/unit/sdk/rds/v3/test_datastore.py
@@ -0,0 +1,43 @@
+# 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.sdk.rds.v3 import datastore
+
+IDENTIFIER = 'IDENTIFIER'
+EXAMPLE = {"id": IDENTIFIER, "name": "5.7"}
+
+
+class TestDatastore(base.TestCase):
+    def setUp(self):
+        super(TestDatastore, self).setUp()
+
+    def test_basic(self):
+        sot = datastore.Datastore()
+        self.assertEqual('dataStores', sot.resources_key)
+        self.assertEqual('/datastores/%(database_name)s', sot.base_path)
+        self.assertIsNone(sot.resource_key)
+        self.assertTrue(sot.allow_list)
+        self.assertFalse(sot.allow_fetch)
+        self.assertFalse(sot.allow_create)
+        self.assertFalse(sot.allow_delete)
+        self.assertFalse(sot.allow_commit)
+        self.assertDictEqual({
+            'limit': 'limit',
+            'marker': 'marker'
+        }, sot._query_mapping._mapping)
+
+    def test_make_it(self):
+        sot = datastore.Datastore(**EXAMPLE)
+        self.assertEqual(IDENTIFIER, sot.id)
+        self.assertEqual(EXAMPLE['name'], sot.name)
diff --git a/otcextensions/tests/unit/sdk/rds/v3/test_flavor.py b/otcextensions/tests/unit/sdk/rds/v3/test_flavor.py
new file mode 100644
index 000000000..3bf256ba6
--- /dev/null
+++ b/otcextensions/tests/unit/sdk/rds/v3/test_flavor.py
@@ -0,0 +1,50 @@
+# 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.sdk.rds.v3 import flavor
+
+EXAMPLE = {
+    "vcpus": "1",
+    "ram": 2,
+    "spec_code": "rds.mysql.c2.medium.ha",
+    "instance_mode": "ha"
+}
+
+
+class TestFlavor(base.TestCase):
+
+    def test_basic(self):
+        sot = flavor.Flavor()
+
+        self.assertEqual('/flavors/%(datastore_name)s', sot.base_path)
+        self.assertEqual('flavors', sot.resources_key)
+        self.assertIsNone(sot.resource_key)
+
+        self.assertTrue(sot.allow_list)
+        self.assertFalse(sot.allow_fetch)
+        self.assertFalse(sot.allow_create)
+        self.assertFalse(sot.allow_delete)
+        self.assertFalse(sot.allow_commit)
+        self.assertDictEqual({'limit': 'limit',
+                              'marker': 'marker',
+                              'version_name': 'version_name'},
+                             sot._query_mapping._mapping)
+
+    def test_make_it(self):
+
+        sot = flavor.Flavor(**EXAMPLE)
+        self.assertEqual(EXAMPLE['spec_code'], sot.spec_code)
+        self.assertEqual(EXAMPLE['spec_code'], sot.name)
+        self.assertEqual(EXAMPLE['vcpus'], sot.vcpus)
+        self.assertEqual(EXAMPLE['ram'], sot.ram)
+        self.assertEqual(EXAMPLE['instance_mode'], sot.instance_mode)
diff --git a/otcextensions/tests/unit/sdk/rds/v3/test_instance.py b/otcextensions/tests/unit/sdk/rds/v3/test_instance.py
new file mode 100644
index 000000000..5c7a44216
--- /dev/null
+++ b/otcextensions/tests/unit/sdk/rds/v3/test_instance.py
@@ -0,0 +1,251 @@
+# 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 keystoneauth1 import adapter
+
+import copy
+import mock
+
+from openstack.tests.unit import base
+
+from otcextensions.sdk.rds.v3 import instance
+
+IDENTIFIER = 'IDENTIFIER'
+EXAMPLE = {
+    "id": IDENTIFIER,
+    "availability_zone": "fake_az",
+    "status": "ACTIVE",
+    "name": "mysql-0820-022709-01",
+    "port": 3306,
+    "type": "Single",
+    "region": "eu-de",
+    "datastore": {
+        "type": "mysql",
+        "version": "5.7"
+    },
+    "replica_of_id": "some_fake",
+    "created": "2018-08-20T02:33:49+0800",
+    "updated": "2018-08-20T02:33:50+0800",
+    "volume": {
+        "type": "ULTRAHIGH",
+        "size": 100
+    },
+    "ha": {
+        "replication_mode": "sync"
+    },
+    "nodes": [{
+        "id": "06f1c2ad57604ae89e153e4d27f4e4b8no01",
+        "name": "mysql-0820-022709-01_node0",
+        "role": "master",
+        "status": "ACTIVE",
+        "availability_zone": "eu-de-01"
+    }],
+    "private_ips": ["192.168.0.142"],
+    "public_ips": ["10.154.219.187", "10.154.219.186"],
+    "password": "fake_pass",
+    "vpc_id": "b21630c1-e7d3-450d-907d-39ef5f445ae7",
+    "subnet_id": "45557a98-9e17-4600-8aec-999150bc4eef",
+    "security_group_id": "38815c5c-482b-450a-80b6-0a301f2afd97",
+    "flavor_ref": "rds.mysql.s1.large",
+    "switch_strategy": "",
+    "backup_strategy": {
+        "start_time": "19:00-20:00",
+        "keep_days": 7
+    },
+    "maintenance_window": "02:00-06:00",
+    "related_instance": [],
+    "disk_encryption_id": "",
+    "time_zone": ""
+}
+
+
+class TestInstance(base.TestCase):
+    def setUp(self):
+        super(TestInstance, self).setUp()
+        self.sess = mock.Mock(spec=adapter.Adapter)
+        self.sess.get = mock.Mock()
+        self.sess.default_microversion = None
+        self.sess._get_connection = mock.Mock(return_value=self.cloud)
+        # self.sess.get_project_id = mock.Mock(return_value=PROJECT_ID)
+        self.sot = instance.Instance(**EXAMPLE)
+
+    def test_basic(self):
+        sot = instance.Instance()
+        self.assertIsNone(sot.resource_key)
+        self.assertEqual('instances', sot.resources_key)
+        self.assertEqual('/instances', sot.base_path)
+        self.assertTrue(sot.allow_list)
+        self.assertTrue(sot.allow_create)
+        self.assertFalse(sot.allow_fetch)
+        self.assertTrue(sot.allow_commit)
+        self.assertTrue(sot.allow_delete)
+
+    def test_make_it(self):
+        sot = instance.Instance(**EXAMPLE)
+        self.assertEqual(IDENTIFIER, sot.id)
+        self.assertEqual(EXAMPLE['availability_zone'], sot.availability_zone)
+        self.assertEqual(EXAMPLE['backup_strategy'], sot.backup_strategy)
+        self.assertEqual(EXAMPLE['created'], sot.created_at)
+        self.assertEqual(EXAMPLE['datastore'], sot.datastore)
+        self.assertEqual(EXAMPLE['disk_encryption_id'], sot.disk_encryption_id)
+        self.assertEqual(EXAMPLE['flavor_ref'], sot.flavor_ref)
+        self.assertEqual(EXAMPLE['ha'], sot.ha)
+        self.assertEqual(EXAMPLE['nodes'], sot.nodes)
+        self.assertEqual(EXAMPLE['password'], sot.password)
+        self.assertEqual(EXAMPLE['port'], sot.port)
+        self.assertEqual(EXAMPLE['volume'], sot.volume)
+        self.assertEqual(EXAMPLE['region'], sot.region)
+        self.assertEqual(EXAMPLE['port'], sot.port)
+        self.assertEqual(EXAMPLE['private_ips'], sot.private_ips)
+        self.assertEqual(EXAMPLE['public_ips'], sot.public_ips)
+        self.assertEqual(EXAMPLE['region'], sot.region)
+        self.assertEqual(EXAMPLE['related_instance'], sot.related_instances)
+        self.assertEqual(EXAMPLE['replica_of_id'], sot.replica_of_id)
+        self.assertEqual(EXAMPLE['vpc_id'], sot.router_id)
+        self.assertEqual(EXAMPLE['security_group_id'], sot.security_group_id)
+        self.assertEqual(EXAMPLE['subnet_id'], sot.subnet_id)
+        self.assertEqual(EXAMPLE['switch_strategy'], sot.switch_strategy)
+        self.assertEqual(EXAMPLE['maintenance_window'], sot.maintenance_window)
+        self.assertEqual(EXAMPLE['time_zone'], sot.time_zone)
+
+    def test_translate_response(self):
+        response = mock.Mock()
+        response.status_code = 200
+        response.json.return_value = {
+            'job_id': 'fake_job_id',
+            'instance': copy.deepcopy(EXAMPLE)
+        }
+        response.headers = {}
+        sot = instance.Instance.new()
+
+        sot._translate_response(response)
+        self.assertEqual('fake_job_id', sot.job_id)
+        self.assertEqual(IDENTIFIER, sot.id)
+        self.assertEqual(EXAMPLE['vpc_id'], sot.router_id)
+
+    def test_fetch_restore_times(self):
+        sot = instance.Instance(**EXAMPLE)
+        restore_times = [{
+            'start_time': 'some_start_time',
+            'end_time': 'some_end_time'
+        }]
+        response = mock.Mock()
+        response.status_code = 200
+        response.json.return_value = {
+            'restore_time': restore_times}
+        response.headers = {}
+        self.sess.get.return_value = response
+
+        rt = sot.fetch_restore_times(self.sess)
+
+        self.assertEqual(restore_times, rt)
+        self.assertEqual(restore_times, sot.restore_time)
+
+    def test_fetch(self):
+        sot = instance.Instance.existing(id=IDENTIFIER)
+
+        response = mock.Mock()
+        response.status_code = 200
+        response.json.return_value = {'instances': [EXAMPLE]}
+        response.headers = {}
+        self.sess.get.return_value = response
+
+        # Restore from backup
+        rt = sot.fetch(self.sess)
+
+        self.sess.get.assert_called_with(
+            '/instances', headers={'Accept': 'application/json'},
+            microversion=None, params={'id': IDENTIFIER})
+        self.assertIsInstance(rt, instance.Instance)
+        self.assertDictEqual(
+            rt.to_dict(),
+            instance.Instance(**EXAMPLE)
+        )
+
+    def test_restore(self):
+        sot = instance.Instance(**EXAMPLE)
+        job_id = 'fake_job'
+
+        response = mock.Mock()
+        response.status_code = 200
+        response.json.return_value = {'job_id': job_id}
+        response.headers = {}
+        self.sess.post.return_value = response
+
+        class FakeResource(object):
+            def __init__(self, id):
+                self.id = id
+
+        # Restore from backup
+        rt = sot.restore(self.sess, FakeResource('bid'))
+
+        self.sess.post.assert_called_with(
+            'instances/recovery',
+            json={
+                'source': {
+                    'type': 'backup', 'backup_id': 'bid',
+                    'instance_id': IDENTIFIER},
+                'target': {'instance_id': IDENTIFIER}})
+
+        # PIT
+        rt = sot.restore(self.sess, None, 'rit')
+
+        self.sess.post.assert_called_with(
+            'instances/recovery',
+            json={
+                'source': {
+                    'type': 'timestamp', 'restore_time': 'rit',
+                    'instance_id': IDENTIFIER},
+                'target': {'instance_id': IDENTIFIER}})
+
+        self.assertEqual(job_id, rt)
+
+    def test_get_backup_policy(self):
+        sot = instance.Instance(**EXAMPLE)
+        backup_policy = {
+            'keep_days': 7,
+            'start_time': '19:00-20:00',
+            'period': '1,2'
+        }
+        response = mock.Mock()
+        response.status_code = 200
+        response.json.return_value = {
+            'backup_policy': backup_policy}
+        response.headers = {}
+        self.sess.get.return_value = response
+
+        rt = sot.get_backup_policy(self.sess)
+
+        self.sess.get.assert_called_with('instances/IDENTIFIER/backups/policy')
+
+        self.assertEqual(backup_policy, rt)
+
+    def test_set_backup_policy(self):
+        sot = instance.Instance(**EXAMPLE)
+        backup_policy = {
+            'keep_days': 7,
+            'start_time': '19:00-20:00',
+            'period': '1,2'
+        }
+
+        response = mock.Mock()
+        response.status_code = 200
+        response.headers = {}
+        self.sess.put.return_value = response
+
+        rt = sot.set_backup_policy(self.sess, **backup_policy)
+
+        self.sess.put.assert_called_with(
+            'instances/IDENTIFIER/backups/policy',
+            json={'backup_policy': {'keep_days': 7, 'start_time':
+                                    '19:00-20:00', 'period': '1,2'}})
+
+        self.assertIsNone(rt)
diff --git a/otcextensions/tests/unit/sdk/rds/v3/test_proxy.py b/otcextensions/tests/unit/sdk/rds/v3/test_proxy.py
new file mode 100644
index 000000000..3a88dd194
--- /dev/null
+++ b/otcextensions/tests/unit/sdk/rds/v3/test_proxy.py
@@ -0,0 +1,204 @@
+# 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 otcextensions.sdk.rds.v3 import _proxy
+from otcextensions.sdk.rds.v3 import backup
+from otcextensions.sdk.rds.v3 import configuration
+from otcextensions.sdk.rds.v3 import datastore
+from otcextensions.sdk.rds.v3 import flavor
+from otcextensions.sdk.rds.v3 import instance
+
+from openstack.tests.unit import test_proxy_base
+
+
+class TestRdsProxy(test_proxy_base.TestProxyBase):
+    def setUp(self):
+        super(TestRdsProxy, self).setUp()
+        self.proxy = _proxy.Proxy(self.session)
+
+
+class TestFlavor(TestRdsProxy):
+    def test_flavors(self):
+        self.verify_list(self.proxy.flavors,
+                         flavor.Flavor,
+                         method_kwargs={
+                             'datastore_name': 'MySQL',
+                             'version_name': '5.7'
+                         },
+                         expected_kwargs={
+                             'datastore_name': 'MySQL',
+                             'version_name': '5.7'
+                         })
+
+
+class TestDatastore(TestRdsProxy):
+    def test_datastores(self):
+        self.verify_list(self.proxy.datastores,
+                         datastore.Datastore,
+                         method_args=['ss'],
+                         expected_kwargs={
+                             'database_name': 'ss'
+                         })
+
+
+class TestConfiguration(TestRdsProxy):
+    def test_configurations(self):
+        self.verify_list(self.proxy.configurations,
+                         configuration.Configuration,
+                         expected_kwargs={'paginated': False})
+
+    def test_get_configuration(self):
+        self.verify_get(
+            self.proxy.get_configuration,
+            configuration.Configuration)
+
+    def test_create_configuration(self):
+        self.verify_create(
+            self.proxy.create_configuration,
+            configuration.Configuration,
+            method_kwargs={'a': 'b'},
+            expected_kwargs={'prepend_key': False, 'a': 'b'})
+
+    def test_delete_configuration(self):
+        self.verify_delete(self.proxy.delete_configuration,
+                           configuration.Configuration, False)
+
+    def test_delete_configuration_ignore(self):
+        self.verify_delete(self.proxy.delete_configuration,
+                           configuration.Configuration, True)
+
+    def test_update_configuration(self):
+        self.verify_update(self.proxy.update_configuration,
+                           configuration.Configuration)
+
+    def test_apply_configuration(self):
+        self._verify(
+            'otcextensions.sdk.rds.v3.configuration.Configuration.apply',
+            self.proxy.apply_configuration,
+            method_args=["val", ['a', 'b']],
+            expected_args=[['a', 'b']]
+        )
+
+
+class TestBackup(TestRdsProxy):
+    def test_backups(self):
+        self.verify_list(self.proxy.backups,
+                         backup.Backup, method_args=['inst'],
+                         expected_kwargs={'instance_id': 'inst'})
+
+    def test_create_backup(self):
+        self.verify_create(
+            self.proxy.create_backup,
+            backup.Backup,
+            method_args=['inst'],
+            method_kwargs={'x': 1, 'y': 2, 'z': 3},
+            expected_kwargs={
+                'instance_id': 'inst',
+                'x': 1, 'y': 2, 'z': 3
+            })
+
+    def test_delete_backup(self):
+        self.verify_delete(self.proxy.delete_backup,
+                           backup.Backup, False)
+
+    def test_delete_backup_ignore(self):
+        self.verify_delete(self.proxy.delete_backup,
+                           backup.Backup, True)
+
+    def test_find_backup(self):
+        self.verify_find(self.proxy.find_backup, backup.Backup,
+                         value=['name_or_id', 'iid'],
+                         expected_kwargs={'instance_id': 'iid'})
+
+    def test_download_links(self):
+        self.verify_list(self.proxy.backup_download_links,
+                         backup.BackupFile,
+                         method_args=['bck_id'],
+                         expected_kwargs={'backup_id': 'bck_id'})
+
+
+class TestInstance(TestRdsProxy):
+    def test_instances(self):
+        self.verify_list(self.proxy.instances,
+                         instance.Instance)
+
+    def test_create_instance(self):
+        self.verify_create(
+            self.proxy.create_instance,
+            instance.Instance)
+
+    def test_get_instance(self):
+        self.verify_get(
+            self.proxy.get_instance,
+            instance.Instance)
+
+    def test_find_instance(self):
+        self.verify_find(
+            self.proxy.find_instance,
+            instance.Instance)
+
+    def test_delete_instance(self):
+        self.verify_delete(self.proxy.delete_instance,
+                           instance.Instance, False)
+
+    def test_delete_instance_ignore(self):
+        self.verify_delete(self.proxy.delete_instance,
+                           instance.Instance, True)
+
+    def test_fetch_restore_times(self):
+        self._verify2(
+            'otcextensions.sdk.rds.v3.instance.Instance.fetch_restore_times',
+            self.proxy.get_instance_restore_time,
+            method_args=["inst"],
+            expected_args=[self.proxy]
+        )
+
+    def test_restore(self):
+        self._verify2(
+            'otcextensions.sdk.rds.v3.instance.Instance.restore',
+            self.proxy.restore_instance,
+            method_args=["inst"],
+            method_kwargs={
+                'backup': backup.Backup(id='bck'),
+                'restore_time': 'rt'},
+            expected_args=[self.proxy, backup.Backup(id='bck'), 'rt'],
+        )
+
+    def test_get_instance_configuration(self):
+        pass
+
+    def test_update_instance_configuration(self):
+        pass
+
+    def test_get_instance_backup_policy(self):
+        self._verify(
+            'otcextensions.sdk.rds.v3.instance.Instance.get_backup_policy',
+            self.proxy.get_instance_backup_policy,
+            method_args=["val"],
+        )
+
+    def test_update_instance_backup_policy(self):
+        self._verify(
+            'otcextensions.sdk.rds.v3.instance.Instance.set_backup_policy',
+            self.proxy.set_instance_backup_policy,
+            method_args=["val"],
+            method_kwargs={
+                'keep_days': 1,
+                'start_time': '2',
+                'period': '3'
+            },
+            expected_kwargs={
+                'keep_days': 1,
+                'start_time': '2',
+                'period': '3'
+            }
+        )
diff --git a/setup.cfg b/setup.cfg
index 2e160dcf4..8b3f1a691 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -69,29 +69,39 @@ openstack.rds.v1 =
   rds_datastore_show = otcextensions.osclient.rds.v1.datastore:ShowDatastore
   rds_datastore_version_list = otcextensions.osclient.rds.v1.datastore:ListDatastoreVersions
   rds_datastore_version_show = otcextensions.osclient.rds.v1.datastore:ShowDatastoreVersion
-  #  rds_configuration_list = otcextensions.osclient.rds.v1.configuration:ListConfigurations
-  #  rds_configuration_show = otcextensions.osclient.rds.v1.configuration:ShowConfiguration
-  #  rds configuration_parameter_list = otcextensions.osclient.rds.v1.configuration:ListDatabaseConfigurationParameters
-  #  rds configuration_parameter_show = otcextensions.osclient.rds.v1.configuration:ShowDatabaseConfigurationParameter
-  #  rds_configuration_create = otcextensions.osclient.rds.v1.configuration:CreateConfiguration
-  #  rds_configuration_delete = otcextensions.osclient.rds.v1.configuration:DeleteConfiguration
-  #  rds_configuration_set = otcextensions.osclient.rds.v1.configuration:SetConfiguration
-  #  rds_instance_create_from_backup = otcextensions.osclient.rds.v1.instance:CreateInstanceFromBackup
-  #  rds_instance_reset_status = otcextensions.osclient.rds.v1.instance:ResetDatabaseInstanceStatus
-  #  rds_instance_resize_flavor = otcextensions.osclient.rds.v1.instance:ResizeDatabaseInstanceFlavor
-  #  rds_instance_resize_volume = otcextensions.osclient.rds.v1.instance:ResizeDatabaseInstanceVolume
-  #  rds_instance_update = otcextensions.osclient.rds.v1.instance:UpdateDatabaseInstance
-  #  rds_instance_upgrade = otcextensions.osclient.rds.v1.instance:UpgradeDatabaseInstance
   rds_instance_list = otcextensions.osclient.rds.v1.instance:ListDatabaseInstances
   rds_instance_show = otcextensions.osclient.rds.v1.instance:ShowDatabaseInstance
   rds_instance_create = otcextensions.osclient.rds.v1.instance:CreateDatabaseInstance
   rds_instance_delete = otcextensions.osclient.rds.v1.instance:DeleteDatabaseInstance
   rds_instance_restart = otcextensions.osclient.rds.v1.instance:RestartDatabaseInstance
   rds_instance_restore = otcextensions.osclient.rds.v1.instance:RestoreDatabaseInstance
-  rds_backup_list = otcextensions.osclient.rds.v1.backup:ListBackup
   rds_backup_create = otcextensions.osclient.rds.v1.backup:CreateBackup
   rds_backup_delete = otcextensions.osclient.rds.v1.backup:DeleteBackup
 
+openstack.rds.v3 =
+  rds_flavor_list = otcextensions.osclient.rds.v3.flavor:ListDatabaseFlavors
+  rds_datastore_type_list = otcextensions.osclient.rds.v3.datastore:ListDatastoreTypes
+  rds_datastore_version_list = otcextensions.osclient.rds.v3.datastore:ListDatastoreVersions
+  rds_configuration_list = otcextensions.osclient.rds.v3.configuration:ListConfigurations
+  rds_configuration_show = otcextensions.osclient.rds.v3.configuration:ShowConfiguration
+  rds_configuration_set = otcextensions.osclient.rds.v3.configuration:SetConfiguration
+  rds_configuration_create = otcextensions.osclient.rds.v3.configuration:CreateConfiguration
+  rds_configuration_apply = otcextensions.osclient.rds.v3.configuration:ApplyConfiguration
+  rds_configuration_delete = otcextensions.osclient.rds.v3.configuration:DeleteConfiguration
+  rds_configuration_parameter_list = otcextensions.osclient.rds.v3.configuration:ListConfigurationParameters
+  rds_instance_list = otcextensions.osclient.rds.v3.instance:ListDatabaseInstances
+  rds_instance_show = otcextensions.osclient.rds.v3.instance:ShowDatabaseInstance
+  rds_instance_restore_time_show = otcextensions.osclient.rds.v3.instance:ShowAvailableRestoreTime
+  rds_instance_create = otcextensions.osclient.rds.v3.instance:CreateDatabaseInstance
+  rds_instance_restore = otcextensions.osclient.rds.v3.instance:RestoreDatabaseInstance
+  rds_instance_delete = otcextensions.osclient.rds.v3.instance:DeleteDatabaseInstance
+  rds_instance_backup_policy_show = otcextensions.osclient.rds.v3.instance:ShowBackupPolicy
+  rds_instance_backup_policy_set = otcextensions.osclient.rds.v3.instance:SetBackupPolicy
+  rds_backup_list = otcextensions.osclient.rds.v3.backup:ListBackup
+  rds_backup_create = otcextensions.osclient.rds.v3.backup:CreateBackup
+  rds_backup_delete = otcextensions.osclient.rds.v3.backup:DeleteBackup
+  rds_backup_download_links = otcextensions.osclient.rds.v3.backup:ListBackupDownloadLinks
+
 openstack.auto_scaling.v1 =
   as_group_list = otcextensions.osclient.auto_scaling.v1.group:ListAutoScalingGroup
   as_group_show = otcextensions.osclient.auto_scaling.v1.group:ShowAutoScalingGroup