tests: enhance functional tests primitives

Adding a method to create a new flavor with or without an extra_spec,
and a method to create a full server configuration, using a flavor_id.
This will allow the functional tests to build custom test servers.

Also splitting the setup_services method in _IntegratedTestBase in to
separate methods, for the functional tests to override it and
control the initialization of each service.

Change-Id: Ic5ef388f5daae7394d20bda5ed1db6f718564dbc

nova/tests/functional/api/client.py

@@ -295,6 +295,10 @@ class TestOpenStackClient(object):
     def delete_flavor(self, flavor_id):
         return self.api_delete('/flavors/%s' % flavor_id)
 
+    def post_extra_spec(self, flavor_id, spec):
+        return self.api_post('/flavors/%s/os-extra_specs' %
+                             flavor_id, spec)
+
     def get_volume(self, volume_id):
         return self.api_get('/volumes/%s' % volume_id).body['volume']
 

nova/tests/functional/integrated_helpers.py

@@ -82,8 +82,6 @@ class _IntegratedTestBase(test.TestCase):
                        fake_crypto.fetch_ca)
         self.stubs.Set(crypto, 'generate_x509_cert',
                        fake_crypto.generate_x509_cert)
-        self.flags(scheduler_driver='nova.scheduler.'
-                    'chance.ChanceScheduler')
         self._setup_services()
 
         self.api_fixture = self.useFixture(
@@ -100,15 +98,23 @@ class _IntegratedTestBase(test.TestCase):
 
         self.addCleanup(nova.tests.unit.image.fake.FakeImageService_reset)
 
+    def _setup_compute_service(self):
+        return self.start_service('compute')
+
+    def _setup_scheduler_service(self):
+        self.flags(scheduler_driver='nova.scheduler.'
+                    'chance.ChanceScheduler')
+        return self.start_service('scheduler')
+
     def _setup_services(self):
         self.conductor = self.start_service('conductor',
                                             manager=CONF.conductor.manager)
-        self.compute = self.start_service('compute')
+        self.compute = self._setup_compute_service()
         self.cert = self.start_service('cert')
         self.consoleauth = self.start_service('consoleauth')
 
         self.network = self.start_service('network')
-        self.scheduler = self.start_service('scheduler')
+        self.scheduler = self._setup_scheduler_service()
         self.cells = self.start_service('cells', manager=CONF.cells.manager)
 
     def _get_test_client(self):
@@ -134,12 +140,20 @@ class _IntegratedTestBase(test.TestCase):
         server_names = [server['name'] for server in servers]
         return generate_new_element(server_names, 'server')
 
+    def get_unused_flavor_name_id(self):
+        flavors = self.api.get_flavors()
+        flavor_names = list()
+        flavor_ids = list()
+        [(flavor_names.append(flavor['name']),
+         flavor_ids.append(flavor['id']))
+         for flavor in flavors]
+        return (generate_new_element(flavor_names, 'flavor'),
+                int(generate_new_element(flavor_ids, '', True)))
+
     def get_invalid_image(self):
         return str(uuid.uuid4())
 
-    def _build_minimal_create_server_request(self):
-        server = {}
-
+    def _get_any_image_href(self):
         image = self.api.get_images()[0]
         LOG.debug("Image: %s" % image)
 
@@ -148,6 +162,12 @@ class _IntegratedTestBase(test.TestCase):
         else:
             image_href = image['id']
             image_href = 'http://fake.server/%s' % image_href
+        return image_href
+
+    def _build_minimal_create_server_request(self):
+        server = {}
+
+        image_href = self._get_any_image_href()
 
         # We now have a valid imageId
         server[self._image_ref_parameter] = image_href
@@ -162,3 +182,59 @@ class _IntegratedTestBase(test.TestCase):
         server_name = self.get_unused_server_name()
         server['name'] = server_name
         return server
+
+    def _create_flavor_body(self, name, ram, vcpus, disk, ephemeral, id, swap,
+                            rxtx_factor, is_public):
+        return {
+            "flavor": {
+                "name": name,
+                "ram": ram,
+                "vcpus": vcpus,
+                "disk": disk,
+                "OS-FLV-EXT-DATA:ephemeral": ephemeral,
+                "id": id,
+                "swap": swap,
+                "rxtx_factor": rxtx_factor,
+                "os-flavor-access:is_public": is_public,
+            }
+        }
+
+    def _create_flavor(self, memory_mb=2048, vcpu=2, disk=10, ephemeral=10,
+                       swap=0, rxtx_factor=1.0, is_public=True,
+                       extra_spec=None):
+        flv_name, flv_id = self.get_unused_flavor_name_id()
+        body = self._create_flavor_body(flv_name, memory_mb, vcpu, disk,
+                                        ephemeral, flv_id, swap, rxtx_factor,
+                                        is_public)
+        self.api_fixture.admin_api.post_flavor(body)
+        if extra_spec is not None:
+            spec = {"extra_specs": extra_spec}
+            self.api_fixture.admin_api.post_extra_spec(flv_id, spec)
+        return flv_id
+
+    def _build_server(self, flavor_id):
+        server = {}
+
+        image_href = self._get_any_image_href()
+        image = self.api.get_images()[0]
+        LOG.debug("Image: %s" % image)
+
+        if self._image_ref_parameter in image:
+            image_href = image[self._image_ref_parameter]
+        else:
+            image_href = image['id']
+            image_href = 'http://fake.server/%s' % image_href
+
+        # We now have a valid imageId
+        server[self._image_ref_parameter] = image_href
+
+        # Set a valid flavorId
+        flavor = self.api.get_flavor(flavor_id)
+        LOG.debug("Using flavor: %s" % flavor)
+        server[self._flavor_ref_parameter] = ('http://fake.server/%s'
+                                              % flavor['id'])
+
+        # Set a valid server name
+        server_name = self.get_unused_server_name()
+        server['name'] = server_name
+        return server