Add next tests:

*  create instance with verification of network cannectivity
* create / attach volume

Change base module for sanity networks test:
change request list admin from iuser to admin

etc/test.conf

@@ -25,7 +25,7 @@ username = admin
 # The above non-administrative user's password
 password = nova
 # The above non-administrative user's tenant name
-tenant_name = service
+tenant_name = admin
 
 # This should be the username of an alternate user WITHOUT
 # administrative privileges
@@ -196,7 +196,7 @@ public_network_id = eeb739fc-97a0-46b3-b8b9-12212b8247c4
 # A shared public router would commonly be used where IP namespaces
 # were disabled.  If namespaces are enabled, it would be preferable
 # for each tenant to have their own router.
-public_router_id =
+public_router_id = 30dc6a2e-d22e-48e5-8fa3-34a7d501d673
 
 # Whether or not quantum is expected to be available
 quantum_available = true

fuel_health/common/test_mixins.py

@@ -68,3 +68,18 @@ class FuelTestAssertMixin(object):
         if content in body:
             return
         self.assertTrue(content in body, msg)
+
+    def verify_response_body_content(self, exp_content, act_content, msg):
+        """
+        Method provides human readable message for the verification
+        if the content value ib body is the same as expected
+
+        :param exp_content: expected value
+        :param act_content: actual content that is present in the body
+        :param msg: message to be used instead the default one
+        """
+        self.assertEquals(exp_content,
+                          act_content,
+                          ''.join(('Actual value - {actual_content}'.format(
+                              actual_content=act_content),
+                          '\n', msg)))

fuel_health/nmanager.py

@@ -230,11 +230,10 @@ class NetworkScenarioTest(OfficialClientTest):
     def _create_keypair(self, client, namestart='ost1_test-keypair-smoke-'):
         kp_name = rand_name(namestart)
         keypair = client.keypairs.create(kp_name)
-        try:
+        self.verify_response_body_content(keypair.id,
-            self.assertEqual(keypair.id, kp_name)
+                                          kp_name,
-            self.set_resource(kp_name, keypair)
+                                          'Creation of keypair failed')
-        except AttributeError:
+        self.set_resource(kp_name, keypair)
-            self.fail("Keypair object not successfully created.")
         return keypair
 
     def _create_security_group(self, client, namestart='ost1_test-secgroup-smoke-'):
@@ -242,12 +241,13 @@ class NetworkScenarioTest(OfficialClientTest):
         sg_name = rand_name(namestart)
         sg_desc = sg_name + " description"
         secgroup = client.security_groups.create(sg_name, sg_desc)
-        try:
+        self.verify_response_body_content(secgroup.name,
-            self.assertEqual(secgroup.name, sg_name)
+                                          sg_name,
-            self.assertEqual(secgroup.description, sg_desc)
+                                          "Security group creation failed")
-            self.set_resource(sg_name, secgroup)
+        self.verify_response_body_content(secgroup.description,
-        except AttributeError:
+                                          sg_desc,
-            self.fail("SecurityGroup object not successfully created.")
+                                          "Security group creation failed")
+        self.set_resource(sg_name, secgroup)
 
         # Add rules to the security group
 
@@ -290,8 +290,9 @@ class NetworkScenarioTest(OfficialClientTest):
         result = self.network_client.create_network(body=body)
         network = net_common.DeletableNetwork(client=self.network_client,
                                               **result['network'])
-        self.assertEqual(network.name, name)
+        self.verify_response_body_content(network.name,
-        self.set_resource(name, network)
+                                          name,
+                                          "Network creation failed")
         return network
 
     def _list_networks(self):
@@ -335,7 +336,9 @@ class NetworkScenarioTest(OfficialClientTest):
         self.assertIsNotNone(result, 'Unable to allocate tenant network')
         subnet = net_common.DeletableSubnet(client=self.network_client,
                                             **result['subnet'])
-        self.assertEqual(subnet.cidr, str(subnet_cidr))
+        self.verify_response_body_content(subnet.cidr,
+                                          str(subnet_cidr),
+                                          "Sub-net creation failed")
         self.set_resource(rand_name(namestart), subnet)
         return subnet
 
@@ -364,11 +367,10 @@ class NetworkScenarioTest(OfficialClientTest):
         }
         server = client.servers.create(name, base_image_id, flavor_id,
                                        **create_kwargs)
