diff --git a/ironic_tempest_plugin/README.rst b/ironic_tempest_plugin/README.rst
index 0ea008c..6de7741 100644
--- a/ironic_tempest_plugin/README.rst
+++ b/ironic_tempest_plugin/README.rst
@@ -1,18 +1,15 @@
-=======================================
-Tempest Integration of ironic-inspector
-=======================================
+=====================
+Ironic tempest plugin
+=====================
 
-This directory contains Tempest tests to cover the ironic-inspector project.
+This directory contains Tempest tests to cover the ironic and ironic-inspector
+projects, as well as a plugin to automatically load these tests into tempest.
 
-It uses tempest plugin to automatically load these tests into tempest. More
-information about tempest plugin could be found here:
-`Plugin <https://docs.openstack.org/tempest/latest/plugin.html>`_
+See the tempest plugin documentation for information about creating
+a plugin, stable API interface, TempestPlugin class interface, plugin
+structure, and how to use plugins:
+https://docs.openstack.org/tempest/latest/plugin.html
 
-The legacy method of running Tempest is to just treat the Tempest source code
-as a python unittest:
-`Run tests <https://docs.openstack.org/tempest/latest/overview.html#legacy-run-method>`_
-
-There is also tox configuration for tempest, use following regex for running
-introspection tests::
-
-    $ tox -e all-plugin -- inspector_tempest_plugin
+See the Ironic documentation for information about how to run the
+tempest tests:
+https://docs.openstack.org/ironic/latest/contributor/dev-quickstart.html#running-tempest-tests
diff --git a/ironic_tempest_plugin/clients.py b/ironic_tempest_plugin/clients.py
new file mode 100644
index 0000000..2b81878
--- /dev/null
+++ b/ironic_tempest_plugin/clients.py
@@ -0,0 +1,53 @@
+# All Rights Reserved.
+#
+#    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 import clients
+from tempest.common import credentials_factory as common_creds
+from tempest import config
+
+from ironic_tempest_plugin.services.baremetal.v1.json.baremetal_client import \
+    BaremetalClient
+
+
+CONF = config.CONF
+
+ADMIN_CREDS = None
+
+
+class Manager(clients.Manager):
+    def __init__(self,
+                 credentials=None):
+        """Initialization of Manager class.
+
+        Setup service client and make it available for test cases.
+        :param credentials: type Credentials or TestResources
+        """
+        if credentials is None:
+            global ADMIN_CREDS
+            if ADMIN_CREDS is None:
+                ADMIN_CREDS = common_creds.get_configured_admin_credentials()
+            credentials = ADMIN_CREDS
+        super(Manager, self).__init__(credentials)
+        default_params_with_timeout_values = {
+            'build_interval': CONF.compute.build_interval,
+            'build_timeout': CONF.compute.build_timeout
+        }
+        default_params_with_timeout_values.update(self.default_params)
+
+        self.baremetal_client = BaremetalClient(
+            self.auth_provider,
+            CONF.baremetal.catalog_type,
+            CONF.identity.region,
+            endpoint_type=CONF.baremetal.endpoint_type,
+            **default_params_with_timeout_values)
diff --git a/ironic_tempest_plugin/common/__init__.py b/ironic_tempest_plugin/common/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/ironic_tempest_plugin/common/__init__.py
diff --git a/ironic_tempest_plugin/common/utils.py b/ironic_tempest_plugin/common/utils.py
new file mode 100644
index 0000000..67c4922
--- /dev/null
+++ b/ironic_tempest_plugin/common/utils.py
@@ -0,0 +1,33 @@
+#    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.
+
+
+def get_node(client, node_id=None, instance_uuid=None):
+    """Get a node by its identifier or instance UUID.
+
+    If both node_id and instance_uuid specified, node_id will be used.
+
+    :param client: an instance of tempest plugin BaremetalClient.
+    :param node_id: identifier (UUID or name) of the node.
+    :param instance_uuid: UUID of the instance.
+    :returns: the requested node.
+    :raises: AssertionError, if neither node_id nor instance_uuid was provided
+    """
+    assert node_id or instance_uuid, ('Either node or instance identifier '
+                                      'has to be provided.')
+    if node_id:
+        _, body = client.show_node(node_id)
+        return body
+    elif instance_uuid:
+        _, body = client.show_node_by_instance_uuid(instance_uuid)
+        if body['nodes']:
+            return body['nodes'][0]
diff --git a/ironic_tempest_plugin/common/waiters.py b/ironic_tempest_plugin/common/waiters.py
new file mode 100644
index 0000000..b706ac0
--- /dev/null
+++ b/ironic_tempest_plugin/common/waiters.py
@@ -0,0 +1,112 @@
+# All Rights Reserved.
+#
+#    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 six
+from tempest import config
+from tempest.lib.common.utils import test_utils
+from tempest.lib import exceptions as lib_exc
+
+from ironic_tempest_plugin.common import utils
+
+CONF = config.CONF
+
+
+def _determine_and_check_timeout_interval(timeout, default_timeout,
+                                          interval, default_interval):
+    if timeout is None:
+        timeout = default_timeout
+    if interval is None:
+        interval = default_interval
+    if (not isinstance(timeout, six.integer_types) or
+            not isinstance(interval, six.integer_types) or
+            timeout < 0 or interval < 0):
+        raise AssertionError(
+            'timeout and interval should be >= 0 or None, current values are: '
+            '%(timeout)s, %(interval)s respectively. If timeout and/or '
+            'interval are None, the default_timeout and default_interval are '
+            'used, and they should be integers >= 0, current values are: '
+            '%(default_timeout)s, %(default_interval)s respectively.' % dict(
+                timeout=timeout, interval=interval,
+                default_timeout=default_timeout,
+                default_interval=default_interval)
+        )
+    return timeout, interval
+
+
+def wait_for_bm_node_status(client, node_id, attr, status, timeout=None,
+                            interval=None):
+    """Waits for a baremetal node attribute to reach given status.
+
+    :param client: an instance of tempest plugin BaremetalClient.
+    :param node_id: identifier of the node.
+    :param attr: node's API-visible attribute to check status of.
+    :param status: desired status. Can be a list of statuses.
+    :param timeout: the timeout after which the check is considered as failed.
+        Defaults to client.build_timeout.
+    :param interval: an interval between show_node calls for status check.
+        Defaults to client.build_interval.
+
+    The client should have a show_node(node_id) method to get the node.
+    """
+    timeout, interval = _determine_and_check_timeout_interval(
+        timeout, client.build_timeout, interval, client.build_interval)
+
+    if not isinstance(status, list):
+        status = [status]
+
+    def is_attr_in_status():
+        node = utils.get_node(client, node_id=node_id)
+        if node[attr] in status:
+            return True
+        return False
+
+    if not test_utils.call_until_true(is_attr_in_status, timeout,
+                                      interval):
+        message = ('Node %(node_id)s failed to reach %(attr)s=%(status)s '
+                   'within the required time (%(timeout)s s).' %
+                   {'node_id': node_id,
+                    'attr': attr,
+                    'status': status,
+                    'timeout': timeout})
+        caller = test_utils.find_test_caller()
+        if caller:
+            message = '(%s) %s' % (caller, message)
+        raise lib_exc.TimeoutException(message)
+
+
+def wait_node_instance_association(client, instance_uuid, timeout=None,
+                                   interval=None):
+    """Waits for a node to be associated with instance_id.
+
+    :param client: an instance of tempest plugin BaremetalClient.
+    :param instance_uuid: UUID of the instance.
+    :param timeout: the timeout after which the check is considered as failed.
+        Defaults to CONF.baremetal.association_timeout.
+    :param interval: an interval between show_node calls for status check.
+        Defaults to client.build_interval.
+    """
+    timeout, interval = _determine_and_check_timeout_interval(
+        timeout, CONF.baremetal.association_timeout,
+        interval, client.build_interval)
+
+    def is_some_node_associated():
+        node = utils.get_node(client, instance_uuid=instance_uuid)
+        return node is not None
+
+    if not test_utils.call_until_true(is_some_node_associated, timeout,
+                                      interval):
+        msg = ('Timed out waiting to get Ironic node by instance UUID '
+               '%(instance_uuid)s within the required time (%(timeout)s s).'
+               % {'instance_uuid': instance_uuid, 'timeout': timeout})
+        raise lib_exc.TimeoutException(msg)
diff --git a/ironic_tempest_plugin/config.py b/ironic_tempest_plugin/config.py
index e586900..aa416b8 100644
--- a/ironic_tempest_plugin/config.py
+++ b/ironic_tempest_plugin/config.py
@@ -1,3 +1,6 @@
+# Copyright 2015 NEC Corporation
+# All Rights Reserved.
+#
 #    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
@@ -12,10 +15,28 @@
 
 from oslo_config import cfg
 
-service_option = cfg.BoolOpt("ironic-inspector",
-                             default=True,
-                             help="Whether or not ironic-inspector is expected"
-                                  " to be available")
+from tempest import config  # noqa
+
+
+ironic_service_option = cfg.BoolOpt('ironic',
+                                    default=False,
+                                    help='Whether or not ironic is expected '
+                                    'to be available')
+
+inspector_service_option = cfg.BoolOpt("ironic-inspector",
+                                       default=True,
+                                       help="Whether or not ironic-inspector "
+                                       "is expected to be available")
+
+baremetal_group = cfg.OptGroup(name='baremetal',
+                               title='Baremetal provisioning service options',
+                               help='When enabling baremetal tests, Nova '
+                                    'must be configured to use the Ironic '
+                                    'driver. The following parameters for the '
+                                    '[compute] section must be disabled: '
+                                    'console_output, interface_attach, '
+                                    'live_migration, pause, rescue, resize, '
+                                    'shelve, snapshot, and suspend')
 
 baremetal_introspection_group = cfg.OptGroup(
     name="baremetal_introspection",
@@ -23,6 +44,87 @@
     help="When enabling baremetal introspection tests,"
          "Ironic must be configured.")
 
