Merge "move all functional tests to tests module"

79 files changed, 4653 insertions, 0 deletions

diff --git a/openstackclient/tests/functional/__init__.py b/openstackclient/tests/functional/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/__init__.py
diff --git a/openstackclient/tests/functional/base.py b/openstackclient/tests/functional/base.py
new file mode 100644
index 00000000..f7f0361e
--- /dev/null
+++ b/openstackclient/tests/functional/base.py
@@ -0,0 +1,120 @@
+#    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 os
+import re
+import shlex
+import subprocess
+import testtools
+
+import six
+from tempest.lib.cli import output_parser
+from tempest.lib import exceptions
+
+
+COMMON_DIR = os.path.dirname(os.path.abspath(__file__))
+FUNCTIONAL_DIR = os.path.normpath(os.path.join(COMMON_DIR, '..'))
+ROOT_DIR = os.path.normpath(os.path.join(FUNCTIONAL_DIR, '..'))
+EXAMPLE_DIR = os.path.join(ROOT_DIR, 'examples')
+
+
+def execute(cmd, fail_ok=False, merge_stderr=False):
+    """Executes specified command for the given action."""
+    cmdlist = shlex.split(cmd)
+    result = ''
+    result_err = ''
+    stdout = subprocess.PIPE
+    stderr = subprocess.STDOUT if merge_stderr else subprocess.PIPE
+    proc = subprocess.Popen(cmdlist, stdout=stdout, stderr=stderr)
+    result, result_err = proc.communicate()
+    result = result.decode('utf-8')
+    if not fail_ok and proc.returncode != 0:
+        raise exceptions.CommandFailed(proc.returncode, cmd, result,
+                                       result_err)
+    return result
+
+
+class TestCase(testtools.TestCase):
+
+    delimiter_line = re.compile('^\+\-[\+\-]+\-\+$')
+
+    @classmethod
+    def openstack(cls, cmd, fail_ok=False):
+        """Executes openstackclient command for the given action."""
+        return execute('openstack ' + cmd, fail_ok=fail_ok)
+
+    @classmethod
+    def get_openstack_configuration_value(cls, configuration):
+        opts = cls.get_opts([configuration])
+        return cls.openstack('configuration show ' + opts)
+
+    @classmethod
+    def get_opts(cls, fields, format='value'):
+        return ' -f {0} {1}'.format(format,
+                                    ' '.join(['-c ' + it for it in fields]))
+
+    @classmethod
+    def assertOutput(cls, expected, actual):
+        if expected != actual:
+            raise Exception(expected + ' != ' + actual)
+
+    @classmethod
+    def assertInOutput(cls, expected, actual):
+        if expected not in actual:
+            raise Exception(expected + ' not in ' + actual)
+
+    def assert_table_structure(self, items, field_names):
+        """Verify that all items have keys listed in field_names."""
+        for item in items:
+            for field in field_names:
+                self.assertIn(field, item)
+
+    def assert_show_fields(self, items, field_names):
+        """Verify that all items have keys listed in field_names."""
+        for item in items:
+            for key in six.iterkeys(item):
+                self.assertIn(key, field_names)
+
+    def assert_show_structure(self, items, field_names):
+        """Verify that all field_names listed in keys of all items."""
+        if isinstance(items, list):
+            o = {}
+            for d in items:
+                o.update(d)
+        else:
+            o = items
+        item_keys = o.keys()
+        for field in field_names:
+            self.assertIn(field, item_keys)
+
+    def parse_show_as_object(self, raw_output):
+        """Return a dict with values parsed from cli output."""
+        items = self.parse_show(raw_output)
+        o = {}
+        for item in items:
+            o.update(item)
+        return o
+
+    def parse_show(self, raw_output):
+        """Return list of dicts with item values parsed from cli output."""
+
+        items = []
+        table_ = output_parser.table(raw_output)
+        for row in table_['values']:
+            item = {}
+            item[row[0]] = row[1]
+            items.append(item)
+        return items
+
+    def parse_listing(self, raw_output):
+        """Return list of dicts with basic item parsed from cli output."""
+        return output_parser.listing(raw_output)
diff --git a/openstackclient/tests/functional/common/__init__.py b/openstackclient/tests/functional/common/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/common/__init__.py
diff --git a/openstackclient/tests/functional/common/test_availability_zone.py b/openstackclient/tests/functional/common/test_availability_zone.py
new file mode 100644
index 00000000..f73e1ed9
--- /dev/null
+++ b/openstackclient/tests/functional/common/test_availability_zone.py
@@ -0,0 +1,25 @@
+#    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 openstackclient.tests.functional import base
+
+
+class AvailabilityZoneTests(base.TestCase):
+    """Functional tests for availability zone. """
+    HEADERS = ["'Zone Name'"]
+    # So far, all components have the same default availability zone name.
+    DEFAULT_AZ_NAME = 'nova'
+
+    def test_availability_zone_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('availability zone list' + opts)
+        self.assertIn(self.DEFAULT_AZ_NAME, raw_output)
diff --git a/openstackclient/tests/functional/common/test_configuration.py b/openstackclient/tests/functional/common/test_configuration.py
new file mode 100644
index 00000000..f47d3b00
--- /dev/null
+++ b/openstackclient/tests/functional/common/test_configuration.py
@@ -0,0 +1,44 @@
+#    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 os
+
+from openstackclient.common import configuration
+from openstackclient.tests.functional import base
+
+
+BASIC_CONFIG_HEADERS = ['Field', 'Value']
+
+
+class ConfigurationTests(base.TestCase):
+
+    opts = "-f value -c auth.password"
+
+    def test_configuration_show(self):
+        raw_output = self.openstack('configuration show')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, BASIC_CONFIG_HEADERS)
+
+    def test_configuration_show_unmask(self):
+        raw_output = self.openstack('configuration show --unmask ' + self.opts)
+        # If we are using os-client-config, this will not be set.  Rather than
+        # parse clouds.yaml to get the right value, just make sure
+        # we are not getting redacted.
+        passwd = os.environ.get('OS_PASSWORD')
+        if passwd:
+            self.assertEqual(passwd + '\n', raw_output)
+        else:
+            self.assertNotEqual(configuration.REDACTED + '\n', raw_output)
+
+    def test_configuration_show_mask(self):
+        raw_output = self.openstack('configuration show --mask ' + self.opts)
+        self.assertEqual(configuration.REDACTED + '\n', raw_output)
diff --git a/openstackclient/tests/functional/common/test_help.py b/openstackclient/tests/functional/common/test_help.py
new file mode 100644
index 00000000..bbc52197
--- /dev/null
+++ b/openstackclient/tests/functional/common/test_help.py
@@ -0,0 +1,66 @@
+#    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 openstackclient.tests.functional import base
+
+
+class HelpTests(base.TestCase):
+    """Functional tests for openstackclient help output."""
+
+    SERVER_COMMANDS = [
+        ('server add security group', 'Add security group to server'),
+        ('server add volume', 'Add volume to server'),
+        ('server backup create', 'Create a server backup image'),
+        ('server create', 'Create a new server'),
+        ('server delete', 'Delete server(s)'),
+        ('server dump create', 'Create a dump file in server(s)'),
+        ('server image create',
+         'Create a new server disk image from an existing server'),
+        ('server list', 'List servers'),
+        ('server lock',
+         'Lock server(s). '
+         'A non-admin user will not be able to execute actions'),
+        ('server migrate', 'Migrate server to different host'),
+        ('server pause', 'Pause server(s)'),
+        ('server reboot', 'Perform a hard or soft server reboot'),
+        ('server rebuild', 'Rebuild server'),
+        ('server remove security group', 'Remove security group from server'),
+        ('server remove volume', 'Remove volume from server'),
+        ('server rescue', 'Put server in rescue mode'),
+        ('server resize', 'Scale server to a new flavor'),
+        ('server resume', 'Resume server(s)'),
+        ('server set', 'Set server properties'),
+        ('server shelve', 'Shelve server(s)'),
+        ('server show', 'Show server details'),
+        ('server ssh', 'SSH to server'),
+        ('server start', 'Start server(s).'),
+        ('server stop', 'Stop server(s).'),
+        ('server suspend', 'Suspend server(s)'),
+        ('server unlock', 'Unlock server(s)'),
+        ('server unpause', 'Unpause server(s)'),
+        ('server unrescue', 'Restore server from rescue mode'),
+        ('server unset', 'Unset server properties'),
+        ('server unshelve', 'Unshelve server(s)')
+    ]
+
+    def test_server_commands_main_help(self):
+        """Check server commands in main help message."""
+        raw_output = self.openstack('help')
+        for command, description in self.SERVER_COMMANDS:
+            self.assertIn(command, raw_output)
+            self.assertIn(description, raw_output)
+
+    def test_server_only_help(self):
+        """Check list of server-related commands only."""
+        raw_output = self.openstack('help server')
+        for command in [row[0] for row in self.SERVER_COMMANDS]:
+            self.assertIn(command, raw_output)
diff --git a/openstackclient/tests/functional/common/test_quota.py b/openstackclient/tests/functional/common/test_quota.py
new file mode 100644
index 00000000..fd45be38
--- /dev/null
+++ b/openstackclient/tests/functional/common/test_quota.py
@@ -0,0 +1,42 @@
+#    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 openstackclient.tests.functional import base
+
+
+class QuotaTests(base.TestCase):
+    """Functional tests for quota. """
+    # Test quota information for compute, network and volume.
+    EXPECTED_FIELDS = ['instances', 'networks', 'volumes']
+    PROJECT_NAME = None
+
+    @classmethod
+    def setUpClass(cls):
+        cls.PROJECT_NAME =\
+            cls.get_openstack_configuration_value('auth.project_name')
+
+    def test_quota_set(self):
+        self.openstack('quota set --instances 11 --volumes 11 --networks 11 '
+                       + self.PROJECT_NAME)
+        opts = self.get_opts(self.EXPECTED_FIELDS)
+        raw_output = self.openstack('quota show ' + self.PROJECT_NAME + opts)
+        self.assertEqual("11\n11\n11\n", raw_output)
+
+    def test_quota_show(self):
+        raw_output = self.openstack('quota show ' + self.PROJECT_NAME)
+        for expected_field in self.EXPECTED_FIELDS:
+            self.assertIn(expected_field, raw_output)
+
+    def test_quota_show_default_project(self):
+        raw_output = self.openstack('quota show')
+        for expected_field in self.EXPECTED_FIELDS:
+            self.assertIn(expected_field, raw_output)
diff --git a/openstackclient/tests/functional/compute/__init__.py b/openstackclient/tests/functional/compute/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/compute/__init__.py
diff --git a/openstackclient/tests/functional/compute/v2/__init__.py b/openstackclient/tests/functional/compute/v2/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/compute/v2/__init__.py
diff --git a/openstackclient/tests/functional/compute/v2/test_agent.py b/openstackclient/tests/functional/compute/v2/test_agent.py
new file mode 100644
index 00000000..7115db1f
--- /dev/null
+++ b/openstackclient/tests/functional/compute/v2/test_agent.py
@@ -0,0 +1,77 @@
+#    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 hashlib
+
+from openstackclient.tests.functional import base
+
+
+class ComputeAgentTests(base.TestCase):
+    """Functional tests for compute agent."""
+
+    ID = None
+    MD5HASH = hashlib.md5().hexdigest()
+    URL = "http://localhost"
+    VER = "v1"
+    OS = "TEST_OS"
+    ARCH = "x86_64"
+    HYPER = "kvm"
+
+    HEADERS = ['agent_id', 'md5hash']
+    FIELDS = ['agent_id', 'md5hash']
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.HEADERS)
+        raw_output = cls.openstack('compute agent create ' +
+                                   cls.OS + ' ' + cls.ARCH + ' ' +
+                                   cls.VER + ' ' + cls.URL + ' ' +
+                                   cls.MD5HASH + ' ' + cls.HYPER + ' ' +
+                                   opts)
+
+        # Get agent id because agent can only be deleted by ID
+        output_list = raw_output.split('\n', 1)
+        cls.ID = output_list[0]
+
+        cls.assertOutput(cls.MD5HASH + '\n', output_list[1])
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('compute agent delete ' + cls.ID)
+        cls.assertOutput('', raw_output)
+
+    def test_agent_list(self):
+        raw_output = self.openstack('compute agent list')
+        self.assertIn(self.ID, raw_output)
+        self.assertIn(self.OS, raw_output)
+        self.assertIn(self.ARCH, raw_output)
+        self.assertIn(self.VER, raw_output)
+        self.assertIn(self.URL, raw_output)
+        self.assertIn(self.MD5HASH, raw_output)
+        self.assertIn(self.HYPER, raw_output)
+
+    def test_agent_set(self):
+        ver = 'v2'
+        url = "http://openstack"
+        md5hash = hashlib.md5().hexdigest()
+
+        self.openstack('compute agent set '
+                       + self.ID
+                       + ' --agent-version ' + ver
+                       + ' --url ' + url
+                       + ' --md5hash ' + md5hash)
+
+        raw_output = self.openstack('compute agent list')
+        self.assertIn(self.ID, raw_output)
+        self.assertIn(ver, raw_output)
+        self.assertIn(url, raw_output)
+        self.assertIn(md5hash, raw_output)
diff --git a/openstackclient/tests/functional/compute/v2/test_aggregate.py b/openstackclient/tests/functional/compute/v2/test_aggregate.py
new file mode 100644
index 00000000..2bc88e7b
--- /dev/null
+++ b/openstackclient/tests/functional/compute/v2/test_aggregate.py
@@ -0,0 +1,67 @@
+#    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 AggregateTests(base.TestCase):
+    """Functional tests for aggregate."""
+
+    NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        # Use the default 'nova' availability zone for the aggregate.
+        raw_output = cls.openstack(
+            'aggregate create --zone nova ' + cls.NAME + opts
+        )
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('aggregate delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_aggregate_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('aggregate list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_aggregate_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('aggregate show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
+
+    def test_aggregate_properties(self):
+        opts = self.get_opts(['properties'])
+
+        raw_output = self.openstack(
+            'aggregate set --property a=b --property c=d ' + self.NAME
+        )
+        self.assertEqual('', raw_output)
+
+        raw_output = self.openstack('aggregate show ' + self.NAME + opts)
+        self.assertIn("a='b', c='d'\n", raw_output)
+
+        raw_output = self.openstack(
+            'aggregate unset --property a ' + self.NAME
+        )
+        self.assertEqual('', raw_output)
+
+        raw_output = self.openstack('aggregate show ' + self.NAME + opts)
+        self.assertIn("c='d'\n", raw_output)
diff --git a/openstackclient/tests/functional/compute/v2/test_flavor.py b/openstackclient/tests/functional/compute/v2/test_flavor.py
new file mode 100644
index 00000000..794a6cc3
--- /dev/null
+++ b/openstackclient/tests/functional/compute/v2/test_flavor.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.
+
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class FlavorTests(base.TestCase):
+    """Functional tests for flavor."""
+
+    NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack(
+            'flavor create --property a=b --property c=d ' + cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('flavor delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_flavor_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('flavor list' + opts)
+        self.assertIn("small", raw_output)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_flavor_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('flavor show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
+
+    def test_flavor_properties(self):
+        opts = self.get_opts(['properties'])
+        # check the properties we added in create command.
+        raw_output = self.openstack('flavor show ' + self.NAME + opts)
+        self.assertEqual("a='b', c='d'\n", raw_output)
+
+        raw_output = self.openstack(
+            'flavor set --property e=f --property g=h ' + self.NAME
+        )
+        self.assertEqual('', raw_output)
+
+        raw_output = self.openstack('flavor show ' + self.NAME + opts)
+        self.assertEqual("a='b', c='d', e='f', g='h'\n", raw_output)
+
+        raw_output = self.openstack(
+            'flavor unset --property a --property c ' + self.NAME
+        )
+        self.assertEqual('', raw_output)
+
+        raw_output = self.openstack('flavor show ' + self.NAME + opts)
+        self.assertEqual("e='f', g='h'\n", raw_output)
diff --git a/openstackclient/tests/functional/compute/v2/test_keypair.py b/openstackclient/tests/functional/compute/v2/test_keypair.py
new file mode 100644
index 00000000..01078c61
--- /dev/null
+++ b/openstackclient/tests/functional/compute/v2/test_keypair.py
@@ -0,0 +1,168 @@
+#    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 tempfile
+
+from openstackclient.tests.functional import base
+
+from tempest.lib.common.utils import data_utils
+from tempest.lib import exceptions
+
+
+class KeypairBase(base.TestCase):
+    """Methods for functional tests."""
+
+    def keypair_create(self, name=data_utils.rand_uuid()):
+        """Create keypair and add cleanup."""
+        raw_output = self.openstack('keypair create ' + name)
+        self.addCleanup(self.keypair_delete, name, True)
+        if not raw_output:
+            self.fail('Keypair has not been created!')
+
+    def keypair_list(self, params=''):
+        """Return dictionary with list of keypairs."""
+        raw_output = self.openstack('keypair list')
+        keypairs = self.parse_show_as_object(raw_output)
+        return keypairs
+
+    def keypair_delete(self, name, ignore_exceptions=False):
+        """Try to delete keypair by name."""
+        try:
+            self.openstack('keypair delete ' + name)
+        except exceptions.CommandFailed:
+            if not ignore_exceptions:
+                raise
+
+
+class KeypairTests(KeypairBase):
+    """Functional tests for compute keypairs."""
+
+    PUBLIC_KEY = (
+        'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDWNGczJxNaFUrJJVhta4dWsZY6bU'
+        '5HUMPbyfSMu713ca3mYtG848W4dfDCB98KmSQx2Bl0D6Q2nrOszOXEQWAXNdfMadnW'
+        'c4mNwhZcPBVohIFoC1KZJC8kcBTvFZcoz3mdIijxJtywZNpGNh34VRJlZeHyYjg8/D'
+        'esHzdoBVd5c/4R36emQSIV9ukY6PHeZ3scAH4B3K9PxItJBwiFtouSRphQG0bJgOv/'
+        'gjAjMElAvg5oku98cb4QiHZ8T8WY68id804raHR6pJxpVVJN4TYJmlUs+NOVM+pPKb'
+        'KJttqrIBTkawGK9pLHNfn7z6v1syvUo/4enc1l0Q/Qn2kWiz67 fake@openstack'
+    )
+
+    def setUp(self):
+        """Create keypair with randomized name for tests."""
+        super(KeypairTests, self).setUp()
+        self.KPName = data_utils.rand_name('TestKeyPair')
+        self.keypair = self.keypair_create(self.KPName)
+
+    def test_keypair_create_duplicate(self):
+        """Try to create duplicate name keypair.
+
+        Test steps:
+        1) Create keypair in setUp
+        2) Try to create duplicate keypair with the same name
+        """
+        self.assertRaises(exceptions.CommandFailed,
+                          self.openstack, 'keypair create ' + self.KPName)
+
+    def test_keypair_create_noname(self):
+        """Try to create keypair without name.
+
+        Test steps:
+        1) Try to create keypair without a name
+        """
+        self.assertRaises(exceptions.CommandFailed,
+                          self.openstack, 'keypair create')
+
+    def test_keypair_create_public_key(self):
+        """Test for create keypair with --public-key option.
+
+        Test steps:
+        1) Create keypair with given public key
+        2) Delete keypair
+        """
+        with tempfile.NamedTemporaryFile() as f:
+            f.write(self.PUBLIC_KEY)
+            f.flush()
+
+            raw_output = self.openstack(
+                'keypair create --public-key %s tmpkey' % f.name,
+            )
+            self.addCleanup(
+                self.openstack,
+                'keypair delete tmpkey',
+            )
+            self.assertIn('tmpkey', raw_output)
+
+    def test_keypair_create(self):
+        """Test keypair create command.
+
+        Test steps:
+        1) Create keypair in setUp
+        2) Check RSA private key in output
+        3) Check for new keypair in keypairs list
+        """
+        NewName = data_utils.rand_name('TestKeyPairCreated')
+        raw_output = self.openstack('keypair create ' + NewName)
+        self.addCleanup(self.openstack, 'keypair delete ' + NewName)
+        self.assertInOutput('-----BEGIN RSA PRIVATE KEY-----', raw_output)
+        self.assertRegex(raw_output, "[0-9A-Za-z+/]+[=]{0,3}\n")
+        self.assertInOutput('-----END RSA PRIVATE KEY-----', raw_output)
+        self.assertIn(NewName, self.keypair_list())
+
+    def test_keypair_delete_not_existing(self):
+        """Try to delete keypair with not existing name.
+
+        Test steps:
+        1) Create keypair in setUp
+        2) Try to delete not existing keypair
+        """
+        self.assertRaises(exceptions.CommandFailed,
+                          self.openstack, 'keypair delete not_existing')
+
+    def test_keypair_delete(self):
+        """Test keypair delete command.
+
+        Test steps:
+        1) Create keypair in setUp
+        2) Delete keypair
+        3) Check that keypair not in keypairs list
+        """
+        self.openstack('keypair delete ' + self.KPName)
+        self.assertNotIn(self.KPName, self.keypair_list())
+
+    def test_keypair_list(self):
+        """Test keypair list command.
+
+        Test steps:
+        1) Create keypair in setUp
+        2) List keypairs
+        3) Check output table structure
+        4) Check keypair name in output
+        """
+        HEADERS = ['Name', 'Fingerprint']
+        raw_output = self.openstack('keypair list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, HEADERS)
+        self.assertIn(self.KPName, raw_output)
+
+    def test_keypair_show(self):
+        """Test keypair show command.
+
+        Test steps:
+        1) Create keypair in setUp
+        2) Show keypair
+        3) Check output table structure
+        4) Check keypair name in output
+        """
+        HEADERS = ['Field', 'Value']
+        raw_output = self.openstack('keypair show ' + self.KPName)
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, HEADERS)
+        self.assertInOutput(self.KPName, raw_output)
diff --git a/openstackclient/tests/functional/compute/v2/test_server.py b/openstackclient/tests/functional/compute/v2/test_server.py
new file mode 100644
index 00000000..6eedf408
--- /dev/null
+++ b/openstackclient/tests/functional/compute/v2/test_server.py
@@ -0,0 +1,308 @@
+#    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 time
+
+from tempest.lib.common.utils import data_utils
+
+from openstackclient.tests.functional import base
+from tempest.lib import exceptions
+
+
+class ServerTests(base.TestCase):
+    """Functional tests for openstack server commands."""
+
+    @classmethod
+    def get_flavor(cls):
+        # NOTE(rtheis): Get cirros256 or m1.tiny flavors since functional
+        # tests may create other flavors.
+        flavors = cls.openstack('flavor list -c Name -f value').split('\n')
+        server_flavor = None
+        for flavor in flavors:
+            if flavor in ['m1.tiny', 'cirros256']:
+                server_flavor = flavor
+                break
+        return server_flavor
+
+    @classmethod
+    def get_image(cls):
+        # NOTE(rtheis): Get cirros image since functional tests may
+        # create other images.
+        images = cls.openstack('image list -c Name -f value').split('\n')
+        server_image = None
+        for image in images:
+            if image.startswith('cirros-') and image.endswith('-uec'):
+                server_image = image
+                break
+        return server_image
+
+    @classmethod
+    def get_network(cls):
+        try:
+            # NOTE(rtheis): Get private network since functional tests may
+            # create other networks.
+            raw_output = cls.openstack('network show private -c id -f value')
+        except exceptions.CommandFailed:
+            return ''
+        return ' --nic net-id=' + raw_output.strip('\n')
+
+    def server_create(self, name=None):
+        """Create server. Add cleanup."""
+        name = name or data_utils.rand_uuid()
+        opts = self.get_opts(self.FIELDS)
+        flavor = self.get_flavor()
+        image = self.get_image()
+        network = self.get_network()
+        raw_output = self.openstack('--debug server create --flavor ' +
+                                    flavor +
+                                    ' --image ' + image + network + ' ' +
+                                    name + opts)
+        if not raw_output:
+            self.fail('Server has not been created!')
+        self.addCleanup(self.server_delete, name)
+
+    def server_list(self, params=[]):
+        """List servers."""
+        opts = self.get_opts(params)
+        return self.openstack('server list' + opts)
+
+    def server_delete(self, name):
+        """Delete server by name."""
+        self.openstack('server delete ' + name)
+
+    def setUp(self):
+        """Set necessary variables and create server."""
+        super(ServerTests, self).setUp()
+        self.NAME = data_utils.rand_name('TestServer')
+        self.OTHER_NAME = data_utils.rand_name('TestServer')
+        self.HEADERS = ['"Name"']
+        self.FIELDS = ['name']
+        self.IP_POOL = 'public'
+        self.server_create(self.NAME)
+
+    def test_server_rename(self):
+        """Test server rename command.
+
+        Test steps:
+        1) Boot server in setUp
+        2) Rename server
+        3) Check output
+        4) Rename server back to original name
+        """
+        raw_output = self.openstack('server set --name ' + self.OTHER_NAME +
+                                    ' ' + self.NAME)
+        self.assertOutput("", raw_output)
+        self.assertNotIn(self.NAME, self.server_list(['Name']))
+        self.assertIn(self.OTHER_NAME, self.server_list(['Name']))
+        self.openstack('server set --name ' + self.NAME + ' ' +
+                       self.OTHER_NAME)
+
+    def test_server_list(self):
+        """Test server list command.
+
+        Test steps:
+        1) Boot server in setUp
+        2) List servers
+        3) Check output
+        """
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('server list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_server_show(self):
+        """Test server show command.
+
+        Test steps:
+        1) Boot server in setUp
+        2) Show server
+        3) Check output
+        """
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('server show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
+
+    def test_server_metadata(self):
+        """Test command to set server metadata.
+
+        Test steps:
+        1) Boot server in setUp
+        2) Set properties for server
+        3) Check server properties in server show output
+        4) Unset properties for server
+        5) Check server properties in server show output
+        """
+        self.wait_for_status("ACTIVE")
+        # metadata
+        raw_output = self.openstack(
+            'server set --property a=b --property c=d ' + self.NAME)
+        opts = self.get_opts(["name", "properties"])
+        raw_output = self.openstack('server show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\na='b', c='d'\n", raw_output)
+
+        raw_output = self.openstack(
+            'server unset --property a ' + self.NAME)
+        opts = self.get_opts(["name", "properties"])
+        raw_output = self.openstack('server show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\nc='d'\n", raw_output)
+
+    def test_server_suspend_resume(self):
+        """Test server suspend and resume commands.
+
+        Test steps:
+        1) Boot server in setUp
+        2) Suspend server
+        3) Check for SUSPENDED server status
+        4) Resume server
+        5) Check for ACTIVE server status
+        """
+        self.wait_for_status("ACTIVE")
+        # suspend
+        raw_output = self.openstack('server suspend ' + self.NAME)
+        self.assertEqual("", raw_output)
+        self.wait_for_status("SUSPENDED")
+        # resume
+        raw_output = self.openstack('server resume ' + self.NAME)
+        self.assertEqual("", raw_output)
+        self.wait_for_status("ACTIVE")
+
+    def test_server_lock_unlock(self):
+        """Test server lock and unlock commands.
+
+        Test steps:
+        1) Boot server in setUp
+        2) Lock server
+        3) Check output
+        4) Unlock server
+        5) Check output
+        """
+        self.wait_for_status("ACTIVE")
+        # lock
+        raw_output = self.openstack('server lock ' + self.NAME)
+        self.assertEqual("", raw_output)
+        # unlock
+        raw_output = self.openstack('server unlock ' + self.NAME)
+        self.assertEqual("", raw_output)
+
+    def test_server_pause_unpause(self):
+        """Test server pause and unpause commands.
+
+        Test steps:
+        1) Boot server in setUp
+        2) Pause server
+        3) Check for PAUSED server status
+        4) Unpause server
+        5) Check for ACTIVE server status
+        """
+        self.wait_for_status("ACTIVE")
+        # pause
+        raw_output = self.openstack('server pause ' + self.NAME)
+        self.assertEqual("", raw_output)
+        self.wait_for_status("PAUSED")
+        # unpause
+        raw_output = self.openstack('server unpause ' + self.NAME)
+        self.assertEqual("", raw_output)
+        self.wait_for_status("ACTIVE")
+
+    def test_server_rescue_unrescue(self):
+        """Test server rescue and unrescue commands.
+
+        Test steps:
+        1) Boot server in setUp
+        2) Rescue server
+        3) Check for RESCUE server status
+        4) Unrescue server
+        5) Check for ACTIVE server status
+        """
+        self.wait_for_status("ACTIVE")
+        # rescue
+        opts = self.get_opts(["adminPass"])
+        raw_output = self.openstack('server rescue ' + self.NAME + opts)
+        self.assertNotEqual("", raw_output)
+        self.wait_for_status("RESCUE")
+        # unrescue
+        raw_output = self.openstack('server unrescue ' + self.NAME)
+        self.assertEqual("", raw_output)
+        self.wait_for_status("ACTIVE")
+
+    def test_server_attach_detach_floating_ip(self):
+        """Test commands to attach and detach floating IP for server.
+
+        Test steps:
+        1) Boot server in setUp
+        2) Create floating IP
+        3) Add floating IP to server
+        4) Check for floating IP in server show output
+        5) Remove floating IP from server
+        6) Check that floating IP is  not in server show output
+        7) Delete floating IP
+        8) Check output
+        """
+        self.wait_for_status("ACTIVE")
+        # attach ip
+        opts = self.get_opts(["id", "floating_ip_address"])
+        raw_output = self.openstack('floating ip create ' +
+                                    self.IP_POOL +
+                                    opts)
+        ip, ipid, rol = tuple(raw_output.split('\n'))
+        self.assertNotEqual("", ipid)
+        self.assertNotEqual("", ip)
+        raw_output = self.openstack('server add floating ip ' + self.NAME +
+                                    ' ' + ip)
+        self.assertEqual("", raw_output)
+        raw_output = self.openstack('server show ' + self.NAME)
+        self.assertIn(ip, raw_output)
+
+        # detach ip
+        raw_output = self.openstack('server remove floating ip ' + self.NAME +
+                                    ' ' + ip)
+        self.assertEqual("", raw_output)
+        raw_output = self.openstack('server show ' + self.NAME)
+        self.assertNotIn(ip, raw_output)
+        raw_output = self.openstack('floating ip delete ' + ipid)
+        self.assertEqual("", raw_output)
+
+    def test_server_reboot(self):
+        """Test server reboot command.
+
+        Test steps:
+        1) Boot server in setUp
+        2) Reboot server
+        3) Check for ACTIVE server status
+        """
+        self.wait_for_status("ACTIVE")
+        # reboot
+        raw_output = self.openstack('server reboot ' + self.NAME)
+        self.assertEqual("", raw_output)
+        self.wait_for_status("ACTIVE")
+
+    def wait_for_status(self, expected_status='ACTIVE', wait=900, interval=30):
+        """Wait until server reaches expected status."""
+        # TODO(thowe): Add a server wait command to osc
+        failures = ['ERROR']
+        total_sleep = 0
+        opts = self.get_opts(['status'])
+        while total_sleep < wait:
+            status = self.openstack('server show ' + self.NAME + opts)
+            status = status.rstrip()
+            print('Waiting for {} current status: {}'.format(expected_status,
+                                                             status))
+            if status == expected_status:
+                break
+            self.assertNotIn(status, failures)
+            time.sleep(interval)
+            total_sleep += interval
+
+        status = self.openstack('server show ' + self.NAME + opts)
+        status = status.rstrip()
+        self.assertEqual(status, expected_status)
+        # give it a little bit more time
+        time.sleep(5)
diff --git a/openstackclient/tests/functional/compute/v2/test_server_group.py b/openstackclient/tests/functional/compute/v2/test_server_group.py
new file mode 100644
index 00000000..3f0a24e5
--- /dev/null
+++ b/openstackclient/tests/functional/compute/v2/test_server_group.py
@@ -0,0 +1,46 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class ServerGroupTests(base.TestCase):
+    """Functional tests for servergroup."""
+
+    NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('server group create --policy affinity ' +
+                                   cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('server group delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_server_group_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('server group list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_server_group_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('server group show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
diff --git a/openstackclient/tests/functional/examples/__init__.py b/openstackclient/tests/functional/examples/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/examples/__init__.py
diff --git a/openstackclient/tests/functional/examples/test_examples.py b/openstackclient/tests/functional/examples/test_examples.py
new file mode 100644
index 00000000..031f036a
--- /dev/null
+++ b/openstackclient/tests/functional/examples/test_examples.py
@@ -0,0 +1,28 @@
+#    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 openstackclient.tests.functional import base
+
+
+class ExampleTests(base.TestCase):
+    """Functional tests for running examples."""
+
+    def test_common(self):
+        # NOTE(stevemar): If an examples has a non-zero return
+        # code, then execute will raise an error by default.
+        base.execute('python', base.EXAMPLE_DIR + '/common.py --debug')
+
+    def test_object_api(self):
+        base.execute('python', base.EXAMPLE_DIR + '/object_api.py --debug')
+
+    def test_osc_lib(self):
+        base.execute('python', base.EXAMPLE_DIR + '/osc-lib.py --debug')
diff --git a/openstackclient/tests/functional/identity/__init__.py b/openstackclient/tests/functional/identity/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/identity/__init__.py
diff --git a/openstackclient/tests/functional/identity/v2/__init__.py b/openstackclient/tests/functional/identity/v2/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v2/__init__.py
diff --git a/openstackclient/tests/functional/identity/v2/common.py b/openstackclient/tests/functional/identity/v2/common.py
new file mode 100644
index 00000000..b390c5bc
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v2/common.py
@@ -0,0 +1,181 @@
+#    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 os
+
+from tempest.lib.common.utils import data_utils
+
+from openstackclient.tests.functional import base
+
+BASIC_LIST_HEADERS = ['ID', 'Name']
+
+
+class IdentityTests(base.TestCase):
+    """Functional tests for Identity commands. """
+
+    USER_FIELDS = ['email', 'enabled', 'id', 'name', 'project_id',
+                   'username', 'domain_id', 'default_project_id']
+    PROJECT_FIELDS = ['enabled', 'id', 'name', 'description', 'domain_id']
+    TOKEN_FIELDS = ['expires', 'id', 'project_id', 'user_id']
+    ROLE_FIELDS = ['id', 'name', 'links', 'domain_id']
+    SERVICE_FIELDS = ['id', 'enabled', 'name', 'type', 'description']
+    ENDPOINT_FIELDS = ['id', 'region', 'service_id', 'service_name',
+                       'service_type', 'enabled', 'publicurl',
+                       'adminurl', 'internalurl']
+
+    EC2_CREDENTIALS_FIELDS = ['access', 'project_id', 'secret',
+                              'trust_id', 'user_id']
+    EC2_CREDENTIALS_LIST_HEADERS = ['Access', 'Secret',
+                                    'Project ID', 'User ID']
+    CATALOG_LIST_HEADERS = ['Name', 'Type', 'Endpoints']
+    ENDPOINT_LIST_HEADERS = ['ID', 'Region', 'Service Name', 'Service Type']
+
+    @classmethod
+    def setUpClass(cls):
+        # prepare v2 env
+        os.environ['OS_IDENTITY_API_VERSION'] = '2.0'
+        auth_url = os.environ.get('OS_AUTH_URL')
+        auth_url = auth_url.replace('v3', 'v2.0')
+        os.environ['OS_AUTH_URL'] = auth_url
+
+        # create dummy project
+        cls.project_name = data_utils.rand_name('TestProject')
+        cls.project_description = data_utils.rand_name('description')
+        cls.openstack(
+            'project create '
+            '--description %(description)s '
+            '--enable '
+            '%(name)s' % {'description': cls.project_description,
+                          'name': cls.project_name})
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.openstack('project delete %s' % cls.project_name)
+
+    def _create_dummy_project(self, add_clean_up=True):
+        project_name = data_utils.rand_name('TestProject')
+        project_description = data_utils.rand_name('description')
+        raw_output = self.openstack(
+            'project create '
+            '--description %(description)s '
+            '--enable %(name)s' % {'description': project_description,
+                                   'name': project_name})
+        project = self.parse_show_as_object(raw_output)
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'project delete %s' % project['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.PROJECT_FIELDS)
+        return project_name
+
+    def _create_dummy_user(self, add_clean_up=True):
+        username = data_utils.rand_name('TestUser')
+        password = data_utils.rand_name('password')
+        email = data_utils.rand_name() + '@example.com'
+        raw_output = self.openstack(
+            'user create '
+            '--project %(project)s '
+            '--password %(password)s '
+            '--email %(email)s '
+            '--enable '
+            '%(name)s' % {'project': self.project_name,
+                          'email': email,
+                          'password': password,
+                          'name': username})
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'user delete %s' % self.parse_show_as_object(raw_output)['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.USER_FIELDS)
+        return username
+
+    def _create_dummy_role(self, add_clean_up=True):
+        role_name = data_utils.rand_name('TestRole')
+        raw_output = self.openstack('role create %s' % role_name)
+        role = self.parse_show_as_object(raw_output)
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'role delete %s' % role['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
+        self.assertEqual(role_name, role['name'])
+        return role_name
+
+    def _create_dummy_ec2_credentials(self, add_clean_up=True):
+        raw_output = self.openstack('ec2 credentials create')
+        ec2_credentials = self.parse_show_as_object(raw_output)
+        access_key = ec2_credentials['access']
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'ec2 credentials delete %s' % access_key)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.EC2_CREDENTIALS_FIELDS)
+        return access_key
+
+    def _create_dummy_token(self, add_clean_up=True):
+        raw_output = self.openstack('token issue')
+        token = self.parse_show_as_object(raw_output)
+        if add_clean_up:
+            self.addCleanup(self.openstack,
+                            'token revoke %s' % token['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.TOKEN_FIELDS)
+        return token['id']
+
+    def _create_dummy_service(self, add_clean_up=True):
+        service_name = data_utils.rand_name('TestService')
+        description = data_utils.rand_name('description')
+        type_name = data_utils.rand_name('TestType')
+        raw_output = self.openstack(
+            'service create '
+            '--name %(name)s '
+            '--description %(description)s '
+            '%(type)s' % {'name': service_name,
+                          'description': description,
+                          'type': type_name})
+        if add_clean_up:
+            service = self.parse_show_as_object(raw_output)
+            self.addCleanup(self.openstack,
+                            'service delete %s' % service['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.SERVICE_FIELDS)
+        return service_name
+
+    def _create_dummy_endpoint(self, add_clean_up=True):
+        region_id = data_utils.rand_name('TestRegion')
+        service_name = self._create_dummy_service()
+        public_url = data_utils.rand_url()
+        admin_url = data_utils.rand_url()
+        internal_url = data_utils.rand_url()
+        raw_output = self.openstack(
+            'endpoint create '
+            '--publicurl %(publicurl)s '
+            '--adminurl %(adminurl)s '
+            '--internalurl %(internalurl)s '
+            '--region %(region)s '
+            '%(service)s' % {'publicurl': public_url,
+                             'adminurl': admin_url,
+                             'internalurl': internal_url,
+                             'region': region_id,
+                             'service': service_name})
+        endpoint = self.parse_show_as_object(raw_output)
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'endpoint delete %s' % endpoint['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ENDPOINT_FIELDS)
+        return endpoint['id']
diff --git a/openstackclient/tests/functional/identity/v2/test_catalog.py b/openstackclient/tests/functional/identity/v2/test_catalog.py
new file mode 100644
index 00000000..f403fbfc
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v2/test_catalog.py
@@ -0,0 +1,42 @@
+#    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 openstackclient.tests.functional.identity.v2 import common
+
+
+class CatalogTests(common.IdentityTests):
+
+    def test_catalog_list(self):
+        raw_output = self.openstack('catalog list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.CATALOG_LIST_HEADERS)
+
+    def test_catalog_show(self):
+        """test catalog show command
+
+        The output example:
+        +-----------+-------------------------------------------+
+        | Field     | Value                                     |
+        +-----------+-------------------------------------------+
+        | endpoints | test1                                     |
+        |           |   publicURL: http://localhost:5000/v2.0   |
+        |           |   internalURL: http://localhost:5000/v2.0 |
+        |           |   adminURL: http://localhost:5000/v2.0    |
+        |           |                                           |
+        | name      | keystone                                  |
+        | type      | identity                                  |
+        +-----------+-------------------------------------------+
+        """
+        raw_output = self.openstack('catalog show %s' % 'identity')
+        items = self.parse_show(raw_output)
+        # items may have multiple endpoint urls with empty key
+        self.assert_show_fields(items, ['endpoints', 'name', 'type', ''])
diff --git a/openstackclient/tests/functional/identity/v2/test_ec2_credentials.py b/openstackclient/tests/functional/identity/v2/test_ec2_credentials.py
new file mode 100644
index 00000000..43dff91f
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v2/test_ec2_credentials.py
@@ -0,0 +1,48 @@
+# 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 openstackclient.tests.functional.identity.v2 import common
+
+
+class EC2CredentialsTests(common.IdentityTests):
+
+    def test_ec2_credentials_create(self):
+        self._create_dummy_ec2_credentials()
+
+    def test_ec2_credentials_delete(self):
+        access_key = self._create_dummy_ec2_credentials(add_clean_up=False)
+        raw_output = self.openstack(
+            'ec2 credentials delete %s' % access_key,
+        )
+        self.assertEqual(0, len(raw_output))
+
+    def test_ec2_credentials_multi_delete(self):
+        access_key_1 = self._create_dummy_ec2_credentials(add_clean_up=False)
+        access_key_2 = self._create_dummy_ec2_credentials(add_clean_up=False)
+        raw_output = self.openstack(
+            'ec2 credentials delete ' + access_key_1 + ' ' + access_key_2
+        )
+        self.assertEqual(0, len(raw_output))
+
+    def test_ec2_credentials_list(self):
+        self._create_dummy_ec2_credentials()
+        raw_output = self.openstack('ec2 credentials list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.EC2_CREDENTIALS_LIST_HEADERS)
+
+    def test_ec2_credentials_show(self):
+        access_key = self._create_dummy_ec2_credentials()
+        show_output = self.openstack(
+            'ec2 credentials show %s' % access_key,
+        )
+        items = self.parse_show(show_output)
+        self.assert_show_fields(items, self.EC2_CREDENTIALS_FIELDS)
diff --git a/openstackclient/tests/functional/identity/v2/test_endpoint.py b/openstackclient/tests/functional/identity/v2/test_endpoint.py
new file mode 100644
index 00000000..9df5ca8a
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v2/test_endpoint.py
@@ -0,0 +1,45 @@
+#    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 openstackclient.tests.functional.identity.v2 import common
+
+
+class EndpointTests(common.IdentityTests):
+
+    def test_endpoint_create(self):
+        self._create_dummy_endpoint()
+
+    def test_endpoint_delete(self):
+        endpoint_id = self._create_dummy_endpoint(add_clean_up=False)
+        raw_output = self.openstack(
+            'endpoint delete %s' % endpoint_id)
+        self.assertEqual(0, len(raw_output))
+
+    def test_endpoint_multi_delete(self):
+        endpoint_id_1 = self._create_dummy_endpoint(add_clean_up=False)
+        endpoint_id_2 = self._create_dummy_endpoint(add_clean_up=False)
+        raw_output = self.openstack(
+            'endpoint delete ' + endpoint_id_1 + ' ' + endpoint_id_2)
+        self.assertEqual(0, len(raw_output))
+
+    def test_endpoint_list(self):
+        endpoint_id = self._create_dummy_endpoint()
+        raw_output = self.openstack('endpoint list')
+        self.assertIn(endpoint_id, raw_output)
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.ENDPOINT_LIST_HEADERS)
+
+    def test_endpoint_show(self):
+        endpoint_id = self._create_dummy_endpoint()
+        raw_output = self.openstack('endpoint show %s' % endpoint_id)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ENDPOINT_FIELDS)
diff --git a/openstackclient/tests/functional/identity/v2/test_project.py b/openstackclient/tests/functional/identity/v2/test_project.py
new file mode 100644
index 00000000..b6222a1b
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v2/test_project.py
@@ -0,0 +1,86 @@
+# 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 tempest.lib.common.utils import data_utils
+
+from openstackclient.tests.functional.identity.v2 import common
+
+
+class ProjectTests(common.IdentityTests):
+
+    def test_project_create(self):
+        project_name = data_utils.rand_name('TestProject')
+        description = data_utils.rand_name('description')
+        raw_output = self.openstack(
+            'project create '
+            '--description %(description)s '
+            '--enable '
+            '--property k1=v1 '
+            '--property k2=v2 '
+            '%(name)s' % {'description': description,
+                          'name': project_name})
+        self.addCleanup(
+            self.openstack,
+            'project delete %s' % project_name
+        )
+        items = self.parse_show(raw_output)
+        show_fields = list(self.PROJECT_FIELDS)
+        show_fields.extend(['k1', 'k2'])
+        self.assert_show_fields(items, show_fields)
+        project = self.parse_show_as_object(raw_output)
+        self.assertEqual('v1', project['k1'])
+        self.assertEqual('v2', project['k2'])
+
+    def test_project_delete(self):
+        project_name = self._create_dummy_project(add_clean_up=False)
+        raw_output = self.openstack(
+            'project delete %s' % project_name)
+        self.assertEqual(0, len(raw_output))
+
+    def test_project_list(self):
+        raw_output = self.openstack('project list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+
+    def test_project_set(self):
+        project_name = self._create_dummy_project()
+        new_project_name = data_utils.rand_name('NewTestProject')
+        raw_output = self.openstack(
+            'project set '
+            '--name %(new_name)s '
+            '--disable '
+            '--property k0=v0 '
+            '%(name)s' % {'new_name': new_project_name,
+                          'name': project_name})
+        self.assertEqual(0, len(raw_output))
+        # check project details
+        raw_output = self.openstack(
+            'project show %s' % new_project_name
+        )
+        items = self.parse_show(raw_output)
+        fields = list(self.PROJECT_FIELDS)
+        fields.extend(['properties'])
+        self.assert_show_fields(items, fields)
+        project = self.parse_show_as_object(raw_output)
+        self.assertEqual(new_project_name, project['name'])
+        self.assertEqual('False', project['enabled'])
+        self.assertEqual("k0='v0'", project['properties'])
+
+    def test_project_show(self):
+        project_name = self._create_dummy_project()
+        raw_output = self.openstack(
+            'project show %s' % project_name
+        )
+        items = self.parse_show(raw_output)
+        fields = list(self.PROJECT_FIELDS)
+        fields.extend(['properties'])
+        self.assert_show_fields(items, fields)
diff --git a/openstackclient/tests/functional/identity/v2/test_role.py b/openstackclient/tests/functional/identity/v2/test_role.py
new file mode 100644
index 00000000..82e19aab
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v2/test_role.py
@@ -0,0 +1,110 @@
+#    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 openstackclient.tests.functional.identity.v2 import common
+
+
+class RoleTests(common.IdentityTests):
+
+    def test_role_create(self):
+        self._create_dummy_role()
+
+    def test_role_delete(self):
+        role_name = self._create_dummy_role(add_clean_up=False)
+        raw_output = self.openstack('role delete %s' % role_name)
+        self.assertEqual(0, len(raw_output))
+
+    def test_role_list(self):
+        self._create_dummy_role()
+        raw_output = self.openstack('role list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+
+    def test_role_list_with_user_project(self):
+        project_name = self._create_dummy_project()
+        role_name = self._create_dummy_role()
+        username = self._create_dummy_user()
+        raw_output = self.openstack(
+            'role add '
+            '--project %(project)s '
+            '--user %(user)s '
+            '%(role)s' % {'project': project_name,
+                          'user': username,
+                          'role': role_name})
+        self.addCleanup(
+            self.openstack,
+            'role remove '
+            '--project %(project)s '
+            '--user %(user)s '
+            '%(role)s' % {'project': project_name,
+                          'user': username,
+                          'role': role_name})
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
+
+        raw_output = self.openstack(
+            'role list '
+            '--project %(project)s '
+            '--user %(user)s '
+            '' % {'project': project_name,
+                  'user': username})
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+        self.assertEqual(1, len(items))
+
+    def test_role_show(self):
+        role_name = self._create_dummy_role()
+        raw_output = self.openstack('role show %s' % role_name)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
+
+    def test_role_add(self):
+        role_name = self._create_dummy_role()
+        username = self._create_dummy_user()
+        raw_output = self.openstack(
+            'role add '
+            '--project %(project)s '
+            '--user %(user)s '
+            '%(role)s' % {'project': self.project_name,
+                          'user': username,
+                          'role': role_name})
+        self.addCleanup(
+            self.openstack,
+            'role remove '
+            '--project %(project)s '
+            '--user %(user)s '
+            '%(role)s' % {'project': self.project_name,
+                          'user': username,
+                          'role': role_name})
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
+
+    def test_role_remove(self):
+        role_name = self._create_dummy_role()
+        username = self._create_dummy_user()
+        add_raw_output = self.openstack(
+            'role add '
+            '--project %(project)s '
+            '--user %(user)s '
+            '%(role)s' % {'project': self.project_name,
+                          'user': username,
+                          'role': role_name})
+        del_raw_output = self.openstack(
+            'role remove '
+            '--project %(project)s '
+            '--user %(user)s '
+            '%(role)s' % {'project': self.project_name,
+                          'user': username,
+                          'role': role_name})
+        items = self.parse_show(add_raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
+        self.assertEqual(0, len(del_raw_output))
diff --git a/openstackclient/tests/functional/identity/v2/test_service.py b/openstackclient/tests/functional/identity/v2/test_service.py
new file mode 100644
index 00000000..d0e03804
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v2/test_service.py
@@ -0,0 +1,44 @@
+#    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 openstackclient.tests.functional.identity.v2 import common
+
+
+class ServiceTests(common.IdentityTests):
+
+    def test_service_create(self):
+        self._create_dummy_service()
+
+    def test_service_delete(self):
+        service_name = self._create_dummy_service(add_clean_up=False)
+        raw_output = self.openstack('service delete %s' % service_name)
+        self.assertEqual(0, len(raw_output))
+
+    def test_service_multi_delete(self):
+        service_name_1 = self._create_dummy_service(add_clean_up=False)
+        service_name_2 = self._create_dummy_service(add_clean_up=False)
+        raw_output = self.openstack(
+            'service delete ' + service_name_1 + ' ' + service_name_2)
+        self.assertEqual(0, len(raw_output))
+
+    def test_service_list(self):
+        self._create_dummy_service()
+        raw_output = self.openstack('service list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+
+    def test_service_show(self):
+        service_name = self._create_dummy_service()
+        raw_output = self.openstack(
+            'service show %s' % service_name)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.SERVICE_FIELDS)
diff --git a/openstackclient/tests/functional/identity/v2/test_token.py b/openstackclient/tests/functional/identity/v2/test_token.py
new file mode 100644
index 00000000..f8569744
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v2/test_token.py
@@ -0,0 +1,24 @@
+#    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 openstackclient.tests.functional.identity.v2 import common
+
+
+class TokenTests(common.IdentityTests):
+
+    def test_token_issue(self):
+        self._create_dummy_token()
+
+    def test_token_revoke(self):
+        token_id = self._create_dummy_token(add_clean_up=False)
+        raw_output = self.openstack('token revoke %s' % token_id)
+        self.assertEqual(0, len(raw_output))
diff --git a/openstackclient/tests/functional/identity/v2/test_user.py b/openstackclient/tests/functional/identity/v2/test_user.py
new file mode 100644
index 00000000..ac609b94
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v2/test_user.py
@@ -0,0 +1,60 @@
+# 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 tempest.lib.common.utils import data_utils
+from tempest.lib import exceptions
+
+from openstackclient.tests.functional.identity.v2 import common
+
+
+class UserTests(common.IdentityTests):
+
+    def test_user_create(self):
+        self._create_dummy_user()
+
+    def test_user_delete(self):
+        username = self._create_dummy_user(add_clean_up=False)
+        raw_output = self.openstack('user delete %s' % username)
+        self.assertEqual(0, len(raw_output))
+
+    def test_user_list(self):
+        raw_output = self.openstack('user list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+
+    def test_user_set(self):
+        username = self._create_dummy_user()
+        raw_output = self.openstack('user show %s' % username)
+        user = self.parse_show_as_object(raw_output)
+        new_username = data_utils.rand_name('NewTestUser')
+        new_email = data_utils.rand_name() + '@example.com'
+        raw_output = self.openstack('user set '
+                                    '--email %(email)s '
+                                    '--name %(new_name)s '
+                                    '%(id)s' % {'email': new_email,
+                                                'new_name': new_username,
+                                                'id': user['id']})
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack('user show %s' % new_username)
+        new_user = self.parse_show_as_object(raw_output)
+        self.assertEqual(user['id'], new_user['id'])
+        self.assertEqual(new_email, new_user['email'])
+
+    def test_user_show(self):
+        username = self._create_dummy_user()
+        raw_output = self.openstack('user show %s' % username)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.USER_FIELDS)
+
+    def test_bad_user_command(self):
+        self.assertRaises(exceptions.CommandFailed,
+                          self.openstack, 'user unlist')
diff --git a/openstackclient/tests/functional/identity/v3/__init__.py b/openstackclient/tests/functional/identity/v3/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/__init__.py
diff --git a/openstackclient/tests/functional/identity/v3/common.py b/openstackclient/tests/functional/identity/v3/common.py
new file mode 100644
index 00000000..5dd42e70
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/common.py
@@ -0,0 +1,289 @@
+#    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 os
+
+from tempest.lib.common.utils import data_utils
+
+from openstackclient.tests.functional import base
+
+
+BASIC_LIST_HEADERS = ['ID', 'Name']
+
+
+class IdentityTests(base.TestCase):
+    """Functional tests for Identity commands. """
+
+    DOMAIN_FIELDS = ['description', 'enabled', 'id', 'name', 'links']
+    GROUP_FIELDS = ['description', 'domain_id', 'id', 'name', 'links']
+    TOKEN_FIELDS = ['expires', 'id', 'project_id', 'user_id']
+    USER_FIELDS = ['email', 'enabled', 'id', 'name', 'name',
+                   'domain_id', 'default_project_id', 'description',
+                   'password_expires_at']
+    PROJECT_FIELDS = ['description', 'id', 'domain_id', 'is_domain',
+                      'enabled', 'name', 'parent_id', 'links']
+    ROLE_FIELDS = ['id', 'name', 'links', 'domain_id']
+    SERVICE_FIELDS = ['id', 'enabled', 'name', 'type', 'description']
+    REGION_FIELDS = ['description', 'enabled', 'parent_region', 'region']
+    ENDPOINT_FIELDS = ['id', 'region', 'region_id', 'service_id',
+                       'service_name', 'service_type', 'enabled',
+                       'interface', 'url']
+
+    REGION_LIST_HEADERS = ['Region', 'Parent Region', 'Description']
+    ENDPOINT_LIST_HEADERS = ['ID', 'Region', 'Service Name', 'Service Type',
+                             'Enabled', 'Interface', 'URL']
+
+    IDENTITY_PROVIDER_FIELDS = ['description', 'enabled', 'id', 'remote_ids']
+    IDENTITY_PROVIDER_LIST_HEADERS = ['ID', 'Enabled', 'Description']
+
+    SERVICE_PROVIDER_FIELDS = ['auth_url', 'description', 'enabled',
+                               'id', 'relay_state_prefix', 'sp_url']
+    SERVICE_PROVIDER_LIST_HEADERS = ['ID', 'Enabled', 'Description',
+                                     'Auth URL']
+
+    @classmethod
+    def setUpClass(cls):
+        # prepare v3 env
+        os.environ['OS_IDENTITY_API_VERSION'] = '3'
+        auth_url = os.environ.get('OS_AUTH_URL')
+        auth_url = auth_url.replace('v2.0', 'v3')
+        os.environ['OS_AUTH_URL'] = auth_url
+
+        # create dummy domain
+        cls.domain_name = data_utils.rand_name('TestDomain')
+        cls.domain_description = data_utils.rand_name('description')
+        cls.openstack(
+            'domain create '
+            '--description %(description)s '
+            '--enable '
+            '%(name)s' % {'description': cls.domain_description,
+                          'name': cls.domain_name})
+
+        # create dummy project
+        cls.project_name = data_utils.rand_name('TestProject')
+        cls.project_description = data_utils.rand_name('description')
+        cls.openstack(
+            'project create '
+            '--domain %(domain)s '
+            '--description %(description)s '
+            '--enable '
+            '%(name)s' % {'domain': cls.domain_name,
+                          'description': cls.project_description,
+                          'name': cls.project_name})
+
+    @classmethod
+    def tearDownClass(cls):
+        # delete dummy project
+        cls.openstack('project delete %s' % cls.project_name)
+        # disable and delete dummy domain
+        cls.openstack('domain set --disable %s' % cls.domain_name)
+        cls.openstack('domain delete %s' % cls.domain_name)
+
+    def _create_dummy_user(self, add_clean_up=True):
+        username = data_utils.rand_name('TestUser')
+        password = data_utils.rand_name('password')
+        email = data_utils.rand_name() + '@example.com'
+        description = data_utils.rand_name('description')
+        raw_output = self.openstack(
+            'user create '
+            '--domain %(domain)s '
+            '--project %(project)s '
+            '--project-domain %(project_domain)s '
+            '--password %(password)s '
+            '--email %(email)s '
+            '--description %(description)s '
+            '--enable '
+            '%(name)s' % {'domain': self.domain_name,
+                          'project': self.project_name,
+                          'project_domain': self.domain_name,
+                          'email': email,
+                          'password': password,
+                          'description': description,
+                          'name': username})
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'user delete %s' % self.parse_show_as_object(raw_output)['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.USER_FIELDS)
+        return username
+
+    def _create_dummy_role(self, add_clean_up=True):
+        role_name = data_utils.rand_name('TestRole')
+        raw_output = self.openstack('role create %s' % role_name)
+        role = self.parse_show_as_object(raw_output)
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'role delete %s' % role['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
+        self.assertEqual(role_name, role['name'])
+        return role_name
+
+    def _create_dummy_group(self, add_clean_up=True):
+        group_name = data_utils.rand_name('TestGroup')
+        description = data_utils.rand_name('description')
+        raw_output = self.openstack(
+            'group create '
+            '--domain %(domain)s '
+            '--description %(description)s '
+            '%(name)s' % {'domain': self.domain_name,
+                          'description': description,
+                          'name': group_name})
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'group delete '
+                '--domain %(domain)s '
+                '%(name)s' % {'domain': self.domain_name,
+                              'name': group_name})
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.GROUP_FIELDS)
+        return group_name
+
+    def _create_dummy_domain(self, add_clean_up=True):
+        domain_name = data_utils.rand_name('TestDomain')
+        domain_description = data_utils.rand_name('description')
+        self.openstack(
+            'domain create '
+            '--description %(description)s '
+            '--enable %(name)s' % {'description': domain_description,
+                                   'name': domain_name})
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'domain delete %s' % domain_name
+            )
+            self.addCleanup(
+                self.openstack,
+                'domain set --disable %s' % domain_name
+            )
+        return domain_name
+
+    def _create_dummy_project(self, add_clean_up=True):
+        project_name = data_utils.rand_name('TestProject')
+        project_description = data_utils.rand_name('description')
+        self.openstack(
+            'project create '
+            '--domain %(domain)s '
+            '--description %(description)s '
+            '--enable %(name)s' % {'domain': self.domain_name,
+                                   'description': project_description,
+                                   'name': project_name})
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'project delete '
+                '--domain %(domain)s '
+                '%(name)s' % {'domain': self.domain_name,
+                              'name': project_name})
+        return project_name
+
+    def _create_dummy_region(self, parent_region=None, add_clean_up=True):
+        region_id = data_utils.rand_name('TestRegion')
+        description = data_utils.rand_name('description')
+        parent_region_arg = ''
+        if parent_region is not None:
+            parent_region_arg = '--parent-region %s' % parent_region
+        raw_output = self.openstack(
+            'region create '
+            '%(parent_region_arg)s '
+            '--description %(description)s '
+            '%(id)s' % {'parent_region_arg': parent_region_arg,
+                        'description': description,
+                        'id': region_id})
+        if add_clean_up:
+            self.addCleanup(self.openstack,
+                            'region delete %s' % region_id)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.REGION_FIELDS)
+        return region_id
+
+    def _create_dummy_service(self, add_clean_up=True):
+        service_name = data_utils.rand_name('TestService')
+        description = data_utils.rand_name('description')
+        type_name = data_utils.rand_name('TestType')
+        raw_output = self.openstack(
+            'service create '
+            '--name %(name)s '
+            '--description %(description)s '
+            '--enable '
+            '%(type)s' % {'name': service_name,
+                          'description': description,
+                          'type': type_name})
+        if add_clean_up:
+            service = self.parse_show_as_object(raw_output)
+            self.addCleanup(self.openstack,
+                            'service delete %s' % service['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.SERVICE_FIELDS)
+        return service_name
+
+    def _create_dummy_endpoint(self, interface='public', add_clean_up=True):
+        region_id = self._create_dummy_region()
+        service_name = self._create_dummy_service()
+        endpoint_url = data_utils.rand_url()
+        raw_output = self.openstack(
+            'endpoint create '
+            '--region %(region)s '
+            '--enable '
+            '%(service)s '
+            '%(interface)s '
+            '%(url)s' % {'region': region_id,
+                         'service': service_name,
+                         'interface': interface,
+                         'url': endpoint_url})
+        endpoint = self.parse_show_as_object(raw_output)
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'endpoint delete %s' % endpoint['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ENDPOINT_FIELDS)
+        return endpoint['id']
+
+    def _create_dummy_idp(self, add_clean_up=True):
+        identity_provider = data_utils.rand_name('IdentityProvider')
+        description = data_utils.rand_name('description')
+        raw_output = self.openstack(
+            'identity provider create '
+            ' %(name)s '
+            '--description %(description)s '
+            '--enable ' % {'name': identity_provider,
+                           'description': description})
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'identity provider delete %s' % identity_provider)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.IDENTITY_PROVIDER_FIELDS)
+        return identity_provider
+
+    def _create_dummy_sp(self, add_clean_up=True):
+        service_provider = data_utils.rand_name('ServiceProvider')
+        description = data_utils.rand_name('description')
+        raw_output = self.openstack(
+            'service provider create '
+            ' %(name)s '
+            '--description %(description)s '
+            '--auth-url https://sp.example.com:35357 '
+            '--service-provider-url https://sp.example.com:5000 '
+            '--enable ' % {'name': service_provider,
+                           'description': description})
+        if add_clean_up:
+            self.addCleanup(
+                self.openstack,
+                'service provider delete %s' % service_provider)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.SERVICE_PROVIDER_FIELDS)
+        return service_provider
diff --git a/openstackclient/tests/functional/identity/v3/test_catalog.py b/openstackclient/tests/functional/identity/v3/test_catalog.py
new file mode 100644
index 00000000..c8361406
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_catalog.py
@@ -0,0 +1,45 @@
+#    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 openstackclient.tests.functional.identity.v3 import common
+
+
+class CatalogTests(common.IdentityTests):
+
+    def test_catalog_list(self):
+        raw_output = self.openstack('catalog list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, ['Name', 'Type', 'Endpoints'])
+
+    def test_catalog_show(self):
+        """test catalog show command
+
+        The output example:
+        +-----------+----------------------------------------+
+        | Field     | Value                                  |
+        +-----------+----------------------------------------+
+        | endpoints | test1                                  |
+        |           |   public: http://localhost:5000/v2.0   |
+        |           | test1                                  |
+        |           |   internal: http://localhost:5000/v2.0 |
+        |           | test1                                  |
+        |           |   admin: http://localhost:35357/v2.0   |
+        |           |                                        |
+        | id        | e1e68b5ba21a43a39ff1cf58e736c3aa       |
+        | name      | keystone                               |
+        | type      | identity                               |
+        +-----------+----------------------------------------+
+        """
+        raw_output = self.openstack('catalog show %s' % 'identity')
+        items = self.parse_show(raw_output)
+        # items may have multiple endpoint urls with empty key
+        self.assert_show_fields(items, ['endpoints', 'name', 'type', '', 'id'])
diff --git a/openstackclient/tests/functional/identity/v3/test_domain.py b/openstackclient/tests/functional/identity/v3/test_domain.py
new file mode 100644
index 00000000..d8946d1e
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_domain.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.
+
+from tempest.lib.common.utils import data_utils
+from tempest.lib import exceptions
+
+from openstackclient.tests.functional.identity.v3 import common
+
+
+class DomainTests(common.IdentityTests):
+
+    def test_domain_create(self):
+        domain_name = data_utils.rand_name('TestDomain')
+        raw_output = self.openstack('domain create %s' % domain_name)
+        # disable domain first before deleting it
+        self.addCleanup(self.openstack,
+                        'domain delete %s' % domain_name)
+        self.addCleanup(self.openstack,
+                        'domain set --disable %s' % domain_name)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.DOMAIN_FIELDS)
+
+    def test_domain_list(self):
+        self._create_dummy_domain()
+        raw_output = self.openstack('domain list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+
+    def test_domain_delete(self):
+        domain_name = self._create_dummy_domain(add_clean_up=False)
+        # cannot delete enabled domain, disable it first
+        raw_output = self.openstack('domain set --disable %s' % domain_name)
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack('domain delete %s' % domain_name)
+        self.assertEqual(0, len(raw_output))
+
+    def test_domain_multi_delete(self):
+        domain_1 = self._create_dummy_domain(add_clean_up=False)
+        domain_2 = self._create_dummy_domain(add_clean_up=False)
+        # cannot delete enabled domain, disable it first
+        raw_output = self.openstack('domain set --disable %s' % domain_1)
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack('domain set --disable %s' % domain_2)
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack(
+            'domain delete %s %s' % (domain_1, domain_2))
+        self.assertEqual(0, len(raw_output))
+
+    def test_domain_delete_failure(self):
+        domain_name = self._create_dummy_domain()
+        # cannot delete enabled domain
+        self.assertRaises(exceptions.CommandFailed,
+                          self.openstack,
+                          'domain delete %s' % domain_name)
+
+    def test_domain_show(self):
+        domain_name = self._create_dummy_domain()
+        raw_output = self.openstack('domain show %s' % domain_name)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.DOMAIN_FIELDS)
diff --git a/openstackclient/tests/functional/identity/v3/test_endpoint.py b/openstackclient/tests/functional/identity/v3/test_endpoint.py
new file mode 100644
index 00000000..22dc1b65
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_endpoint.py
@@ -0,0 +1,67 @@
+#    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 tempest.lib.common.utils import data_utils
+
+from openstackclient.tests.functional.identity.v3 import common
+
+
+class EndpointTests(common.IdentityTests):
+
+    def test_endpoint_create(self):
+        self._create_dummy_endpoint(interface='public')
+        self._create_dummy_endpoint(interface='admin')
+        self._create_dummy_endpoint(interface='internal')
+
+    def test_endpoint_delete(self):
+        endpoint_id = self._create_dummy_endpoint(add_clean_up=False)
+        raw_output = self.openstack(
+            'endpoint delete %s' % endpoint_id)
+        self.assertEqual(0, len(raw_output))
+
+    def test_endpoint_multi_delete(self):
+        endpoint_1 = self._create_dummy_endpoint(add_clean_up=False)
+        endpoint_2 = self._create_dummy_endpoint(add_clean_up=False)
+        raw_output = self.openstack(
+            'endpoint delete %s %s' % (endpoint_1, endpoint_2))
+        self.assertEqual(0, len(raw_output))
+
+    def test_endpoint_list(self):
+        endpoint_id = self._create_dummy_endpoint()
+        raw_output = self.openstack('endpoint list')
+        self.assertIn(endpoint_id, raw_output)
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.ENDPOINT_LIST_HEADERS)
+
+    def test_endpoint_set(self):
+        endpoint_id = self._create_dummy_endpoint()
+        new_endpoint_url = data_utils.rand_url()
+        raw_output = self.openstack(
+            'endpoint set '
+            '--interface %(interface)s '
+            '--url %(url)s '
+            '--disable '
+            '%(endpoint_id)s' % {'interface': 'admin',
+                                 'url': new_endpoint_url,
+                                 'endpoint_id': endpoint_id})
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack('endpoint show %s' % endpoint_id)
+        endpoint = self.parse_show_as_object(raw_output)
+        self.assertEqual('admin', endpoint['interface'])
+        self.assertEqual(new_endpoint_url, endpoint['url'])
+        self.assertEqual('False', endpoint['enabled'])
+
+    def test_endpoint_show(self):
+        endpoint_id = self._create_dummy_endpoint()
+        raw_output = self.openstack('endpoint show %s' % endpoint_id)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ENDPOINT_FIELDS)
diff --git a/openstackclient/tests/functional/identity/v3/test_group.py b/openstackclient/tests/functional/identity/v3/test_group.py
new file mode 100644
index 00000000..70491183
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_group.py
@@ -0,0 +1,178 @@
+#    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 tempest.lib.common.utils import data_utils
+
+from openstackclient.tests.functional.identity.v3 import common
+
+
+class GroupTests(common.IdentityTests):
+
+    def test_group_create(self):
+        self._create_dummy_group()
+
+    def test_group_list(self):
+        group_name = self._create_dummy_group()
+        raw_output = self.openstack('group list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+        self.assertIn(group_name, raw_output)
+
+    def test_group_list_with_domain(self):
+        group_name = self._create_dummy_group()
+        raw_output = self.openstack(
+            'group list --domain %s' % self.domain_name)
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+        self.assertIn(group_name, raw_output)
+
+    def test_group_delete(self):
+        group_name = self._create_dummy_group(add_clean_up=False)
+        raw_output = self.openstack(
+            'group delete '
+            '--domain %(domain)s '
+            '%(name)s' % {'domain': self.domain_name,
+                          'name': group_name})
+        self.assertEqual(0, len(raw_output))
+
+    def test_group_show(self):
+        group_name = self._create_dummy_group()
+        raw_output = self.openstack(
+            'group show '
+            '--domain %(domain)s '
+            '%(name)s' % {'domain': self.domain_name,
+                          'name': group_name})
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.GROUP_FIELDS)
+
+    def test_group_set(self):
+        group_name = self._create_dummy_group()
+        new_group_name = data_utils.rand_name('NewTestGroup')
+        raw_output = self.openstack(
+            'group set '
+            '--domain %(domain)s '
+            '--name %(new_group)s '
+            '%(group)s' % {'domain': self.domain_name,
+                           'new_group': new_group_name,
+                           'group': group_name})
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack(
+            'group show '
+            '--domain %(domain)s '
+            '%(group)s' % {'domain': self.domain_name,
+                           'group': new_group_name})
+        group = self.parse_show_as_object(raw_output)
+        self.assertEqual(new_group_name, group['name'])
+        # reset group name to make sure it will be cleaned up
+        raw_output = self.openstack(
+            'group set '
+            '--domain %(domain)s '
+            '--name %(new_group)s '
+            '%(group)s' % {'domain': self.domain_name,
+                           'new_group': group_name,
+                           'group': new_group_name})
+        self.assertEqual(0, len(raw_output))
+
+    def test_group_add_user(self):
+        group_name = self._create_dummy_group()
+        username = self._create_dummy_user()
+        raw_output = self.openstack(
+            'group add user '
+            '--group-domain %(group_domain)s '
+            '--user-domain %(user_domain)s '
+            '%(group)s %(user)s' % {'group_domain': self.domain_name,
+                                    'user_domain': self.domain_name,
+                                    'group': group_name,
+                                    'user': username})
+        self.addCleanup(
+            self.openstack,
+            'group remove user '
+            '--group-domain %(group_domain)s '
+            '--user-domain %(user_domain)s '
+            '%(group)s %(user)s' % {'group_domain': self.domain_name,
+                                    'user_domain': self.domain_name,
+                                    'group': group_name,
+                                    'user': username})
+        self.assertEqual(
+            '%(user)s added to group %(group)s\n' % {'user': username,
+                                                     'group': group_name},
+            raw_output
+        )
+
+    def test_group_contains_user(self):
+        group_name = self._create_dummy_group()
+        username = self._create_dummy_user()
+        raw_output = self.openstack(
+            'group add user '
+            '--group-domain %(group_domain)s '
+            '--user-domain %(user_domain)s '
+            '%(group)s %(user)s' % {'group_domain': self.domain_name,
+                                    'user_domain': self.domain_name,
+                                    'group': group_name,
+                                    'user': username})
+        self.addCleanup(
+            self.openstack,
+            'group remove user '
+            '--group-domain %(group_domain)s '
+            '--user-domain %(user_domain)s '
+            '%(group)s %(user)s' % {'group_domain': self.domain_name,
+                                    'user_domain': self.domain_name,
+                                    'group': group_name,
+                                    'user': username})
+        self.assertEqual(
+            '%(user)s added to group %(group)s\n' % {'user': username,
+                                                     'group': group_name},
+            raw_output
+        )
+        raw_output = self.openstack(
+            'group contains user '
+            '--group-domain %(group_domain)s '
+            '--user-domain %(user_domain)s '
+            '%(group)s %(user)s' % {'group_domain': self.domain_name,
+                                    'user_domain': self.domain_name,
+                                    'group': group_name,
+                                    'user': username})
+        self.assertEqual(
+            '%(user)s in group %(group)s\n' % {'user': username,
+                                               'group': group_name},
+            raw_output)
+
+    def test_group_remove_user(self):
+        group_name = self._create_dummy_group()
+        username = self._create_dummy_user()
+        add_raw_output = self.openstack(
+            'group add user '
+            '--group-domain %(group_domain)s '
+            '--user-domain %(user_domain)s '
+            '%(group)s %(user)s' % {'group_domain': self.domain_name,
+                                    'user_domain': self.domain_name,
+                                    'group': group_name,
+                                    'user': username})
+        remove_raw_output = self.openstack(
+            'group remove user '
+            '--group-domain %(group_domain)s '
+            '--user-domain %(user_domain)s '
+            '%(group)s %(user)s' % {'group_domain': self.domain_name,
+                                    'user_domain': self.domain_name,
+                                    'group': group_name,
+                                    'user': username})
+        self.assertEqual(
+            '%(user)s added to group %(group)s\n' % {'user': username,
+                                                     'group': group_name},
+            add_raw_output
+        )
+        self.assertEqual(
+            '%(user)s removed from '
+            'group %(group)s\n' % {'user': username,
+                                   'group': group_name},
+            remove_raw_output
+        )
diff --git a/openstackclient/tests/functional/identity/v3/test_idp.py b/openstackclient/tests/functional/identity/v3/test_idp.py
new file mode 100644
index 00000000..f9d8cb80
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_idp.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.
+
+from openstackclient.tests.functional.identity.v3 import common
+from tempest.lib.common.utils import data_utils
+
+
+class IdentityProviderTests(common.IdentityTests):
+    # Introduce functional test case for command 'Identity Provider'
+
+    def test_idp_create(self):
+        self._create_dummy_idp()
+
+    def test_idp_delete(self):
+        identity_provider = self._create_dummy_idp(add_clean_up=False)
+        raw_output = self.openstack('identity provider delete %s'
+                                    % identity_provider)
+        self.assertEqual(0, len(raw_output))
+
+    def test_idp_multi_delete(self):
+        idp_1 = self._create_dummy_idp(add_clean_up=False)
+        idp_2 = self._create_dummy_idp(add_clean_up=False)
+        raw_output = self.openstack(
+            'identity provider delete %s %s' % (idp_1, idp_2))
+        self.assertEqual(0, len(raw_output))
+
+    def test_idp_show(self):
+        identity_provider = self._create_dummy_idp(add_clean_up=True)
+        raw_output = self.openstack('identity provider show %s'
+                                    % identity_provider)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.IDENTITY_PROVIDER_FIELDS)
+
+    def test_idp_list(self):
+        self._create_dummy_idp(add_clean_up=True)
+        raw_output = self.openstack('identity provider list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.IDENTITY_PROVIDER_LIST_HEADERS)
+
+    def test_idp_set(self):
+        identity_provider = self._create_dummy_idp(add_clean_up=True)
+        new_remoteid = data_utils.rand_name('newRemoteId')
+        raw_output = self.openstack('identity provider set '
+                                    '%(identity-provider)s '
+                                    '--remote-id %(remote-id)s '
+                                    % {'identity-provider': identity_provider,
+                                       'remote-id': new_remoteid})
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack('identity provider show %s'
+                                    % identity_provider)
+        updated_value = self.parse_show_as_object(raw_output)
+        self.assertIn(new_remoteid, updated_value['remote_ids'])
diff --git a/openstackclient/tests/functional/identity/v3/test_project.py b/openstackclient/tests/functional/identity/v3/test_project.py
new file mode 100644
index 00000000..77438841
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_project.py
@@ -0,0 +1,113 @@
+#    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 tempest.lib.common.utils import data_utils
+
+from openstackclient.tests.functional.identity.v3 import common
+
+
+class ProjectTests(common.IdentityTests):
+
+    def test_project_create(self):
+        project_name = data_utils.rand_name('TestProject')
+        description = data_utils.rand_name('description')
+        raw_output = self.openstack(
+            'project create '
+            '--domain %(domain)s '
+            '--description %(description)s '
+            '--enable '
+            '--property k1=v1 '
+            '--property k2=v2 '
+            '%(name)s' % {'domain': self.domain_name,
+                          'description': description,
+                          'name': project_name})
+        self.addCleanup(
+            self.openstack,
+            'project delete '
+            '--domain %(domain)s '
+            '%(name)s' % {'domain': self.domain_name,
+                          'name': project_name}
+        )
+        items = self.parse_show(raw_output)
+        show_fields = list(self.PROJECT_FIELDS)
+        show_fields.extend(['k1', 'k2'])
+        self.assert_show_fields(items, show_fields)
+        project = self.parse_show_as_object(raw_output)
+        self.assertEqual('v1', project['k1'])
+        self.assertEqual('v2', project['k2'])
+
+    def test_project_delete(self):
+        project_name = self._create_dummy_project(add_clean_up=False)
+        raw_output = self.openstack(
+            'project delete '
+            '--domain %(domain)s '
+            '%(name)s' % {'domain': self.domain_name,
+                          'name': project_name})
+        self.assertEqual(0, len(raw_output))
+
+    def test_project_list(self):
+        raw_output = self.openstack('project list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+
+    def test_project_list_with_domain(self):
+        project_name = self._create_dummy_project()
+        raw_output = self.openstack(
+            'project list --domain %s' % self.domain_name)
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+        self.assertIn(project_name, raw_output)
+        self.assertTrue(len(items) > 0)
+
+    def test_project_set(self):
+        project_name = self._create_dummy_project()
+        new_project_name = data_utils.rand_name('NewTestProject')
+        raw_output = self.openstack(
+            'project set '
+            '--name %(new_name)s '
+            '--disable '
+            '--property k0=v0 '
+            '%(name)s' % {'new_name': new_project_name,
+                          'domain': self.domain_name,
+                          'name': project_name})
+        self.assertEqual(0, len(raw_output))
+        # check project details
+        raw_output = self.openstack(
+            'project show '
+            '--domain %(domain)s '
+            '%(name)s' % {'domain': self.domain_name,
+                          'name': new_project_name}
+        )
+        items = self.parse_show(raw_output)
+        fields = list(self.PROJECT_FIELDS)
+        fields.extend(['k0'])
+        self.assert_show_fields(items, fields)
+        project = self.parse_show_as_object(raw_output)
+        self.assertEqual(new_project_name, project['name'])
+        self.assertEqual('False', project['enabled'])
+        self.assertEqual('v0', project['k0'])
+        # reset project to make sure it will be cleaned up
+        self.openstack(
+            'project set '
+            '--name %(new_name)s '
+            '--enable '
+            '%(name)s' % {'new_name': project_name,
+                          'name': new_project_name})
+
+    def test_project_show(self):
+        raw_output = self.openstack(
+            'project show '
+            '--domain %(domain)s '
+            '%(name)s' % {'domain': self.domain_name,
+                          'name': self.project_name})
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.PROJECT_FIELDS)
diff --git a/openstackclient/tests/functional/identity/v3/test_region.py b/openstackclient/tests/functional/identity/v3/test_region.py
new file mode 100644
index 00000000..2a402bd1
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_region.py
@@ -0,0 +1,70 @@
+# 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 openstackclient.tests.functional.identity.v3 import common
+
+
+class RegionTests(common.IdentityTests):
+
+    def test_region_create(self):
+        self._create_dummy_region()
+
+    def test_region_create_with_parent_region(self):
+        parent_region_id = self._create_dummy_region()
+        self._create_dummy_region(parent_region=parent_region_id)
+
+    def test_region_delete(self):
+        region_id = self._create_dummy_region(add_clean_up=False)
+        raw_output = self.openstack('region delete %s' % region_id)
+        self.assertEqual(0, len(raw_output))
+
+    def test_region_multi_delete(self):
+        region_1 = self._create_dummy_region(add_clean_up=False)
+        region_2 = self._create_dummy_region(add_clean_up=False)
+        raw_output = self.openstack(
+            'region delete %s %s' % (region_1, region_2))
+        self.assertEqual(0, len(raw_output))
+
+    def test_region_list(self):
+        raw_output = self.openstack('region list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.REGION_LIST_HEADERS)
+
+    def test_region_set(self):
+        # prepare region with parent-region
+        parent_region_id = self._create_dummy_region()
+        new_parent_region_id = self._create_dummy_region()
+        region_id = self._create_dummy_region(parent_region_id)
+        # check region details
+        raw_output = self.openstack('region show %s' % region_id)
+        region = self.parse_show_as_object(raw_output)
+        self.assertEqual(parent_region_id, region['parent_region'])
+        self.assertEqual(region_id, region['region'])
+        # update parent-region
+        raw_output = self.openstack(
+            'region set '
+            '--parent-region %(parent_region)s '
+            '%(region)s' % {'parent_region': new_parent_region_id,
+                            'region': region_id})
+        self.assertEqual(0, len(raw_output))
+        # check updated region details
+        raw_output = self.openstack('region show %s' % region_id)
+        region = self.parse_show_as_object(raw_output)
+        self.assertEqual(new_parent_region_id, region['parent_region'])
+        self.assertEqual(region_id, region['region'])
+
+    def test_region_show(self):
+        region_id = self._create_dummy_region()
+        raw_output = self.openstack('region show %s' % region_id)
+        region = self.parse_show_as_object(raw_output)
+        self.assertEqual(region_id, region['region'])
+        self.assertEqual('None', region['parent_region'])
diff --git a/openstackclient/tests/functional/identity/v3/test_role.py b/openstackclient/tests/functional/identity/v3/test_role.py
new file mode 100644
index 00000000..ab8af9c0
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_role.py
@@ -0,0 +1,145 @@
+#    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 tempest.lib.common.utils import data_utils
+
+from openstackclient.tests.functional.identity.v3 import common
+
+
+class RoleTests(common.IdentityTests):
+
+    def test_role_create(self):
+        self._create_dummy_role()
+
+    def test_role_delete(self):
+        role_name = self._create_dummy_role(add_clean_up=False)
+        raw_output = self.openstack('role delete %s' % role_name)
+        self.assertEqual(0, len(raw_output))
+
+    def test_role_list(self):
+        self._create_dummy_role()
+        raw_output = self.openstack('role list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+
+    def test_role_list_with_user_project(self):
+        role_name = self._create_dummy_role()
+        username = self._create_dummy_user()
+        raw_output = self.openstack(
+            'role add '
+            '--project %(project)s '
+            '--project-domain %(project_domain)s '
+            '--user %(user)s '
+            '--user-domain %(user_domain)s '
+            '%(role)s' % {'project': self.project_name,
+                          'project_domain': self.domain_name,
+                          'user': username,
+                          'user_domain': self.domain_name,
+                          'role': role_name})
+        self.addCleanup(
+            self.openstack,
+            'role remove '
+            '--project %(project)s '
+            '--project-domain %(project_domain)s '
+            '--user %(user)s '
+            '--user-domain %(user_domain)s '
+            '%(role)s' % {'project': self.project_name,
+                          'project_domain': self.domain_name,
+                          'user': username,
+                          'user_domain': self.domain_name,
+                          'role': role_name})
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack(
+            'role list '
+            '--project %(project)s '
+            '--project-domain %(project_domain)s '
+            '--user %(user)s '
+            '--user-domain %(user_domain)s '
+            '' % {'project': self.project_name,
+                  'project_domain': self.domain_name,
+                  'user': username,
+                  'user_domain': self.domain_name})
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+        self.assertEqual(1, len(items))
+
+    def test_role_show(self):
+        role_name = self._create_dummy_role()
+        raw_output = self.openstack('role show %s' % role_name)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
+
+    def test_role_set(self):
+        role_name = self._create_dummy_role()
+        new_role_name = data_utils.rand_name('NewTestRole')
+        raw_output = self.openstack(
+            'role set --name %s %s' % (new_role_name, role_name))
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack('role show %s' % new_role_name)
+        role = self.parse_show_as_object(raw_output)
+        self.assertEqual(new_role_name, role['name'])
+
+    def test_role_add(self):
+        role_name = self._create_dummy_role()
+        username = self._create_dummy_user()
+        raw_output = self.openstack(
+            'role add '
+            '--project %(project)s '
+            '--project-domain %(project_domain)s '
+            '--user %(user)s '
+            '--user-domain %(user_domain)s '
+            '%(role)s' % {'project': self.project_name,
+                          'project_domain': self.domain_name,
+                          'user': username,
+                          'user_domain': self.domain_name,
+                          'role': role_name})
+        self.addCleanup(
+            self.openstack,
+            'role remove '
+            '--project %(project)s '
+            '--project-domain %(project_domain)s '
+            '--user %(user)s '
+            '--user-domain %(user_domain)s '
+            '%(role)s' % {'project': self.project_name,
+                          'project_domain': self.domain_name,
+                          'user': username,
+                          'user_domain': self.domain_name,
+                          'role': role_name})
+        self.assertEqual(0, len(raw_output))
+
+    def test_role_remove(self):
+        role_name = self._create_dummy_role()
+        username = self._create_dummy_user()
+        add_raw_output = self.openstack(
+            'role add '
+            '--project %(project)s '
+            '--project-domain %(project_domain)s '
+            '--user %(user)s '
+            '--user-domain %(user_domain)s '
+            '%(role)s' % {'project': self.project_name,
+                          'project_domain': self.domain_name,
+                          'user': username,
+                          'user_domain': self.domain_name,
+                          'role': role_name})
+        remove_raw_output = self.openstack(
+            'role remove '
+            '--project %(project)s '
+            '--project-domain %(project_domain)s '
+            '--user %(user)s '
+            '--user-domain %(user_domain)s '
+            '%(role)s' % {'project': self.project_name,
+                          'project_domain': self.domain_name,
+                          'user': username,
+                          'user_domain': self.domain_name,
+                          'role': role_name})
+        self.assertEqual(0, len(add_raw_output))
+        self.assertEqual(0, len(remove_raw_output))
diff --git a/openstackclient/tests/functional/identity/v3/test_service.py b/openstackclient/tests/functional/identity/v3/test_service.py
new file mode 100644
index 00000000..1ecda45a
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_service.py
@@ -0,0 +1,71 @@
+#    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 tempest.lib.common.utils import data_utils
+
+from openstackclient.tests.functional.identity.v3 import common
+
+
+class ServiceTests(common.IdentityTests):
+
+    def test_service_create(self):
+        self._create_dummy_service()
+
+    def test_service_delete(self):
+        service_name = self._create_dummy_service(add_clean_up=False)
+        raw_output = self.openstack('service delete %s' % service_name)
+        self.assertEqual(0, len(raw_output))
+
+    def test_service_multi_delete(self):
+        service_1 = self._create_dummy_service(add_clean_up=False)
+        service_2 = self._create_dummy_service(add_clean_up=False)
+        raw_output = self.openstack(
+            'service delete %s %s' % (service_1, service_2))
+        self.assertEqual(0, len(raw_output))
+
+    def test_service_list(self):
+        self._create_dummy_service()
+        raw_output = self.openstack('service list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+
+    def test_service_set(self):
+        service_name = self._create_dummy_service()
+        # set service
+        new_service_name = data_utils.rand_name('NewTestService')
+        new_service_description = data_utils.rand_name('description')
+        new_service_type = data_utils.rand_name('NewTestType')
+        raw_output = self.openstack(
+            'service set '
+            '--type %(type)s '
+            '--name %(name)s '
+            '--description %(description)s '
+            '--disable '
+            '%(service)s' % {'type': new_service_type,
+                             'name': new_service_name,
+                             'description': new_service_description,
+                             'service': service_name})
+        self.assertEqual(0, len(raw_output))
+        # get service details
+        raw_output = self.openstack('service show %s' % new_service_name)
+        # assert service details
+        service = self.parse_show_as_object(raw_output)
+        self.assertEqual(new_service_type, service['type'])
+        self.assertEqual(new_service_name, service['name'])
+        self.assertEqual(new_service_description, service['description'])
+
+    def test_service_show(self):
+        service_name = self._create_dummy_service()
+        raw_output = self.openstack(
+            'service show %s' % service_name)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.SERVICE_FIELDS)
diff --git a/openstackclient/tests/functional/identity/v3/test_service_provider.py b/openstackclient/tests/functional/identity/v3/test_service_provider.py
new file mode 100644
index 00000000..e072bc93
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_service_provider.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.
+
+from openstackclient.tests.functional.identity.v3 import common
+from tempest.lib.common.utils import data_utils
+
+
+class ServiceProviderTests(common.IdentityTests):
+    # Introduce functional test cases for command 'Service Provider'
+
+    def test_sp_create(self):
+        self._create_dummy_sp(add_clean_up=True)
+
+    def test_sp_delete(self):
+        service_provider = self._create_dummy_sp(add_clean_up=False)
+        raw_output = self.openstack('service provider delete %s'
+                                    % service_provider)
+        self.assertEqual(0, len(raw_output))
+
+    def test_sp_multi_delete(self):
+        sp1 = self._create_dummy_sp(add_clean_up=False)
+        sp2 = self._create_dummy_sp(add_clean_up=False)
+        raw_output = self.openstack(
+            'service provider delete %s %s' % (sp1, sp2))
+        self.assertEqual(0, len(raw_output))
+
+    def test_sp_show(self):
+        service_provider = self._create_dummy_sp(add_clean_up=True)
+        raw_output = self.openstack('service provider show %s'
+                                    % service_provider)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.SERVICE_PROVIDER_FIELDS)
+
+    def test_sp_list(self):
+        self._create_dummy_sp(add_clean_up=True)
+        raw_output = self.openstack('service provider list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, self.SERVICE_PROVIDER_LIST_HEADERS)
+
+    def test_sp_set(self):
+        service_provider = self._create_dummy_sp(add_clean_up=True)
+        new_description = data_utils.rand_name('newDescription')
+        raw_output = self.openstack('service provider set '
+                                    '%(service-provider)s '
+                                    '--description %(description)s '
+                                    % {'service-provider': service_provider,
+                                       'description': new_description})
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack('service provider show %s'
+                                    % service_provider)
+        updated_value = self.parse_show_as_object(raw_output)
+        self.assertIn(new_description, updated_value['description'])
diff --git a/openstackclient/tests/functional/identity/v3/test_token.py b/openstackclient/tests/functional/identity/v3/test_token.py
new file mode 100644
index 00000000..62e90003
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_token.py
@@ -0,0 +1,21 @@
+#    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 openstackclient.tests.functional.identity.v3 import common
+
+
+class TokenTests(common.IdentityTests):
+
+    def test_token_issue(self):
+        raw_output = self.openstack('token issue')
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.TOKEN_FIELDS)
diff --git a/openstackclient/tests/functional/identity/v3/test_user.py b/openstackclient/tests/functional/identity/v3/test_user.py
new file mode 100644
index 00000000..9e9bde96
--- /dev/null
+++ b/openstackclient/tests/functional/identity/v3/test_user.py
@@ -0,0 +1,101 @@
+#    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 tempest.lib.common.utils import data_utils
+
+from openstackclient.tests.functional.identity.v3 import common
+
+
+class UserTests(common.IdentityTests):
+
+    def test_user_create(self):
+        self._create_dummy_user()
+
+    def test_user_delete(self):
+        username = self._create_dummy_user(add_clean_up=False)
+        raw_output = self.openstack('user delete '
+                                    '--domain %(domain)s '
+                                    '%(name)s' % {'domain': self.domain_name,
+                                                  'name': username})
+        self.assertEqual(0, len(raw_output))
+
+    def test_user_list(self):
+        raw_output = self.openstack('user list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, common.BASIC_LIST_HEADERS)
+
+    def test_user_set(self):
+        username = self._create_dummy_user()
+        raw_output = self.openstack('user show '
+                                    '--domain %(domain)s '
+                                    '%(name)s' % {'domain': self.domain_name,
+                                                  'name': username})
+        user = self.parse_show_as_object(raw_output)
+        new_username = data_utils.rand_name('NewTestUser')
+        new_email = data_utils.rand_name() + '@example.com'
+        raw_output = self.openstack('user set '
+                                    '--email %(email)s '
+                                    '--name %(new_name)s '
+                                    '%(id)s' % {'email': new_email,
+                                                'new_name': new_username,
+                                                'id': user['id']})
+        self.assertEqual(0, len(raw_output))
+        raw_output = self.openstack('user show '
+                                    '--domain %(domain)s '
+                                    '%(name)s' % {'domain': self.domain_name,
+                                                  'name': new_username})
+        updated_user = self.parse_show_as_object(raw_output)
+        self.assertEqual(user['id'], updated_user['id'])
+        self.assertEqual(new_email, updated_user['email'])
+
+    def test_user_set_default_project_id(self):
+        username = self._create_dummy_user()
+        project_name = self._create_dummy_project()
+        # get original user details
+        raw_output = self.openstack('user show '
+                                    '--domain %(domain)s '
+                                    '%(name)s' % {'domain': self.domain_name,
+                                                  'name': username})
+        user = self.parse_show_as_object(raw_output)
+        # update user
+        raw_output = self.openstack('user set '
+                                    '--project %(project)s '
+                                    '--project-domain %(project_domain)s '
+                                    '%(id)s' % {'project': project_name,
+                                                'project_domain':
+                                                    self.domain_name,
+                                                'id': user['id']})
+        self.assertEqual(0, len(raw_output))
+        # get updated user details
+        raw_output = self.openstack('user show '
+                                    '--domain %(domain)s '
+                                    '%(name)s' % {'domain': self.domain_name,
+                                                  'name': username})
+        updated_user = self.parse_show_as_object(raw_output)
+        # get project details
+        raw_output = self.openstack('project show '
+                                    '--domain %(domain)s '
+                                    '%(name)s' % {'domain': self.domain_name,
+                                                  'name': project_name})
+        project = self.parse_show_as_object(raw_output)
+        # check updated user details
+        self.assertEqual(user['id'], updated_user['id'])
+        self.assertEqual(project['id'], updated_user['default_project_id'])
+
+    def test_user_show(self):
+        username = self._create_dummy_user()
+        raw_output = self.openstack('user show '
+                                    '--domain %(domain)s '
+                                    '%(name)s' % {'domain': self.domain_name,
+                                                  'name': username})
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.USER_FIELDS)
diff --git a/openstackclient/tests/functional/image/__init__.py b/openstackclient/tests/functional/image/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/image/__init__.py
diff --git a/openstackclient/tests/functional/image/v1/__init__.py b/openstackclient/tests/functional/image/v1/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/image/v1/__init__.py
diff --git a/openstackclient/tests/functional/image/v1/test_image.py b/openstackclient/tests/functional/image/v1/test_image.py
new file mode 100644
index 00000000..2a2b5734
--- /dev/null
+++ b/openstackclient/tests/functional/image/v1/test_image.py
@@ -0,0 +1,67 @@
+#    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 os
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class ImageTests(base.TestCase):
+    """Functional tests for image. """
+
+    NAME = uuid.uuid4().hex
+    OTHER_NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        os.environ['OS_IMAGE_API_VERSION'] = '1'
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('image create ' + cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        # Rename test
+        raw_output = cls.openstack('image set --name ' + cls.OTHER_NAME + ' '
+                                   + cls.NAME)
+        cls.assertOutput('', raw_output)
+        # Delete test
+        raw_output = cls.openstack('image delete ' + cls.OTHER_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_image_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('image list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_image_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('image show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
+
+    def test_image_set(self):
+        opts = self.get_opts([
+            "disk_format", "is_public", "min_disk", "min_ram", "name"])
+        self.openstack('image set --min-disk 4 --min-ram 5 ' +
+                       '--disk-format qcow2  --public ' + self.NAME)
+        raw_output = self.openstack('image show ' + self.NAME + opts)
+        self.assertEqual("qcow2\nTrue\n4\n5\n" + self.NAME + '\n', raw_output)
+
+    def test_image_metadata(self):
+        opts = self.get_opts(["name", "properties"])
+        self.openstack('image set --property a=b --property c=d ' + self.NAME)
+        raw_output = self.openstack('image show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\na='b', c='d'\n", raw_output)
diff --git a/openstackclient/tests/functional/image/v2/__init__.py b/openstackclient/tests/functional/image/v2/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/image/v2/__init__.py
diff --git a/openstackclient/tests/functional/image/v2/test_image.py b/openstackclient/tests/functional/image/v2/test_image.py
new file mode 100644
index 00000000..3f432b02
--- /dev/null
+++ b/openstackclient/tests/functional/image/v2/test_image.py
@@ -0,0 +1,76 @@
+#    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 os
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class ImageTests(base.TestCase):
+    """Functional tests for image. """
+
+    NAME = uuid.uuid4().hex
+    OTHER_NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        os.environ['OS_IMAGE_API_VERSION'] = '2'
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('image create ' + cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        # Rename test
+        raw_output = cls.openstack('image set --name ' + cls.OTHER_NAME + ' '
+                                   + cls.NAME)
+        cls.assertOutput('', raw_output)
+        # Delete test
+        raw_output = cls.openstack('image delete ' + cls.OTHER_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_image_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('image list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_image_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('image show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
+
+    def test_image_set(self):
+        opts = self.get_opts([
+            "disk_format", "visibility", "min_disk", "min_ram", "name"])
+        self.openstack('image set --min-disk 4 --min-ram 5 ' +
+                       '--public ' + self.NAME)
+        raw_output = self.openstack('image show ' + self.NAME + opts)
+        self.assertEqual("raw\n4\n5\n" + self.NAME + '\npublic\n', raw_output)
+
+    def test_image_metadata(self):
+        opts = self.get_opts(["name", "properties"])
+        self.openstack('image set --property a=b --property c=d ' + self.NAME)
+        raw_output = self.openstack('image show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\na='b', c='d'\n", raw_output)
+
+    def test_image_unset(self):
+        opts = self.get_opts(["name", "tags", "properties"])
+        self.openstack('image set --tag 01 ' + self.NAME)
+        self.openstack('image unset --tag 01 ' + self.NAME)
+        # test_image_metadata has set image properties "a" and "c"
+        self.openstack('image unset --property a --property c ' + self.NAME)
+        raw_output = self.openstack('image show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n\n", raw_output)
diff --git a/openstackclient/tests/functional/network/__init__.py b/openstackclient/tests/functional/network/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/network/__init__.py
diff --git a/openstackclient/tests/functional/network/v2/__init__.py b/openstackclient/tests/functional/network/v2/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/__init__.py
diff --git a/openstackclient/tests/functional/network/v2/test_address_scope.py b/openstackclient/tests/functional/network/v2/test_address_scope.py
new file mode 100644
index 00000000..ef4b5756
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_address_scope.py
@@ -0,0 +1,49 @@
+#    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 AddressScopeTests(base.TestCase):
+    """Functional tests for address scope. """
+    NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('address scope create ' + cls.NAME + opts)
+        cls.assertOutput(cls.NAME + "\n", raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('address scope delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_address_scope_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('address scope list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_address_scope_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('address scope show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
+
+    def test_address_scope_set(self):
+        self.openstack('address scope set --share ' + self.NAME)
+        opts = self.get_opts(['shared'])
+        raw_output = self.openstack('address scope show ' + self.NAME + opts)
+        self.assertEqual("True\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_floating_ip.py b/openstackclient/tests/functional/network/v2/test_floating_ip.py
new file mode 100644
index 00000000..f3a1971f
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_floating_ip.py
@@ -0,0 +1,58 @@
+#    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 FloatingIpTests(base.TestCase):
+    """Functional tests for floating ip. """
+    SUBNET_NAME = uuid.uuid4().hex
+    NETWORK_NAME = uuid.uuid4().hex
+    ID = None
+    HEADERS = ['ID']
+    FIELDS = ['id']
+
+    @classmethod
+    def setUpClass(cls):
+        # Create a network for the floating ip.
+        cls.openstack('network create --external ' + cls.NETWORK_NAME)
+        # Create a subnet for the network.
+        cls.openstack(
+            'subnet create --network ' + cls.NETWORK_NAME +
+            ' --subnet-range 10.10.10.0/24 ' +
+            cls.SUBNET_NAME
+        )
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack(
+            'floating ip create ' + cls.NETWORK_NAME + opts)
+        cls.ID = raw_output.strip('\n')
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('floating ip delete ' + cls.ID)
+        cls.assertOutput('', raw_output)
+        raw_output = cls.openstack('subnet delete ' + cls.SUBNET_NAME)
+        cls.assertOutput('', raw_output)
+        raw_output = cls.openstack('network delete ' + cls.NETWORK_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_floating_ip_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('floating ip list' + opts)
+        self.assertIn(self.ID, raw_output)
+
+    def test_floating_ip_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('floating ip show ' + self.ID + opts)
+        self.assertEqual(self.ID + "\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_ip_availability.py b/openstackclient/tests/functional/network/v2/test_ip_availability.py
new file mode 100644
index 00000000..b5c908f4
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_ip_availability.py
@@ -0,0 +1,53 @@
+#    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 IPAvailabilityTests(base.TestCase):
+    """Functional tests for IP availability. """
+    NAME = uuid.uuid4().hex
+    NETWORK_NAME = uuid.uuid4().hex
+    FIELDS = ['network_name']
+
+    @classmethod
+    def setUpClass(cls):
+        # Create a network for the subnet.
+        cls.openstack('network create ' + cls.NETWORK_NAME)
+        opts = cls.get_opts(['name'])
+        raw_output = cls.openstack(
+            'subnet create --network ' + cls.NETWORK_NAME +
+            ' --subnet-range 10.10.10.0/24 ' +
+            cls.NAME + opts
+        )
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_subnet = cls.openstack('subnet delete ' + cls.NAME)
+        raw_network = cls.openstack('network delete ' + cls.NETWORK_NAME)
+        cls.assertOutput('', raw_subnet)
+        cls.assertOutput('', raw_network)
+
+    def test_ip_availability_list(self):
+        opts = ' -f csv -c "Network Name"'
+        raw_output = self.openstack('ip availability list' + opts)
+        self.assertIn(self.NETWORK_NAME, raw_output)
+
+    def test_ip_availability_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack(
+            'ip availability show ' + self.NETWORK_NAME + opts)
+        self.assertEqual(self.NETWORK_NAME + "\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_network.py b/openstackclient/tests/functional/network/v2/test_network.py
new file mode 100644
index 00000000..c77ff642
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_network.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.
+
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class NetworkTests(base.TestCase):
+    """Functional tests for network. """
+    NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('network create ' + cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('network delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_network_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('network list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_network_set(self):
+        raw_output = self.openstack('network set --disable ' + self.NAME)
+        opts = self.get_opts(['name', 'admin_state_up'])
+        raw_output = self.openstack('network show ' + self.NAME + opts)
+        self.assertEqual("DOWN\n" + self.NAME + "\n", raw_output)
+
+    def test_network_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('network show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_network_agent.py b/openstackclient/tests/functional/network/v2/test_network_agent.py
new file mode 100644
index 00000000..dd6112e7
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_network_agent.py
@@ -0,0 +1,41 @@
+#    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 openstackclient.tests.functional import base
+
+
+class NetworkAgentTests(base.TestCase):
+    """Functional tests for network agent. """
+    IDs = None
+    HEADERS = ['ID']
+    FIELDS = ['id']
+
+    @classmethod
+    def test_network_agent_list(cls):
+        opts = cls.get_opts(cls.HEADERS)
+        raw_output = cls.openstack('network agent list' + opts)
+        # get the list of network agent IDs.
+        cls.IDs = raw_output.split('\n')
+
+    def test_network_agent_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('network agent show ' + self.IDs[0] + opts)
+        self.assertEqual(self.IDs[0] + "\n", raw_output)
+
+    def test_network_agent_set(self):
+        opts = self.get_opts(['admin_state_up'])
+        self.openstack('network agent set --disable ' + self.IDs[0])
+        raw_output = self.openstack('network agent show ' + self.IDs[0] + opts)
+        self.assertEqual("DOWN\n", raw_output)
+        self.openstack('network agent set --enable ' + self.IDs[0])
+        raw_output = self.openstack('network agent show ' + self.IDs[0] + opts)
+        self.assertEqual("UP\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_network_rbac.py b/openstackclient/tests/functional/network/v2/test_network_rbac.py
new file mode 100644
index 00000000..6f9f05e7
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_network_rbac.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.
+
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class NetworkRBACTests(base.TestCase):
+    """Functional tests for network rbac. """
+    NET_NAME = uuid.uuid4().hex
+    PROJECT_NAME = uuid.uuid4().hex
+    OBJECT_ID = None
+    ID = None
+    HEADERS = ['ID']
+    FIELDS = ['id']
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('network create ' + cls.NET_NAME + opts)
+        cls.OBJECT_ID = raw_output.strip('\n')
+        opts = cls.get_opts(['id', 'object_id'])
+        raw_output = cls.openstack('network rbac create ' +
+                                   cls.OBJECT_ID +
+                                   ' --action access_as_shared' +
+                                   ' --target-project admin' +
+                                   ' --type network' + opts)
+        cls.ID, object_id, rol = tuple(raw_output.split('\n'))
+        cls.assertOutput(cls.OBJECT_ID, object_id)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output_rbac = cls.openstack('network rbac delete ' + cls.ID)
+        raw_output_network = cls.openstack('network delete ' + cls.OBJECT_ID)
+        cls.assertOutput('', raw_output_rbac)
+        cls.assertOutput('', raw_output_network)
+
+    def test_network_rbac_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('network rbac list' + opts)
+        self.assertIn(self.ID, raw_output)
+
+    def test_network_rbac_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('network rbac show ' + self.ID + opts)
+        self.assertEqual(self.ID + "\n", raw_output)
+
+    def test_network_rbac_set(self):
+        opts = self.get_opts(self.FIELDS)
+        project_id = self.openstack(
+            'project create ' + self.PROJECT_NAME + opts)
+        self.openstack('network rbac set ' + self.ID +
+                       ' --target-project ' + self.PROJECT_NAME)
+        opts = self.get_opts(['target_project_id'])
+        raw_output_rbac = self.openstack('network rbac show ' + self.ID + opts)
+        raw_output_project = self.openstack(
+            'project delete ' + self.PROJECT_NAME)
+        self.assertEqual(project_id, raw_output_rbac)
+        self.assertOutput('', raw_output_project)
diff --git a/openstackclient/tests/functional/network/v2/test_network_segment.py b/openstackclient/tests/functional/network/v2/test_network_segment.py
new file mode 100644
index 00000000..f871e88e
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_network_segment.py
@@ -0,0 +1,60 @@
+#    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 testtools
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+# NOTE(rtheis): Routed networks is still a WIP and not enabled by default.
+@testtools.skip("bp/routed-networks")
+class NetworkSegmentTests(base.TestCase):
+    """Functional tests for network segment. """
+    NETWORK_NAME = uuid.uuid4().hex
+    PHYSICAL_NETWORK_NAME = uuid.uuid4().hex
+    NETWORK_SEGMENT_ID = None
+    NETWORK_ID = None
+
+    @classmethod
+    def setUpClass(cls):
+        # Create a network for the segment.
+        opts = cls.get_opts(['id'])
+        raw_output = cls.openstack('network create ' + cls.NETWORK_NAME + opts)
+        cls.NETWORK_ID = raw_output.strip('\n')
+
+        # Get the segment for the network.
+        opts = cls.get_opts(['ID', 'Network'])
+        raw_output = cls.openstack('--os-beta-command '
+                                   'network segment list '
+                                   ' --network ' + cls.NETWORK_NAME +
+                                   ' ' + opts)
+        raw_output_row = raw_output.split('\n')[0]
+        cls.NETWORK_SEGMENT_ID = raw_output_row.split(' ')[0]
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('network delete ' + cls.NETWORK_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_network_segment_list(self):
+        opts = self.get_opts(['ID'])
+        raw_output = self.openstack('--os-beta-command '
+                                    'network segment list' + opts)
+        self.assertIn(self.NETWORK_SEGMENT_ID, raw_output)
+
+    def test_network_segment_show(self):
+        opts = self.get_opts(['network_id'])
+        raw_output = self.openstack('--os-beta-command '
+                                    'network segment show ' +
+                                    self.NETWORK_SEGMENT_ID + opts)
+        self.assertEqual(self.NETWORK_ID + "\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_port.py b/openstackclient/tests/functional/network/v2/test_port.py
new file mode 100644
index 00000000..decd9553
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_port.py
@@ -0,0 +1,58 @@
+#    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 PortTests(base.TestCase):
+    """Functional tests for port. """
+    NAME = uuid.uuid4().hex
+    NETWORK_NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        # Create a network for the subnet.
+        cls.openstack('network create ' + cls.NETWORK_NAME)
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack(
+            'port create --network ' + cls.NETWORK_NAME + ' ' +
+            cls.NAME + opts
+        )
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('port delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+        raw_output = cls.openstack('network delete ' + cls.NETWORK_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_port_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('port list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_port_set(self):
+        self.openstack('port set --disable ' + self.NAME)
+        opts = self.get_opts(['name', 'admin_state_up'])
+        raw_output = self.openstack('port show ' + self.NAME + opts)
+        self.assertEqual("DOWN\n" + self.NAME + "\n", raw_output)
+
+    def test_port_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('port show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_router.py b/openstackclient/tests/functional/network/v2/test_router.py
new file mode 100644
index 00000000..789c3825
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_router.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.
+
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class RouterTests(base.TestCase):
+    """Functional tests for router. """
+    NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('router create ' + cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('router delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_router_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('router list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_router_set(self):
+        self.openstack('router set --disable ' + self.NAME)
+        opts = self.get_opts(['name', 'admin_state_up'])
+        raw_output = self.openstack('router show ' + self.NAME + opts)
+        self.assertEqual("DOWN\n" + self.NAME + "\n", raw_output)
+
+    def test_router_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('router show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_security_group.py b/openstackclient/tests/functional/network/v2/test_security_group.py
new file mode 100644
index 00000000..debd81df
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_security_group.py
@@ -0,0 +1,60 @@
+#    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 SecurityGroupTests(base.TestCase):
+    """Functional tests for security group. """
+    NAME = uuid.uuid4().hex
+    OTHER_NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('security group create ' + cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        # Rename test
+        raw_output = cls.openstack('security group set --name ' +
+                                   cls.OTHER_NAME + ' ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+        # Delete test
+        raw_output = cls.openstack('security group delete ' + cls.OTHER_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_security_group_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('security group list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_security_group_set(self):
+        raw_output = self.openstack(
+            'security group set --description NSA ' + self.NAME
+        )
+        self.assertEqual('', raw_output)
+
+        opts = self.get_opts(['description'])
+        raw_output = self.openstack('security group show ' + self.NAME + opts)
+        self.assertEqual("NSA\n", raw_output)
+
+    def test_security_group_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('security group show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_security_group_rule.py b/openstackclient/tests/functional/network/v2/test_security_group_rule.py
new file mode 100644
index 00000000..c91de1a5
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_security_group_rule.py
@@ -0,0 +1,67 @@
+#    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 SecurityGroupRuleTests(base.TestCase):
+    """Functional tests for security group rule. """
+    SECURITY_GROUP_NAME = uuid.uuid4().hex
+    SECURITY_GROUP_RULE_ID = None
+    NAME_FIELD = ['name']
+    ID_FIELD = ['id']
+    ID_HEADER = ['ID']
+
+    @classmethod
+    def setUpClass(cls):
+        # Create the security group to hold the rule.
+        opts = cls.get_opts(cls.NAME_FIELD)
+        raw_output = cls.openstack('security group create ' +
+                                   cls.SECURITY_GROUP_NAME +
+                                   opts)
+        expected = cls.SECURITY_GROUP_NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+        # Create the security group rule.
+        opts = cls.get_opts(cls.ID_FIELD)
+        raw_output = cls.openstack('security group rule create ' +
+                                   cls.SECURITY_GROUP_NAME +
+                                   ' --protocol tcp --dst-port 80:80' +
+                                   ' --ingress --ethertype IPv4' +
+                                   opts)
+        cls.SECURITY_GROUP_RULE_ID = raw_output.strip('\n')
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('security group rule delete ' +
+                                   cls.SECURITY_GROUP_RULE_ID)
+        cls.assertOutput('', raw_output)
+
+        raw_output = cls.openstack('security group delete ' +
+                                   cls.SECURITY_GROUP_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_security_group_rule_list(self):
+        opts = self.get_opts(self.ID_HEADER)
+        raw_output = self.openstack('security group rule list ' +
+                                    self.SECURITY_GROUP_NAME +
+                                    opts)
+        self.assertIn(self.SECURITY_GROUP_RULE_ID, raw_output)
+
+    def test_security_group_rule_show(self):
+        opts = self.get_opts(self.ID_FIELD)
+        raw_output = self.openstack('security group rule show ' +
+                                    self.SECURITY_GROUP_RULE_ID +
+                                    opts)
+        self.assertEqual(self.SECURITY_GROUP_RULE_ID + "\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_subnet.py b/openstackclient/tests/functional/network/v2/test_subnet.py
new file mode 100644
index 00000000..231671f3
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_subnet.py
@@ -0,0 +1,66 @@
+#    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 SubnetTests(base.TestCase):
+    """Functional tests for subnet. """
+    NAME = uuid.uuid4().hex
+    NETWORK_NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        # Create a network for the subnet.
+        cls.openstack('network create ' + cls.NETWORK_NAME)
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack(
+            'subnet create --network ' + cls.NETWORK_NAME +
+            ' --subnet-range 10.10.10.0/24 ' +
+            cls.NAME + opts
+        )
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('subnet delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+        raw_output = cls.openstack('network delete ' + cls.NETWORK_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_subnet_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('subnet list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_subnet_set(self):
+        self.openstack('subnet set --no-dhcp ' + self.NAME)
+        opts = self.get_opts(['name', 'enable_dhcp'])
+        raw_output = self.openstack('subnet show ' + self.NAME + opts)
+        self.assertEqual("False\n" + self.NAME + "\n", raw_output)
+
+    def test_subnet_set_service_type(self):
+        TYPE = 'network:floatingip_agent_gateway'
+        self.openstack('subnet set --service-type ' + TYPE + ' ' + self.NAME)
+        opts = self.get_opts(['name', 'service_types'])
+        raw_output = self.openstack('subnet show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n" + TYPE + "\n", raw_output)
+
+    def test_subnet_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('subnet show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
diff --git a/openstackclient/tests/functional/network/v2/test_subnet_pool.py b/openstackclient/tests/functional/network/v2/test_subnet_pool.py
new file mode 100644
index 00000000..e52f06fc
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_subnet_pool.py
@@ -0,0 +1,55 @@
+#    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 SubnetPoolTests(base.TestCase):
+    """Functional tests for subnet pool. """
+    NAME = uuid.uuid4().hex
+    CREATE_POOL_PREFIX = '10.100.0.0/24'
+    SET_POOL_PREFIX = '10.100.0.0/16'
+    HEADERS = ['Name']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('subnet pool create --pool-prefix ' +
+                                   cls.CREATE_POOL_PREFIX + ' ' +
+                                   cls.NAME + opts)
+        cls.assertOutput(cls.NAME + '\n', raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('subnet pool delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_subnet_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('subnet pool list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_subnet_set(self):
+        self.openstack('subnet pool set --pool-prefix ' +
+                       self.SET_POOL_PREFIX + ' ' + self.NAME)
+        opts = self.get_opts(['prefixes', 'name'])
+        raw_output = self.openstack('subnet pool show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + '\n' + self.SET_POOL_PREFIX + '\n',
+                         raw_output)
+
+    def test_subnet_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('subnet pool show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + '\n', raw_output)
diff --git a/openstackclient/tests/functional/object/__init__.py b/openstackclient/tests/functional/object/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/object/__init__.py
diff --git a/openstackclient/tests/functional/object/v1/__init__.py b/openstackclient/tests/functional/object/v1/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/object/v1/__init__.py
diff --git a/openstackclient/tests/functional/object/v1/test_container.py b/openstackclient/tests/functional/object/v1/test_container.py
new file mode 100644
index 00000000..af76efd9
--- /dev/null
+++ b/openstackclient/tests/functional/object/v1/test_container.py
@@ -0,0 +1,41 @@
+#    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 ContainerTests(base.TestCase):
+    """Functional tests for object containers. """
+    NAME = uuid.uuid4().hex
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(['container'])
+        raw_output = cls.openstack('container create ' + cls.NAME + opts)
+        cls.assertOutput(cls.NAME + '\n', raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('container delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_container_list(self):
+        opts = self.get_opts(['Name'])
+        raw_output = self.openstack('container list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_container_show(self):
+        opts = self.get_opts(['container'])
+        raw_output = self.openstack('container show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
diff --git a/openstackclient/tests/functional/object/v1/test_object.py b/openstackclient/tests/functional/object/v1/test_object.py
new file mode 100644
index 00000000..776cf47c
--- /dev/null
+++ b/openstackclient/tests/functional/object/v1/test_object.py
@@ -0,0 +1,81 @@
+#    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 os
+import tempfile
+import uuid
+
+from openstackclient.tests.functional import base
+
+BASIC_LIST_HEADERS = ['Name']
+CONTAINER_FIELDS = ['account', 'container', 'x-trans-id']
+OBJECT_FIELDS = ['object', 'container', 'etag']
+
+
+class ObjectTests(base.TestCase):
+    """Functional tests for Object commands. """
+
+    CONTAINER_NAME = uuid.uuid4().hex
+
+    def test_object(self):
+        with tempfile.NamedTemporaryFile() as f:
+            f.write('test content')
+            f.flush()
+            self._test_object(f.name)
+
+    def _test_object(self, object_file):
+        raw_output = self.openstack('container create ' + self.CONTAINER_NAME)
+        items = self.parse_listing(raw_output)
+        self.assert_show_fields(items, CONTAINER_FIELDS)
+
+        raw_output = self.openstack('container list')
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, BASIC_LIST_HEADERS)
+
+        self.openstack('container show ' + self.CONTAINER_NAME)
+        # TODO(stevemar): Assert returned fields
+
+        self.openstack('container save ' + self.CONTAINER_NAME)
+        # TODO(stevemar): Assert returned fields
+
+        raw_output = self.openstack('object create ' + self.CONTAINER_NAME
+                                    + ' ' + object_file)
+        items = self.parse_listing(raw_output)
+        self.assert_show_fields(items, OBJECT_FIELDS)
+
+        raw_output = self.openstack('object list ' + self.CONTAINER_NAME)
+        items = self.parse_listing(raw_output)
+        self.assert_table_structure(items, BASIC_LIST_HEADERS)
+
+        self.openstack('object save ' + self.CONTAINER_NAME
+                       + ' ' + object_file)
+        # TODO(stevemar): Assert returned fields
+
+        tmp_file = 'tmp.txt'
+        self.addCleanup(os.remove, tmp_file)
+        self.openstack('object save ' + self.CONTAINER_NAME
+                       + ' ' + object_file + ' --file ' + tmp_file)
+        # TODO(stevemar): Assert returned fields
+
+        self.openstack('object show ' + self.CONTAINER_NAME
+                       + ' ' + object_file)
+        # TODO(stevemar): Assert returned fields
+
+        raw_output = self.openstack('object delete ' + self.CONTAINER_NAME
+                                    + ' ' + object_file)
+        self.assertEqual(0, len(raw_output))
+
+        self.openstack('object create ' + self.CONTAINER_NAME
+                       + ' ' + object_file)
+        raw_output = self.openstack('container delete -r ' +
+                                    self.CONTAINER_NAME)
+        self.assertEqual(0, len(raw_output))
diff --git a/openstackclient/tests/functional/post_test_hook.sh b/openstackclient/tests/functional/post_test_hook.sh
new file mode 100755
index 00000000..e555470d
--- /dev/null
+++ b/openstackclient/tests/functional/post_test_hook.sh
@@ -0,0 +1,43 @@
+#!/bin/bash
+
+# This is a script that kicks off a series of functional tests against an
+# OpenStack cloud. It will attempt to create an instance if one is not
+# available. Do not run this script unless you know what you're doing.
+# For more information refer to:
+# http://docs.openstack.org/developer/python-openstackclient/
+
+function generate_testr_results {
+    if [ -f .testrepository/0 ]; then
+        sudo .tox/functional/bin/testr last --subunit > $WORKSPACE/testrepository.subunit
+        sudo mv $WORKSPACE/testrepository.subunit $BASE/logs/testrepository.subunit
+        sudo .tox/functional/bin/subunit2html $BASE/logs/testrepository.subunit $BASE/logs/testr_results.html
+        sudo gzip -9 $BASE/logs/testrepository.subunit
+        sudo gzip -9 $BASE/logs/testr_results.html
+        sudo chown jenkins:jenkins $BASE/logs/testrepository.subunit.gz $BASE/logs/testr_results.html.gz
+        sudo chmod a+r $BASE/logs/testrepository.subunit.gz $BASE/logs/testr_results.html.gz
+    fi
+}
+
+OPENSTACKCLIENT_DIR=$(cd $(dirname "$0") && pwd)
+sudo chown -R jenkins:stack $OPENSTACKCLIENT_DIR
+
+# Run tests
+echo "Running openstackclient functional test suite"
+set +e
+
+# Go to the openstackclient dir
+cd $OPENSTACKCLIENT_DIR
+
+# Source environment variables to kick things off
+source ~stack/devstack/openrc admin admin
+echo 'Running tests with:'
+env | grep OS
+
+# Preserve env for OS_ credentials
+sudo -E -H -u jenkins tox -efunctional
+EXIT_CODE=$?
+set -e
+
+# Collect and parse result
+generate_testr_results
+exit $EXIT_CODE
diff --git a/openstackclient/tests/functional/volume/__init__.py b/openstackclient/tests/functional/volume/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/volume/__init__.py
diff --git a/openstackclient/tests/functional/volume/v1/__init__.py b/openstackclient/tests/functional/volume/v1/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v1/__init__.py
diff --git a/openstackclient/tests/functional/volume/v1/common.py b/openstackclient/tests/functional/volume/v1/common.py
new file mode 100644
index 00000000..a442850d
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v1/common.py
@@ -0,0 +1,23 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import os
+
+from openstackclient.tests.functional import base
+
+
+class BaseVolumeTests(base.TestCase):
+    """Base class for Volume functional tests. """
+
+    @classmethod
+    def setUpClass(cls):
+        os.environ['OS_VOLUME_API_VERSION'] = '1'
diff --git a/openstackclient/tests/functional/volume/v1/test_qos.py b/openstackclient/tests/functional/volume/v1/test_qos.py
new file mode 100644
index 00000000..770d5acb
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v1/test_qos.py
@@ -0,0 +1,55 @@
+#    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.volume.v1 import common
+
+
+class QosTests(common.BaseVolumeTests):
+    """Functional tests for volume qos. """
+
+    NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['id', 'name']
+    ID = None
+
+    @classmethod
+    def setUpClass(cls):
+        super(QosTests, cls).setUpClass()
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('volume qos create ' + cls.NAME + opts)
+        cls.ID, name, rol = raw_output.split('\n')
+        cls.assertOutput(cls.NAME, name)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('volume qos delete ' + cls.ID)
+        cls.assertOutput('', raw_output)
+
+    def test_volume_qos_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('volume qos list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_volume_qos_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('volume qos show ' + self.ID + opts)
+        self.assertEqual(self.ID + "\n" + self.NAME + "\n", raw_output)
+
+    def test_volume_qos_metadata(self):
+        raw_output = self.openstack(
+            'volume qos set --property a=b --property c=d ' + self.ID)
+        self.assertEqual("", raw_output)
+        opts = self.get_opts(['name', 'specs'])
+        raw_output = self.openstack('volume qos show ' + self.ID + opts)
+        self.assertEqual(self.NAME + "\na='b', c='d'\n", raw_output)
diff --git a/openstackclient/tests/functional/volume/v1/test_volume.py b/openstackclient/tests/functional/volume/v1/test_volume.py
new file mode 100644
index 00000000..6ac7f2bf
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v1/test_volume.py
@@ -0,0 +1,77 @@
+#    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.volume.v1 import common
+
+
+class VolumeTests(common.BaseVolumeTests):
+    """Functional tests for volume. """
+
+    NAME = uuid.uuid4().hex
+    OTHER_NAME = uuid.uuid4().hex
+    HEADERS = ['"Display Name"']
+    FIELDS = ['display_name']
+
+    @classmethod
+    def setUpClass(cls):
+        super(VolumeTests, cls).setUpClass()
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('volume create --size 1 ' + cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        # Rename test
+        raw_output = cls.openstack(
+            'volume set --name ' + cls.OTHER_NAME + ' ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+        # Delete test
+        raw_output = cls.openstack('volume delete ' + cls.OTHER_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_volume_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('volume list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_volume_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('volume show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
+
+    def test_volume_properties(self):
+        raw_output = self.openstack(
+            'volume set --property a=b --property c=d ' + self.NAME)
+        self.assertEqual("", raw_output)
+        opts = self.get_opts(["properties"])
+        raw_output = self.openstack('volume show ' + self.NAME + opts)
+        self.assertEqual("a='b', c='d'\n", raw_output)
+
+        raw_output = self.openstack('volume unset --property a ' + self.NAME)
+        self.assertEqual("", raw_output)
+        raw_output = self.openstack('volume show ' + self.NAME + opts)
+        self.assertEqual("c='d'\n", raw_output)
+
+    def test_volume_set(self):
+        self.openstack('volume set --description RAMAC ' + self.NAME)
+        opts = self.get_opts(["display_description", "display_name"])
+        raw_output = self.openstack('volume show ' + self.NAME + opts)
+        self.assertEqual("RAMAC\n" + self.NAME + "\n", raw_output)
+
+    def test_volume_set_size(self):
+        self.openstack('volume set --size 2 ' + self.NAME)
+        opts = self.get_opts(["display_name", "size"])
+        raw_output = self.openstack('volume show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n2\n", raw_output)
diff --git a/openstackclient/tests/functional/volume/v1/test_volume_type.py b/openstackclient/tests/functional/volume/v1/test_volume_type.py
new file mode 100644
index 00000000..538545ab
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v1/test_volume_type.py
@@ -0,0 +1,74 @@
+#    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 time
+import uuid
+
+from openstackclient.tests.functional.volume.v1 import common
+
+
+class VolumeTypeTests(common.BaseVolumeTests):
+    """Functional tests for volume type. """
+
+    NAME = uuid.uuid4().hex
+    HEADERS = ['"Name"']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        super(VolumeTypeTests, cls).setUpClass()
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('volume type create ' + cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('volume type delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_volume_type_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('volume type list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_volume_type_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('volume type show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
+
+    def test_volume_type_set_unset_properties(self):
+        raw_output = self.openstack(
+            'volume type set --property a=b --property c=d ' + self.NAME)
+        self.assertEqual("", raw_output)
+
+        opts = self.get_opts(["properties"])
+        raw_output = self.openstack('volume type show ' + self.NAME + opts)
+        self.assertEqual("a='b', c='d'\n", raw_output)
+
+        raw_output = self.openstack('volume type unset --property a '
+                                    + self.NAME)
+        self.assertEqual("", raw_output)
+        raw_output = self.openstack('volume type show ' + self.NAME + opts)
+        self.assertEqual("c='d'\n", raw_output)
+
+    def test_multi_delete(self):
+        vol_type1 = uuid.uuid4().hex
+        vol_type2 = uuid.uuid4().hex
+        self.openstack('volume type create ' + vol_type1)
+        time.sleep(5)
+        self.openstack('volume type create ' + vol_type2)
+        time.sleep(5)
+        cmd = 'volume type delete %s %s' % (vol_type1, vol_type2)
+        time.sleep(5)
+        raw_output = self.openstack(cmd)
+        self.assertOutput('', raw_output)
diff --git a/openstackclient/tests/functional/volume/v2/__init__.py b/openstackclient/tests/functional/volume/v2/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v2/__init__.py
diff --git a/openstackclient/tests/functional/volume/v2/common.py b/openstackclient/tests/functional/volume/v2/common.py
new file mode 100644
index 00000000..e279a6f6
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v2/common.py
@@ -0,0 +1,23 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import os
+
+from openstackclient.tests.functional import base
+
+
+class BaseVolumeTests(base.TestCase):
+    """Base class for Volume functional tests. """
+
+    @classmethod
+    def setUpClass(cls):
+        os.environ['OS_VOLUME_API_VERSION'] = '2'
diff --git a/openstackclient/tests/functional/volume/v2/test_qos.py b/openstackclient/tests/functional/volume/v2/test_qos.py
new file mode 100644
index 00000000..a54acbfd
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v2/test_qos.py
@@ -0,0 +1,62 @@
+#    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.volume.v2 import common
+
+
+class QosTests(common.BaseVolumeTests):
+    """Functional tests for volume qos. """
+
+    NAME = uuid.uuid4().hex
+    HEADERS = ['Name']
+    FIELDS = ['id', 'name']
+    ID = None
+
+    @classmethod
+    def setUpClass(cls):
+        super(QosTests, cls).setUpClass()
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack('volume qos create ' + cls.NAME + opts)
+        cls.ID, name, rol = raw_output.split('\n')
+        cls.assertOutput(cls.NAME, name)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('volume qos delete ' + cls.ID)
+        cls.assertOutput('', raw_output)
+
+    def test_volume_qos_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('volume qos list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_volume_qos_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('volume qos show ' + self.ID + opts)
+        self.assertEqual(self.ID + "\n" + self.NAME + "\n", raw_output)
+
+    def test_volume_qos_metadata(self):
+        raw_output = self.openstack(
+            'volume qos set --property a=b --property c=d ' + self.ID)
+        self.assertEqual("", raw_output)
+        opts = self.get_opts(['name', 'specs'])
+        raw_output = self.openstack('volume qos show ' + self.ID + opts)
+        self.assertEqual(self.NAME + "\na='b', c='d'\n", raw_output)
+
+        raw_output = self.openstack(
+            'volume qos unset --property a ' + self.ID)
+        self.assertEqual("", raw_output)
+        opts = self.get_opts(['name', 'specs'])
+        raw_output = self.openstack('volume qos show ' + self.ID + opts)
+        self.assertEqual(self.NAME + "\nc='d'\n", raw_output)
diff --git a/openstackclient/tests/functional/volume/v2/test_snapshot.py b/openstackclient/tests/functional/volume/v2/test_snapshot.py
new file mode 100644
index 00000000..4582b67d
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v2/test_snapshot.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.
+
+import time
+import uuid
+
+from openstackclient.tests.functional.volume.v2 import common
+
+
+class SnapshotTests(common.BaseVolumeTests):
+    """Functional tests for snapshot. """
+
+    VOLLY = uuid.uuid4().hex
+    NAME = uuid.uuid4().hex
+    OTHER_NAME = uuid.uuid4().hex
+    HEADERS = ['"Name"']
+
+    @classmethod
+    def wait_for_status(cls, command, status, tries):
+        opts = cls.get_opts(['status'])
+        for attempt in range(tries):
+            time.sleep(1)
+            raw_output = cls.openstack(command + opts)
+            if (raw_output == status):
+                return
+        cls.assertOutput(status, raw_output)
+
+    @classmethod
+    def setUpClass(cls):
+        super(SnapshotTests, cls).setUpClass()
+        cls.openstack('volume create --size 1 ' + cls.VOLLY)
+        cls.wait_for_status('volume show ' + cls.VOLLY, 'available\n', 3)
+        opts = cls.get_opts(['status'])
+        raw_output = cls.openstack('snapshot create --name ' + cls.NAME +
+                                   ' ' + cls.VOLLY + opts)
+        cls.assertOutput('creating\n', raw_output)
+        cls.wait_for_status('snapshot show ' + cls.NAME, 'available\n', 3)
+
+    @classmethod
+    def tearDownClass(cls):
+        # Rename test
+        raw_output = cls.openstack(
+            'snapshot set --name ' + cls.OTHER_NAME + ' ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+        # Delete test
+        raw_output = cls.openstack('snapshot delete ' + cls.OTHER_NAME)
+        cls.assertOutput('', raw_output)
+        cls.openstack('volume delete --force ' + cls.VOLLY, fail_ok=True)
+
+    def test_snapshot_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('snapshot list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_snapshot_properties(self):
+        raw_output = self.openstack(
+            'snapshot set --property a=b --property c=d ' + self.NAME)
+        self.assertEqual("", raw_output)
+        opts = self.get_opts(["properties"])
+        raw_output = self.openstack('snapshot show ' + self.NAME + opts)
+        self.assertEqual("a='b', c='d'\n", raw_output)
+
+        raw_output = self.openstack('snapshot unset --property a ' + self.NAME)
+        self.assertEqual("", raw_output)
+        raw_output = self.openstack('snapshot show ' + self.NAME + opts)
+        self.assertEqual("c='d'\n", raw_output)
+
+    def test_snapshot_set(self):
+        raw_output = self.openstack(
+            'snapshot set --description backup ' + self.NAME)
+        self.assertEqual("", raw_output)
+        opts = self.get_opts(["description", "name"])
+        raw_output = self.openstack('snapshot show ' + self.NAME + opts)
+        self.assertEqual("backup\n" + self.NAME + "\n", raw_output)
diff --git a/openstackclient/tests/functional/volume/v2/test_volume.py b/openstackclient/tests/functional/volume/v2/test_volume.py
new file mode 100644
index 00000000..73273573
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v2/test_volume.py
@@ -0,0 +1,137 @@
+#    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 time
+import uuid
+
+from openstackclient.tests.functional.volume.v2 import common
+
+
+class VolumeTests(common.BaseVolumeTests):
+    """Functional tests for volume. """
+
+    NAME = uuid.uuid4().hex
+    SNAPSHOT_NAME = uuid.uuid4().hex
+    VOLUME_FROM_SNAPSHOT_NAME = uuid.uuid4().hex
+    OTHER_NAME = uuid.uuid4().hex
+    HEADERS = ['"Display Name"']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        super(VolumeTests, cls).setUpClass()
+        opts = cls.get_opts(cls.FIELDS)
+
+        # Create test volume
+        raw_output = cls.openstack('volume create --size 1 ' + cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        # Rename test volume
+        raw_output = cls.openstack(
+            'volume set --name ' + cls.OTHER_NAME + ' ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+        # Set volume state
+        cls.openstack('volume set --state error ' + cls.OTHER_NAME)
+        opts = cls.get_opts(["status"])
+        raw_output_status = cls.openstack(
+            'volume show ' + cls.OTHER_NAME + opts)
+
+        # Delete test volume
+        raw_output = cls.openstack('volume delete ' + cls.OTHER_NAME)
+        cls.assertOutput('', raw_output)
+        cls.assertOutput('error\n', raw_output_status)
+
+    def test_volume_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('volume list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_volume_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('volume show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
+
+    def test_volume_properties(self):
+        raw_output = self.openstack(
+            'volume set --property a=b --property c=d ' + self.NAME)
+        self.assertEqual("", raw_output)
+        opts = self.get_opts(["properties"])
+        raw_output = self.openstack('volume show ' + self.NAME + opts)
+        self.assertEqual("a='b', c='d'\n", raw_output)
+
+        raw_output = self.openstack('volume unset --property a ' + self.NAME)
+        self.assertEqual("", raw_output)
+        raw_output = self.openstack('volume show ' + self.NAME + opts)
+        self.assertEqual("c='d'\n", raw_output)
+
+    def test_volume_set(self):
+        discription = uuid.uuid4().hex
+        self.openstack('volume set --description ' + discription + ' ' +
+                       self.NAME)
+        opts = self.get_opts(["description", "name"])
+        raw_output = self.openstack('volume show ' + self.NAME + opts)
+        self.assertEqual(discription + "\n" + self.NAME + "\n", raw_output)
+
+    def test_volume_set_size(self):
+        self.openstack('volume set --size 2 ' + self.NAME)
+        opts = self.get_opts(["name", "size"])
+        raw_output = self.openstack('volume show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n2\n", raw_output)
+
+    def test_volume_snapshot(self):
+        opts = self.get_opts(self.FIELDS)
+
+        # Create snapshot from test volume
+        raw_output = self.openstack('snapshot create ' + self.NAME +
+                                    ' --name ' + self.SNAPSHOT_NAME + opts)
+        expected = self.SNAPSHOT_NAME + '\n'
+        self.assertOutput(expected, raw_output)
+        self.wait_for("snapshot", self.SNAPSHOT_NAME, "available")
+
+        # Create volume from snapshot
+        raw_output = self.openstack('volume create --size 2 --snapshot ' +
+                                    self.SNAPSHOT_NAME + ' ' +
+                                    self.VOLUME_FROM_SNAPSHOT_NAME + opts)
+        expected = self.VOLUME_FROM_SNAPSHOT_NAME + '\n'
+        self.assertOutput(expected, raw_output)
+        self.wait_for("volume", self.VOLUME_FROM_SNAPSHOT_NAME, "available")
+
+        # Delete volume that create from snapshot
+        raw_output = self.openstack('volume delete ' +
+                                    self.VOLUME_FROM_SNAPSHOT_NAME)
+        self.assertOutput('', raw_output)
+
+        # Delete test snapshot
+        raw_output = self.openstack('snapshot delete ' + self.SNAPSHOT_NAME)
+        self.assertOutput('', raw_output)
+        self.wait_for("volume", self.NAME, "available")
+
+    def wait_for(self, check_type, check_name, desired_status, wait=120,
+                 interval=5, failures=['ERROR']):
+        status = "notset"
+        total_sleep = 0
+        opts = self.get_opts(['status'])
+        while total_sleep < wait:
+            status = self.openstack(check_type + ' show ' + check_name + opts)
+            status = status.rstrip()
+            print('Checking {} {} Waiting for {} current status: {}'
+                  .format(check_type, check_name, desired_status, status))
+            if status == desired_status:
+                break
+            self.assertNotIn(status, failures)
+            time.sleep(interval)
+            total_sleep += interval
+        self.assertEqual(desired_status, status)
diff --git a/openstackclient/tests/functional/volume/v2/test_volume_type.py b/openstackclient/tests/functional/volume/v2/test_volume_type.py
new file mode 100644
index 00000000..b62cbb39
--- /dev/null
+++ b/openstackclient/tests/functional/volume/v2/test_volume_type.py
@@ -0,0 +1,84 @@
+#    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 time
+import uuid
+
+from openstackclient.tests.functional.volume.v2 import common
+
+
+class VolumeTypeTests(common.BaseVolumeTests):
+    """Functional tests for volume type. """
+
+    NAME = uuid.uuid4().hex
+    HEADERS = ['"Name"']
+    FIELDS = ['name']
+
+    @classmethod
+    def setUpClass(cls):
+        super(VolumeTypeTests, cls).setUpClass()
+        opts = cls.get_opts(cls.FIELDS)
+        raw_output = cls.openstack(
+            'volume type create --private ' + cls.NAME + opts)
+        expected = cls.NAME + '\n'
+        cls.assertOutput(expected, raw_output)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('volume type delete ' + cls.NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_volume_type_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('volume type list' + opts)
+        self.assertIn(self.NAME, raw_output)
+
+    def test_volume_type_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('volume type show ' + self.NAME + opts)
+        self.assertEqual(self.NAME + "\n", raw_output)
+
+    def test_volume_type_set_unset_properties(self):
+        raw_output = self.openstack(
+            'volume type set --property a=b --property c=d ' + self.NAME)
+        self.assertEqual("", raw_output)
+
+        opts = self.get_opts(["properties"])
+        raw_output = self.openstack('volume type show ' + self.NAME + opts)
+        self.assertEqual("a='b', c='d'\n", raw_output)
+
+        raw_output = self.openstack('volume type unset --property a '
+                                    + self.NAME)
+        self.assertEqual("", raw_output)
+        raw_output = self.openstack('volume type show ' + self.NAME + opts)
+        self.assertEqual("c='d'\n", raw_output)
+
+    def test_volume_type_set_unset_project(self):
+        raw_output = self.openstack(
+            'volume type set --project admin ' + self.NAME)
+        self.assertEqual("", raw_output)
+
+        raw_output = self.openstack(
+            'volume type unset --project admin ' + self.NAME)
+        self.assertEqual("", raw_output)
+
+    def test_multi_delete(self):
+        vol_type1 = uuid.uuid4().hex
+        vol_type2 = uuid.uuid4().hex
+        self.openstack('volume type create ' + vol_type1)
+        time.sleep(5)
+        self.openstack('volume type create ' + vol_type2)
+        time.sleep(5)
+        cmd = 'volume type delete %s %s' % (vol_type1, vol_type2)
+        time.sleep(5)
+        raw_output = self.openstack(cmd)
+        self.assertOutput('', raw_output)