-        try:
+        self.verify_response_body_content(server.name,
-            self.assertEqual(server.name, name)
+                                          name,
-            self.set_resource(name, server)
+                                          "Instance creation failed")
-        except AttributeError:
+        self.set_resource(name, server)
-            self.fail("Server not successfully created.")
         self.status_timeout(client.servers, server.id, 'ACTIVE')
         # The instance retrieved on creation is missing network
         # details, necessitating retrieval after it becomes active to
@@ -380,8 +382,10 @@ class NetworkScenarioTest(OfficialClientTest):
     def _create_floating_ip(self, server, external_network_id):
         result = self.network_client.list_ports(device_id=server.id)
         ports = result.get('ports', [])
-        self.assertEqual(len(ports), 1,
+        self.verify_response_body_content(len(ports), 1,
-                         "Unable to determine which port to target.")
+                                          ("Unable to determine "
+                                           "which port to target."))
+
         port_id = ports[0]['id']
         body = dict(
             floatingip=dict(

fuel_health/tests/smoke/base.py

@@ -2,9 +2,9 @@ import netaddr
 import time
 
 from fuel_health import clients
-from fuel_health import exceptions
 from fuel_health.common import log as logging
 from fuel_health.common.utils.data_utils import rand_name
+from fuel_health import exceptions
 import fuel_health.test
 from fuel_health.tests import smoke
 
@@ -57,6 +57,7 @@ class BaseComputeTest(fuel_health.test.BaseTestCase):
             cls.network_client = os.config.network
 
         cls.servers = []
+        cls.volumes = []
 
         cls.servers_client_v3_auth = os.servers_client_v3_auth
 
@@ -157,9 +158,23 @@ class BaseComputeTest(fuel_health.test.BaseTestCase):
             except Exception:
                 pass
 
+    @classmethod
+    def clear_volumes(cls):
+        for volume in cls.volumes:
+            try:
+                cls.volumes_client.delete_volume(volume['id'])
+            except Exception:
+                pass
+        for volume in cls.volumes:
+            try:
+                cls.volumes_client.wait_for_resource_deletion(volume['id'])
+            except Exception:
+                pass
+
     @classmethod
     def create_server(cls, **kwargs):
         """Wrapper utility that returns a test server."""
+        name = rand_name('ost1_test-' + '-instance' + cls.__name__ )
         name = rand_name("ost1_test-" + cls.__name__ + "-instance")
         if 'name' in kwargs:
             name = kwargs.pop('name')
@@ -189,6 +204,7 @@ class BaseComputeTest(fuel_health.test.BaseTestCase):
     def tearDownClass(cls):
         cls.clear_servers()
         cls.clear_isolated_creds()
+        cls.clear_volumes()
 
     def wait_for(self, condition):
         """Repeatedly calls condition() until a timeout."""

fuel_health/tests/smoke/test_create_instance_with_connectivity.py

@@ -131,7 +131,9 @@ class TestNetwork(nmanager.NetworkScenarioTest):
         result = self.network_client.create_router(body=body)
         router = net_common.DeletableRouter(client=self.network_client,
                                             **result['router'])
-        self.assertEqual(router.name, name)
+        self.verify_response_body_content(router.name,
+                                          name,
+                                          "Router creation failed")
         self.set_resource(name, router)
         return router
 
@@ -167,21 +169,35 @@ class TestNetwork(nmanager.NetworkScenarioTest):
         seen_names = [n['name'] for n in seen_nets]
         seen_ids = [n['id'] for n in seen_nets]
         for mynet in self.networks:
-            self.assertIn(mynet.name, seen_names)
+            self.verify_response_body(seen_names,
-            self.assertIn(mynet.id, seen_ids)
+                                      mynet.name,
+                                      ('Network is not created '
+                                       'properly'))
+            self.verify_response_body(seen_ids,
+                                      mynet.id,
+                                      ('Network does is created'
+                                       ' properly '))
         seen_subnets = self._list_subnets()
         seen_net_ids = [n['network_id'] for n in seen_subnets]
         seen_subnet_ids = [n['id'] for n in seen_subnets]
         for mynet in self.networks:
-            self.assertIn(mynet.id, seen_net_ids)
+            self.verify_response_body(seen_net_ids,
+                                      mynet.id,
+                                      'Network is not created properly')
         for mysubnet in self.subnets:
-            self.assertIn(mysubnet.id, seen_subnet_ids)
+            self.verify_response_body(seen_subnet_ids,
+                                      mysubnet.id,
+                                      'Sub-net is not created properly')
         seen_routers = self._list_routers()
         seen_router_ids = [n['id'] for n in seen_routers]
         seen_router_names = [n['name'] for n in seen_routers]
         for myrouter in self.routers:
-            self.assertIn(myrouter.name, seen_router_names)
+            self.verify_response_body(seen_router_names,
-            self.assertIn(myrouter.id, seen_router_ids)
+                                      myrouter.name,
+                                      'Router is not created properly')
+            self.verify_response_body(seen_router_ids,
+                                      myrouter.id,
+                                      'Router is not created properly')
 
     @attr(type=['fuel', 'smoke'])
     def test_005_create_servers(self):
@@ -249,4 +265,3 @@ class TestNetwork(nmanager.NetworkScenarioTest):
             for floating_ip in floating_ips:
                 ip_address = floating_ip.floating_ip_address
                 self._check_vm_connectivity(ip_address, ssh_login, private_key)
-

fuel_health/tests/smoke/test_create_volume.py

@@ -0,0 +1,97 @@
+from fuel_health.common.utils.data_utils import rand_name
+from fuel_health.test import attr
+from fuel_health.tests.smoke import base
+
+class VolumesTest(base.BaseComputeTest):
+
+    _interface = 'json'
+
+    @classmethod
+    def setUpClass(cls):
+        super(VolumesTest, cls).setUpClass()
+        cls.client = cls.servers_client
+        resp, server = cls.create_server(name='ost1_test-instance',
+                                         wait_until='ACTIVE',
+                                         adminPass='password')
+        resp, server['addresses'] = cls.client.list_addresses(server['id'])
+        cls.server_id = server['id']
+        cls.server_address = server['addresses']
+        cls.device = 'vdb'
+
+    @classmethod
+    def tearDownClass(cls):
+        super(VolumesTest, cls).tearDownClass()
+
+    @attr(type=["fuel", "smoke"])
+    def test_volume_create(self):
+        """
+        Test verifies:
+        that user can create instance
+        that user can create volume
+        that user can attach volume to instance
+        that user can detach volume from instance
+        that user can delete volume
+        """
+        v_name = rand_name('ost1_test-test')
+        metadata = {'Type': 'work'}
+
+        #Create volume
+        resp, volume = self.volumes_client.create_volume(size=1,
+                                                         display_name=v_name,
+                                                         metadata=metadata)
+        self.verify_response_status(resp.status, 'Compute')
+
+        self.verify_response_body(volume, 'id',
+                                  'Volume is not created. '
+                                  'Looks like something broken in Storage.')
+        self.verify_response_body(volume, 'display_name',
+                                  'Volume is not created. '
+                                  'Looks like something broken in Storage.')
+
+        self.verify_response_body_content(v_name,
+                                          volume['display_name'],
+                                          ("The created volume"
+                                           " name is not equal "
+                                           "to the requested"
+                                           " name"))
+
+        #Wait for Volume status to become AVAILABLE
+        self.volumes_client.wait_for_volume_status(volume['id'], 'available')
+
+        # Attach the volume to the server
+        device = '/dev/%s' % self.device
+        resp, body = self.servers_client.attach_volume(self.server_id,
+                                                       volume['id'],
+                                                       device=device)
+        self.verify_response_status(resp.status, 'Nova Compute')
+
+        self.volumes_client.wait_for_volume_status(volume['id'], 'in-use')
+
+        self.attached = True
+
+        resp, body = self.volumes_client.get_volume(volume['id'])
+        self.verify_response_status(resp.status, 'Storage Objects')
+
+        for attachment in body['attachments']:
+            self.verify_response_body_content('/dev/%s' % self.device,
+                                              attachment['device'],
+                                              ('Device is not equal, '
+                                               'attach volume fail'))
+
+            self.verify_response_body_content(self.server_id,
+                                              attachment['server_id'],
+                                              ('Server id is not equal,'
+                                               'Volume attachment fails'))
+
+            self.verify_response_body_content(volume['id'],
+                                              attachment['volume_id'],
+                                              'Wrong volume is attached')
+
+        # detach volume
+        self.servers_client.detach_volume(self.server_id, volume['id'])
+        self.volumes_client.wait_for_volume_status(volume['id'], 'available')
+
+        # delete volume
+        resp, body = self.volumes_client.delete_volume(volume['id'])
+        self.verify_response_status(resp.status, 'Storage Object')
+