+baremetal_features_group = cfg.OptGroup(
+    name='baremetal_feature_enabled',
+    title="Enabled Baremetal Service Features")
+
+BaremetalGroup = [
+    cfg.StrOpt('catalog_type',
+               default='baremetal',
+               help="Catalog type of the baremetal provisioning service"),
+    cfg.StrOpt('driver',
+               default='fake',
+               help="Driver name which Ironic uses"),
+    cfg.StrOpt('endpoint_type',
+               default='publicURL',
+               choices=['public', 'admin', 'internal',
+                        'publicURL', 'adminURL', 'internalURL'],
+               help="The endpoint type to use for the baremetal provisioning"
+                    " service"),
+    cfg.IntOpt('deploywait_timeout',
+               default=15,
+               help="Timeout for Ironic node to reach the "
+                    "wait-callback state after powering on."),
+    cfg.IntOpt('active_timeout',
+               default=300,
+               help="Timeout for Ironic node to completely provision"),
+    cfg.IntOpt('association_timeout',
+               default=30,
+               help="Timeout for association of Nova instance and Ironic "
+                    "node"),
+    cfg.IntOpt('power_timeout',
+               default=60,
+               help="Timeout for Ironic power transitions."),
+    cfg.IntOpt('unprovision_timeout',
+               default=300,
+               help="Timeout for unprovisioning an Ironic node. "
+                    "Takes longer since Kilo as Ironic performs an extra "
+                    "step in Node cleaning."),
+    cfg.StrOpt('min_microversion',
+               help="Lower version of the test target microversion range. "
+                    "The format is 'X.Y', where 'X' and 'Y' are int values. "
+                    "Tempest selects tests based on the range between "
+                    "min_microversion and max_microversion. "
+                    "If both values are None, Tempest avoids tests which "
+                    "require a microversion."),
+    cfg.StrOpt('max_microversion',
+               default='latest',
+               help="Upper version of the test target microversion range. "
+                    "The format is 'X.Y', where 'X' and 'Y' are int values. "
+                    "Tempest selects tests based on the range between "
+                    "min_microversion and max_microversion. "
+                    "If both values are None, Tempest avoids tests which "
+                    "require a microversion."),
+    cfg.BoolOpt('use_provision_network',
+                default=False,
+                help="Whether the Ironic/Neutron tenant isolation is enabled"),
+    cfg.StrOpt('whole_disk_image_ref',
+               help="UUID of the wholedisk image to use in the tests."),
+    cfg.StrOpt('whole_disk_image_url',
+               help="An http link to the wholedisk image to use in the "
+                    "tests."),
+    cfg.StrOpt('whole_disk_image_checksum',
+               help="An MD5 checksum of the image."),
+    cfg.StrOpt('partition_image_ref',
+               help="UUID of the partitioned image to use in the tests."),
+    cfg.ListOpt('enabled_drivers',
+                default=['fake', 'pxe_ipmitool', 'agent_ipmitool'],
+                help="List of Ironic enabled drivers."),
+    cfg.ListOpt('enabled_hardware_types',
+                default=['ipmi'],
+                help="List of Ironic enabled hardware types."),
+    cfg.IntOpt('adjusted_root_disk_size_gb',
+               min=0,
+               help="Ironic adjusted disk size to use in the standalone tests "
+                    "as instance_info/root_gb value."),
+]
+
+BaremetalFeaturesGroup = [
+    cfg.BoolOpt('ipxe_enabled',
+                default=True,
+                help="Defines if IPXE is enabled"),
+]
+
 BaremetalIntrospectionGroup = [
     cfg.StrOpt('catalog_type',
                default='baremetal-introspection',
diff --git a/ironic_tempest_plugin/manager.py b/ironic_tempest_plugin/manager.py
new file mode 100644
index 0000000..9967a5d
--- /dev/null
+++ b/ironic_tempest_plugin/manager.py
@@ -0,0 +1,559 @@
+# Copyright 2012 OpenStack Foundation
+# Copyright 2013 IBM Corp.
+# All Rights Reserved.
+#
+#    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.
+
+# NOTE(soliosg) Do not edit this file. It will only stay temporarily
+# in ironic, while QA refactors the tempest.scenario interface. This
+# file was copied from openstack/tempest/tempest/scenario/manager.py,
+# openstack/tempest commit: 82a278e88c9e9f9ba49f81c1f8dba0bca7943daf
+
+import subprocess
+
+from oslo_log import log
+from oslo_utils import netutils
+from tempest.common import compute
+from tempest.common.utils.linux import remote_client
+from tempest.common.utils import net_utils
+from tempest.common import waiters
+from tempest import config
+from tempest import exceptions
+from tempest.lib.common.utils import data_utils
+from tempest.lib.common.utils import test_utils
+from tempest.lib import exceptions as lib_exc
+import tempest.test
+
+CONF = config.CONF
+
+LOG = log.getLogger(__name__)
+
+
+class ScenarioTest(tempest.test.BaseTestCase):
+    """Base class for scenario tests. Uses tempest own clients. """
+
+    credentials = ['primary']
+
+    @classmethod
+    def setup_clients(cls):
+        super(ScenarioTest, cls).setup_clients()
+        # Clients (in alphabetical order)
+        cls.flavors_client = cls.os_primary.flavors_client
+        cls.compute_floating_ips_client = (
+            cls.os_primary.compute_floating_ips_client)
+        if CONF.service_available.glance:
+            # Check if glance v1 is available to determine which client to use.
+            if CONF.image_feature_enabled.api_v1:
+                cls.image_client = cls.os_primary.image_client
+            elif CONF.image_feature_enabled.api_v2:
+                cls.image_client = cls.os_primary.image_client_v2
+            else:
+                raise lib_exc.InvalidConfiguration(
+                    'Either api_v1 or api_v2 must be True in '
+                    '[image-feature-enabled].')
+        # Compute image client
+        cls.compute_images_client = cls.os_primary.compute_images_client
+        cls.keypairs_client = cls.os_primary.keypairs_client
+        # Nova security groups client
+        cls.compute_security_groups_client = (
+            cls.os_primary.compute_security_groups_client)
+        cls.compute_security_group_rules_client = (
+            cls.os_primary.compute_security_group_rules_client)
+        cls.servers_client = cls.os_primary.servers_client
+        cls.interface_client = cls.os_primary.interfaces_client
+        # Neutron network client
+        cls.networks_client = cls.os_primary.networks_client
+        cls.ports_client = cls.os_primary.ports_client
+        cls.routers_client = cls.os_primary.routers_client
+        cls.subnets_client = cls.os_primary.subnets_client
+        cls.floating_ips_client = cls.os_primary.floating_ips_client
+        cls.security_groups_client = cls.os_primary.security_groups_client
+        cls.security_group_rules_client = (
+            cls.os_primary.security_group_rules_client)
+
+        if CONF.volume_feature_enabled.api_v2:
+            cls.volumes_client = cls.os_primary.volumes_v2_client
+            cls.snapshots_client = cls.os_primary.snapshots_v2_client
+        else:
+            cls.volumes_client = cls.os_primary.volumes_client
+            cls.snapshots_client = cls.os_primary.snapshots_client
+
+    # ## Test functions library
+    #
+    # The create_[resource] functions only return body and discard the
+    # resp part which is not used in scenario tests
+
+    def _create_port(self, network_id, client=None, namestart='port-quotatest',
+                     **kwargs):
+        if not client:
+            client = self.ports_client
+        name = data_utils.rand_name(namestart)
+        result = client.create_port(
+            name=name,
+            network_id=network_id,
+            **kwargs)
+        self.assertIsNotNone(result, 'Unable to allocate port')
+        port = result['port']
+        self.addCleanup(test_utils.call_and_ignore_notfound_exc,
+                        client.delete_port, port['id'])
+        return port
+
+    def create_keypair(self, client=None):
+        if not client:
+            client = self.keypairs_client
+        name = data_utils.rand_name(self.__class__.__name__)
+        # We don't need to create a keypair by pubkey in scenario
+        body = client.create_keypair(name=name)
+        self.addCleanup(client.delete_keypair, name)
+        return body['keypair']
+
+    def create_server(self, name=None, image_id=None, flavor=None,
+                      validatable=False, wait_until='ACTIVE',
+                      clients=None, **kwargs):
+        """Wrapper utility that returns a test server.
+
+        This wrapper utility calls the common create test server and
+        returns a test server. The purpose of this wrapper is to minimize
+        the impact on the code of the tests already using this
+        function.
+        """
+
+        # NOTE(jlanoux): As a first step, ssh checks in the scenario
+        # tests need to be run regardless of the run_validation and
+        # validatable parameters and thus until the ssh validation job
+        # becomes voting in CI. The test resources management and IP
+        # association are taken care of in the scenario tests.
+        # Therefore, the validatable parameter is set to false in all
+        # those tests. In this way create_server just return a standard
+        # server and the scenario tests always perform ssh checks.
+
+        # Needed for the cross_tenant_traffic test:
+        if clients is None:
+            clients = self.os_primary
+
+        if name is None:
+            name = data_utils.rand_name(self.__class__.__name__ + "-server")
+
+        vnic_type = CONF.network.port_vnic_type
+
+        # If vnic_type is configured create port for
+        # every network
+        if vnic_type:
+            ports = []
+
+            create_port_body = {'binding:vnic_type': vnic_type,
+                                'namestart': 'port-smoke'}
+            if kwargs:
+                # Convert security group names to security group ids
+                # to pass to create_port
+                if 'security_groups' in kwargs:
+                    security_groups = \
+                        clients.security_groups_client.list_security_groups(
+                        ).get('security_groups')
+                    sec_dict = dict([(s['name'], s['id'])
+                                    for s in security_groups])
+
+                    sec_groups_names = [s['name'] for s in kwargs.pop(
+                        'security_groups')]
+                    security_groups_ids = [sec_dict[s]
+                                           for s in sec_groups_names]
+
+                    if security_groups_ids:
+                        create_port_body[
+                            'security_groups'] = security_groups_ids
+                networks = kwargs.pop('networks', [])
+            else:
+                networks = []
+
+            # If there are no networks passed to us we look up
+            # for the project's private networks and create a port.
+            # The same behaviour as we would expect when passing
+            # the call to the clients with no networks
+            if not networks:
+                networks = clients.networks_client.list_networks(
+                    **{'router:external': False, 'fields': 'id'})['networks']
+
+            # It's net['uuid'] if networks come from kwargs
+            # and net['id'] if they come from
+            # clients.networks_client.list_networks
+            for net in networks:
+                net_id = net.get('uuid', net.get('id'))
+                if 'port' not in net:
+                    port = self._create_port(network_id=net_id,
+                                             client=clients.ports_client,
+                                             **create_port_body)
+                    ports.append({'port': port['id']})
+                else:
+                    ports.append({'port': net['port']})
+            if ports:
+                kwargs['networks'] = ports
+            self.ports = ports
+
+        tenant_network = self.get_tenant_network()
+
+        body, servers = compute.create_test_server(
+            clients,
+            tenant_network=tenant_network,
+            wait_until=wait_until,
+            name=name, flavor=flavor,
+            image_id=image_id, **kwargs)
+
+        self.addCleanup(waiters.wait_for_server_termination,
+                        clients.servers_client, body['id'])
+        self.addCleanup(test_utils.call_and_ignore_notfound_exc,
+                        clients.servers_client.delete_server, body['id'])
+        server = clients.servers_client.show_server(body['id'])['server']
+        return server
+
+    def get_remote_client(self, ip_address, username=None, private_key=None):
+        """Get a SSH client to a remote server
+
+        @param ip_address the server floating or fixed IP address to use
+                          for ssh validation
+        @param username name of the Linux account on the remote server
+        @param private_key the SSH private key to use
+        @return a RemoteClient object
+        """
+
+        if username is None:
+            username = CONF.validation.image_ssh_user
+        # Set this with 'keypair' or others to log in with keypair or
+        # username/password.
+        if CONF.validation.auth_method == 'keypair':
+            password = None
+            if private_key is None:
+                private_key = self.keypair['private_key']
+        else:
+            password = CONF.validation.image_ssh_password
+            private_key = None
+        linux_client = remote_client.RemoteClient(ip_address, username,
+                                                  pkey=private_key,
+                                                  password=password)
+        try:
+            linux_client.validate_authentication()
+        except Exception as e:
+            message = ('Initializing SSH connection to %(ip)s failed. '
+                       'Error: %(error)s' % {'ip': ip_address,
+                                             'error': e})
+            caller = test_utils.find_test_caller()
+            if caller:
+                message = '(%s) %s' % (caller, message)
+            LOG.exception(message)
+            self._log_console_output()
+            raise
+
+        return linux_client
+
+    def _log_console_output(self, servers=None):
+        if not CONF.compute_feature_enabled.console_output:
+            LOG.debug('Console output not supported, cannot log')
+            return
+        if not servers:
+            servers = self.servers_client.list_servers()
+            servers = servers['servers']
+        for server in servers:
+            try:
+                console_output = self.servers_client.get_console_output(
+                    server['id'])['output']
+                LOG.debug('Console output for %s\nbody=\n%s',
+                          server['id'], console_output)
+            except lib_exc.NotFound:
+                LOG.debug("Server %s disappeared(deleted) while looking "
+                          "for the console log", server['id'])
+
+    def rebuild_server(self, server_id, image=None,
+                       preserve_ephemeral=False, wait=True,
+                       rebuild_kwargs=None):
+        if image is None:
+            image = CONF.compute.image_ref
+
+        rebuild_kwargs = rebuild_kwargs or {}
+
+        LOG.debug("Rebuilding server (id: %s, image: %s, preserve eph: %s)",
+                  server_id, image, preserve_ephemeral)
+        self.servers_client.rebuild_server(
+            server_id=server_id, image_ref=image,
+            preserve_ephemeral=preserve_ephemeral,
+            **rebuild_kwargs)
+        if wait:
+            waiters.wait_for_server_status(self.servers_client,
+                                           server_id, 'ACTIVE')
+
+    def ping_ip_address(self, ip_address, should_succeed=True,
+                        ping_timeout=None, mtu=None):
+        timeout = ping_timeout or CONF.validation.ping_timeout
+        cmd = ['ping', '-c1', '-w1']
+
+        if mtu:
+            cmd += [
+                # don't fragment
+                '-M', 'do',
+                # ping receives just the size of ICMP payload
+                '-s', str(net_utils.get_ping_payload_size(mtu, 4))
+            ]
+        cmd.append(ip_address)
+
+        def ping():
+            proc = subprocess.Popen(cmd,
+                                    stdout=subprocess.PIPE,
+                                    stderr=subprocess.PIPE)
+            proc.communicate()
+
+            return (proc.returncode == 0) == should_succeed
+
+        caller = test_utils.find_test_caller()
+        LOG.debug('%(caller)s begins to ping %(ip)s in %(timeout)s sec and the'
+                  ' expected result is %(should_succeed)s', {
+                      'caller': caller, 'ip': ip_address, 'timeout': timeout,
+                      'should_succeed':
+                      'reachable' if should_succeed else 'unreachable'
+                  })
+        result = test_utils.call_until_true(ping, timeout, 1)
+        LOG.debug('%(caller)s finishes ping %(ip)s in %(timeout)s sec and the '
+                  'ping result is %(result)s', {
+                      'caller': caller, 'ip': ip_address, 'timeout': timeout,
+                      'result': 'expected' if result else 'unexpected'
+                  })
+        return result
+
+    def check_vm_connectivity(self, ip_address,
+                              username=None,
+                              private_key=None,
+                              should_connect=True,
+                              mtu=None):
+        """Check server connectivity
+
+        :param ip_address: server to test against
+        :param username: server's ssh username
+        :param private_key: server's ssh private key to be used
+        :param should_connect: True/False indicates positive/negative test
+            positive - attempt ping and ssh
+            negative - attempt ping and fail if succeed
+        :param mtu: network MTU to use for connectivity validation
+
+        :raises: AssertError if the result of the connectivity check does
+            not match the value of the should_connect param
+        """
+        if should_connect:
+            msg = "Timed out waiting for %s to become reachable" % ip_address
+        else:
+            msg = "ip address %s is reachable" % ip_address
+        self.assertTrue(self.ping_ip_address(ip_address,
+                                             should_succeed=should_connect,
+                                             mtu=mtu),
+                        msg=msg)
+        if should_connect:
+            # no need to check ssh for negative connectivity
+            self.get_remote_client(ip_address, username, private_key)
+
+    def create_floating_ip(self, thing, pool_name=None):
+        """Create a floating IP and associates to a server on Nova"""
+
+        if not pool_name:
+            pool_name = CONF.network.floating_network_name
+        floating_ip = (self.compute_floating_ips_client.
+                       create_floating_ip(pool=pool_name)['floating_ip'])
+        self.addCleanup(test_utils.call_and_ignore_notfound_exc,
+                        self.compute_floating_ips_client.delete_floating_ip,
+                        floating_ip['id'])
+        self.compute_floating_ips_client.associate_floating_ip_to_server(
+            floating_ip['ip'], thing['id'])
+        return floating_ip
+
+    def create_timestamp(self, ip_address, dev_name=None, mount_path='/mnt',
+                         private_key=None):
+        ssh_client = self.get_remote_client(ip_address,
+                                            private_key=private_key)
+        if dev_name is not None:
+            ssh_client.make_fs(dev_name)
+            ssh_client.exec_command('sudo mount /dev/%s %s' % (dev_name,
+                                                               mount_path))
+        cmd_timestamp = 'sudo sh -c "date > %s/timestamp; sync"' % mount_path
+        ssh_client.exec_command(cmd_timestamp)
+        timestamp = ssh_client.exec_command('sudo cat %s/timestamp'
+                                            % mount_path)
+        if dev_name is not None:
+            ssh_client.exec_command('sudo umount %s' % mount_path)
+        return timestamp
+
+    def get_server_ip(self, server):
+        """Get the server fixed or floating IP.
+
+        Based on the configuration we're in, return a correct ip
+        address for validating that a guest is up.
+        """
+        if CONF.validation.connect_method == 'floating':
+            # The tests calling this method don't have a floating IP
+            # and can't make use of the validation resources. So the
+            # method is creating the floating IP there.
+            return self.create_floating_ip(server)['ip']
+        elif CONF.validation.connect_method == 'fixed':
+            # Determine the network name to look for based on config or creds
+            # provider network resources.
+            if CONF.validation.network_for_ssh:
+                addresses = server['addresses'][
+                    CONF.validation.network_for_ssh]
+            else:
+                creds_provider = self._get_credentials_provider()
+                net_creds = creds_provider.get_primary_creds()
+                network = getattr(net_creds, 'network', None)
+                addresses = (server['addresses'][network['name']]
+                             if network else [])
+            for address in addresses:
+                if (address['version'] == CONF.validation.ip_version_for_ssh
+                        and address['OS-EXT-IPS:type'] == 'fixed'):
+                    return address['addr']
+            raise exceptions.ServerUnreachable(server_id=server['id'])
+        else:
+            raise lib_exc.InvalidConfiguration()
+
+    def _get_router(self, client=None, tenant_id=None):
+        """Retrieve a router for the given tenant id.
+
+        If a public router has been configured, it will be returned.
+
+        If a public router has not been configured, but a public
+        network has, a tenant router will be created and returned that
+        routes traffic to the public network.
+        """
+        if not client:
+            client = self.routers_client
+        if not tenant_id:
+            tenant_id = client.tenant_id
+        router_id = CONF.network.public_router_id
+        network_id = CONF.network.public_network_id
+        if router_id:
+            body = client.show_router(router_id)
+            return body['router']
+        elif network_id:
+            router = self._create_router(client, tenant_id)
+            kwargs = {'external_gateway_info': dict(network_id=network_id)}
+            router = client.update_router(router['id'], **kwargs)['router']
+            return router
+        else:
+            raise Exception("Neither of 'public_router_id' or "
+                            "'public_network_id' has been defined.")
+
+    def _create_router(self, client=None, tenant_id=None,
+                       namestart='router-smoke'):
+        if not client:
+            client = self.routers_client
+        if not tenant_id:
+            tenant_id = client.tenant_id
+        name = data_utils.rand_name(namestart)
+        result = client.create_router(name=name,
+                                      admin_state_up=True,
+                                      tenant_id=tenant_id)
+        router = result['router']
+        self.assertEqual(router['name'], name)
+        self.addCleanup(test_utils.call_and_ignore_notfound_exc,
+                        client.delete_router,
+                        router['id'])
+        return router
+
+
+class NetworkScenarioTest(ScenarioTest):
+    """Base class for network scenario tests.
+
+    This class provide helpers for network scenario tests, using the neutron
+    API. Helpers from ancestor which use the nova network API are overridden
+    with the neutron API.
+
+    This Class also enforces using Neutron instead of novanetwork.
+    Subclassed tests will be skipped if Neutron is not enabled
+
+    """
+
+    credentials = ['primary', 'admin']
+
+    @classmethod
+    def skip_checks(cls):
+        super(NetworkScenarioTest, cls).skip_checks()
+        if not CONF.service_available.neutron:
+            raise cls.skipException('Neutron not available')
+
+    def _create_network(self, networks_client=None,
+                        tenant_id=None,
+                        namestart='network-smoke-',
+                        port_security_enabled=True):
+        if not networks_client:
+            networks_client = self.networks_client
+        if not tenant_id:
+            tenant_id = networks_client.tenant_id
+        name = data_utils.rand_name(namestart)
+        network_kwargs = dict(name=name, tenant_id=tenant_id)
+        # Neutron disables port security by default so we have to check the
+        # config before trying to create the network with port_security_enabled
+        if CONF.network_feature_enabled.port_security:
+            network_kwargs['port_security_enabled'] = port_security_enabled
+        result = networks_client.create_network(**network_kwargs)
+        network = result['network']
+
+        self.assertEqual(network['name'], name)
+        self.addCleanup(test_utils.call_and_ignore_notfound_exc,
+                        networks_client.delete_network,
+                        network['id'])
+        return network
+
+    def _get_server_port_id_and_ip4(self, server, ip_addr=None):
+        ports = self.os_admin.ports_client.list_ports(
+            device_id=server['id'], fixed_ip=ip_addr)['ports']
+        # A port can have more than one IP address in some cases.
+        # If the network is dual-stack (IPv4 + IPv6), this port is associated
+        # with 2 subnets
+        p_status = ['ACTIVE']
+        # NOTE(vsaienko) With Ironic, instances live on separate hardware
+        # servers. Neutron does not bind ports for Ironic instances, as a
+        # result the port remains in the DOWN state.
+        # TODO(vsaienko) remove once bug: #1599836 is resolved.
+        if getattr(CONF.service_available, 'ironic', False):
+            p_status.append('DOWN')
+        port_map = [(p["id"], fxip["ip_address"])
+                    for p in ports
+                    for fxip in p["fixed_ips"]
+                    if netutils.is_valid_ipv4(fxip["ip_address"])
+                    and p['status'] in p_status]
+        inactive = [p for p in ports if p['status'] != 'ACTIVE']
+        if inactive:
+            LOG.warning("Instance has ports that are not ACTIVE: %s", inactive)
+
+        self.assertNotEqual(0, len(port_map),
+                            "No IPv4 addresses found in: %s" % ports)
+        self.assertEqual(len(port_map), 1,
+                         "Found multiple IPv4 addresses: %s. "
+                         "Unable to determine which port to target."
+                         % port_map)
+        return port_map[0]
+
+    def create_floating_ip(self, thing, external_network_id=None,
+                           port_id=None, client=None):
+        """Create a floating IP and associates to a resource/port on Neutron"""
+        if not external_network_id:
+            external_network_id = CONF.network.public_network_id
+        if not client:
+            client = self.floating_ips_client
+        if not port_id:
+            port_id, ip4 = self._get_server_port_id_and_ip4(thing)
+        else:
+            ip4 = None
+        result = client.create_floatingip(
+            floating_network_id=external_network_id,
+            port_id=port_id,
+            tenant_id=thing['tenant_id'],
+            fixed_ip_address=ip4
+        )
+        floating_ip = result['floatingip']
+        self.addCleanup(test_utils.call_and_ignore_notfound_exc,
+                        client.delete_floatingip,
+                        floating_ip['id'])
+        return floating_ip
diff --git a/ironic_tempest_plugin/plugin.py b/ironic_tempest_plugin/plugin.py
index 0428c7d..e20386b 100644
--- a/ironic_tempest_plugin/plugin.py
+++ b/ironic_tempest_plugin/plugin.py
@@ -1,3 +1,6 @@
+# Copyright 2015 NEC Corporation
+# All Rights Reserved.
+#
 #    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
@@ -13,29 +16,35 @@
 
 import os
 
+from tempest import config
 from tempest.test_discover import plugins
 
-from ironic_inspector.test.inspector_tempest_plugin import config
+from ironic_tempest_plugin import config as project_config
+
+_opts = [
+    (project_config.baremetal_group, project_config.BaremetalGroup),
+    (project_config.baremetal_features_group,
+     project_config.BaremetalFeaturesGroup)
+    (project_config.baremetal_introspection_group,
+     project_config.BaremetalIntrospectionGroup),
+]
 
 
-class InspectorTempestPlugin(plugins.TempestPlugin):
+class IronicTempestPlugin(plugins.TempestPlugin):
     def load_tests(self):
         base_path = os.path.split(os.path.dirname(
             os.path.abspath(__file__)))[0]
-        test_dir = "inspector_tempest_plugin/tests"
+        test_dir = "ironic_tempest_plugin/tests"
         full_test_dir = os.path.join(base_path, test_dir)
         return full_test_dir, base_path
 
     def register_opts(self, conf):
-        conf.register_opt(config.service_option,
+        conf.register_opt(project_config.ironic_service_option,
                           group='service_available')
-        conf.register_group(config.baremetal_introspection_group)
-        conf.register_opts(config.BaremetalIntrospectionGroup,
-                           group="baremetal_introspection")
+        conf.register_opt(project_config.inspector_service_option,
+                          group='service_available')
+        for group, option in _opts:
+            config.register_opt_group(conf, group, option)
 
     def get_opt_lists(self):
-        return [
-            (config.baremetal_introspection_group.name,
-             config.BaremetalIntrospectionGroup),
-            ('service_available', [config.service_option])
-        ]
+        return [(group.name, option) for group, option in _opts]
diff --git a/ironic_tempest_plugin/services/baremetal/__init__.py b/ironic_tempest_plugin/services/baremetal/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/ironic_tempest_plugin/services/baremetal/__init__.py
diff --git a/ironic_tempest_plugin/services/baremetal/base.py b/ironic_tempest_plugin/services/baremetal/base.py
new file mode 100644
index 0000000..757a770
--- /dev/null
+++ b/ironic_tempest_plugin/services/baremetal/base.py
@@ -0,0 +1,264 @@
+#    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 functools
+
+from oslo_serialization import jsonutils as json
+from six.moves import http_client
+from six.moves.urllib import parse as urllib
+from tempest.lib.common import api_version_utils
+from tempest.lib.common import rest_client
+
+# NOTE(vsaienko): concurrent tests work because they are launched in
+# separate processes so global variables are not shared among them.
+BAREMETAL_MICROVERSION = None
+
+
+def set_baremetal_api_microversion(baremetal_microversion):
+    global BAREMETAL_MICROVERSION
+    BAREMETAL_MICROVERSION = baremetal_microversion
+
+
+def reset_baremetal_api_microversion():
+    global BAREMETAL_MICROVERSION
+    BAREMETAL_MICROVERSION = None
+
+
+def handle_errors(f):
+    """A decorator that allows to ignore certain types of errors."""
+
+    @functools.wraps(f)
+    def wrapper(*args, **kwargs):
+        param_name = 'ignore_errors'
+        ignored_errors = kwargs.get(param_name, tuple())
+
+        if param_name in kwargs:
+            del kwargs[param_name]
+
+        try:
+            return f(*args, **kwargs)
+        except ignored_errors:
+            # Silently ignore errors
+            pass
+
+    return wrapper
+
+
+class BaremetalClient(rest_client.RestClient):
+    """Base Tempest REST client for Ironic API."""
+
+    api_microversion_header_name = 'X-OpenStack-Ironic-API-Version'
+    uri_prefix = ''
+
+    def get_headers(self):
+        headers = super(BaremetalClient, self).get_headers()
+        if BAREMETAL_MICROVERSION:
+            headers[self.api_microversion_header_name] = BAREMETAL_MICROVERSION
+        return headers
+
+    def request(self, *args, **kwargs):
+        resp, resp_body = super(BaremetalClient, self).request(*args, **kwargs)
+        if (BAREMETAL_MICROVERSION and
+            BAREMETAL_MICROVERSION != api_version_utils.LATEST_MICROVERSION):
+            api_version_utils.assert_version_header_matches_request(
+                self.api_microversion_header_name,
+                BAREMETAL_MICROVERSION,
+                resp)
+        return resp, resp_body
+
+    def serialize(self, object_dict):
+        """Serialize an Ironic object."""
+
+        return json.dumps(object_dict)
+
+    def deserialize(self, object_str):
+        """Deserialize an Ironic object."""
+
+        return json.loads(object_str)
+
+    def _get_uri(self, resource_name, uuid=None, permanent=False):
+        """Get URI for a specific resource or object.
+
+        :param resource_name: The name of the REST resource, e.g., 'nodes'.
+        :param uuid: The unique identifier of an object in UUID format.
+        :returns: Relative URI for the resource or object.
+
+        """
+        prefix = self.uri_prefix if not permanent else ''
+
+        return '{pref}/{res}{uuid}'.format(pref=prefix,
+                                           res=resource_name,
+                                           uuid='/%s' % uuid if uuid else '')
+
+    def _make_patch(self, allowed_attributes, **kwargs):
+        """Create a JSON patch according to RFC 6902.
+
+        :param allowed_attributes: An iterable object that contains a set of
+            allowed attributes for an object.
+        :param **kwargs: Attributes and new values for them.
+        :returns: A JSON path that sets values of the specified attributes to
+            the new ones.
+
+        """
+        def get_change(kwargs, path='/'):
+            for name, value in kwargs.items():
+                if isinstance(value, dict):
+                    for ch in get_change(value, path + '%s/' % name):
+                        yield ch
+                else:
+                    if value is None:
+                        yield {'path': path + name,
+                               'op': 'remove'}
+                    else:
+                        yield {'path': path + name,
+                               'value': value,
+                               'op': 'replace'}
+
+        patch = [ch for ch in get_change(kwargs)
+                 if ch['path'].lstrip('/') in allowed_attributes]
+
+        return patch
+
+    def _list_request(self, resource, permanent=False, headers=None,
+                      extra_headers=False, **kwargs):
+        """Get the list of objects of the specified type.
+
+        :param resource: The name of the REST resource, e.g., 'nodes'.
+        :param headers: List of headers to use in request.
+        :param extra_headers: Specify whether to use headers.
+        :param **kwargs: Parameters for the request.
+        :returns: A tuple with the server response and deserialized JSON list
+                 of objects
+
+        """
+        uri = self._get_uri(resource, permanent=permanent)
+        if kwargs:
+            uri += "?%s" % urllib.urlencode(kwargs)
+
+        resp, body = self.get(uri, headers=headers,
+                              extra_headers=extra_headers)
+        self.expected_success(http_client.OK, resp.status)
+
+        return resp, self.deserialize(body)
+
+    def _show_request(self,
+                      resource,
+                      uuid=None,
+                      permanent=False,
+                      **kwargs):
+        """Gets a specific object of the specified type.
+
+        :param uuid: Unique identifier of the object in UUID format.
+        :returns: Serialized object as a dictionary.
+
+        """
+        if 'uri' in kwargs:
+            uri = kwargs['uri']
+        else:
+            uri = self._get_uri(resource, uuid=uuid, permanent=permanent)
+        resp, body = self.get(uri)
+        self.expected_success(http_client.OK, resp.status)
+
+        return resp, self.deserialize(body)
+
+    def _create_request(self, resource, object_dict):
+        """Create an object of the specified type.
+
+        :param resource: The name of the REST resource, e.g., 'nodes'.
+        :param object_dict: A Python dict that represents an object of the
+                            specified type.
+        :returns: A tuple with the server response and the deserialized created
+                 object.
+
+        """
+        body = self.serialize(object_dict)
+        uri = self._get_uri(resource)
+
+        resp, body = self.post(uri, body=body)
+        self.expected_success(http_client.CREATED, resp.status)
+
+        return resp, self.deserialize(body)
+
+    def _create_request_no_response_body(self, resource, object_dict):
+        """Create an object of the specified type.
+
+           Do not expect any body in the response.
+
+        :param resource: The name of the REST resource, e.g., 'nodes'.
+        :param object_dict: A Python dict that represents an object of the
+                            specified type.
+        :returns: The server response.
+        """
+
+        body = self.serialize(object_dict)
+        uri = self._get_uri(resource)
+
+        resp, body = self.post(uri, body=body)
+        self.expected_success(http_client.NO_CONTENT, resp.status)
+
+        return resp
+
+    def _delete_request(self, resource, uuid):
+        """Delete specified object.
+
+        :param resource: The name of the REST resource, e.g., 'nodes'.
+        :param uuid: The unique identifier of an object in UUID format.
+        :returns: A tuple with the server response and the response body.
+
+        """
+        uri = self._get_uri(resource, uuid)
+
+        resp, body = self.delete(uri)
+        self.expected_success(http_client.NO_CONTENT, resp.status)
+        return resp, body
+
+    def _patch_request(self, resource, uuid, patch_object):
+        """Update specified object with JSON-patch.
+
+        :param resource: The name of the REST resource, e.g., 'nodes'.
+        :param uuid: The unique identifier of an object in UUID format.
+        :returns: A tuple with the server response and the serialized patched
+                 object.
+
+        """
+        uri = self._get_uri(resource, uuid)
+        patch_body = json.dumps(patch_object)
+
+        resp, body = self.patch(uri, body=patch_body)
+        self.expected_success(http_client.OK, resp.status)
+        return resp, self.deserialize(body)
+
+    @handle_errors
+    def get_api_description(self):
+        """Retrieves all versions of the Ironic API."""
+
+        return self._list_request('', permanent=True)
+
+    @handle_errors
+    def get_version_description(self, version='v1'):
+        """Retrieves the description of the API.
+
+        :param version: The version of the API. Default: 'v1'.
+        :returns: Serialized description of API resources.
+
+        """
+        return self._list_request(version, permanent=True)
+
+    def _put_request(self, resource, put_object):
+        """Update specified object with JSON-patch."""
+        uri = self._get_uri(resource)
+        put_body = json.dumps(put_object)
+
+        resp, body = self.put(uri, body=put_body)
+        self.expected_success([http_client.ACCEPTED, http_client.NO_CONTENT],
+                              resp.status)
+        return resp, body
diff --git a/ironic_tempest_plugin/services/baremetal/v1/__init__.py b/ironic_tempest_plugin/services/baremetal/v1/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/ironic_tempest_plugin/services/baremetal/v1/__init__.py
diff --git a/ironic_tempest_plugin/services/baremetal/v1/json/__init__.py b/ironic_tempest_plugin/services/baremetal/v1/json/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/ironic_tempest_plugin/services/baremetal/v1/json/__init__.py
diff --git a/ironic_tempest_plugin/services/baremetal/v1/json/baremetal_client.py b/ironic_tempest_plugin/services/baremetal/v1/json/baremetal_client.py
new file mode 100644
index 0000000..9712dba
--- /dev/null
+++ b/ironic_tempest_plugin/services/baremetal/v1/json/baremetal_client.py
@@ -0,0 +1,641 @@
+#    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 six.moves import http_client
+
+from ironic_tempest_plugin.services.baremetal import base
+
+
+class BaremetalClient(base.BaremetalClient):
+    """Base Tempest REST client for Ironic API v1."""
+    version = '1'
+    uri_prefix = 'v1'
+
+    @base.handle_errors
+    def list_nodes(self, **kwargs):
+        """List all existing nodes."""
+        return self._list_request('nodes', **kwargs)
+
+    @base.handle_errors
+    def list_nodes_detail(self, **kwargs):
+        """Detailed list of all existing nodes."""
+        return self._list_request('/nodes/detail', **kwargs)
+
+    @base.handle_errors
+    def list_chassis(self):
+        """List all existing chassis."""
+        return self._list_request('chassis')
+
+    @base.handle_errors
+    def list_chassis_nodes(self, chassis_uuid):
+        """List all nodes associated with a chassis."""
+        return self._list_request('/chassis/%s/nodes' % chassis_uuid)
+
+    @base.handle_errors
+    def list_ports(self, **kwargs):
+        """List all existing ports."""
+        return self._list_request('ports', **kwargs)
+
+    @base.handle_errors
+    def list_portgroups(self, **kwargs):
+        """List all existing port groups."""
+        return self._list_request('portgroups', **kwargs)
+
+    @base.handle_errors
+    def list_volume_connectors(self, **kwargs):
+        """List all existing volume connectors."""
+        return self._list_request('volume/connectors', **kwargs)
+
+    @base.handle_errors
+    def list_volume_targets(self, **kwargs):
+        """List all existing volume targets."""
+        return self._list_request('volume/targets', **kwargs)
+
+    @base.handle_errors
+    def list_node_ports(self, uuid):
+        """List all ports associated with the node."""
+        return self._list_request('/nodes/%s/ports' % uuid)
+
+    @base.handle_errors
+    def list_nodestates(self, uuid):
+        """List all existing states."""
+        return self._list_request('/nodes/%s/states' % uuid)
+
+    @base.handle_errors
+    def list_ports_detail(self, **kwargs):
+        """Details list all existing ports."""
+        return self._list_request('/ports/detail', **kwargs)
+
+    @base.handle_errors
+    def list_drivers(self):
+        """List all existing drivers."""
+        return self._list_request('drivers')
+
+    @base.handle_errors
+    def show_node(self, uuid):
+        """Gets a specific node.
+
+        :param uuid: Unique identifier of the node in UUID format.
+        :return: Serialized node as a dictionary.
+
+        """
+        return self._show_request('nodes', uuid)
+
+    @base.handle_errors
+    def show_node_by_instance_uuid(self, instance_uuid):
+        """Gets a node associated with given instance uuid.
+
+        :param instance_uuid: Unique identifier of the instance in UUID format.
+        :return: Serialized node as a dictionary.
+
+        """
+        uri = '/nodes/detail?instance_uuid=%s' % instance_uuid
+
+        return self._show_request('nodes',
+                                  uuid=None,
+                                  uri=uri)
+
+    @base.handle_errors
+    def show_chassis(self, uuid):
+        """Gets a specific chassis.
+
+        :param uuid: Unique identifier of the chassis in UUID format.
+        :return: Serialized chassis as a dictionary.
+
+        """
+        return self._show_request('chassis', uuid)
+
+    @base.handle_errors
+    def show_port(self, uuid):
+        """Gets a specific port.
+
+        :param uuid: Unique identifier of the port in UUID format.
+        :return: Serialized port as a dictionary.
+
+        """
+        return self._show_request('ports', uuid)
+
+    @base.handle_errors
+    def show_portgroup(self, portgroup_ident):
+        """Gets a specific port group.
+
+        :param portgroup_ident: Name or UUID of the port group.
+        :return: Serialized port group as a dictionary.
+        """
+        return self._show_request('portgroups', portgroup_ident)
+
+    @base.handle_errors
+    def show_volume_connector(self, volume_connector_ident):
+        """Gets a specific volume connector.
+
+        :param volume_connector_ident: UUID of the volume connector.
+        :return: Serialized volume connector as a dictionary.
+        """
+        return self._show_request('volume/connectors', volume_connector_ident)
+
+    @base.handle_errors
+    def show_volume_target(self, volume_target_ident):
+        """Gets a specific volume target.
+
+        :param volume_target_ident: UUID of the volume target.
+        :return: Serialized volume target as a dictionary.
+        """
+        return self._show_request('volume/targets', volume_target_ident)
+
+    @base.handle_errors
+    def show_port_by_address(self, address):
+        """Gets a specific port by address.
+
+        :param address: MAC address of the port.
+        :return: Serialized port as a dictionary.
+
+        """
+        uri = '/ports/detail?address=%s' % address
+
+        return self._show_request('ports', uuid=None, uri=uri)
+
+    def show_driver(self, driver_name):
+        """Gets a specific driver.
+
+        :param driver_name: Name of driver.
+        :return: Serialized driver as a dictionary.
+        """
+        return self._show_request('drivers', driver_name)
+
+    @base.handle_errors
+    def create_node(self, chassis_id=None, **kwargs):
+        """Create a baremetal node with the specified parameters.
+
+        :param chassis_id: The unique identifier of the chassis.
+        :param cpu_arch: CPU architecture of the node. Default: x86_64.
+        :param cpus: Number of CPUs. Default: 8.
+        :param local_gb: Disk size. Default: 1024.
+        :param memory_mb: Available RAM. Default: 4096.
+        :param driver: Driver name. Default: "fake"
+        :return: A tuple with the server response and the created node.
+
+        """
+        node = {}
+        if kwargs.get('resource_class'):
+            node['resource_class'] = kwargs['resource_class']
+
+        node.update(
+            {'chassis_uuid': chassis_id,
+             'properties': {'cpu_arch': kwargs.get('cpu_arch', 'x86_64'),
+                            'cpus': kwargs.get('cpus', 8),
+                            'local_gb': kwargs.get('local_gb', 1024),
+                            'memory_mb': kwargs.get('memory_mb', 4096)},
+             'driver': kwargs.get('driver', 'fake')}
+        )
+
+        return self._create_request('nodes', node)
+
+    @base.handle_errors
+    def create_chassis(self, **kwargs):
+        """Create a chassis with the specified parameters.
+
+        :param description: The description of the chassis.
+            Default: test-chassis
+        :return: A tuple with the server response and the created chassis.
+
+        """
+        chassis = {'description': kwargs.get('description', 'test-chassis')}
+
+        if 'uuid' in kwargs:
+            chassis.update({'uuid': kwargs.get('uuid')})
+
+        return self._create_request('chassis', chassis)
+
+    @base.handle_errors
+    def create_port(self, node_id, **kwargs):
+        """Create a port with the specified parameters.
+
+        :param node_id: The ID of the node which owns the port.
+        :param address: MAC address of the port.
+        :param extra: Meta data of the port. Default: {'foo': 'bar'}.
+        :param uuid: UUID of the port.
+        :param portgroup_uuid: The UUID of a portgroup of which this port is a
+            member.
+        :param physical_network: The physical network to which the port is
+            attached.
+        :return: A tuple with the server response and the created port.
+
+        """
+        port = {'extra': kwargs.get('extra', {'foo': 'bar'}),
+                'uuid': kwargs['uuid']}
+
+        if node_id is not None:
+            port['node_uuid'] = node_id
+
+        for key in ('address', 'physical_network', 'portgroup_uuid'):
+            if kwargs.get(key) is not None:
+                port[key] = kwargs[key]
+
+        return self._create_request('ports', port)
+
+    @base.handle_errors
+    def create_portgroup(self, node_uuid, **kwargs):
+        """Create a port group with the specified parameters.
+
+        :param node_uuid: The UUID of the node which owns the port group.
+        :param kwargs:
+            address: MAC address of the port group. Optional.
+            extra: Meta data of the port group. Default: {'foo': 'bar'}.
+            name: Name of the port group. Optional.
+            uuid: UUID of the port group. Optional.
+        :return: A tuple with the server response and the created port group.
+        """
+        portgroup = {'extra': kwargs.get('extra', {'foo': 'bar'})}
+
+        portgroup['node_uuid'] = node_uuid
+
+        if kwargs.get('address'):
+            portgroup['address'] = kwargs['address']
+
+        if kwargs.get('name'):
+            portgroup['name'] = kwargs['name']
+
+        return self._create_request('portgroups', portgroup)
+
+    @base.handle_errors
+    def create_volume_connector(self, node_uuid, **kwargs):
+        """Create a volume connector with the specified parameters.
+
+        :param node_uuid: The UUID of the node which owns the volume connector.
+        :param kwargs:
+            type: type of the volume connector.
+            connector_id: connector_id of the volume connector.
+            uuid: UUID of the volume connector. Optional.
+            extra: meta data of the volume connector; a dictionary. Optional.
+        :return: A tuple with the server response and the created volume
+            connector.
+        """
+        volume_connector = {'node_uuid': node_uuid}
+
+        for arg in ('type', 'connector_id', 'uuid', 'extra'):
+            if arg in kwargs:
+                volume_connector[arg] = kwargs[arg]
+
+        return self._create_request('volume/connectors', volume_connector)
+
+    @base.handle_errors
+    def create_volume_target(self, node_uuid, **kwargs):
+        """Create a volume target with the specified parameters.
+
+        :param node_uuid: The UUID of the node which owns the volume target.
+        :param kwargs:
+            volume_type: type of the volume target.
+            volume_id: volume_id of the volume target.
+            boot_index: boot index of the volume target.
+            uuid: UUID of the volume target. Optional.
+            extra: meta data of the volume target; a dictionary. Optional.
+            properties: properties related to the type of the volume target;
+                a dictionary. Optional.
+        :return: A tuple with the server response and the created volume
+            target.
+        """
+        volume_target = {'node_uuid': node_uuid}
+
+        for arg in ('volume_type', 'volume_id', 'boot_index', 'uuid', 'extra',
+                    'properties'):
+            if arg in kwargs:
+                volume_target[arg] = kwargs[arg]
+
+        return self._create_request('volume/targets', volume_target)
+
+    @base.handle_errors
+    def delete_node(self, uuid):
+        """Deletes a node having the specified UUID.
+
+        :param uuid: The unique identifier of the node.
+        :return: A tuple with the server response and the response body.
+
+        """
+        return self._delete_request('nodes', uuid)
+
+    @base.handle_errors
+    def delete_chassis(self, uuid):
+        """Deletes a chassis having the specified UUID.
+
+        :param uuid: The unique identifier of the chassis.
+        :return: A tuple with the server response and the response body.
+
+        """
+        return self._delete_request('chassis', uuid)
+
+    @base.handle_errors
+    def delete_port(self, uuid):
+        """Deletes a port having the specified UUID.
+
+        :param uuid: The unique identifier of the port.
+        :return: A tuple with the server response and the response body.
+
+        """
+        return self._delete_request('ports', uuid)
+
+    @base.handle_errors
+    def delete_portgroup(self, portgroup_ident):
+        """Deletes a port group having the specified UUID or name.
+
+        :param portgroup_ident: Name or UUID of the port group.
+        :return: A tuple with the server response and the response body.
+        """
+        return self._delete_request('portgroups', portgroup_ident)
+
+    @base.handle_errors
+    def delete_volume_connector(self, volume_connector_ident):
+        """Deletes a volume connector having the specified UUID.
+
+        :param volume_connector_ident: UUID of the volume connector.
+        :return: A tuple with the server response and the response body.
+        """
+        return self._delete_request('volume/connectors',
+                                    volume_connector_ident)
+
+    @base.handle_errors
+    def delete_volume_target(self, volume_target_ident):
+        """Deletes a volume target having the specified UUID.
+
+        :param volume_target_ident: UUID of the volume target.
+        :return: A tuple with the server response and the response body.
+        """
+        return self._delete_request('volume/targets', volume_target_ident)
+
+    @base.handle_errors
+    def update_node(self, uuid, patch=None, **kwargs):
+        """Update the specified node.
+
+        :param uuid: The unique identifier of the node.
+        :param patch: A JSON path that sets values of the specified attributes
+                      to the new ones.
+        :param **kwargs: Attributes and new values for them, used only when
+                         patch param is not set.
+        :return: A tuple with the server response and the updated node.
+
+        """
+        node_attributes = ('properties/cpu_arch',
+                           'properties/cpus',
+                           'properties/local_gb',
+                           'properties/memory_mb',
+                           'driver',
+                           'instance_uuid',
+                           'resource_class')
+        if not patch:
+            patch = self._make_patch(node_attributes, **kwargs)
+
+        return self._patch_request('nodes', uuid, patch)
+
+    @base.handle_errors
+    def update_chassis(self, uuid, **kwargs):
+        """Update the specified chassis.
+
+        :param uuid: The unique identifier of the chassis.
+        :return: A tuple with the server response and the updated chassis.
+
+        """
+        chassis_attributes = ('description',)
+        patch = self._make_patch(chassis_attributes, **kwargs)
+
+        return self._patch_request('chassis', uuid, patch)
+
+    @base.handle_errors
+    def update_port(self, uuid, patch):
+        """Update the specified port.
+
+        :param uuid: The unique identifier of the port.
+        :param patch: List of dicts representing json patches.
+        :return: A tuple with the server response and the updated port.
+
+        """
+
+        return self._patch_request('ports', uuid, patch)
+
+    @base.handle_errors
+    def update_volume_connector(self, uuid, patch):
+        """Update the specified volume connector.
+
+        :param uuid: The unique identifier of the volume connector.
+        :param patch: List of dicts representing json patches. Each dict
+            has keys 'path', 'op' and 'value'; to update a field.
+        :return: A tuple with the server response and the updated volume
+            connector.
+        """
+
+        return self._patch_request('volume/connectors', uuid, patch)
+
+    @base.handle_errors
+    def update_volume_target(self, uuid, patch):
+        """Update the specified volume target.
+
+        :param uuid: The unique identifier of the volume target.
+        :param patch: List of dicts representing json patches. Each dict
+            has keys 'path', 'op' and 'value'; to update a field.
+        :return: A tuple with the server response and the updated volume
+            target.
+        """
+
+        return self._patch_request('volume/targets', uuid, patch)
+
+    @base.handle_errors
+    def set_node_power_state(self, node_uuid, state):
+        """Set power state of the specified node.
+
+        :param node_uuid: The unique identifier of the node.
+        :param state: desired state to set (on/off/reboot).
+
+        """
+        target = {'target': state}
+        return self._put_request('nodes/%s/states/power' % node_uuid,
+                                 target)
+
+    @base.handle_errors
+    def set_node_provision_state(self, node_uuid, state, configdrive=None,
+                                 clean_steps=None):
+        """Set provision state of the specified node.
+
+        :param node_uuid: The unique identifier of the node.
+        :param state: desired state to set
+                (active/rebuild/deleted/inspect/manage/provide).
+        :param configdrive: A gzipped, base64-encoded
+            configuration drive string.
+        :param clean_steps: A list with clean steps to execute.
+        """
+        data = {'target': state}
+        # NOTE (vsaienk0): Add both here if specified, do not check anything.
+        # API will return an error in case of invalid parameters.
+        if configdrive is not None:
+            data['configdrive'] = configdrive
+        if clean_steps is not None:
+            data['clean_steps'] = clean_steps
+        return self._put_request('nodes/%s/states/provision' % node_uuid,
+                                 data)
+
+    @base.handle_errors
+    def set_node_raid_config(self, node_uuid, target_raid_config):
+        """Set raid config of the specified node.
+
+        :param node_uuid: The unique identifier of the node.
+        :param target_raid_config: desired RAID configuration of the node.
+        """
+        return self._put_request('nodes/%s/states/raid' % node_uuid,
+                                 target_raid_config)
+
+    @base.handle_errors
+    def validate_driver_interface(self, node_uuid):
+        """Get all driver interfaces of a specific node.
+
+        :param node_uuid: Unique identifier of the node in UUID format.
+
+        """
+
+        uri = '{pref}/{res}/{uuid}/{postf}'.format(pref=self.uri_prefix,
+                                                   res='nodes',
+                                                   uuid=node_uuid,
+                                                   postf='validate')
+
+        return self._show_request('nodes', node_uuid, uri=uri)
+
+    @base.handle_errors
+    def set_node_boot_device(self, node_uuid, boot_device, persistent=False):
+        """Set the boot device of the specified node.
+
+        :param node_uuid: The unique identifier of the node.
+        :param boot_device: The boot device name.
+        :param persistent: Boolean value. True if the boot device will
+                           persist to all future boots, False if not.
+                           Default: False.
+
+        """
+        request = {'boot_device': boot_device, 'persistent': persistent}
+        resp, body = self._put_request('nodes/%s/management/boot_device' %
+                                       node_uuid, request)
+        self.expected_success(http_client.NO_CONTENT, resp.status)
+        return body
+
+    @base.handle_errors
+    def get_node_boot_device(self, node_uuid):
+        """Get the current boot device of the specified node.
+
+        :param node_uuid: The unique identifier of the node.
+
+        """
+        path = 'nodes/%s/management/boot_device' % node_uuid
+        resp, body = self._list_request(path)
+        self.expected_success(http_client.OK, resp.status)
+        return body
+
+    @base.handle_errors
+    def get_node_supported_boot_devices(self, node_uuid):
+        """Get the supported boot devices of the specified node.
+
+        :param node_uuid: The unique identifier of the node.
+
+        """
+        path = 'nodes/%s/management/boot_device/supported' % node_uuid
+        resp, body = self._list_request(path)
+        self.expected_success(http_client.OK, resp.status)
+        return body
+
+    @base.handle_errors
+    def get_console(self, node_uuid):
+        """Get connection information about the console.
+
+        :param node_uuid: Unique identifier of the node in UUID format.
+
+        """
+
+        resp, body = self._show_request('nodes/states/console', node_uuid)
+        self.expected_success(http_client.OK, resp.status)
+        return resp, body
+
+    @base.handle_errors
+    def set_console_mode(self, node_uuid, enabled):
+        """Start and stop the node console.
+
+        :param node_uuid: Unique identifier of the node in UUID format.
+        :param enabled: Boolean value; whether to enable or disable the
+                        console.
+
+        """
+
+        enabled = {'enabled': enabled}
+        resp, body = self._put_request('nodes/%s/states/console' % node_uuid,
+                                       enabled)
+        self.expected_success(http_client.ACCEPTED, resp.status)
+        return resp, body
+
+    @base.handle_errors
+    def vif_list(self, node_uuid, api_version=None):
+        """Get list of attached VIFs.
+
+        :param node_uuid: Unique identifier of the node in UUID format.
+        :param api_version: Ironic API version to use.
+        """
+        extra_headers = False
+        headers = None
+        if api_version is not None:
+            extra_headers = True
+            headers = {'x-openstack-ironic-api-version': api_version}
+        return self._list_request('nodes/%s/vifs' % node_uuid,
+                                  headers=headers,
+                                  extra_headers=extra_headers)
+
+    @base.handle_errors
+    def vif_attach(self, node_uuid, vif_id):
+        """Attach a VIF to a node
+
+        :param node_uuid: Unique identifier of the node in UUID format.
+        :param vif_id: An ID representing the VIF
+        """
+        vif = {'id': vif_id}
+        resp = self._create_request_no_response_body(
+            'nodes/%s/vifs' % node_uuid, vif)
+
+        return resp
+
+    @base.handle_errors
+    def vif_detach(self, node_uuid, vif_id):
+        """Detach a VIF from a node
+
+        :param node_uuid: Unique identifier of the node in UUID format.
+        :param vif_id: An ID representing the VIF
+        """
+        resp, body = self._delete_request('nodes/%s/vifs' % node_uuid, vif_id)
+        self.expected_success(http_client.NO_CONTENT, resp.status)
+        return resp, body
+
+    @base.handle_errors
+    def get_driver_properties(self, driver_name):
+        """Get properties information about driver.
+
+        :param driver_name: Name of driver.
+        :return: tuple of response and serialized properties as a dictionary.
+
+        """
+        uri = 'drivers/%s/properties' % driver_name
+        resp, body = self.get(uri)
+        self.expected_success(200, resp.status)
+        return resp, self.deserialize(body)
+
+    @base.handle_errors
+    def get_driver_logical_disk_properties(self, driver_name):
+        """Get driver logical disk properties.
+
+        :param driver_name: Name of driver.
+        :return: tuple of response and serialized logical disk properties as
+                 a dictionary.
+
+        """
+        uri = 'drivers/%s/raid/logical_disk_properties' % driver_name
+        resp, body = self.get(uri)
+        self.expected_success(200, resp.status)
+        return resp, self.deserialize(body)
diff --git a/ironic_tempest_plugin/tests/api/admin/__init__.py b/ironic_tempest_plugin/tests/api/admin/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/__init__.py
diff --git a/ironic_tempest_plugin/tests/api/admin/api_microversion_fixture.py b/ironic_tempest_plugin/tests/api/admin/api_microversion_fixture.py
new file mode 100644
index 0000000..ff7e09a
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/api_microversion_fixture.py
@@ -0,0 +1,26 @@
+# 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 fixtures
+
+from ironic_tempest_plugin.services.baremetal import base
+
+
+class APIMicroversionFixture(fixtures.Fixture):
+
+    def __init__(self, baremetal_microversion):
+        self.baremetal_microversion = baremetal_microversion
+
+    def _setUp(self):
+        super(APIMicroversionFixture, self)._setUp()
+        base.set_baremetal_api_microversion(self.baremetal_microversion)
+        self.addCleanup(base.reset_baremetal_api_microversion)
diff --git a/ironic_tempest_plugin/tests/api/admin/base.py b/ironic_tempest_plugin/tests/api/admin/base.py
new file mode 100644
index 0000000..2e7a4ff
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/base.py
@@ -0,0 +1,351 @@
+#    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 functools
+
+from tempest import config
+from tempest.lib.common import api_version_utils
+from tempest.lib.common.utils import data_utils
+from tempest.lib import exceptions as lib_exc
+from tempest import test
+
+from ironic_tempest_plugin import clients
+from ironic_tempest_plugin.tests.api.admin import api_microversion_fixture
+
+CONF = config.CONF
+
+
+# NOTE(adam_g): The baremetal API tests exercise operations such as enroll
+# node, power on, power off, etc.  Testing against real drivers (ie, IPMI)
+# will require passing driver-specific data to Tempest (addresses,
+# credentials, etc).  Until then, only support testing against the fake driver,
+# which has no external dependencies.
+SUPPORTED_DRIVERS = ['fake']
+
+# NOTE(jroll): resources must be deleted in a specific order, this list
+# defines the resource types to clean up, and the correct order.
+RESOURCE_TYPES = ['port', 'portgroup', 'volume_connector', 'volume_target',
+                  'node', 'chassis']
+
+
+def creates(resource):
+    """Decorator that adds resources to the appropriate cleanup list."""
+
+    def decorator(f):
+        @functools.wraps(f)
+        def wrapper(cls, *args, **kwargs):
+            resp, body = f(cls, *args, **kwargs)
+
+            if 'uuid' in body:
+                cls.created_objects[resource].add(body['uuid'])
+
+            return resp, body
+        return wrapper
+    return decorator
+
+
+class BaseBaremetalTest(api_version_utils.BaseMicroversionTest,
+                        test.BaseTestCase):
+    """Base class for Baremetal API tests."""
+
+    credentials = ['admin']
+
+    @classmethod
+    def skip_checks(cls):
+        super(BaseBaremetalTest, cls).skip_checks()
+        if not CONF.service_available.ironic:
+            raise cls.skipException('Ironic is not enabled.')
+        if CONF.baremetal.driver not in SUPPORTED_DRIVERS:
+            skip_msg = ('%s skipped as Ironic driver %s is not supported for '
+                        'testing.' %
+                        (cls.__name__, CONF.baremetal.driver))
+            raise cls.skipException(skip_msg)
+
+        cfg_min_version = CONF.baremetal.min_microversion
+        cfg_max_version = CONF.baremetal.max_microversion
+        api_version_utils.check_skip_with_microversion(cls.min_microversion,
+                                                       cls.max_microversion,
+                                                       cfg_min_version,
+                                                       cfg_max_version)
+
+    @classmethod
+    def setup_credentials(cls):
+        cls.request_microversion = (
+            api_version_utils.select_request_microversion(
+                cls.min_microversion,
+                CONF.baremetal.min_microversion))
+        cls.services_microversion = {
+            CONF.baremetal.catalog_type: cls.request_microversion}
+        super(BaseBaremetalTest, cls).setup_credentials()
+
+    @classmethod
+    def setup_clients(cls):
+        super(BaseBaremetalTest, cls).setup_clients()
+        cls.client = clients.Manager().baremetal_client
+
+    @classmethod
+    def resource_setup(cls):
+        super(BaseBaremetalTest, cls).resource_setup()
+        cls.request_microversion = (
+            api_version_utils.select_request_microversion(
+                cls.min_microversion,
+                CONF.baremetal.min_microversion))
+        cls.driver = CONF.baremetal.driver
+        cls.power_timeout = CONF.baremetal.power_timeout
+        cls.unprovision_timeout = CONF.baremetal.unprovision_timeout
+        cls.created_objects = {}
+        for resource in RESOURCE_TYPES:
+            cls.created_objects[resource] = set()
+
+    @classmethod
+    def resource_cleanup(cls):
+        """Ensure that all created objects get destroyed."""
+
+        try:
+            for resource in RESOURCE_TYPES:
+                uuids = cls.created_objects[resource]
+                delete_method = getattr(cls.client, 'delete_%s' % resource)
+                for u in uuids:
+                    delete_method(u, ignore_errors=lib_exc.NotFound)
+        finally:
+            super(BaseBaremetalTest, cls).resource_cleanup()
+
+    def _assertExpected(self, expected, actual):
+        """Check if expected keys/values exist in actual response body.
+
+        Check if the expected keys and values are in the actual response body.
+        It will not check the keys 'created_at' and 'updated_at', since they
+        will always have different values. Asserts if any expected key (or
+        corresponding value) is not in the actual response.
+
+        Note: this method has an underscore even though it is used outside of
+        this class, in order to distinguish this method from the more standard
+        assertXYZ methods.
+
+        :param expected: dict of key-value pairs that are expected to be in
+                         'actual' dict.
+        :param actual: dict of key-value pairs.
+
+        """
+        for key, value in expected.items():
+            if key not in ('created_at', 'updated_at'):
+                self.assertIn(key, actual)
+                self.assertEqual(value, actual[key])
+
+    def setUp(self):
+        super(BaseBaremetalTest, self).setUp()
+        self.useFixture(api_microversion_fixture.APIMicroversionFixture(
+            self.request_microversion))
+
+    @classmethod
+    @creates('chassis')
+    def create_chassis(cls, description=None, **kwargs):
+        """Wrapper utility for creating test chassis.
+
+        :param description: A description of the chassis. If not supplied,
+            a random value will be generated.
+        :return: A tuple with the server response and the created chassis.
+
+        """
+        description = description or data_utils.rand_name('test-chassis')
+        resp, body = cls.client.create_chassis(description=description,
+                                               **kwargs)
+        return resp, body
+
+    @classmethod
+    @creates('node')
+    def create_node(cls, chassis_id, cpu_arch='x86', cpus=8, local_gb=10,
+                    memory_mb=4096, resource_class=None):
+        """Wrapper utility for creating test baremetal nodes.
+
+        :param chassis_id: The unique identifier of the chassis.
+        :param cpu_arch: CPU architecture of the node. Default: x86.
+        :param cpus: Number of CPUs. Default: 8.
+        :param local_gb: Disk size. Default: 10.
+        :param memory_mb: Available RAM. Default: 4096.
+        :param resource_class: Node resource class.
+        :return: A tuple with the server response and the created node.
+
+        """
+        resp, body = cls.client.create_node(chassis_id, cpu_arch=cpu_arch,
+                                            cpus=cpus, local_gb=local_gb,
+                                            memory_mb=memory_mb,
+                                            driver=cls.driver,
+                                            resource_class=resource_class)
+
+        return resp, body
+
+    @classmethod
+    @creates('port')
+    def create_port(cls, node_id, address, extra=None, uuid=None,
+                    portgroup_uuid=None, physical_network=None):
+        """Wrapper utility for creating test ports.
+
+        :param node_id: The unique identifier of the node.
+        :param address: MAC address of the port.
+        :param extra: Meta data of the port. If not supplied, an empty
+            dictionary will be created.
+        :param uuid: UUID of the port.
+        :param portgroup_uuid: The UUID of a portgroup of which this port is a
+            member.
+        :param physical_network: The physical network to which the port is
+            attached.
+        :return: A tuple with the server response and the created port.
+
+        """
+        extra = extra or {}
+        resp, body = cls.client.create_port(address=address, node_id=node_id,
+                                            extra=extra, uuid=uuid,
+                                            portgroup_uuid=portgroup_uuid,
+                                            physical_network=physical_network)
+
+        return resp, body
+
+    @classmethod
+    @creates('portgroup')
+    def create_portgroup(cls, node_uuid, **kwargs):
+        """Wrapper utility for creating test port groups.
+
+        :param node_uuid: The unique identifier of the node.
+        :return: A tuple with the server response and the created port group.
+        """
+        resp, body = cls.client.create_portgroup(node_uuid=node_uuid, **kwargs)
+
+        return resp, body
+
+    @classmethod
+    @creates('volume_connector')
+    def create_volume_connector(cls, node_uuid, **kwargs):
+        """Wrapper utility for creating test volume connector.
+
+        :param node_uuid: The unique identifier of the node.
+        :return: A tuple with the server response and the created volume
+            connector.
+        """
+        resp, body = cls.client.create_volume_connector(node_uuid=node_uuid,
+                                                        **kwargs)
+
+        return resp, body
+
+    @classmethod
+    @creates('volume_target')
+    def create_volume_target(cls, node_uuid, **kwargs):
+        """Wrapper utility for creating test volume target.
+
+        :param node_uuid: The unique identifier of the node.
+        :return: A tuple with the server response and the created volume
+            target.
+        """
+        resp, body = cls.client.create_volume_target(node_uuid=node_uuid,
+                                                     **kwargs)
+
+        return resp, body
+
+    @classmethod
+    def delete_chassis(cls, chassis_id):
+        """Deletes a chassis having the specified UUID.
+
+        :param chassis_id: The unique identifier of the chassis.
+        :return: Server response.
+
+        """
+
+        resp, body = cls.client.delete_chassis(chassis_id)
+
+        if chassis_id in cls.created_objects['chassis']:
+            cls.created_objects['chassis'].remove(chassis_id)
+
+        return resp
+
+    @classmethod
+    def delete_node(cls, node_id):
+        """Deletes a node having the specified UUID.
+
+        :param node_id: The unique identifier of the node.
+        :return: Server response.
+
+        """
+
+        resp, body = cls.client.delete_node(node_id)
+
+        if node_id in cls.created_objects['node']:
+            cls.created_objects['node'].remove(node_id)
+
+        return resp
+
+    @classmethod
+    def delete_port(cls, port_id):
+        """Deletes a port having the specified UUID.
+
+        :param port_id: The unique identifier of the port.
+        :return: Server response.
+
+        """
+
+        resp, body = cls.client.delete_port(port_id)
+
+        if port_id in cls.created_objects['port']:
+            cls.created_objects['port'].remove(port_id)
+
+        return resp
+
+    @classmethod
+    def delete_portgroup(cls, portgroup_ident):
+        """Deletes a port group having the specified UUID or name.
+
+        :param portgroup_ident: The name or UUID of the port group.
+        :return: Server response.
+        """
+        resp, body = cls.client.delete_portgroup(portgroup_ident)
+
+        if portgroup_ident in cls.created_objects['portgroup']:
+            cls.created_objects['portgroup'].remove(portgroup_ident)
+
+        return resp
+
+    @classmethod
+    def delete_volume_connector(cls, volume_connector_id):
+        """Deletes a volume connector having the specified UUID.
+
+        :param volume_connector_id: The UUID of the volume connector.
+        :return: Server response.
+        """
+        resp, body = cls.client.delete_volume_connector(volume_connector_id)
+
+        if volume_connector_id in cls.created_objects['volume_connector']:
+            cls.created_objects['volume_connector'].remove(
+                volume_connector_id)
+
+        return resp
+
+    @classmethod
+    def delete_volume_target(cls, volume_target_id):
+        """Deletes a volume target having the specified UUID.
+
+        :param volume_target_id: The UUID of the volume target.
+        :return: Server response.
+        """
+        resp, body = cls.client.delete_volume_target(volume_target_id)
+
+        if volume_target_id in cls.created_objects['volume_target']:
+            cls.created_objects['volume_target'].remove(volume_target_id)
+
+        return resp
+
+    def validate_self_link(self, resource, uuid, link):
+        """Check whether the given self link formatted correctly."""
+        expected_link = "{base}/{pref}/{res}/{uuid}".format(
+                        base=self.client.base_url.rstrip('/'),
+                        pref=self.client.uri_prefix,
+                        res=resource,
+                        uuid=uuid)
+        self.assertEqual(expected_link, link)
diff --git a/ironic_tempest_plugin/tests/api/admin/test_api_discovery.py b/ironic_tempest_plugin/tests/api/admin/test_api_discovery.py
new file mode 100644
index 0000000..de2dada
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/test_api_discovery.py
@@ -0,0 +1,43 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from tempest.lib import decorators
+
+from ironic_tempest_plugin.tests.api.admin import base
+
+
+class TestApiDiscovery(base.BaseBaremetalTest):
+    """Tests for API discovery features."""
+
+    @decorators.idempotent_id('a3c27e94-f56c-42c4-8600-d6790650b9c5')
+    def test_api_versions(self):
+        _, descr = self.client.get_api_description()
+        expected_versions = ('v1',)
+        versions = [version['id'] for version in descr['versions']]
+
+        for v in expected_versions:
+            self.assertIn(v, versions)
+
+    @decorators.idempotent_id('896283a6-488e-4f31-af78-6614286cbe0d')
+    def test_default_version(self):
+        _, descr = self.client.get_api_description()
+        default_version = descr['default_version']
+        self.assertEqual('v1', default_version['id'])
+
+    @decorators.idempotent_id('abc0b34d-e684-4546-9728-ab7a9ad9f174')
+    def test_version_1_resources(self):
+        _, descr = self.client.get_version_description(version='v1')
+        expected_resources = ('nodes', 'chassis',
+                              'ports', 'links', 'media_types')
+
+        for res in expected_resources:
+            self.assertIn(res, descr)
diff --git a/ironic_tempest_plugin/tests/api/admin/test_chassis.py b/ironic_tempest_plugin/tests/api/admin/test_chassis.py
new file mode 100644
index 0000000..19bdc13
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/test_chassis.py
@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+#    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 decorators
+from tempest.lib import exceptions as lib_exc
+
+from ironic_tempest_plugin.tests.api.admin import base
+
+
+class TestChassis(base.BaseBaremetalTest):
+    """Tests for chassis."""
+
+    @classmethod
+    def resource_setup(cls):
+        super(TestChassis, cls).resource_setup()
+        _, cls.chassis = cls.create_chassis()
+
+    @decorators.idempotent_id('7c5a2e09-699c-44be-89ed-2bc189992d42')
+    def test_create_chassis(self):
+        descr = data_utils.rand_name('test-chassis')
+        _, chassis = self.create_chassis(description=descr)
+        self.assertEqual(descr, chassis['description'])
+
+    @decorators.idempotent_id('cabe9c6f-dc16-41a7-b6b9-0a90c212edd5')
+    def test_create_chassis_unicode_description(self):
+        # Use a unicode string for testing:
+        # 'We ♡ OpenStack in Ukraine'
+        descr = u'В Україні ♡ OpenStack!'
+        _, chassis = self.create_chassis(description=descr)
+        self.assertEqual(descr, chassis['description'])
+
+    @decorators.idempotent_id('c84644df-31c4-49db-a307-8942881f41c0')
+    def test_show_chassis(self):
+        _, chassis = self.client.show_chassis(self.chassis['uuid'])
+        self._assertExpected(self.chassis, chassis)
+
+    @decorators.idempotent_id('29c9cd3f-19b5-417b-9864-99512c3b33b3')
+    def test_list_chassis(self):
+        _, body = self.client.list_chassis()
+        self.assertIn(self.chassis['uuid'],
+                      [i['uuid'] for i in body['chassis']])
+
+    @decorators.idempotent_id('5ae649ad-22d1-4fe1-bbc6-97227d199fb3')
+    def test_delete_chassis(self):
+        _, body = self.create_chassis()
+        uuid = body['uuid']
+
+        self.delete_chassis(uuid)
+        self.assertRaises(lib_exc.NotFound, self.client.show_chassis, uuid)
+
+    @decorators.idempotent_id('cda8a41f-6be2-4cbf-840c-994b00a89b44')
+    def test_update_chassis(self):
+        _, body = self.create_chassis()
+        uuid = body['uuid']
+
+        new_description = data_utils.rand_name('new-description')
+        _, body = (self.client.update_chassis(uuid,
+                   description=new_description))
+        _, chassis = self.client.show_chassis(uuid)
+        self.assertEqual(new_description, chassis['description'])
+
+    @decorators.idempotent_id('76305e22-a4e2-4ab3-855c-f4e2368b9335')
+    def test_chassis_node_list(self):
+        _, node = self.create_node(self.chassis['uuid'])
+        _, body = self.client.list_chassis_nodes(self.chassis['uuid'])
+        self.assertIn(node['uuid'], [n['uuid'] for n in body['nodes']])
+
+    @decorators.idempotent_id('dd52bd5d-610c-4f2c-8fa3-d5e59269325f')
+    def test_create_chassis_uuid(self):
+        uuid = data_utils.rand_uuid()
+        _, chassis = self.create_chassis(uuid=uuid)
+        self.assertEqual(uuid, chassis['uuid'])
diff --git a/ironic_tempest_plugin/tests/api/admin/test_drivers.py b/ironic_tempest_plugin/tests/api/admin/test_drivers.py
new file mode 100644
index 0000000..e80a963
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/test_drivers.py
@@ -0,0 +1,54 @@
+# Copyright 2014 NEC Corporation. All rights reserved.
+#
+#    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 import config
+from tempest.lib import decorators
+
+from ironic_tempest_plugin.tests.api.admin import api_microversion_fixture
+from ironic_tempest_plugin.tests.api.admin import base
+
+CONF = config.CONF
+
+
+class TestDrivers(base.BaseBaremetalTest):
+    """Tests for drivers."""
+
+    @classmethod
+    def resource_setup(cls):
+        super(TestDrivers, cls).resource_setup()
+        cls.driver_name = CONF.baremetal.driver
+
+    @decorators.idempotent_id('5aed2790-7592-4655-9b16-99abcc2e6ec5')
+    def test_list_drivers(self):
+        _, drivers = self.client.list_drivers()
+        self.assertIn(self.driver_name,
+                      [d['name'] for d in drivers['drivers']])
+
+    @decorators.idempotent_id('fb3287a3-c4d7-44bf-ae9d-1eef906d78ce')
+    def test_show_driver(self):
+        _, driver = self.client.show_driver(self.driver_name)
+        self.assertEqual(self.driver_name, driver['name'])
+
+    @decorators.idempotent_id('6efa976f-78a2-4859-b3aa-97d960d6e5e5')
+    def test_driver_properties(self):
+        _, properties = self.client.get_driver_properties(self.driver_name)
+        self.assertNotEmpty(properties)
+
+    @decorators.idempotent_id('fdf61f5a-f59d-4235-ad6c-cc718740e3e3')
+    def test_driver_logical_disk_properties(self):
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture('1.12'))
+        _, properties = self.client.get_driver_logical_disk_properties(
+            self.driver_name)
+        self.assertNotEmpty(properties)
diff --git a/ironic_tempest_plugin/tests/api/admin/test_nodes.py b/ironic_tempest_plugin/tests/api/admin/test_nodes.py
new file mode 100644
index 0000000..d992a65
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/test_nodes.py
@@ -0,0 +1,403 @@
+#    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 six
+from tempest import config
+from tempest.lib.common.utils import data_utils
+from tempest.lib import decorators
+from tempest.lib import exceptions as lib_exc
+
+from ironic_tempest_plugin.common import waiters
+from ironic_tempest_plugin.tests.api.admin import api_microversion_fixture
+from ironic_tempest_plugin.tests.api.admin import base
+
+CONF = config.CONF
+
+
+class TestNodes(base.BaseBaremetalTest):
+    """Tests for baremetal nodes."""
+
+    def setUp(self):
+        super(TestNodes, self).setUp()
+
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+
+    def _associate_node_with_instance(self):
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+        waiters.wait_for_bm_node_status(self.client, self.node['uuid'],
+                                        'power_state', 'power off')
+        instance_uuid = data_utils.rand_uuid()
+        self.client.update_node(self.node['uuid'],
+                                instance_uuid=instance_uuid)
+        self.addCleanup(self.client.update_node,
+                        uuid=self.node['uuid'], instance_uuid=None)
+        return instance_uuid
+
+    @decorators.idempotent_id('4e939eb2-8a69-4e84-8652-6fffcbc9db8f')
+    def test_create_node(self):
+        params = {'cpu_arch': 'x86_64',
+                  'cpus': '12',
+                  'local_gb': '10',
+                  'memory_mb': '1024'}
+
+        _, body = self.create_node(self.chassis['uuid'], **params)
+        self._assertExpected(params, body['properties'])
+
+    @decorators.idempotent_id('9ade60a4-505e-4259-9ec4-71352cbbaf47')
+    def test_delete_node(self):
+        _, node = self.create_node(self.chassis['uuid'])
+
+        self.delete_node(node['uuid'])
+
+        self.assertRaises(lib_exc.NotFound, self.client.show_node,
+                          node['uuid'])
+
+    @decorators.idempotent_id('55451300-057c-4ecf-8255-ba42a83d3a03')
+    def test_show_node(self):
+        _, loaded_node = self.client.show_node(self.node['uuid'])
+        self._assertExpected(self.node, loaded_node)
+
+    @decorators.idempotent_id('4ca123c4-160d-4d8d-a3f7-15feda812263')
+    def test_list_nodes(self):
+        _, body = self.client.list_nodes()
+        self.assertIn(self.node['uuid'],
+                      [i['uuid'] for i in body['nodes']])
+
+    @decorators.idempotent_id('85b1f6e0-57fd-424c-aeff-c3422920556f')
+    def test_list_nodes_association(self):
+        _, body = self.client.list_nodes(associated=True)
+        self.assertNotIn(self.node['uuid'],
+                         [n['uuid'] for n in body['nodes']])
+
+        self._associate_node_with_instance()
+
+        _, body = self.client.list_nodes(associated=True)
+        self.assertIn(self.node['uuid'], [n['uuid'] for n in body['nodes']])
+
+        _, body = self.client.list_nodes(associated=False)
+        self.assertNotIn(self.node['uuid'], [n['uuid'] for n in body['nodes']])
+
+    @decorators.idempotent_id('18c4ebd8-f83a-4df7-9653-9fb33a329730')
+    def test_node_port_list(self):
+        _, port = self.create_port(self.node['uuid'],
+                                   data_utils.rand_mac_address())
+        _, body = self.client.list_node_ports(self.node['uuid'])
+        self.assertIn(port['uuid'],
+                      [p['uuid'] for p in body['ports']])
+
+    @decorators.idempotent_id('72591acb-f215-49db-8395-710d14eb86ab')
+    def test_node_port_list_no_ports(self):
+        _, node = self.create_node(self.chassis['uuid'])
+        _, body = self.client.list_node_ports(node['uuid'])
+        self.assertEmpty(body['ports'])
+
+    @decorators.idempotent_id('4fed270a-677a-4d19-be87-fd38ae490320')
+    def test_update_node(self):
+        props = {'cpu_arch': 'x86_64',
+                 'cpus': '12',
+                 'local_gb': '10',
+                 'memory_mb': '128'}
+
+        _, node = self.create_node(self.chassis['uuid'], **props)
+
+        new_p = {'cpu_arch': 'x86',
+                 'cpus': '1',
+                 'local_gb': '10000',
+                 'memory_mb': '12300'}
+
+        _, body = self.client.update_node(node['uuid'], properties=new_p)
+        _, node = self.client.show_node(node['uuid'])
+        self._assertExpected(new_p, node['properties'])
+
+    @decorators.idempotent_id('cbf1f515-5f4b-4e49-945c-86bcaccfeb1d')
+    def test_validate_driver_interface(self):
+        _, body = self.client.validate_driver_interface(self.node['uuid'])
+        core_interfaces = ['power', 'deploy']
+        for interface in core_interfaces:
+            self.assertIn(interface, body)
+
+    @decorators.idempotent_id('5519371c-26a2-46e9-aa1a-f74226e9d71f')
+    def test_set_node_boot_device(self):
+        self.client.set_node_boot_device(self.node['uuid'], 'pxe')
+
+    @decorators.idempotent_id('9ea73775-f578-40b9-bc34-efc639c4f21f')
+    def test_get_node_boot_device(self):
+        body = self.client.get_node_boot_device(self.node['uuid'])
+        self.assertIn('boot_device', body)
+        self.assertIn('persistent', body)
+        self.assertIsInstance(body['boot_device'], six.string_types)
+        self.assertIsInstance(body['persistent'], bool)
+
+    @decorators.idempotent_id('3622bc6f-3589-4bc2-89f3-50419c66b133')
+    def test_get_node_supported_boot_devices(self):
+        body = self.client.get_node_supported_boot_devices(self.node['uuid'])
+        self.assertIn('supported_boot_devices', body)
+        self.assertIsInstance(body['supported_boot_devices'], list)
+
+    @decorators.idempotent_id('f63b6288-1137-4426-8cfe-0d5b7eb87c06')
+    def test_get_console(self):
+        _, body = self.client.get_console(self.node['uuid'])
+        con_info = ['console_enabled', 'console_info']
+        for key in con_info:
+            self.assertIn(key, body)
+
+    @decorators.idempotent_id('80504575-9b21-4670-92d1-143b948f9437')
+    def test_set_console_mode(self):
+        self.client.set_console_mode(self.node['uuid'], True)
+        waiters.wait_for_bm_node_status(self.client, self.node['uuid'],
+                                        'console_enabled', True)
+
+    @decorators.idempotent_id('b02a4f38-5e8b-44b2-aed2-a69a36ecfd69')
+    def test_get_node_by_instance_uuid(self):
+        instance_uuid = self._associate_node_with_instance()
+        _, body = self.client.show_node_by_instance_uuid(instance_uuid)
+        self.assertEqual(1, len(body['nodes']))
+        self.assertIn(self.node['uuid'], [n['uuid'] for n in body['nodes']])
+
+
+class TestNodesResourceClass(base.BaseBaremetalTest):
+
+    min_microversion = '1.21'
+
+    def setUp(self):
+        super(TestNodesResourceClass, self).setUp()
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture(
+                TestNodesResourceClass.min_microversion)
+        )
+        _, self.chassis = self.create_chassis()
+        self.resource_class = data_utils.rand_name(name='Resource_Class')
+        _, self.node = self.create_node(
+            self.chassis['uuid'], resource_class=self.resource_class)
+
+    @decorators.idempotent_id('2a00340c-8152-4a61-9fc5-0b3cdefec258')
+    def test_create_node_resource_class_long(self):
+        """Create new node with specified longest name of resource class."""
+        res_class_long_name = data_utils.arbitrary_string(80)
+        _, body = self.create_node(
+            self.chassis['uuid'],
+            resource_class=res_class_long_name)
+        self.assertEqual(res_class_long_name, body['resource_class'])
+
+    @decorators.idempotent_id('142db00d-ac0f-415b-8da8-9095fbb561f7')
+    def test_update_node_resource_class(self):
+        """Update existing node with specified resource class."""
+        new_res_class_name = data_utils.rand_name(name='Resource_Class')
+        _, body = self.client.update_node(
+            self.node['uuid'], resource_class=new_res_class_name)
+        _, body = self.client.show_node(self.node['uuid'])
+        self.assertEqual(new_res_class_name, body['resource_class'])
+
+    @decorators.idempotent_id('73e6f7b5-3e51-49ea-af5b-146cd49f40ee')
+    def test_show_node_resource_class(self):
+        """Show resource class field of specified node."""
+        _, body = self.client.show_node(self.node['uuid'])
+        self.assertEqual(self.resource_class, body['resource_class'])
+
+    @decorators.idempotent_id('f2bf4465-280c-4fdc-bbf7-fcf5188befa4')
+    def test_list_nodes_resource_class(self):
+        """List nodes of specified resource class only."""
+        res_class = 'ResClass-{0}'.format(data_utils.rand_uuid())
+        for node in range(3):
+            _, body = self.create_node(
+                self.chassis['uuid'], resource_class=res_class)
+
+        _, body = self.client.list_nodes(resource_class=res_class)
+        self.assertEqual(3, len([i['uuid'] for i in body['nodes']]))
+
+    @decorators.idempotent_id('40733bad-bb79-445e-a094-530a44042995')
+    def test_list_nodes_detail_resource_class(self):
+        """Get detailed nodes list of specified resource class only."""
+        res_class = 'ResClass-{0}'.format(data_utils.rand_uuid())
+        for node in range(3):
+            _, body = self.create_node(
+                self.chassis['uuid'], resource_class=res_class)
+
+        _, body = self.client.list_nodes_detail(resource_class=res_class)
+        self.assertEqual(3, len([i['uuid'] for i in body['nodes']]))
+
+        for node in body['nodes']:
+            self.assertEqual(res_class, node['resource_class'])
+
+    @decorators.attr(type='negative')
+    @decorators.idempotent_id('e75136d4-0690-48a5-aef3-75040aee73ad')
+    def test_create_node_resource_class_too_long(self):
+        """Try to create a node with too long resource class name."""
+        resource_class = data_utils.arbitrary_string(81)
+        self.assertRaises(lib_exc.BadRequest, self.create_node,
+                          self.chassis['uuid'], resource_class=resource_class)
+
+    @decorators.attr(type='negative')
+    @decorators.idempotent_id('f0aeece4-8671-44ea-a482-b4047fc4cf74')
+    def test_update_node_resource_class_too_long(self):
+        """Try to update a node with too long resource class name."""
+        resource_class = data_utils.arbitrary_string(81)
+        self.assertRaises(lib_exc.BadRequest, self.client.update_node,
+                          self.node['uuid'], resource_class=resource_class)
+
+
+class TestNodesResourceClassOldApi(base.BaseBaremetalTest):
+
+    def setUp(self):
+        super(TestNodesResourceClassOldApi, self).setUp()
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+
+    @decorators.attr(type='negative')
+    @decorators.idempotent_id('2c364408-4746-4b3c-9821-20d47b57bdec')
+    def test_create_node_resource_class_old_api(self):
+        """Try to create a node with resource class using older api version."""
+        resource_class = data_utils.arbitrary_string()
+        self.assertRaises(lib_exc.UnexpectedResponseCode, self.create_node,
+                          self.chassis['uuid'], resource_class=resource_class)
+
+    @decorators.attr(type='negative')
+    @decorators.idempotent_id('666f3c1a-4922-4a3d-b6d9-dea7c74d30bc')
+    def test_update_node_resource_class_old_api(self):
+        """Try to update a node with resource class using older api version."""
+        resource_class = data_utils.arbitrary_string()
+        self.assertRaises(lib_exc.UnexpectedResponseCode,
+                          self.client.update_node,
+                          self.node['uuid'], resource_class=resource_class)
+
+    @decorators.attr(type='negative')
+    @decorators.idempotent_id('95903480-f16d-4774-8775-6c7f87b27c59')
+    def test_list_nodes_by_resource_class_old_api(self):
+        """Try to list nodes with resource class using older api version."""
+        resource_class = data_utils.arbitrary_string()
+        self.assertRaises(
+            lib_exc.UnexpectedResponseCode,
+            self.client.list_nodes, resource_class=resource_class)
+        self.assertRaises(
+            lib_exc.UnexpectedResponseCode,
+            self.client.list_nodes_detail, resource_class=resource_class)
+
+
+class TestNodesVif(base.BaseBaremetalTest):
+
+    min_microversion = '1.28'
+
+    @classmethod
+    def skip_checks(cls):
+        super(TestNodesVif, cls).skip_checks()
+        if not CONF.service_available.neutron:
+            raise cls.skipException('Neutron is not enabled.')
+
+    def setUp(self):
+        super(TestNodesVif, self).setUp()
+
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+        if CONF.network.shared_physical_network:
+            self.net = self.os_admin.networks_client.list_networks(
+                name=CONF.compute.fixed_network_name)['networks'][0]
+        else:
+            self.net = self.os_admin.networks_client.\
+                create_network()['network']
+            self.addCleanup(self.os_admin.networks_client.delete_network,
+                            self.net['id'])
+
+        self.nport_id = self.os_admin.ports_client.create_port(
+            network_id=self.net['id'])['port']['id']
+        self.addCleanup(self.os_admin.ports_client.delete_port,
+                        self.nport_id)
+
+    @decorators.idempotent_id('a3d319d0-cacb-4e55-a3dc-3fa8b74880f1')
+    def test_vif_on_port(self):
+        """Test attachment and detachment of VIFs on the node with port.
+
+        Test steps:
+        1) Create chassis and node in setUp.
+        2) Create port for the node.
+        3) Attach VIF to the node.
+        4) Check VIF info in VIFs list and port internal_info.
+        5) Detach VIF from the node.
+        6) Check that no more VIF info in VIFs list and port internal_info.
+        """
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture('1.28'))
+        _, self.port = self.create_port(self.node['uuid'],
+                                        data_utils.rand_mac_address())
+        self.client.vif_attach(self.node['uuid'], self.nport_id)
+        _, body = self.client.vif_list(self.node['uuid'])
+        self.assertEqual({'vifs': [{'id': self.nport_id}]}, body)
+        _, port = self.client.show_port(self.port['uuid'])
+        self.assertEqual(self.nport_id,
+                         port['internal_info']['tenant_vif_port_id'])
+        self.client.vif_detach(self.node['uuid'], self.nport_id)
+        _, body = self.client.vif_list(self.node['uuid'])
+        self.assertEqual({'vifs': []}, body)
+        _, port = self.client.show_port(self.port['uuid'])
+        self.assertNotIn('tenant_vif_port_id', port['internal_info'])
+
+    @decorators.idempotent_id('95279515-7d0a-4f5f-987f-93e36aae5585')
+    def test_vif_on_portgroup(self):
+        """Test attachment and detachment of VIFs on the node with port group.
+
+        Test steps:
+        1) Create chassis and node in setUp.
+        2) Create port for the node.
+        3) Create port group for the node.
+        4) Plug port into port group.
+        5) Attach VIF to the node.
+        6) Check VIF info in VIFs list and port group internal_info, but
+           not in port internal_info.
+        7) Detach VIF from the node.
+        8) Check that no VIF info in VIFs list and port group internal_info.
+        """
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture('1.28'))
+        _, self.port = self.create_port(self.node['uuid'],
+                                        data_utils.rand_mac_address())
+        _, self.portgroup = self.create_portgroup(
+            self.node['uuid'], address=data_utils.rand_mac_address())
+
+        patch = [{'path': '/portgroup_uuid',
+                  'op': 'add',
+                  'value': self.portgroup['uuid']}]
+        self.client.update_port(self.port['uuid'], patch)
+
+        self.client.vif_attach(self.node['uuid'], self.nport_id)
+        _, body = self.client.vif_list(self.node['uuid'])
+        self.assertEqual({'vifs': [{'id': self.nport_id}]}, body)
+
+        _, port = self.client.show_port(self.port['uuid'])
+        self.assertNotIn('tenant_vif_port_id', port['internal_info'])
+        _, portgroup = self.client.show_portgroup(self.portgroup['uuid'])
+        self.assertEqual(self.nport_id,
+                         portgroup['internal_info']['tenant_vif_port_id'])
+
+        self.client.vif_detach(self.node['uuid'], self.nport_id)
+        _, body = self.client.vif_list(self.node['uuid'])
+        self.assertEqual({'vifs': []}, body)
+        _, portgroup = self.client.show_portgroup(self.portgroup['uuid'])
+        self.assertNotIn('tenant_vif_port_id', portgroup['internal_info'])
+
+    @decorators.idempotent_id('a3d319d0-cacb-4e55-a3dc-3fa8b74880f2')
+    def test_vif_already_set_on_extra(self):
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture('1.28'))
+        _, self.port = self.create_port(self.node['uuid'],
+                                        data_utils.rand_mac_address())
+        patch = [{'path': '/extra/vif_port_id',
+                  'op': 'add',
+                  'value': self.nport_id}]
+        self.client.update_port(self.port['uuid'], patch)
+
+        _, body = self.client.vif_list(self.node['uuid'])
+        self.assertEqual({'vifs': [{'id': self.nport_id}]}, body)
+
+        self.assertRaises(lib_exc.Conflict, self.client.vif_attach,
+                          self.node['uuid'], self.nport_id)
+
+        self.client.vif_detach(self.node['uuid'], self.nport_id)
diff --git a/ironic_tempest_plugin/tests/api/admin/test_nodestates.py b/ironic_tempest_plugin/tests/api/admin/test_nodestates.py
new file mode 100644
index 0000000..f2a33eb
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/test_nodestates.py
@@ -0,0 +1,193 @@
+# Copyright 2014 NEC Corporation.  All rights reserved.
+#
+#    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 oslo_utils import timeutils
+from tempest.lib import decorators
+from tempest.lib import exceptions
+
+from ironic_tempest_plugin.tests.api.admin import api_microversion_fixture
+from ironic_tempest_plugin.tests.api.admin import base
+
+
+class TestNodeStatesMixin(object):
+    """Mixin for for baremetal node states tests."""
+
+    @classmethod
+    def resource_setup(cls):
+        super(TestNodeStatesMixin, cls).resource_setup()
+        _, cls.chassis = cls.create_chassis()
+
+    def _validate_power_state(self, node_uuid, power_state):
+        # Validate that power state is set within timeout
+        if power_state == 'rebooting':
+            power_state = 'power on'
+        start = timeutils.utcnow()
+        while timeutils.delta_seconds(
+                start, timeutils.utcnow()) < self.power_timeout:
+            _, node = self.client.show_node(node_uuid)
+            if node['power_state'] == power_state:
+                return
+        message = ('Failed to set power state within '
+                   'the required time: %s sec.' % self.power_timeout)
+        raise exceptions.TimeoutException(message)
+
+    def _validate_provision_state(self, node_uuid, target_state):
+        # Validate that provision state is set within timeout
+        start = timeutils.utcnow()
+        while timeutils.delta_seconds(
+                start, timeutils.utcnow()) < self.unprovision_timeout:
+            _, node = self.client.show_node(node_uuid)
+            if node['provision_state'] == target_state:
+                return
+        message = ('Failed to set provision state %(state)s within '
+                   'the required time: %(timeout)s sec.',
+                   {'state': target_state,
+                    'timeout': self.unprovision_timeout})
+        raise exceptions.TimeoutException(message)
+
+    @decorators.idempotent_id('cd8afa5e-3f57-4e43-8185-beb83d3c9015')
+    def test_list_nodestates(self):
+        _, node = self.create_node(self.chassis['uuid'])
+        _, nodestates = self.client.list_nodestates(node['uuid'])
+        for key in nodestates:
+            self.assertEqual(nodestates[key], node[key])
+
+    @decorators.idempotent_id('fc5b9320-0c98-4e5a-8848-877fe5a0322c')
+    def test_set_node_power_state(self):
+        _, node = self.create_node(self.chassis['uuid'])
+        states = ["power on", "rebooting", "power off"]
+        for state in states:
+            # Set power state
+            self.client.set_node_power_state(node['uuid'], state)
+            # Check power state after state is set
+            self._validate_power_state(node['uuid'], state)
+
+
+class TestNodeStatesV1_1(TestNodeStatesMixin, base.BaseBaremetalTest):
+
+    @decorators.idempotent_id('ccb8fca9-2ba0-480c-a037-34c3bd09dc74')
+    def test_set_node_provision_state(self):
+        _, node = self.create_node(self.chassis['uuid'])
+        # Nodes appear in NONE state by default until v1.1
+        self.assertIsNone(node['provision_state'])
+        provision_states_list = ['active', 'deleted']
+        target_states_list = ['active', None]
+        for (provision_state, target_state) in zip(provision_states_list,
+                                                   target_states_list):
+            self.client.set_node_provision_state(node['uuid'], provision_state)
+            self._validate_provision_state(node['uuid'], target_state)
+
+
+class TestNodeStatesV1_2(TestNodeStatesMixin, base.BaseBaremetalTest):
+
+    def setUp(self):
+        super(TestNodeStatesV1_2, self).setUp()
+        self.useFixture(api_microversion_fixture.APIMicroversionFixture('1.2'))
+
+    @decorators.idempotent_id('9c414984-f3b6-4b3d-81da-93b60d4662fb')
+    def test_set_node_provision_state(self):
+        _, node = self.create_node(self.chassis['uuid'])
+        # Nodes appear in AVAILABLE state by default from v1.2 to v1.10
+        self.assertEqual('available', node['provision_state'])
+        provision_states_list = ['active', 'deleted']
+        target_states_list = ['active', 'available']
+        for (provision_state, target_state) in zip(provision_states_list,
+                                                   target_states_list):
+            self.client.set_node_provision_state(node['uuid'], provision_state)
+            self._validate_provision_state(node['uuid'], target_state)
+
+
+class TestNodeStatesV1_4(TestNodeStatesMixin, base.BaseBaremetalTest):
+
+    def setUp(self):
+        super(TestNodeStatesV1_4, self).setUp()
+        self.useFixture(api_microversion_fixture.APIMicroversionFixture('1.4'))
+
+    @decorators.idempotent_id('3d606003-05ce-4b5a-964d-bdee382fafe9')
+    def test_set_node_provision_state(self):
+        _, node = self.create_node(self.chassis['uuid'])
+        # Nodes appear in AVAILABLE state by default from v1.2 to v1.10
+        self.assertEqual('available', node['provision_state'])
+        # MANAGEABLE state and PROVIDE transition have been added in v1.4
+        provision_states_list = [
+            'manage', 'provide', 'active', 'deleted']
+        target_states_list = [
+            'manageable', 'available', 'active', 'available']
+        for (provision_state, target_state) in zip(provision_states_list,
+                                                   target_states_list):
+            self.client.set_node_provision_state(node['uuid'], provision_state)
+            self._validate_provision_state(node['uuid'], target_state)
+
+
+class TestNodeStatesV1_6(TestNodeStatesMixin, base.BaseBaremetalTest):
+
+    def setUp(self):
+        super(TestNodeStatesV1_6, self).setUp()
+        self.useFixture(api_microversion_fixture.APIMicroversionFixture('1.6'))
+
+    @decorators.idempotent_id('6c9ce4a3-713b-4c76-91af-18c48d01f1bb')
+    def test_set_node_provision_state(self):
+        _, node = self.create_node(self.chassis['uuid'])
+        # Nodes appear in AVAILABLE state by default from v1.2 to v1.10
+        self.assertEqual('available', node['provision_state'])
+        # INSPECT* states have been added in v1.6
+        provision_states_list = [
+            'manage', 'inspect', 'provide', 'active', 'deleted']
+        target_states_list = [
+            'manageable', 'manageable', 'available', 'active', 'available']
+        for (provision_state, target_state) in zip(provision_states_list,
+                                                   target_states_list):
+            self.client.set_node_provision_state(node['uuid'], provision_state)
+            self._validate_provision_state(node['uuid'], target_state)
+
+
+class TestNodeStatesV1_11(TestNodeStatesMixin, base.BaseBaremetalTest):
+
+    def setUp(self):
+        super(TestNodeStatesV1_11, self).setUp()
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture('1.11')
+        )
+
+    @decorators.idempotent_id('31f53828-b83d-40c7-98e5-843e28a1b6b9')
+    def test_set_node_provision_state(self):
+        _, node = self.create_node(self.chassis['uuid'])
+        # Nodes appear in ENROLL state by default from v1.11
+        self.assertEqual('enroll', node['provision_state'])
+        provision_states_list = [
+            'manage', 'inspect', 'provide', 'active', 'deleted']
+        target_states_list = [
+            'manageable', 'manageable', 'available', 'active', 'available']
+        for (provision_state, target_state) in zip(provision_states_list,
+                                                   target_states_list):
+            self.client.set_node_provision_state(node['uuid'], provision_state)
+            self._validate_provision_state(node['uuid'], target_state)
+
+
+class TestNodeStatesV1_12(TestNodeStatesMixin, base.BaseBaremetalTest):
+
+    def setUp(self):
+        super(TestNodeStatesV1_12, self).setUp()
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture('1.12')
+        )
+
+    @decorators.idempotent_id('4427b1ca-8e79-4139-83d6-77dfac03e61e')
+    def test_set_node_raid_config(self):
+        _, node = self.create_node(self.chassis['uuid'])
+        target_raid_config = {'logical_disks': [{'size_gb': 100,
+                                                 'raid_level': '1'}]}
+        self.client.set_node_raid_config(node['uuid'], target_raid_config)
+        _, ret = self.client.show_node(node['uuid'])
+        self.assertEqual(target_raid_config, ret['target_raid_config'])
diff --git a/ironic_tempest_plugin/tests/api/admin/test_portgroups.py b/ironic_tempest_plugin/tests/api/admin/test_portgroups.py
new file mode 100644
index 0000000..4a5b84b
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/test_portgroups.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.
+
+from tempest.lib.common.utils import data_utils
+from tempest.lib import decorators
+from tempest.lib import exceptions as lib_exc
+
+from ironic_tempest_plugin.tests.api.admin import api_microversion_fixture
+from ironic_tempest_plugin.tests.api.admin import base
+
+
+class TestPortGroups(base.BaseBaremetalTest):
+    """Basic positive test cases for port groups."""
+
+    min_microversion = '1.23'
+
+    def setUp(self):
+        super(TestPortGroups, self).setUp()
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture(
+                self.min_microversion))
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+        _, self.portgroup = self.create_portgroup(
+            self.node['uuid'], address=data_utils.rand_mac_address(),
+            name=data_utils.rand_name('portgroup'))
+
+    @decorators.idempotent_id('110cd302-256b-4ddc-be10-fc6c9ad8e649')
+    def test_create_portgroup_with_address(self):
+        """Create a port group with specific MAC address."""
+        _, body = self.client.show_portgroup(self.portgroup['uuid'])
+        self.assertEqual(self.portgroup['address'], body['address'])
+
+    @decorators.idempotent_id('4336fa0f-da86-4cec-b788-89f59a7635a5')
+    def test_create_portgroup_no_address(self):
+        """Create a port group without setting MAC address."""
+        _, portgroup = self.create_portgroup(self.node['uuid'])
+        _, body = self.client.show_portgroup(portgroup['uuid'])
+
+        self._assertExpected(portgroup, body)
+        self.assertIsNone(body['address'])
+
+    @decorators.idempotent_id('8378c69f-f806-454b-8ddd-6b7fd93ab12b')
+    def test_delete_portgroup(self):
+        """Delete a port group."""
+        self.delete_portgroup(self.portgroup['uuid'])
+        self.assertRaises(lib_exc.NotFound, self.client.show_portgroup,
+                          self.portgroup['uuid'])
+
+    @decorators.idempotent_id('f6be5e70-3e3b-435c-b2fc-bbb2cc9b3185')
+    def test_show_portgroup(self):
+        """Show a specified port group."""
+        _, portgroup = self.client.show_portgroup(self.portgroup['uuid'])
+        self._assertExpected(self.portgroup, portgroup)
+
+    @decorators.idempotent_id('cf2dfd95-5ea1-4109-8ad3-297cd76aa5d3')
+    def test_list_portgroups(self):
+        """List port groups."""
+        _, body = self.client.list_portgroups()
+        self.assertIn(self.portgroup['uuid'],
+                      [i['uuid'] for i in body['portgroups']])
+        self.assertIn(self.portgroup['address'],
+                      [i['address'] for i in body['portgroups']])
+        self.assertIn(self.portgroup['name'],
+                      [i['name'] for i in body['portgroups']])
diff --git a/ironic_tempest_plugin/tests/api/admin/test_ports.py b/ironic_tempest_plugin/tests/api/admin/test_ports.py
new file mode 100644
index 0000000..a4aea4f
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/test_ports.py
@@ -0,0 +1,376 @@
+#    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 decorators
+from tempest.lib import exceptions as lib_exc
+
+from ironic_tempest_plugin.tests.api.admin import api_microversion_fixture
+from ironic_tempest_plugin.tests.api.admin import base
+
+
+class TestPorts(base.BaseBaremetalTest):
+    """Tests for ports."""
+
+    def setUp(self):
+        super(TestPorts, self).setUp()
+
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+        _, self.port = self.create_port(self.node['uuid'],
+                                        data_utils.rand_mac_address())
+
+    @decorators.idempotent_id('83975898-2e50-42ed-b5f0-e510e36a0b56')
+    def test_create_port(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address)
+
+        _, body = self.client.show_port(port['uuid'])
+
+        self._assertExpected(port, body)
+
+    @decorators.idempotent_id('d1f6b249-4cf6-4fe6-9ed6-a6e84b1bf67b')
+    def test_create_port_specifying_uuid(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        uuid = data_utils.rand_uuid()
+
+        _, port = self.create_port(node_id=node_id,
+                                   address=address, uuid=uuid)
+
+        _, body = self.client.show_port(uuid)
+        self._assertExpected(port, body)
+
+    @decorators.idempotent_id('4a02c4b0-6573-42a4-a513-2e36ad485b62')
+    def test_create_port_with_extra(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        extra = {'str': 'value', 'int': 123, 'float': 0.123,
+                 'bool': True, 'list': [1, 2, 3], 'dict': {'foo': 'bar'}}
+
+        _, port = self.create_port(node_id=node_id, address=address,
+                                   extra=extra)
+
+        _, body = self.client.show_port(port['uuid'])
+        self._assertExpected(port, body)
+
+    @decorators.idempotent_id('1bf257a9-aea3-494e-89c0-63f657ab4fdd')
+    def test_delete_port(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        _, port = self.create_port(node_id=node_id, address=address)
+
+        self.delete_port(port['uuid'])
+
+        self.assertRaises(lib_exc.NotFound, self.client.show_port,
+                          port['uuid'])
+
+    @decorators.idempotent_id('9fa77ab5-ce59-4f05-baac-148904ba1597')
+    def test_show_port(self):
+        _, port = self.client.show_port(self.port['uuid'])
+        self._assertExpected(self.port, port)
+
+    @decorators.idempotent_id('7c1114ff-fc3f-47bb-bc2f-68f61620ba8b')
+    def test_show_port_by_address(self):
+        _, port = self.client.show_port_by_address(self.port['address'])
+        self._assertExpected(self.port, port['ports'][0])
+
+    @decorators.idempotent_id('bd773405-aea5-465d-b576-0ab1780069e5')
+    def test_show_port_with_links(self):
+        _, port = self.client.show_port(self.port['uuid'])
+        self.assertIn('links', port.keys())
+        self.assertEqual(2, len(port['links']))
+        self.assertIn(port['uuid'], port['links'][0]['href'])
+
+    @decorators.idempotent_id('b5e91854-5cd7-4a8e-bb35-3e0a1314606d')
+    def test_list_ports(self):
+        _, body = self.client.list_ports()
+        self.assertIn(self.port['uuid'],
+                      [i['uuid'] for i in body['ports']])
+        # Verify self links.
+        for port in body['ports']:
+            self.validate_self_link('ports', port['uuid'],
+                                    port['links'][0]['href'])
+
+    @decorators.idempotent_id('324a910e-2f80-4258-9087-062b5ae06240')
+    def test_list_with_limit(self):
+        _, body = self.client.list_ports(limit=3)
+
+        next_marker = body['ports'][-1]['uuid']
+        self.assertIn(next_marker, body['next'])
+
+    @decorators.idempotent_id('8a94b50f-9895-4a63-a574-7ecff86e5875')
+    def test_list_ports_details(self):
+        node_id = self.node['uuid']
+
+        uuids = [
+            self.create_port(node_id=node_id,
+                             address=data_utils.rand_mac_address())
+            [1]['uuid'] for i in range(0, 5)]
+
+        _, body = self.client.list_ports_detail()
+
+        ports_dict = dict((port['uuid'], port) for port in body['ports']
+                          if port['uuid'] in uuids)
+
+        for uuid in uuids:
+            self.assertIn(uuid, ports_dict)
+            port = ports_dict[uuid]
+            self.assertIn('extra', port)
+            self.assertIn('node_uuid', port)
+            # never expose the node_id
+            self.assertNotIn('node_id', port)
+            # Verify self link.
+            self.validate_self_link('ports', port['uuid'],
+                                    port['links'][0]['href'])
+
+    @decorators.idempotent_id('8a03f688-7d75-4ecd-8cbc-e06b8f346738')
+    def test_list_ports_details_with_address(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        self.create_port(node_id=node_id, address=address)
+        for i in range(0, 5):
+            self.create_port(node_id=node_id,
+                             address=data_utils.rand_mac_address())
+
+        _, body = self.client.list_ports_detail(address=address)
+        self.assertEqual(1, len(body['ports']))
+        self.assertEqual(address, body['ports'][0]['address'])
+
+    @decorators.idempotent_id('9c26298b-1bcb-47b7-9b9e-8bdd6e3c4aba')
+    def test_update_port_replace(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        extra = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
+
+        _, port = self.create_port(node_id=node_id, address=address,
+                                   extra=extra)
+
+        new_address = data_utils.rand_mac_address()
+        new_extra = {'key1': 'new-value1', 'key2': 'new-value2',
+                     'key3': 'new-value3'}
+
+        patch = [{'path': '/address',
+                  'op': 'replace',
+                  'value': new_address},
+                 {'path': '/extra/key1',
+                  'op': 'replace',
+                  'value': new_extra['key1']},
+                 {'path': '/extra/key2',
+                  'op': 'replace',
+                  'value': new_extra['key2']},
+                 {'path': '/extra/key3',
+                  'op': 'replace',
+                  'value': new_extra['key3']}]
+
+        self.client.update_port(port['uuid'], patch)
+
+        _, body = self.client.show_port(port['uuid'])
+        self.assertEqual(new_address, body['address'])
+        self.assertEqual(new_extra, body['extra'])
+
+    @decorators.idempotent_id('d7e7fece-6ed9-460a-9ebe-9267217e8580')
+    def test_update_port_remove(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        extra = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
+
+        _, port = self.create_port(node_id=node_id, address=address,
+                                   extra=extra)
+
+        # Removing one item from the collection
+        self.client.update_port(port['uuid'],
+                                [{'path': '/extra/key2',
+                                 'op': 'remove'}])
+        extra.pop('key2')
+        _, body = self.client.show_port(port['uuid'])
+        self.assertEqual(extra, body['extra'])
+
+        # Removing the collection
+        self.client.update_port(port['uuid'], [{'path': '/extra',
+                                               'op': 'remove'}])
+        _, body = self.client.show_port(port['uuid'])
+        self.assertEqual({}, body['extra'])
+
+        # Assert nothing else was changed
+        self.assertEqual(node_id, body['node_uuid'])
+        self.assertEqual(address, body['address'])
+
+    @decorators.idempotent_id('241288b3-e98a-400f-a4d7-d1f716146361')
+    def test_update_port_add(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address)
+
+        extra = {'key1': 'value1', 'key2': 'value2'}
+
+        patch = [{'path': '/extra/key1',
+                  'op': 'add',
+                  'value': extra['key1']},
+                 {'path': '/extra/key2',
+                  'op': 'add',
+                  'value': extra['key2']}]
+
+        self.client.update_port(port['uuid'], patch)
+
+        _, body = self.client.show_port(port['uuid'])
+        self.assertEqual(extra, body['extra'])
+
+    @decorators.idempotent_id('5309e897-0799-4649-a982-0179b04c3876')
+    def test_update_port_mixed_ops(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        extra = {'key1': 'value1', 'key2': 'value2'}
+
+        _, port = self.create_port(node_id=node_id, address=address,
+                                   extra=extra)
+
+        new_address = data_utils.rand_mac_address()
+        new_extra = {'key1': 0.123, 'key3': {'cat': 'meow'}}
+
+        patch = [{'path': '/address',
+                  'op': 'replace',
+                  'value': new_address},
+                 {'path': '/extra/key1',
+                  'op': 'replace',
+                  'value': new_extra['key1']},
+                 {'path': '/extra/key2',
+                  'op': 'remove'},
+                 {'path': '/extra/key3',
+                  'op': 'add',
+                  'value': new_extra['key3']}]
+
+        self.client.update_port(port['uuid'], patch)
+
+        _, body = self.client.show_port(port['uuid'])
+        self.assertEqual(new_address, body['address'])
+        self.assertEqual(new_extra, body['extra'])
+
+
+class TestPortsWithPhysicalNetwork(base.BaseBaremetalTest):
+    """Tests for ports with physical network information."""
+
+    min_microversion = '1.34'
+
+    def setUp(self):
+        super(TestPortsWithPhysicalNetwork, self).setUp()
+
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture(
+                TestPortsWithPhysicalNetwork.min_microversion)
+        )
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+
+    @decorators.idempotent_id('f1a5d279-c456-4311-ad31-fea09f61c22b')
+    def test_create_port_with_physical_network(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address,
+                                   physical_network='physnet1')
+
+        _, body = self.client.show_port(port['uuid'])
+
+        self._assertExpected(port, body)
+        self.assertEqual('physnet1', port['physical_network'])
+
+    @decorators.idempotent_id('9c26298b-1bcb-47b7-9b9e-8bdd6e3c4aba')
+    def test_update_port_replace_physical_network(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address,
+                                   physical_network='physnet1')
+
+        new_physnet = 'physnet2'
+
+        patch = [{'path': '/physical_network',
+                  'op': 'replace',
+                  'value': new_physnet}]
+
+        self.client.update_port(port['uuid'], patch)
+
+        _, body = self.client.show_port(port['uuid'])
+        self.assertEqual(new_physnet, body['physical_network'])
+
+    @decorators.idempotent_id('6503309c-b2c7-4f59-b15a-0d92b5de9210')
+    def test_update_port_remove_physical_network(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address,
+                                   physical_network='physnet1')
+
+        patch = [{'path': '/physical_network',
+                  'op': 'remove'}]
+
+        self.client.update_port(port['uuid'], patch)
+
+        _, body = self.client.show_port(port['uuid'])
+        self.assertIsNone(body['physical_network'])
+
+    @decorators.idempotent_id('4155c24d-8474-4b53-a320-aee475f85a68')
+    def test_create_ports_in_portgroup_with_physical_network(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, portgroup = self.create_portgroup(node_id, address=address)
+
+        _, port1 = self.create_port(node_id=node_id, address=address,
+                                    portgroup_uuid=portgroup['uuid'],
+                                    physical_network='physnet1')
+
+        address = data_utils.rand_mac_address()
+        _, port2 = self.create_port(node_id=node_id, address=address,
+                                    portgroup_uuid=portgroup['uuid'],
+                                    physical_network='physnet1')
+
+        _, body = self.client.show_port(port1['uuid'])
+        self.assertEqual('physnet1', body['physical_network'])
+        self.assertEqual(portgroup['uuid'], body['portgroup_uuid'])
+
+        _, body = self.client.show_port(port2['uuid'])
+        self.assertEqual('physnet1', body['physical_network'])
+        self.assertEqual(portgroup['uuid'], body['portgroup_uuid'])
+
+    @decorators.idempotent_id('cf05a3ef-3bc4-4db7-bb4c-4eb871eb9f81')
+    def test_update_ports_in_portgroup_with_physical_network(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, portgroup = self.create_portgroup(node_id, address=address)
+
+        _, port1 = self.create_port(node_id=node_id, address=address,
+                                    portgroup_uuid=portgroup['uuid'],
+                                    physical_network='physnet1')
+
+        address = data_utils.rand_mac_address()
+        _, port2 = self.create_port(node_id=node_id, address=address,
+                                    physical_network='physnet1')
+
+        patch = [{'path': '/portgroup_uuid',
+                  'op': 'replace',
+                  'value': portgroup['uuid']}]
+
+        self.client.update_port(port2['uuid'], patch)
+
+        _, body = self.client.show_port(port1['uuid'])
+        self.assertEqual('physnet1', body['physical_network'])
+        self.assertEqual(portgroup['uuid'], body['portgroup_uuid'])
+
+        _, body = self.client.show_port(port2['uuid'])
+        self.assertEqual('physnet1', body['physical_network'])
+        self.assertEqual(portgroup['uuid'], body['portgroup_uuid'])
diff --git a/ironic_tempest_plugin/tests/api/admin/test_ports_negative.py b/ironic_tempest_plugin/tests/api/admin/test_ports_negative.py
new file mode 100644
index 0000000..c25020b
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/test_ports_negative.py
@@ -0,0 +1,463 @@
+#    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 decorators
+from tempest.lib import exceptions as lib_exc
+
+from ironic_tempest_plugin.tests.api.admin import api_microversion_fixture
+from ironic_tempest_plugin.tests.api.admin import base
+
+
+class TestPortsNegative(base.BaseBaremetalTest):
+    """Negative tests for ports."""
+
+    def setUp(self):
+        super(TestPortsNegative, self).setUp()
+
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('0a6ee1f7-d0d9-4069-8778-37f3aa07303a')
+    def test_create_port_malformed_mac(self):
+        node_id = self.node['uuid']
+        address = 'malformed:mac'
+
+        self.assertRaises(lib_exc.BadRequest,
+                          self.create_port, node_id=node_id, address=address)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('30277ee8-0c60-4f1d-b125-0e51c2f43369')
+    def test_create_port_nonexsistent_node_id(self):
+        node_id = str(data_utils.rand_uuid())
+        address = data_utils.rand_mac_address()
+        self.assertRaises(lib_exc.BadRequest, self.create_port,
+                          node_id=node_id, address=address)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('029190f6-43e1-40a3-b64a-65173ba653a3')
+    def test_show_port_malformed_uuid(self):
+        self.assertRaises(lib_exc.BadRequest, self.client.show_port,
+                          'malformed:uuid')
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('0d00e13d-e2e0-45b1-bcbc-55a6d90ca793')
+    def test_show_port_nonexistent_uuid(self):
+        self.assertRaises(lib_exc.NotFound, self.client.show_port,
+                          data_utils.rand_uuid())
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('4ad85266-31e9-4942-99ac-751897dc9e23')
+    def test_show_port_by_mac_not_allowed(self):
+        self.assertRaises(lib_exc.BadRequest, self.client.show_port,
+                          data_utils.rand_mac_address())
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('89a34380-3c61-4c32-955c-2cd9ce94da21')
+    def test_create_port_duplicated_port_uuid(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        uuid = data_utils.rand_uuid()
+
+        self.create_port(node_id=node_id, address=address, uuid=uuid)
+        self.assertRaises(lib_exc.Conflict, self.create_port, node_id=node_id,
+                          address=address, uuid=uuid)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('65e84917-733c-40ae-ae4b-96a4adff931c')
+    def test_create_port_no_mandatory_field_node_id(self):
+        address = data_utils.rand_mac_address()
+
+        self.assertRaises(lib_exc.BadRequest, self.create_port, node_id=None,
+                          address=address)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('bcea3476-7033-4183-acfe-e56a30809b46')
+    def test_create_port_no_mandatory_field_mac(self):
+        node_id = self.node['uuid']
+
+        self.assertRaises(lib_exc.BadRequest, self.create_port,
+                          node_id=node_id, address=None)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('2b51cd18-fb95-458b-9780-e6257787b649')
+    def test_create_port_malformed_port_uuid(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        uuid = 'malformed:uuid'
+
+        self.assertRaises(lib_exc.BadRequest, self.create_port,
+                          node_id=node_id, address=address, uuid=uuid)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('583a6856-6a30-4ac4-889f-14e2adff8105')
+    def test_create_port_malformed_node_id(self):
+        address = data_utils.rand_mac_address()
+        self.assertRaises(lib_exc.BadRequest, self.create_port,
+                          node_id='malformed:nodeid', address=address)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('e27f8b2e-42c6-4a43-a3cd-accff716bc5c')
+    def test_create_port_duplicated_mac(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        self.create_port(node_id=node_id, address=address)
+        self.assertRaises(lib_exc.Conflict,
+                          self.create_port, node_id=node_id,
+                          address=address)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('8907082d-ac5e-4be3-b05f-d072ede82020')
+    def test_update_port_by_mac_not_allowed(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        extra = {'key': 'value'}
+
+        self.create_port(node_id=node_id, address=address, extra=extra)
+
+        patch = [{'path': '/extra/key',
+                  'op': 'replace',
+                  'value': 'new-value'}]
+
+        self.assertRaises(lib_exc.BadRequest,
+                          self.client.update_port, address,
+                          patch)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('df1ac70c-db9f-41d9-90f1-78cd6b905718')
+    def test_update_port_nonexistent(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        extra = {'key': 'value'}
+
+        _, port = self.create_port(node_id=node_id, address=address,
+                                   extra=extra)
+        port_id = port['uuid']
+
+        _, body = self.client.delete_port(port_id)
+
+        patch = [{'path': '/extra/key',
+                  'op': 'replace',
+                  'value': 'new-value'}]
+        self.assertRaises(lib_exc.NotFound,
+                          self.client.update_port, port_id, patch)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('c701e315-aa52-41ea-817c-65c5ca8ca2a8')
+    def test_update_port_malformed_port_uuid(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        self.create_port(node_id=node_id, address=address)
+
+        new_address = data_utils.rand_mac_address()
+        self.assertRaises(lib_exc.BadRequest, self.client.update_port,
+                          uuid='malformed:uuid',
+                          patch=[{'path': '/address', 'op': 'replace',
+                                  'value': new_address}])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('f8f15803-34d6-45dc-b06f-e5e04bf1b38b')
+    def test_update_port_add_nonexistent_property(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address)
+        port_id = port['uuid']
+
+        self.assertRaises(lib_exc.BadRequest, self.client.update_port, port_id,
+                          [{'path': '/nonexistent', ' op': 'add',
+                            'value': 'value'}])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('898ec904-38b1-4fcb-9584-1187d4263a2a')
+    def test_update_port_replace_node_id_with_malformed(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address)
+        port_id = port['uuid']
+
+        patch = [{'path': '/node_uuid',
+                  'op': 'replace',
+                  'value': 'malformed:node_uuid'}]
+        self.assertRaises(lib_exc.BadRequest,
+                          self.client.update_port, port_id, patch)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('2949f30f-5f59-43fa-a6d9-4eac578afab4')
+    def test_update_port_replace_mac_with_duplicated(self):
+        node_id = self.node['uuid']
+        address1 = data_utils.rand_mac_address()
+        address2 = data_utils.rand_mac_address()
+
+        _, port1 = self.create_port(node_id=node_id, address=address1)
+
+        _, port2 = self.create_port(node_id=node_id, address=address2)
+        port_id = port2['uuid']
+
+        patch = [{'path': '/address',
+                  'op': 'replace',
+                  'value': address1}]
+        self.assertRaises(lib_exc.Conflict,
+                          self.client.update_port, port_id, patch)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('97f6e048-6e4f-4eba-a09d-fbbc78b77a77')
+    def test_update_port_replace_node_id_with_nonexistent(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address)
+        port_id = port['uuid']
+
+        patch = [{'path': '/node_uuid',
+                  'op': 'replace',
+                  'value': data_utils.rand_uuid()}]
+        self.assertRaises(lib_exc.BadRequest,
+                          self.client.update_port, port_id, patch)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('375022c5-9e9e-4b11-9ca4-656729c0c9b2')
+    def test_update_port_replace_mac_with_malformed(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address)
+        port_id = port['uuid']
+
+        patch = [{'path': '/address',
+                  'op': 'replace',
+                  'value': 'malformed:mac'}]
+
+        self.assertRaises(lib_exc.BadRequest,
+                          self.client.update_port, port_id, patch)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('5722b853-03fc-4854-8308-2036a1b67d85')
+    def test_update_port_replace_nonexistent_property(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address)
+        port_id = port['uuid']
+
+        patch = [{'path': '/nonexistent', ' op': 'replace', 'value': 'value'}]
+
+        self.assertRaises(lib_exc.BadRequest,
+                          self.client.update_port, port_id, patch)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('ae2696ca-930a-4a7f-918f-30ae97c60f56')
+    def test_update_port_remove_mandatory_field_mac(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address)
+        port_id = port['uuid']
+
+        self.assertRaises(lib_exc.BadRequest, self.client.update_port, port_id,
+                          [{'path': '/address', 'op': 'remove'}])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('5392c1f0-2071-4697-9064-ec2d63019018')
+    def test_update_port_remove_mandatory_field_port_uuid(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address)
+        port_id = port['uuid']
+
+        self.assertRaises(lib_exc.BadRequest, self.client.update_port, port_id,
+                          [{'path': '/uuid', 'op': 'remove'}])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('06b50d82-802a-47ef-b079-0a3311cf85a2')
+    def test_update_port_remove_nonexistent_property(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, port = self.create_port(node_id=node_id, address=address)
+        port_id = port['uuid']
+
+        self.assertRaises(lib_exc.BadRequest, self.client.update_port, port_id,
+                          [{'path': '/nonexistent', 'op': 'remove'}])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('03d42391-2145-4a6c-95bf-63fe55eb64fd')
+    def test_delete_port_by_mac_not_allowed(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        self.create_port(node_id=node_id, address=address)
+        self.assertRaises(lib_exc.BadRequest, self.client.delete_port, address)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('0629e002-818e-4763-b25b-ae5e07b1cb23')
+    def test_update_port_mixed_ops_integrity(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+        extra = {'key1': 'value1', 'key2': 'value2'}
+
+        _, port = self.create_port(node_id=node_id, address=address,
+                                   extra=extra)
+        port_id = port['uuid']
+
+        new_address = data_utils.rand_mac_address()
+        new_extra = {'key1': 'new-value1', 'key3': 'new-value3'}
+
+        patch = [{'path': '/address',
+                  'op': 'replace',
+                  'value': new_address},
+                 {'path': '/extra/key1',
+                  'op': 'replace',
+                  'value': new_extra['key1']},
+                 {'path': '/extra/key2',
+                  'op': 'remove'},
+                 {'path': '/extra/key3',
+                  'op': 'add',
+                  'value': new_extra['key3']},
+                 {'path': '/nonexistent',
+                  'op': 'replace',
+                  'value': 'value'}]
+
+        self.assertRaises(lib_exc.BadRequest, self.client.update_port, port_id,
+                          patch)
+
+        # patch should not be applied
+        _, body = self.client.show_port(port_id)
+        self.assertEqual(address, body['address'])
+        self.assertEqual(extra, body['extra'])
+
+
+class TestPortsWithPhysicalNetworkOldAPI(base.BaseBaremetalTest):
+    """Negative tests for ports with physical network information."""
+
+    def setUp(self):
+        super(TestPortsWithPhysicalNetworkOldAPI, self).setUp()
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('307e57e9-082f-4830-9480-91affcbfda08')
+    def test_create_port_with_physical_network_old_api(self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        self.assertRaises((lib_exc.BadRequest, lib_exc.UnexpectedResponseCode),
+                          self.create_port,
+                          node_id=node_id, address=address,
+                          physical_network='physnet1')
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('0b278c0a-d334-424e-a5c5-b6d001c2a715')
+    def test_update_port_replace_physical_network_old_api(self):
+        _, port = self.create_port(self.node['uuid'],
+                                   data_utils.rand_mac_address())
+
+        new_physnet = 'physnet1'
+
+        patch = [{'path': '/physical_network',
+                  'op': 'replace',
+                  'value': new_physnet}]
+
+        self.assertRaises((lib_exc.BadRequest, lib_exc.UnexpectedResponseCode),
+                          self.client.update_port,
+                          port['uuid'], patch)
+
+
+class TestPortsNegativeWithPhysicalNetwork(base.BaseBaremetalTest):
+    """Negative tests for ports with physical network information."""
+
+    min_microversion = '1.34'
+
+    def setUp(self):
+        super(TestPortsNegativeWithPhysicalNetwork, self).setUp()
+
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture(
+                TestPortsNegativeWithPhysicalNetwork.min_microversion)
+        )
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('e20156fb-956b-4d5b-89a4-f379044a1d3c')
+    def test_create_ports_in_portgroup_with_inconsistent_physical_network(
+            self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, portgroup = self.create_portgroup(node_id, address=address)
+
+        _, _ = self.create_port(node_id=node_id, address=address,
+                                portgroup_uuid=portgroup['uuid'],
+                                physical_network='physnet1')
+
+        address = data_utils.rand_mac_address()
+        self.assertRaises(lib_exc.Conflict,
+                          self.create_port,
+                          node_id=node_id, address=address,
+                          portgroup_uuid=portgroup['uuid'],
+                          physical_network='physnet2')
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('050e792c-22c9-4e4a-ae89-dfbfc52ad00d')
+    def test_update_ports_in_portgroup_with_inconsistent_physical_network(
+            self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, portgroup = self.create_portgroup(node_id, address=address)
+
+        _, _ = self.create_port(node_id=node_id, address=address,
+                                portgroup_uuid=portgroup['uuid'],
+                                physical_network='physnet1')
+
+        address = data_utils.rand_mac_address()
+        _, port2 = self.create_port(node_id=node_id, address=address,
+                                    physical_network='physnet2')
+
+        patch = [{'path': '/portgroup_uuid',
+                  'op': 'replace',
+                  'value': portgroup['uuid']}]
+
+        self.assertRaises(lib_exc.Conflict,
+                          self.client.update_port,
+                          port2['uuid'], patch)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('3cd1c8ec-57d1-40cb-922b-dd02431beea3')
+    def test_update_ports_in_portgroup_with_inconsistent_physical_network_2(
+            self):
+        node_id = self.node['uuid']
+        address = data_utils.rand_mac_address()
+
+        _, portgroup = self.create_portgroup(node_id, address=address)
+
+        _, _ = self.create_port(node_id=node_id, address=address,
+                                portgroup_uuid=portgroup['uuid'],
+                                physical_network='physnet1')
+
+        address = data_utils.rand_mac_address()
+        _, port2 = self.create_port(node_id=node_id, address=address,
+                                    portgroup_uuid=portgroup['uuid'],
+                                    physical_network='physnet1')
+
+        patch = [{'path': '/physical_network',
+                  'op': 'replace',
+                  'value': 'physnet2'}]
+
+        self.assertRaises(lib_exc.Conflict,
+                          self.client.update_port,
+                          port2['uuid'], patch)
diff --git a/ironic_tempest_plugin/tests/api/admin/test_volume_connector.py b/ironic_tempest_plugin/tests/api/admin/test_volume_connector.py
new file mode 100644
index 0000000..0b936a2
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/test_volume_connector.py
@@ -0,0 +1,227 @@
+# Copyright 2017 FUJITSU LIMITED
+#
+# 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 decorators
+from tempest.lib import exceptions as lib_exc
+
+from ironic_tempest_plugin.tests.api.admin import api_microversion_fixture
+from ironic_tempest_plugin.tests.api.admin import base
+
+
+class TestVolumeConnector(base.BaseBaremetalTest):
+    """Basic test cases for volume connector."""
+
+    min_microversion = '1.32'
+    extra = {'key1': 'value1', 'key2': 'value2'}
+
+    def setUp(self):
+        super(TestVolumeConnector, self).setUp()
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture(
+                self.min_microversion))
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+        _, self.volume_connector = self.create_volume_connector(
+            self.node['uuid'], type='iqn',
+            connector_id=data_utils.rand_name('connector_id'),
+            extra=self.extra)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('3c3cbf45-488a-4386-a811-bf0aa2589c58')
+    def test_create_volume_connector_error(self):
+        """Create a volume connector.
+
+        Fail when creating a volume connector with same connector_id
+        & type as an existing volume connector.
+        """
+        regex_str = (r'.*A volume connector .*already exists')
+
+        self.assertRaisesRegex(
+            lib_exc.Conflict, regex_str,
+            self.create_volume_connector,
+            self.node['uuid'],
+            type=self.volume_connector['type'],
+            connector_id=self.volume_connector['connector_id'])
+
+    @decorators.idempotent_id('5795f816-0789-42e6-bb9c-91b4876ad13f')
+    def test_delete_volume_connector(self):
+        """Delete a volume connector."""
+        # Powering off the Node before deleting a volume connector.
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+
+        self.delete_volume_connector(self.volume_connector['uuid'])
+        self.assertRaises(lib_exc.NotFound, self.client.show_volume_connector,
+                          self.volume_connector['uuid'])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('ccbda5e6-52b7-400c-94d7-25eec1d590f0')
+    def test_delete_volume_connector_error(self):
+        """Delete a volume connector
+
+        Fail when deleting a volume connector on node
+        with powered on state.
+        """
+
+        # Powering on the Node before deleting a volume connector.
+        self.client.set_node_power_state(self.node['uuid'], 'power on')
+
+        regex_str = (r'.*The requested action \\\\"volume connector '
+                     r'deletion\\\\" can not be performed on node*')
+
+        self.assertRaisesRegex(lib_exc.BadRequest,
+                               regex_str,
+                               self.delete_volume_connector,
+                               self.volume_connector['uuid'])
+
+    @decorators.idempotent_id('6e4f50b7-0f4f-41c2-971e-d751abcac4e0')
+    def test_show_volume_connector(self):
+        """Show a specified volume connector."""
+        _, volume_connector = self.client.show_volume_connector(
+            self.volume_connector['uuid'])
+        self._assertExpected(self.volume_connector, volume_connector)
+
+    @decorators.idempotent_id('a4725778-e164-4ee5-96a0-66119a35f783')
+    def test_list_volume_connectors(self):
+        """List volume connectors."""
+        _, body = self.client.list_volume_connectors()
+        self.assertIn(self.volume_connector['uuid'],
+                      [i['uuid'] for i in body['connectors']])
+        self.assertIn(self.volume_connector['type'],
+                      [i['type'] for i in body['connectors']])
+        self.assertIn(self.volume_connector['connector_id'],
+                      [i['connector_id'] for i in body['connectors']])
+
+    @decorators.idempotent_id('1d0459ad-01c0-46db-b930-7301bc2a3c98')
+    def test_list_with_limit(self):
+        """List volume connectors with limit."""
+        _, body = self.client.list_volume_connectors(limit=3)
+
+        next_marker = body['connectors'][-1]['uuid']
+        self.assertIn(next_marker, body['next'])
+
+    @decorators.idempotent_id('3c6f8354-e9bd-4f21-aae2-6deb96b04be7')
+    def test_update_volume_connector_replace(self):
+        """Update a volume connector with new connector id."""
+        new_connector_id = data_utils.rand_name('connector_id')
+
+        patch = [{'path': '/connector_id',
+                  'op': 'replace',
+                  'value': new_connector_id}]
+
+        # Powering off the Node before updating a volume connector.
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+
+        self.client.update_volume_connector(
+            self.volume_connector['uuid'], patch)
+
+        _, body = self.client.show_volume_connector(
+            self.volume_connector['uuid'])
+        self.assertEqual(new_connector_id, body['connector_id'])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('5af8dc7a-9965-4787-8184-e60aeaf30957')
+    def test_update_volume_connector_replace_error(self):
+        """Updating a volume connector.
+
+        Fail when updating a volume connector on node
+        with power on state.
+        """
+
+        new_connector_id = data_utils.rand_name('connector_id')
+
+        patch = [{'path': '/connector_id',
+                  'op': 'replace',
+                  'value': new_connector_id}]
+
+        # Powering on the Node before updating a volume connector.
+        self.client.set_node_power_state(self.node['uuid'], 'power on')
+
+        regex_str = (r'.*The requested action \\\\"volume connector '
+                     r'update\\\\" can not be performed on node*')
+        self.assertRaisesRegex(lib_exc.BadRequest,
+                               regex_str,
+                               self.client.update_volume_connector,
+                               self.volume_connector['uuid'],
+                               patch)
+
+    @decorators.idempotent_id('b95c75eb-4048-482e-99ff-fe1d32538383')
+    def test_update_volume_connector_remove_item(self):
+        """Update a volume connector by removing one item from collection."""
+        new_extra = {'key1': 'value1'}
+        _, body = self.client.show_volume_connector(
+            self.volume_connector['uuid'])
+        connector_id = body['connector_id']
+        connector_type = body['type']
+
+        # Powering off the Node before updating a volume connector.
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+
+        # Removing one item from the collection
+        self.client.update_volume_connector(self.volume_connector['uuid'],
+                                            [{'path': '/extra/key2',
+                                              'op': 'remove'}])
+        _, body = self.client.show_volume_connector(
+            self.volume_connector['uuid'])
+        self.assertEqual(new_extra, body['extra'])
+
+        # Assert nothing else was changed
+        self.assertEqual(connector_id, body['connector_id'])
+        self.assertEqual(connector_type, body['type'])
+
+    @decorators.idempotent_id('8de03acd-532a-476f-8bc9-0e8b23bfe609')
+    def test_update_volume_connector_remove_collection(self):
+        """Update a volume connector by removing collection."""
+        _, body = self.client.show_volume_connector(
+            self.volume_connector['uuid'])
+        connector_id = body['connector_id']
+        connector_type = body['type']
+
+        # Powering off the Node before updating a volume connector.
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+
+        # Removing the collection
+        self.client.update_volume_connector(self.volume_connector['uuid'],
+                                            [{'path': '/extra',
+                                              'op': 'remove'}])
+        _, body = self.client.show_volume_connector(
+            self.volume_connector['uuid'])
+        self.assertEqual({}, body['extra'])
+
+        # Assert nothing else was changed
+        self.assertEqual(connector_id, body['connector_id'])
+        self.assertEqual(connector_type, body['type'])
+
+    @decorators.idempotent_id('bfb0ca6b-086d-4663-9b25-e0eaf42da55b')
+    def test_update_volume_connector_add(self):
+        """Update a volume connector by adding one item to collection."""
+        new_extra = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
+
+        patch = [{'path': '/extra/key3',
+                  'op': 'add',
+                  'value': new_extra['key3']},
+                 {'path': '/extra/key3',
+                  'op': 'add',
+                  'value': new_extra['key3']}]
+
+        # Powering off the Node before updating a volume connector.
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+
+        self.client.update_volume_connector(
+            self.volume_connector['uuid'], patch)
+
+        _, body = self.client.show_volume_connector(
+            self.volume_connector['uuid'])
+        self.assertEqual(new_extra, body['extra'])
diff --git a/ironic_tempest_plugin/tests/api/admin/test_volume_target.py b/ironic_tempest_plugin/tests/api/admin/test_volume_target.py
new file mode 100644
index 0000000..731467c
--- /dev/null
+++ b/ironic_tempest_plugin/tests/api/admin/test_volume_target.py
@@ -0,0 +1,210 @@
+# Copyright 2017 FUJITSU LIMITED
+#
+# 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 decorators
+from tempest.lib import exceptions as lib_exc
+
+from ironic_tempest_plugin.tests.api.admin import api_microversion_fixture
+from ironic_tempest_plugin.tests.api.admin import base
+
+
+class TestVolumeTarget(base.BaseBaremetalTest):
+    """Basic test cases for volume target."""
+
+    min_microversion = '1.32'
+    extra = {'key1': 'value1', 'key2': 'value2'}
+
+    def setUp(self):
+        super(TestVolumeTarget, self).setUp()
+        self.useFixture(
+            api_microversion_fixture.APIMicroversionFixture(
+                self.min_microversion))
+        _, self.chassis = self.create_chassis()
+        _, self.node = self.create_node(self.chassis['uuid'])
+        _, self.volume_target = self.create_volume_target(
+            self.node['uuid'], volume_type=data_utils.rand_name('volume_type'),
+            volume_id=data_utils.rand_name('volume_id'),
+            boot_index=10,
+            extra=self.extra)
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('da5c27d4-68cc-499f-b8ab-3048b87d3bca')
+    def test_create_volume_target_error(self):
+        """Create a volume target.
+
+        Fail when creating a volume target with same boot index as the
+        existing volume target.
+        """
+        regex_str = (r'.*A volume target .*already exists')
+
+        self.assertRaisesRegex(
+            lib_exc.Conflict, regex_str,
+            self.create_volume_target,
+            self.node['uuid'],
+            volume_type=data_utils.rand_name('volume_type'),
+            volume_id=data_utils.rand_name('volume_id'),
+            boot_index=self.volume_target['boot_index'])
+
+    @decorators.idempotent_id('ea3a9b2e-8971-4830-9274-abaf0239f1ce')
+    def test_delete_volume_target(self):
+        """Delete a volume target."""
+        # Powering off the Node before deleting a volume target.
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+
+        self.delete_volume_target(self.volume_target['uuid'])
+        self.assertRaises(lib_exc.NotFound, self.client.show_volume_target,
+                          self.volume_target['uuid'])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('532a06bc-a9b2-44b0-828a-c53279c87cb2')
+    def test_delete_volume_target_error(self):
+        """Fail when deleting a volume target on node with power on state."""
+        # Powering on the Node before deleting a volume target.
+        self.client.set_node_power_state(self.node['uuid'], 'power on')
+
+        regex_str = (r'.*The requested action \\\\"volume target '
+                     r'deletion\\\\" can not be performed on node*')
+
+        self.assertRaisesRegex(lib_exc.BadRequest,
+                               regex_str,
+                               self.delete_volume_target,
+                               self.volume_target['uuid'])
+
+    @decorators.idempotent_id('a2598388-8f61-4b7e-944f-f37e4f60e1e2')
+    def test_show_volume_target(self):
+        """Show a specified volume target."""
+        _, volume_target = self.client.show_volume_target(
+            self.volume_target['uuid'])
+        self._assertExpected(self.volume_target, volume_target)
+
+    @decorators.idempotent_id('ae99a986-d93c-4324-9cdc-41d89e3a659f')
+    def test_list_volume_targets(self):
+        """List volume targets."""
+        _, body = self.client.list_volume_targets()
+        self.assertIn(self.volume_target['uuid'],
+                      [i['uuid'] for i in body['targets']])
+        self.assertIn(self.volume_target['volume_type'],
+                      [i['volume_type'] for i in body['targets']])
+        self.assertIn(self.volume_target['volume_id'],
+                      [i['volume_id'] for i in body['targets']])
+
+    @decorators.idempotent_id('9da25447-0370-4b33-9c1f-d4503f5950ae')
+    def test_list_with_limit(self):
+        """List volume targets with limit."""
+        _, body = self.client.list_volume_targets(limit=3)
+
+        next_marker = body['targets'][-1]['uuid']
+        self.assertIn(next_marker, body['next'])
+
+    @decorators.idempotent_id('8559cd08-feae-4f1a-a0ad-5bad8ea12b76')
+    def test_update_volume_target_replace(self):
+        """Update a volume target by replacing volume id."""
+        new_volume_id = data_utils.rand_name('volume_id')
+
+        patch = [{'path': '/volume_id',
+                  'op': 'replace',
+                  'value': new_volume_id}]
+
+        # Powering off the Node before updating a volume target.
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+
+        self.client.update_volume_target(self.volume_target['uuid'], patch)
+
+        _, body = self.client.show_volume_target(self.volume_target['uuid'])
+        self.assertEqual(new_volume_id, body['volume_id'])
+
+    @decorators.attr(type=['negative'])
+    @decorators.idempotent_id('fd5266d3-4f3c-4dce-9c87-bfdea2b756c7')
+    def test_update_volume_target_replace_error(self):
+        """Fail when updating a volume target on node with power on state."""
+        new_volume_id = data_utils.rand_name('volume_id')
+
+        patch = [{'path': '/volume_id',
+                  'op': 'replace',
+                  'value': new_volume_id}]
+
+        # Powering on the Node before updating a volume target.
+        self.client.set_node_power_state(self.node['uuid'], 'power on')
+
+        regex_str = (r'.*The requested action \\\\"volume target '
+                     r'update\\\\" can not be performed on node*')
+
+        self.assertRaisesRegex(lib_exc.BadRequest,
+                               regex_str,
+                               self.client.update_volume_target,
+                               self.volume_target['uuid'],
+                               patch)
+
+    @decorators.idempotent_id('1c13a4ee-1a49-4739-8c19-77960fbd1af8')
+    def test_update_volume_target_remove_item(self):
+        """Update a volume target by removing one item from the collection."""
+        new_extra = {'key1': 'value1'}
+        _, body = self.client.show_volume_target(self.volume_target['uuid'])
+        volume_id = body['volume_id']
+        volume_type = body['volume_type']
+
+        # Powering off the Node before updating a volume target.
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+
+        # Removing one item from the collection
+        self.client.update_volume_target(self.volume_target['uuid'],
+                                         [{'path': '/extra/key2',
+                                           'op': 'remove'}])
+
+        _, body = self.client.show_volume_target(self.volume_target['uuid'])
+        self.assertEqual(new_extra, body['extra'])
+
+        # Assert nothing else was changed
+        self.assertEqual(volume_id, body['volume_id'])
+        self.assertEqual(volume_type, body['volume_type'])
+
+    @decorators.idempotent_id('6784ddb0-9144-41ea-b8a0-f888ad5c5b62')
+    def test_update_volume_target_remove_collection(self):
+        """Update a volume target by removing the collection."""
+        _, body = self.client.show_volume_target(self.volume_target['uuid'])
+        volume_id = body['volume_id']
+        volume_type = body['volume_type']
+
+        # Powering off the Node before updating a volume target.
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+
+        # Removing the collection
+        self.client.update_volume_target(self.volume_target['uuid'],
+                                         [{'path': '/extra',
+                                           'op': 'remove'}])
+        _, body = self.client.show_volume_target(self.volume_target['uuid'])
+        self.assertEqual({}, body['extra'])
+
+        # Assert nothing else was changed
+        self.assertEqual(volume_id, body['volume_id'])
+        self.assertEqual(volume_type, body['volume_type'])
+
+    @decorators.idempotent_id('9629715d-57ba-423b-b985-232674cc3a25')
+    def test_update_volume_target_add(self):
+        """Update a volume target by adding to the collection."""
+        new_extra = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
+
+        patch = [{'path': '/extra/key3',
+                  'op': 'add',
+                  'value': new_extra['key3']}]
+
+        # Powering off the Node before updating a volume target.
+        self.client.set_node_power_state(self.node['uuid'], 'power off')
+
+        self.client.update_volume_target(self.volume_target['uuid'], patch)
+
+        _, body = self.client.show_volume_target(self.volume_target['uuid'])
+        self.assertEqual(new_extra, body['extra'])
diff --git a/ironic_tempest_plugin/tests/scenario/baremetal_manager.py b/ironic_tempest_plugin/tests/scenario/baremetal_manager.py
new file mode 100644
index 0000000..bd6f1bd
--- /dev/null
+++ b/ironic_tempest_plugin/tests/scenario/baremetal_manager.py
@@ -0,0 +1,231 @@
+# Copyright 2012 OpenStack Foundation
+# Copyright 2013 IBM Corp.
+# All Rights Reserved.
+#
+#    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.common import waiters
+from tempest import config
+from tempest.lib.common import api_version_utils
+from tempest.lib import exceptions as lib_exc
+
+from ironic_tempest_plugin import clients
+from ironic_tempest_plugin.common import utils
+from ironic_tempest_plugin.common import waiters as ironic_waiters
+from ironic_tempest_plugin import manager
+
+CONF = config.CONF
+
+
+def retry_on_conflict(func):
+    def inner(*args, **kwargs):
+        # TODO(vsaienko): make number of retries and delay between
+        # them configurable in future.
+        e = None
+        for att in range(10):
+            try:
+                return func(*args, **kwargs)
+            except lib_exc.Conflict as e:
+                time.sleep(1)
+        raise lib_exc.Conflict(e)
+
+    return inner
+
+
+# power/provision states as of icehouse
+class BaremetalPowerStates(object):
+    """Possible power states of an Ironic node."""
+    POWER_ON = 'power on'
+    POWER_OFF = 'power off'
+    REBOOT = 'rebooting'
+    SUSPEND = 'suspended'
+
+
+class BaremetalProvisionStates(object):
+    """Possible provision states of an Ironic node."""
+    ENROLL = 'enroll'
+    NOSTATE = None
+    AVAILABLE = 'available'
+    INIT = 'initializing'
+    ACTIVE = 'active'
+    BUILDING = 'building'
+    DEPLOYWAIT = 'wait call-back'
+    DEPLOYING = 'deploying'
+    DEPLOYFAIL = 'deploy failed'
+    DEPLOYDONE = 'deploy complete'
+    DELETING = 'deleting'
+    DELETED = 'deleted'
+    ERROR = 'error'
+    MANAGEABLE = 'manageable'
+
+
+class BaremetalScenarioTest(manager.ScenarioTest):
+
+    credentials = ['primary', 'admin']
+    min_microversion = None
+    max_microversion = api_version_utils.LATEST_MICROVERSION
+
+    @classmethod
+    def skip_checks(cls):
+        super(BaremetalScenarioTest, cls).skip_checks()
+        if not CONF.service_available.ironic:
+            raise cls.skipException('Ironic is not enabled.')
+        cfg_min_version = CONF.baremetal.min_microversion
+        cfg_max_version = CONF.baremetal.max_microversion
+        api_version_utils.check_skip_with_microversion(cls.min_microversion,
+                                                       cls.max_microversion,
+                                                       cfg_min_version,
+                                                       cfg_max_version)
+
+    @classmethod
+    def setup_clients(cls):
+        super(BaremetalScenarioTest, cls).setup_clients()
+
+        cls.baremetal_client = clients.Manager().baremetal_client
+
+    @classmethod
+    def resource_setup(cls):
+        super(BaremetalScenarioTest, cls).resource_setup()
+        # allow any issues obtaining the node list to raise early
+        cls.baremetal_client.list_nodes()
+
+    @classmethod
+    def wait_provisioning_state(cls, node_id, state, timeout=10, interval=1):
+        ironic_waiters.wait_for_bm_node_status(
+            cls.baremetal_client, node_id=node_id, attr='provision_state',
+            status=state, timeout=timeout, interval=interval)
+
+    @classmethod
+    def wait_power_state(cls, node_id, state):
+        ironic_waiters.wait_for_bm_node_status(
+            cls.baremetal_client, node_id=node_id, attr='power_state',
+            status=state, timeout=CONF.baremetal.power_timeout)
+
+    def wait_node(self, instance_id):
+        """Waits for a node to be associated with instance_id."""
+        ironic_waiters.wait_node_instance_association(self.baremetal_client,
+                                                      instance_id)
+
+    @classmethod
+    def get_node(cls, node_id=None, instance_id=None):
+        return utils.get_node(cls.baremetal_client, node_id, instance_id)
+
+    def get_ports(self, node_uuid):
+        ports = []
+        _, body = self.baremetal_client.list_node_ports(node_uuid)
+        for port in body['ports']:
+            _, p = self.baremetal_client.show_port(port['uuid'])
+            ports.append(p)
+        return ports
+
+    def get_node_vifs(self, node_uuid, api_version='1.28'):
+        _, body = self.baremetal_client.vif_list(node_uuid,
+                                                 api_version=api_version)
+        return body['vifs']
+
+    def add_keypair(self):
+        self.keypair = self.create_keypair()
+
+    @classmethod
+    @retry_on_conflict
+    def update_node_driver(cls, node_id, driver):
+        _, body = cls.baremetal_client.update_node(
+            node_id, driver=driver)
+        return body
+
+    @classmethod
+    @retry_on_conflict
+    def update_node(cls, node_id, patch):
+        cls.baremetal_client.update_node(node_id, patch=patch)
+
+    @classmethod
+    @retry_on_conflict
+    def set_node_provision_state(cls, node_id, state, configdrive=None,
+                                 clean_steps=None):
+        cls.baremetal_client.set_node_provision_state(
+            node_id, state, configdrive=configdrive, clean_steps=clean_steps)
+
+    def verify_connectivity(self, ip=None):
+        if ip:
+            dest = self.get_remote_client(ip)
+        else:
+            dest = self.get_remote_client(self.instance)
+        dest.validate_authentication()
+
+    def boot_instance(self, clients=None, keypair=None,
+                      net_id=None, fixed_ip=None, **create_kwargs):
+        if clients is None:
+            servers_client = self.servers_client
+        else:
+            servers_client = clients.servers_client
+        if keypair is None:
+            keypair = self.keypair
+
+        if any([net_id, fixed_ip]):
+            network = {}
+            if net_id:
+                network['uuid'] = net_id
+            if fixed_ip:
+                network['fixed_ip'] = fixed_ip
+            instance = self.create_server(
+                key_name=keypair['name'],
+                networks=[network],
+                clients=clients,
+                **create_kwargs
+            )
+        else:
+            instance = self.create_server(
+                key_name=keypair['name'],
+                clients=clients,
+                **create_kwargs
+            )
+
+        self.wait_node(instance['id'])
+        node = self.get_node(instance_id=instance['id'])
+
+        self.wait_power_state(node['uuid'], BaremetalPowerStates.POWER_ON)
+
+        self.wait_provisioning_state(
+            node['uuid'],
+            [BaremetalProvisionStates.DEPLOYWAIT,
+             BaremetalProvisionStates.ACTIVE],
+            timeout=CONF.baremetal.deploywait_timeout)
+
+        self.wait_provisioning_state(node['uuid'],
+                                     BaremetalProvisionStates.ACTIVE,
+                                     timeout=CONF.baremetal.active_timeout,
+                                     interval=30)
+
+        waiters.wait_for_server_status(servers_client,
+                                       instance['id'], 'ACTIVE')
+        node = self.get_node(instance_id=instance['id'])
+        instance = servers_client.show_server(instance['id'])['server']
+
+        return instance, node
+
+    def terminate_instance(self, instance, servers_client=None):
+        if servers_client is None:
+            servers_client = self.servers_client
+
+        node = self.get_node(instance_id=instance['id'])
+        servers_client.delete_server(instance['id'])
+        self.wait_power_state(node['uuid'],
+                              BaremetalPowerStates.POWER_OFF)
+        self.wait_provisioning_state(
+            node['uuid'],
+            [BaremetalProvisionStates.NOSTATE,
+             BaremetalProvisionStates.AVAILABLE],
+            timeout=CONF.baremetal.unprovision_timeout,
+            interval=30)
diff --git a/ironic_tempest_plugin/tests/scenario/baremetal_standalone_manager.py b/ironic_tempest_plugin/tests/scenario/baremetal_standalone_manager.py
new file mode 100644
index 0000000..1d19c47
--- /dev/null
+++ b/ironic_tempest_plugin/tests/scenario/baremetal_standalone_manager.py
@@ -0,0 +1,339 @@
+#
+#    Copyright 2017 Mirantis Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import random
+
+from oslo_utils import uuidutils
+from tempest import config
+from tempest.lib.common.utils import test_utils
+from tempest.lib import exceptions as lib_exc
+from tempest.scenario import manager
+
+from ironic_tempest_plugin.services.baremetal import base
+from ironic_tempest_plugin.tests.scenario import baremetal_manager as bm
+
+CONF = config.CONF
+
+
+class BaremetalStandaloneManager(bm.BaremetalScenarioTest,
+                                 manager.NetworkScenarioTest):
+
+    credentials = ['primary', 'admin']
+    # NOTE(vsaienko): Standalone tests are using v1/node/<node_ident>/vifs to
+    # attach VIF to a node.
+    min_microversion = '1.28'
+
+    @classmethod
+    def skip_checks(cls):
+        """Defines conditions to skip these tests."""
+        super(BaremetalStandaloneManager, cls).skip_checks()
+        if CONF.service_available.nova:
+            raise cls.skipException('Nova is enabled. Stand-alone tests will '
+                                    'be skipped.')
+
+    @classmethod
+    def create_networks(cls):
+        """Create a network with a subnet connected to a router.
+
+        Return existed network specified in compute/fixed_network_name
+        config option.
+        TODO(vsaienko): Add network/subnet/router when we setup
+        ironic-standalone with multitenancy.
+
+        :returns: network, subnet, router
+        """
+        network = None
+        subnet = None
+        router = None
+        if CONF.network.shared_physical_network:
+            if not CONF.compute.fixed_network_name:
+                m = ('Configuration option "[compute]/fixed_network_name" '
+                     'must be set.')
+                raise lib_exc.InvalidConfiguration(m)
+            network = cls.os_admin.networks_client.list_networks(
+                name=CONF.compute.fixed_network_name)['networks'][0]
+        return network, subnet, router
+
+    @classmethod
+    def get_available_nodes(cls):
+        """Get all ironic nodes that can be deployed.
+
+        We can deploy on nodes when the following conditions are met:
+          * provision_state is 'available'
+          * maintenance is False
+          * No instance_uuid is associated to node.
+
+        :returns: a list of Ironic nodes.
+        """
+        fields = ['uuid', 'driver', 'instance_uuid', 'provision_state',
+                  'name', 'maintenance']
+        _, body = cls.baremetal_client.list_nodes(provision_state='available',
+                                                  associated=False,
+                                                  maintenance=False,
+                                                  fields=','.join(fields))
+        return body['nodes']
+
+    @classmethod
+    def get_random_available_node(cls):
+        """Randomly pick an available node for deployment."""
+        nodes = cls.get_available_nodes()
+        if nodes:
+            return random.choice(nodes)
+
+    @classmethod
+    def create_neutron_port(cls, *args, **kwargs):
+        """Creates a neutron port.
+
+        For a full list of available parameters, please refer to the official
+        API reference:
+        http://developer.openstack.org/api-ref/networking/v2/index.html#create-port
+
+        :returns: server response body.
+        """
+        port = cls.ports_client.create_port(*args, **kwargs)['port']
+        return port
+
+    @classmethod
+    def _associate_instance_with_node(cls, node_id, instance_uuid):
+        """Update instance_uuid for a given node.
+
+        :param node_id: Name or UUID of the node.
+        :param instance_uuid: UUID of the instance to associate.
+        :returns: server response body.
+        """
+        _, body = cls.baremetal_client.update_node(
+            node_id, instance_uuid=instance_uuid)
+        return body
+
+    @classmethod
+    def get_node_vifs(cls, node_id):
+        """Return a list of VIFs for a given node.
+
+        :param node_id: Name or UUID of the node.
+        :returns: A list of VIFs associated with the node.
+        """
+        _, body = cls.baremetal_client.vif_list(node_id)
+        vifs = [v['id'] for v in body['vifs']]
+        return vifs
+
+    @classmethod
+    def add_floatingip_to_node(cls, node_id):
+        """Add floating IP to node.
+
+        Create and associate floating IP with node VIF.
+
+        :param node_id: Name or UUID of the node.
+        :returns: IP address of associated floating IP.
+        """
+        vif = cls.get_node_vifs(node_id)[0]
+        body = cls.floating_ips_client.create_floatingip(
+            floating_network_id=CONF.network.public_network_id)
+        floating_ip = body['floatingip']
+        cls.floating_ips_client.update_floatingip(floating_ip['id'],
+                                                  port_id=vif)
+        return floating_ip['floating_ip_address']
+
+    @classmethod
+    def cleanup_floating_ip(cls, ip_address):
+        """Removes floating IP."""
+        body = cls.os_admin.floating_ips_client.list_floatingips()
+        floating_ip_id = [f['id'] for f in body['floatingips'] if
+                          f['floating_ip_address'] == ip_address][0]
+        cls.os_admin.floating_ips_client.delete_floatingip(floating_ip_id)
+
+    @classmethod
+    @bm.retry_on_conflict
+    def detach_all_vifs_from_node(cls, node_id):
+        """Detach all VIFs from a given node.
+
+        :param node_id: Name or UUID of the node.
+        """
+        vifs = cls.get_node_vifs(node_id)
+        for vif in vifs:
+            cls.baremetal_client.vif_detach(node_id, vif)
+
+    @classmethod
+    @bm.retry_on_conflict
+    def vif_attach(cls, node_id, vif_id):
+        """Attach VIF to a give node.
+
+        :param node_id: Name or UUID of the node.
+        :param vif_id: Identifier of the VIF to attach.
+        """
+        cls.baremetal_client.vif_attach(node_id, vif_id)
+
+    @classmethod
+    def get_and_reserve_node(cls, node=None):
+        """Pick an available node for deployment and reserve it.
+
+        Only one instance_uuid may be associated, use this behaviour as
+        reservation node when tests are launched concurrently. If node is
+        not passed directly pick random available for deployment node.
+
+        :param node: Ironic node to associate instance_uuid with.
+        :returns: Ironic node.
+        """
+        instance_uuid = uuidutils.generate_uuid()
+        nodes = []
+
+        def _try_to_associate_instance():
+            n = node or cls.get_random_available_node()
+            try:
+                cls._associate_instance_with_node(n['uuid'], instance_uuid)
+                nodes.append(n)
+            except lib_exc.Conflict:
+                return False
+            return True
+
+        if (not test_utils.call_until_true(_try_to_associate_instance,
+            duration=CONF.baremetal.association_timeout, sleep_for=1)):
+            msg = ('Timed out waiting to associate instance to ironic node '
+                   'uuid %s' % instance_uuid)
+            raise lib_exc.TimeoutException(msg)
+
+        return nodes[0]
+
+    @classmethod
+    def boot_node(cls, driver, image_ref, image_checksum=None):
+        """Boot ironic node.
+
+        The following actions are executed:
+          * Randomly pick an available node for deployment and reserve it.
+          * Update node driver.
+          * Create/Pick networks to boot node in.
+          * Create Neutron port and attach it to node.
+          * Update node image_source/root_gb.
+          * Deploy node.
+          * Wait until node is deployed.
+
+        :param driver: Node driver to use.
+        :param image_ref: Reference to user image to boot node with.
+        :param image_checksum: md5sum of image specified in image_ref.
+                               Needed only when direct HTTP link is provided.
+        :returns: Ironic node.
+        """
+        node = cls.get_and_reserve_node()
+        cls.update_node_driver(node['uuid'], driver)
+        network, subnet, router = cls.create_networks()
+        n_port = cls.create_neutron_port(network_id=network['id'])
+        cls.vif_attach(node_id=node['uuid'], vif_id=n_port['id'])
+        patch = [{'path': '/instance_info/image_source',
+                  'op': 'add',
+                  'value': image_ref}]
+        if image_checksum is not None:
+            patch.append({'path': '/instance_info/image_checksum',
+                          'op': 'add',
+                          'value': image_checksum})
+        patch.append({'path': '/instance_info/root_gb',
+                      'op': 'add',
+                      'value': CONF.baremetal.adjusted_root_disk_size_gb})
+        # TODO(vsaienko) add testing for custom configdrive
+        cls.update_node(node['uuid'], patch=patch)
+        cls.set_node_provision_state(node['uuid'], 'active')
+        cls.wait_power_state(node['uuid'], bm.BaremetalPowerStates.POWER_ON)
+        cls.wait_provisioning_state(node['uuid'],
+                                    bm.BaremetalProvisionStates.ACTIVE,
+                                    timeout=CONF.baremetal.active_timeout,
+                                    interval=30)
+        return node
+
+    @classmethod
+    def terminate_node(cls, node_id):
+        """Terminate active ironic node.
+
+        The following actions are executed:
+           * Detach all VIFs from the given node.
+           * Unprovision node.
+           * Wait until node become available.
+
+        :param node_id: Name or UUID for the node.
+        """
+        cls.detach_all_vifs_from_node(node_id)
+        cls.set_node_provision_state(node_id, 'deleted')
+        # NOTE(vsaienko) We expect here fast switching from deleted to
+        # available as automated cleaning is disabled so poll status each 1s.
+        cls.wait_provisioning_state(
+            node_id,
+            [bm.BaremetalProvisionStates.NOSTATE,
+             bm.BaremetalProvisionStates.AVAILABLE],
+            timeout=CONF.baremetal.unprovision_timeout,
+            interval=1)
+
+
+class BaremetalStandaloneScenarioTest(BaremetalStandaloneManager):
+
+    # API microversion to use among all calls
+    api_microversion = '1.28'
+
+    # The node driver to use in the test
+    driver = None
+
+    # User image ref to boot node with.
+    image_ref = None
+
+    # Boolean value specify if image is wholedisk or not.
+    wholedisk_image = None
+
+    # Image checksum, required when image is stored on HTTP server.
+    image_checksum = None
+
+    mandatory_attr = ['driver', 'image_ref', 'wholedisk_image']
+
+    node = None
+    node_ip = None
+
+    @classmethod
+    def skip_checks(cls):
+        super(BaremetalStandaloneScenarioTest, cls).skip_checks()
+        if (cls.driver not in CONF.baremetal.enabled_drivers +
+                CONF.baremetal.enabled_hardware_types):
+            raise cls.skipException(
+                'The driver: %(driver)s used in test is not in the list of '
+                'enabled_drivers %(enabled_drivers)s or '
+                'enabled_hardware_types %(enabled_hw_types)s '
+                'in the tempest config.' % {
+                    'driver': cls.driver,
+                    'enabled_drivers': CONF.baremetal.enabled_drivers,
+                    'enabled_hw_types': CONF.baremetal.enabled_hardware_types})
+        if not cls.wholedisk_image and CONF.baremetal.use_provision_network:
+            raise cls.skipException(
+                'Partitioned images are not supported with multitenancy.')
+
+    @classmethod
+    def resource_setup(cls):
+        super(BaremetalStandaloneScenarioTest, cls).resource_setup()
+        base.set_baremetal_api_microversion(cls.api_microversion)
+        for v in cls.mandatory_attr:
+            if getattr(cls, v) is None:
+                raise lib_exc.InvalidConfiguration(
+                    "Mandatory attribute %s not set." % v)
+        image_checksum = None
+        if not uuidutils.is_uuid_like(cls.image_ref):
+            image_checksum = cls.image_checksum
+        cls.node = cls.boot_node(cls.driver, cls.image_ref,
+                                 image_checksum=image_checksum)
+        cls.node_ip = cls.add_floatingip_to_node(cls.node['uuid'])
+
+    @classmethod
+    def resource_cleanup(cls):
+        cls.cleanup_floating_ip(cls.node_ip)
+        vifs = cls.get_node_vifs(cls.node['uuid'])
+        # Remove ports before deleting node, to catch regression for cases
+        # when user did this prior unprovision node.
+        for vif in vifs:
+            cls.ports_client.delete_port(vif)
+        cls.terminate_node(cls.node['uuid'])
+        base.reset_baremetal_api_microversion()
+        super(BaremetalStandaloneManager, cls).resource_cleanup()
diff --git a/ironic_tempest_plugin/tests/scenario/ironic_standalone/__init__.py b/ironic_tempest_plugin/tests/scenario/ironic_standalone/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/ironic_tempest_plugin/tests/scenario/ironic_standalone/__init__.py
diff --git a/ironic_tempest_plugin/tests/scenario/ironic_standalone/test_basic_ops.py b/ironic_tempest_plugin/tests/scenario/ironic_standalone/test_basic_ops.py
new file mode 100644
index 0000000..f6e02e1
--- /dev/null
+++ b/ironic_tempest_plugin/tests/scenario/ironic_standalone/test_basic_ops.py
@@ -0,0 +1,145 @@
+#
+# Copyright 2017 Mirantis Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      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.common import utils
+from tempest import config
+from tempest.lib import decorators
+
+from ironic_tempest_plugin.tests.scenario import \
+    baremetal_standalone_manager as bsm
+
+CONF = config.CONF
+
+
+class BaremetalAgentIpmitoolWholedisk(bsm.BaremetalStandaloneScenarioTest):
+
+    driver = 'agent_ipmitool'
+    image_ref = CONF.baremetal.whole_disk_image_ref
+    wholedisk_image = True
+
+    @decorators.idempotent_id('defff515-a6ff-44f6-9d8d-2ded51196d98')
+    @utils.services('image', 'network', 'object_storage')
+    def test_ip_access_to_server(self):
+        self.assertTrue(self.ping_ip_address(self.node_ip,
+                                             should_succeed=True))
+
+
+class BaremetalAgentIpmitoolWholediskHttpLink(
+        bsm.BaremetalStandaloneScenarioTest):
+
+    driver = 'agent_ipmitool'
+    image_ref = CONF.baremetal.whole_disk_image_url
+    image_checksum = CONF.baremetal.whole_disk_image_checksum
+    wholedisk_image = True
+
+    @classmethod
+    def skip_checks(cls):
+        super(BaremetalAgentIpmitoolWholediskHttpLink, cls).skip_checks()
+        if not CONF.baremetal_feature_enabled.ipxe_enabled:
+            skip_msg = ("HTTP server is not available when ipxe is disabled.")
+            raise cls.skipException(skip_msg)
+
+    @decorators.idempotent_id('d926c683-1a32-44df-afd0-e60134346fd0')
+    @utils.services('network')
+    def test_ip_access_to_server(self):
+        self.assertTrue(self.ping_ip_address(self.node_ip,
+                                             should_succeed=True))
+
+
+class BaremetalAgentIpmitoolPartitioned(bsm.BaremetalStandaloneScenarioTest):
+
+    driver = 'agent_ipmitool'
+    image_ref = CONF.baremetal.partition_image_ref
+    wholedisk_image = False
+
+    @decorators.idempotent_id('27b86130-d8dc-419d-880a-fbbbe4ce3f8c')
+    @utils.services('image', 'network', 'object_storage')
+    def test_ip_access_to_server(self):
+        self.assertTrue(self.ping_ip_address(self.node_ip,
+                                             should_succeed=True))
+
+
+class BaremetalPxeIpmitoolWholedisk(bsm.BaremetalStandaloneScenarioTest):
+
+    driver = 'pxe_ipmitool'
+    image_ref = CONF.baremetal.whole_disk_image_ref
+    wholedisk_image = True
+
+    @decorators.idempotent_id('d8c5badd-45db-4d05-bbe8-35babbed6e86')
+    @utils.services('image', 'network')
+    def test_ip_access_to_server(self):
+        self.assertTrue(self.ping_ip_address(self.node_ip,
+                                             should_succeed=True))
+
+
+class BaremetalPxeIpmitoolWholediskHttpLink(
+        bsm.BaremetalStandaloneScenarioTest):
+
+    driver = 'pxe_ipmitool'
+    image_ref = CONF.baremetal.whole_disk_image_url
+    image_checksum = CONF.baremetal.whole_disk_image_checksum
+    wholedisk_image = True
+
+    @classmethod
+    def skip_checks(cls):
+        super(BaremetalPxeIpmitoolWholediskHttpLink, cls).skip_checks()
+        if not CONF.baremetal_feature_enabled.ipxe_enabled:
+            skip_msg = ("HTTP server is not available when ipxe is disabled.")
+            raise cls.skipException(skip_msg)
+
+    @decorators.idempotent_id('71ccf06f-6765-40fd-8252-1b1bfa423b9b')
+    @utils.services('network')
+    def test_ip_access_to_server(self):
+        self.assertTrue(self.ping_ip_address(self.node_ip,
+                                             should_succeed=True))
+
+
+class BaremetalPxeIpmitoolPartitioned(bsm.BaremetalStandaloneScenarioTest):
+
+    driver = 'pxe_ipmitool'
+    image_ref = CONF.baremetal.partition_image_ref
+    wholedisk_image = False
+
+    @decorators.idempotent_id('ea85e19c-6869-4577-b9bb-2eb150f77c90')
+    @utils.services('image', 'network')
+    def test_ip_access_to_server(self):
+        self.assertTrue(self.ping_ip_address(self.node_ip,
+                                             should_succeed=True))
+
+
+class BaremetalIpmiWholedisk(bsm.BaremetalStandaloneScenarioTest):
+
+    driver = 'ipmi'
+    image_ref = CONF.baremetal.whole_disk_image_ref
+    wholedisk_image = True
+
+    @decorators.idempotent_id('c2db24e7-07dc-4a20-8f93-d4efae2bfd4e')
+    @utils.services('image', 'network')
+    def test_ip_access_to_server(self):
+        self.assertTrue(self.ping_ip_address(self.node_ip,
+                                             should_succeed=True))
+
+
+class BaremetalIpmiPartitioned(bsm.BaremetalStandaloneScenarioTest):
+
+    driver = 'ipmi'
+    image_ref = CONF.baremetal.partition_image_ref
+    wholedisk_image = False
+
+    @decorators.idempotent_id('7d0b205e-edbc-4e2d-9f6d-95cd74eefecb')
+    @utils.services('image', 'network')
+    def test_ip_access_to_server(self):
+        self.assertTrue(self.ping_ip_address(self.node_ip,
+                                             should_succeed=True))
diff --git a/ironic_tempest_plugin/tests/scenario/test_baremetal_basic_ops.py b/ironic_tempest_plugin/tests/scenario/test_baremetal_basic_ops.py
new file mode 100644
index 0000000..47fc07e
--- /dev/null
+++ b/ironic_tempest_plugin/tests/scenario/test_baremetal_basic_ops.py
@@ -0,0 +1,146 @@
+#
+# Copyright 2014 Hewlett-Packard Development Company, L.P.
+#
+# 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 oslo_log import log as logging
+from tempest.common import utils
+from tempest.common import waiters
+from tempest import config
+from tempest.lib.common import api_version_request
+from tempest.lib import decorators
+
+from ironic_tempest_plugin.tests.scenario import baremetal_manager
+
+LOG = logging.getLogger(__name__)
+CONF = config.CONF
+
+
+class BaremetalBasicOps(baremetal_manager.BaremetalScenarioTest):
+    """This smoke test tests the pxe_ssh Ironic driver.
+
+    It follows this basic set of operations:
+        * Creates a keypair
+        * Boots an instance using the keypair
+        * Monitors the associated Ironic node for power and
+          expected state transitions
+        * Validates Ironic node's port data has been properly updated
+        * Verifies SSH connectivity using created keypair via fixed IP
+        * Associates a floating ip
+        * Verifies SSH connectivity using created keypair via floating IP
+        * Verifies instance rebuild with ephemeral partition preservation
+        * Deletes instance
+        * Monitors the associated Ironic node for power and
+          expected state transitions
+    """
+
+    def rebuild_instance(self, preserve_ephemeral=False):
+        self.rebuild_server(server_id=self.instance['id'],
+                            preserve_ephemeral=preserve_ephemeral,
+                            wait=False)
+
+        node = self.get_node(instance_id=self.instance['id'])
+
+        # We should remain on the same node
+        self.assertEqual(self.node['uuid'], node['uuid'])
+        self.node = node
+
+        waiters.wait_for_server_status(
+            self.servers_client,
+            server_id=self.instance['id'],
+            status='REBUILD',
+            ready_wait=False)
+        waiters.wait_for_server_status(
+            self.servers_client,
+            server_id=self.instance['id'],
+            status='ACTIVE')
+
+    def verify_partition(self, client, label, mount, gib_size):
+        """Verify a labeled partition's mount point and size."""
+        LOG.info("Looking for partition %s mounted on %s", label, mount)
+
+        # Validate we have a device with the given partition label
+        cmd = "/sbin/blkid | grep '%s' | cut -d':' -f1" % label
+        device = client.exec_command(cmd).rstrip('\n')
+        LOG.debug("Partition device is %s", device)
+        self.assertNotEqual('', device)
+
+        # Validate the mount point for the device
+        cmd = "mount | grep '%s' | cut -d' ' -f3" % device
+        actual_mount = client.exec_command(cmd).rstrip('\n')
+        LOG.debug("Partition mount point is %s", actual_mount)
+        self.assertEqual(actual_mount, mount)
+
+        # Validate the partition size matches what we expect
+        numbers = '0123456789'
+        devnum = device.replace('/dev/', '')
+        cmd = "cat /sys/block/%s/%s/size" % (devnum.rstrip(numbers), devnum)
+        num_bytes = client.exec_command(cmd).rstrip('\n')
+        num_bytes = int(num_bytes) * 512
+        actual_gib_size = num_bytes / (1024 * 1024 * 1024)
+        LOG.debug("Partition size is %d GiB", actual_gib_size)
+        self.assertEqual(actual_gib_size, gib_size)
+
+    def get_flavor_ephemeral_size(self):
+        """Returns size of the ephemeral partition in GiB."""
+        f_id = self.instance['flavor']['id']
+        flavor = self.flavors_client.show_flavor(f_id)['flavor']
+        ephemeral = flavor.get('OS-FLV-EXT-DATA:ephemeral')
+        if not ephemeral or ephemeral == 'N/A':
+            return None
+        return int(ephemeral)
+
+    def validate_ports(self):
+        node_uuid = self.node['uuid']
+        vifs = []
+        # TODO(vsaienko) switch to get_node_vifs() when all stable releases
+        # supports Ironic API 1.28
+        if (api_version_request.APIVersionRequest(
+            CONF.baremetal.max_microversion) >=
+                api_version_request.APIVersionRequest('1.28')):
+            vifs = self.get_node_vifs(node_uuid)
+        else:
+            for port in self.get_ports(self.node['uuid']):
+                vif = port['extra'].get('vif_port_id')
+                if vif:
+                    vifs.append({'id': vif})
+
+        ir_ports = self.get_ports(node_uuid)
+        ir_ports_addresses = [x['address'] for x in ir_ports]
+        for vif in vifs:
+            n_port_id = vif['id']
+            body = self.ports_client.show_port(n_port_id)
+            n_port = body['port']
+            self.assertEqual(n_port['device_id'], self.instance['id'])
+            self.assertIn(n_port['mac_address'], ir_ports_addresses)
+
+    @decorators.idempotent_id('549173a5-38ec-42bb-b0e2-c8b9f4a08943')
+    @utils.services('compute', 'image', 'network')
+    def test_baremetal_server_ops(self):
+        self.add_keypair()
+        self.instance, self.node = self.boot_instance()
+        self.validate_ports()
+        ip_address = self.get_server_ip(self.instance)
+        self.get_remote_client(ip_address).validate_authentication()
+        vm_client = self.get_remote_client(ip_address)
+
+        # We expect the ephemeral partition to be mounted on /mnt and to have
+        # the same size as our flavor definition.
+        eph_size = self.get_flavor_ephemeral_size()
+        if eph_size:
+            self.verify_partition(vm_client, 'ephemeral0', '/mnt', eph_size)
+            # Create the test file
+            self.create_timestamp(
+                ip_address, private_key=self.keypair['private_key'])
+
+        self.terminate_instance(self.instance)
diff --git a/ironic_tempest_plugin/tests/scenario/test_baremetal_boot_from_volume.py b/ironic_tempest_plugin/tests/scenario/test_baremetal_boot_from_volume.py
new file mode 100644
index 0000000..9908270
--- /dev/null
+++ b/ironic_tempest_plugin/tests/scenario/test_baremetal_boot_from_volume.py
@@ -0,0 +1,152 @@
+# Copyright 2017 FUJITSU LIMITED
+#
+# 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.common import utils
+from tempest.common import waiters
+from tempest import config
+from tempest.lib.common.utils import data_utils
+from tempest.lib.common.utils import test_utils
+from tempest.lib import decorators
+
+from ironic_tempest_plugin.tests.scenario import baremetal_manager
+
+CONF = config.CONF
+
+
+class BaremetalBFV(baremetal_manager.BaremetalScenarioTest):
+    """Check baremetal instance that can boot from Cinder volume:
+
+    * Create a volume from an image
+    * Create a keypair
+    * Boot an instance from the volume using the keypair
+    * Verify instance IP address
+    * Delete instance
+    """
+
+    credentials = ['primary', 'admin']
+
+    min_microversion = '1.32'
+
+    @classmethod
+    def skip_checks(cls):
+        super(BaremetalBFV, cls).skip_checks()
+        if CONF.baremetal.use_provision_network:
+            msg = 'Ironic boot-from-volume requires a flat network.'
+            raise cls.skipException(msg)
+
+    def create_volume(self, size=None, name=None, snapshot_id=None,
+                      image_id=None, volume_type=None):
+        if size is None:
+            size = CONF.volume.volume_size
+        if image_id is None:
+            image = self.compute_images_client.show_image(image_id)['image']
+            min_disk = image.get('minDisk')
+            size = max(size, min_disk)
+        if name is None:
+            name = data_utils.rand_name(self.__class__.__name__ + "-volume")
+        kwargs = {'display_name': name,
+                  'snapshot_id': snapshot_id,
+                  'imageRef': image_id,
+                  'volume_type': volume_type,
+                  'size': size}
+        volume = self.volumes_client.create_volume(**kwargs)['volume']
+
+        self.addCleanup(self.volumes_client.wait_for_resource_deletion,
+                        volume['id'])
+        self.addCleanup(test_utils.call_and_ignore_notfound_exc,
+                        self.volumes_client.delete_volume, volume['id'])
+        self.assertEqual(name, volume['name'])
+        waiters.wait_for_volume_resource_status(self.volumes_client,
+                                                volume['id'], 'available')
+        # The volume retrieved on creation has a non-up-to-date status.
+        # Retrieval after it becomes active ensures correct details.
+        volume = self.volumes_client.show_volume(volume['id'])['volume']
+        return volume
+
+    def _create_volume_from_image(self):
+        """Create a cinder volume from the default image."""
+        image_id = CONF.compute.image_ref
+        vol_name = data_utils.rand_name(
+            self.__class__.__name__ + '-volume-origin')
+        return self.create_volume(name=vol_name, image_id=image_id)
+
+    def _get_bdm(self, source_id, source_type, delete_on_termination=False):
+        """Create block device mapping config options dict.
+
+        :param source_id: id of the source device.
+        :param source_type: type of the source device.
+        :param delete_on_termination: what to do with the volume when
+          the instance is terminated.
+        :return: a dictionary of configuration options for block
+          device mapping.
+        """
+        bd_map_v2 = [{
+            'uuid': source_id,
+            'source_type': source_type,
+            'destination_type': 'volume',
+            'boot_index': 0,
+            'delete_on_termination': delete_on_termination}]
+        return {'block_device_mapping_v2': bd_map_v2}
+
+    def _boot_instance_from_resource(self, source_id,
+                                     source_type,
+                                     keypair=None,
+                                     delete_on_termination=False):
+        """Boot instance from the specified resource."""
+        # NOTE(tiendc): Boot to the volume, use image_id=''.
+        # We don't pass image_id=None as that will cause the default image
+        # to be used.
+        create_kwargs = {'image_id': ''}
+        create_kwargs.update(self._get_bdm(
+            source_id,
+            source_type,
+            delete_on_termination=delete_on_termination))
+
+        return self.boot_instance(
+            clients=self.os_primary,
+            keypair=keypair,
+            **create_kwargs
+        )
+
+    @decorators.idempotent_id('d6e05e61-8221-44ac-b785-57545f8e0fcf')
+    @utils.services('compute', 'image', 'network', 'volume')
+    def test_baremetal_boot_from_volume(self):
+        """Test baremetal node can boot from a cinder volume.
+
+        This test function first creates a cinder volume from an image.
+        Then it executes "server create" action with appropriate block
+        device mapping config options, the baremetal node will boot
+        from the newly created volume. This requires a volume connector
+        is created for the node, and the node capabilities flag
+        iscsi_boot is set to true.
+        """
+        # Create volume from image
+        volume_origin = self._create_volume_from_image()
+
+        # NOTE: node properties/capabilities for flag iscsi_boot=true,
+        # and volume connector should be added by devstack already.
+
+        # Boot instance
+        self.keypair = self.create_keypair()
+        self.instance, self.node = self._boot_instance_from_resource(
+            source_id=volume_origin['id'],
+            source_type='volume',
+            keypair=self.keypair
+        )
+
+        # Get server ip and validate authentication
+        ip_address = self.get_server_ip(self.instance)
+        self.get_remote_client(ip_address).validate_authentication()
+
+        self.terminate_instance(instance=self.instance)
diff --git a/ironic_tempest_plugin/tests/scenario/test_baremetal_multitenancy.py b/ironic_tempest_plugin/tests/scenario/test_baremetal_multitenancy.py
new file mode 100644
index 0000000..013eb2e
--- /dev/null
+++ b/ironic_tempest_plugin/tests/scenario/test_baremetal_multitenancy.py
@@ -0,0 +1,153 @@
+#
+# Copyright (c) 2015 Mirantis, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      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.common import utils
+from tempest import config
+from tempest.lib.common.utils import data_utils
+from tempest.lib import decorators
+
+from ironic_tempest_plugin import manager
+from ironic_tempest_plugin.tests.scenario import baremetal_manager
+
+CONF = config.CONF
+
+
+class BaremetalMultitenancy(baremetal_manager.BaremetalScenarioTest,
+                            manager.NetworkScenarioTest):
+    """Check L2 isolation of baremetal instances in different tenants:
+
+    * Create a keypair, network, subnet and router for the primary tenant
+    * Boot 2 instances in the different tenant's network using the keypair
+    * Associate floating ips to both instance
+    * Verify there is no L3 connectivity between instances of different tenants
+    * Verify connectivity between instances floating IP's
+    * Delete both instances
+    """
+
+    credentials = ['primary', 'alt', 'admin']
+
+    @classmethod
+    def skip_checks(cls):
+        super(BaremetalMultitenancy, cls).skip_checks()
+        if not CONF.baremetal.use_provision_network:
+            msg = 'Ironic/Neutron tenant isolation is not configured.'
+            raise cls.skipException(msg)
+
+    def create_tenant_network(self, clients, tenant_cidr):
+        network = self._create_network(
+            networks_client=clients.networks_client,
+            tenant_id=clients.credentials.tenant_id)
+        router = self._get_router(
+            client=clients.routers_client,
+            tenant_id=clients.credentials.tenant_id)
+
+        result = clients.subnets_client.create_subnet(
+            name=data_utils.rand_name('subnet'),
+            network_id=network['id'],
+            tenant_id=clients.credentials.tenant_id,
+            ip_version=4,
+            cidr=tenant_cidr)
+        subnet = result['subnet']
+        clients.routers_client.add_router_interface(router['id'],
+                                                    subnet_id=subnet['id'])
+        self.addCleanup(clients.subnets_client.delete_subnet, subnet['id'])
+        self.addCleanup(clients.routers_client.remove_router_interface,
+                        router['id'], subnet_id=subnet['id'])
+
+        return network, subnet, router
+
+    def verify_l3_connectivity(self, source_ip, private_key,
+                               destination_ip, conn_expected=True):
+        remote = self.get_remote_client(source_ip, private_key=private_key)
+        remote.validate_authentication()
+
+        cmd = 'ping %s -c4 -w4 || exit 0' % destination_ip
+        success_substring = "64 bytes from %s" % destination_ip
+        output = remote.exec_command(cmd)
+        if conn_expected:
+            self.assertIn(success_substring, output)
+        else:
+            self.assertNotIn(success_substring, output)
+
+    @decorators.idempotent_id('26e2f145-2a8e-4dc7-8457-7f2eb2c6749d')
+    @utils.services('compute', 'image', 'network')
+    def test_baremetal_multitenancy(self):
+
+        tenant_cidr = '10.0.100.0/24'
+        fixed_ip1 = '10.0.100.3'
+        fixed_ip2 = '10.0.100.5'
+        keypair = self.create_keypair()
+        network, subnet, router = self.create_tenant_network(
+            self.os_primary, tenant_cidr)
+
+        # Boot 2 instances in the primary tenant network
+        # and check L2 connectivity between them
+        instance1, node1 = self.boot_instance(
+            clients=self.os_primary,
+            keypair=keypair,
+            net_id=network['id'],
+            fixed_ip=fixed_ip1
+        )
+        floating_ip1 = self.create_floating_ip(
+            instance1,
+        )['floating_ip_address']
+        self.check_vm_connectivity(ip_address=floating_ip1,
+                                   private_key=keypair['private_key'])
+
+        # Boot instance in the alt tenant network and ensure there is no
+        # L2 connectivity between instances of the different tenants
+        alt_keypair = self.create_keypair(self.os_alt.keypairs_client)
+        alt_network, alt_subnet, alt_router = self.create_tenant_network(
+            self.os_alt, tenant_cidr)
+
+        alt_instance, alt_node = self.boot_instance(
+            keypair=alt_keypair,
+            clients=self.os_alt,
+            net_id=alt_network['id'],
+            fixed_ip=fixed_ip2
+        )
+        alt_floating_ip = self.create_floating_ip(
+            alt_instance,
+            client=self.os_alt.floating_ips_client
+        )['floating_ip_address']
+
+        self.check_vm_connectivity(ip_address=alt_floating_ip,
+                                   private_key=alt_keypair['private_key'])
+
+        self.verify_l3_connectivity(
+            alt_floating_ip,
+            alt_keypair['private_key'],
+            fixed_ip1,
+            conn_expected=False
+        )
+
+        self.verify_l3_connectivity(
+            floating_ip1,
+            keypair['private_key'],
+            fixed_ip2,
+            conn_expected=False
+        )
+
+        self.verify_l3_connectivity(
+            floating_ip1,
+            keypair['private_key'],
+            alt_floating_ip,
+            conn_expected=True
+        )
+
+        self.terminate_instance(
+            instance=alt_instance,
+            servers_client=self.os_alt.servers_client)
+        self.terminate_instance(instance=instance1)