sync with upstream

doc/requirements.txt

@@ -5,7 +5,7 @@ docutils>=0.11 # OSI-Approved Open Source, Public Domain
 beautifulsoup4>=4.6.0 # MIT
 reno>=2.5.0 # Apache-2.0
 otcdocstheme # Apache-2.0
-sphinx!=1.6.6,!=1.6.7,>=1.6.5 # BSD
+sphinx>=1.8.0,!=2.1.0 # BSD
 sphinxcontrib-apidoc>=0.2.0 # BSD
 cliff!=2.9.0,>=2.8.0 # Apache-2.0
 oslo.i18n>=3.15.3 # Apache-2.0

otcextensions/_hacking.py

@@ -0,0 +1,43 @@
+# Copyright (c) 2019, Red Hat, 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 re
+
+from hacking import core
+
+"""
+Guidelines for writing new hacking checks
+
+ - Use only for openstacksdk specific tests. OpenStack general tests
+   should be submitted to the common 'hacking' module.
+ - Pick numbers in the range O3xx. Find the current test with
+   the highest allocated number and then pick the next value.
+ - Keep the test method code in the source file ordered based
+   on the O3xx value.
+ - List the new rule in the top level HACKING.rst file
+ - Add test cases for each new rule to nova/tests/unit/test_hacking.py
+
+"""
+
+SETUPCLASS_RE = re.compile(r"def setUpClass\(")
+
+
+@core.flake8ext
+def assert_no_setupclass(logical_line):
+    """Check for use of setUpClass
+
+    O300
+    """
+    if SETUPCLASS_RE.match(logical_line):
+        yield (0, "O300: setUpClass not allowed")

otcextensions/tests/functional/base.py

@@ -42,16 +42,10 @@ def _get_resource_value(resource_key, default):
 
 class BaseFunctionalTest(base.TestCase):
 
-    @classmethod
-    def setUpClass(cls):
-        super(BaseFunctionalTest, cls).setUpClass()
-        cls.conn = connection.Connection(config=TEST_CLOUD_REGION)
-        sdk.register_otc_extensions(cls.conn)
-
-    # def setUp(self):
-    #     super(BaseFunctionalTest, self).setUp()
-    #     self.conn = connection.Connection(config=TEST_CLOUD_REGION)
-    #     sdk.register_otc_extensions(self.conn)
+    def setUp(self):
+        super(BaseFunctionalTest, self).setUp()
+        self.conn = connection.Connection(config=TEST_CLOUD_REGION)
+        sdk.register_otc_extensions(self.conn)
 
     def addEmptyCleanup(self, func, *args, **kwargs):
         def cleanup():

otcextensions/tests/functional/osclient/obs/v1/test_container.py

@@ -29,26 +29,22 @@ class ObsContainerTests(base.TestCase):
     NAME = uuid.uuid4().hex
     OTHER_NAME = uuid.uuid4().hex
 
-    @classmethod
-    def setUpClass(cls):
-        super(ObsContainerTests, cls).setUpClass()
-        json_output = json.loads(cls.openstack(
-            CREATE_COMMAND % {'name': cls.NAME}
-        ))
-        cls.container_id = json_output["id"]
-        cls.assertOutput(cls.NAME, json_output['name'])
-
-    @classmethod
-    def tearDownClass(cls):
+    def tearDown(self):
         try:
-            cls.openstack(
-                DELETE_COMMAND % {'name': cls.NAME}
+            self.openstack(
+                DELETE_COMMAND % {'name': self.NAME}
             )
         finally:
-            super(ObsContainerTests, cls).tearDownClass()
+            super(ObsContainerTests, self).tearDown()
 
     def setUp(self):
         super(ObsContainerTests, self).setUp()
+        json_output = json.loads(self.openstack(
+            CREATE_COMMAND % {'name': self.NAME}
+        ))
+        self.container_id = json_output["id"]
+        self.assertOutput(self.NAME, json_output['name'])
+
         ver_fixture = fixtures.EnvironmentVariable(
             'OS_OBS_API_VERSION', '1'
         )

otcextensions/tests/functional/osclient/obs/v1/test_obj.py

@@ -35,43 +35,39 @@ class ObsObjectTests(base.TestCase):
 
     OBJECT_CONTENT = uuid.uuid4().hex
 
-    @classmethod
-    def setUpClass(cls):
-        super(ObsObjectTests, cls).setUpClass()
-        json_output = json.loads(cls.openstack(
-            CONTAINER_CREATE_COMMAND % {'name': cls.CONTAINER_NAME}
-        ))
-        cls.container_id = json_output["id"]
-        cls.assertOutput(cls.CONTAINER_NAME, json_output['name'])
-        with open(cls.OBJECT_NAME, 'w') as file:
-            file.write(cls.OBJECT_CONTENT)
-        json_output = json.loads(cls.openstack(
-            OBJECT_CREATE_COMMAND % {
-                'name': cls.OBJECT_NAME,
-                'container': cls.CONTAINER_NAME
-            }
-        ))
-        cls.object_id = json_output["id"]
-        cls.assertOutput(cls.OBJECT_NAME, json_output['name'])
-
-    @classmethod
-    def tearDownClass(cls):
+    def tearDown(self):
         try:
-            cls.openstack(
+            self.openstack(
                 OBJECT_DELETE_COMMAND % {
-                    'name': cls.OBJECT_NAME,
-                    'container': cls.CONTAINER_NAME
+                    'name': self.OBJECT_NAME,
+                    'container': self.CONTAINER_NAME
                 }
             )
-            cls.openstack(
-                CONTAINER_DELETE_COMMAND % {'name': cls.CONTAINER_NAME}
+            self.openstack(
+                CONTAINER_DELETE_COMMAND % {'name': self.CONTAINER_NAME}
             )
-            os.remove(cls.OBJECT_NAME)
+            os.remove(self.OBJECT_NAME)
         finally:
-            super(ObsObjectTests, cls).tearDownClass()
+            super(ObsObjectTests, self).tearDown()
 
     def setUp(self):
         super(ObsObjectTests, self).setUp()
+        json_output = json.loads(self.openstack(
+            CONTAINER_CREATE_COMMAND % {'name': self.CONTAINER_NAME}
+        ))
+        self.container_id = json_output["id"]
+        self.assertOutput(self.CONTAINER_NAME, json_output['name'])
+        with open(self.OBJECT_NAME, 'w') as file:
+            file.write(self.OBJECT_CONTENT)
+        json_output = json.loads(self.openstack(
+            OBJECT_CREATE_COMMAND % {
+                'name': self.OBJECT_NAME,
+                'container': self.CONTAINER_NAME
+            }
+        ))
+        self.object_id = json_output["id"]
+        self.assertOutput(self.OBJECT_NAME, json_output['name'])
+
         ver_fixture = fixtures.EnvironmentVariable(
             'OS_OBS_API_VERSION', '1'
         )

otcextensions/tests/functional/osclient/volume_backup/v2/test_policy.py

@@ -30,26 +30,21 @@ class VolumeBackupPolicyTests(base.TestCase):
     NAME = uuid.uuid4().hex
     OTHER_NAME = uuid.uuid4().hex
 
-    @classmethod
-    def setUpClass(cls):
-        super(VolumeBackupPolicyTests, cls).setUpClass()
-        json_output = json.loads(cls.openstack(
-            CREATE_COMMAND % {'name': cls.NAME}
-        ))
-        cls.policy_id = json_output["id"]
-        cls.assertOutput(cls.NAME, json_output['name'])
-
-    @classmethod
-    def tearDownClass(cls):
+    def tearDown(self):
         try:
-            cls.openstack(
-                DELETE_COMMAND % {'id': cls.policy_id}
+            self.openstack(
+                DELETE_COMMAND % {'id': self.policy_id}
             )
         finally:
-            super(VolumeBackupPolicyTests, cls).tearDownClass()
+            super(VolumeBackupPolicyTests, self).tearDown()
 
     def setUp(self):
         super(VolumeBackupPolicyTests, self).setUp()
+        json_output = json.loads(self.openstack(
+            CREATE_COMMAND % {'name': self.NAME}
+        ))
+        self.policy_id = json_output["id"]
+        self.assertOutput(self.NAME, json_output['name'])
         ver_fixture = fixtures.EnvironmentVariable(
             'OS_VBS_API_VERSION', '2'
         )

otcextensions/tests/functional/sdk/deh/v1/test_host.py

@@ -19,26 +19,24 @@
 
 class TestHost(base.BaseFunctionalTest):
 
-    @classmethod
-    def setUpClass(cls):
-        super(TestHost, cls).setUpClass()
+    def setUp(self):
+        super(TestHost, self).setUp()
         openstack.enable_logging(debug=True, http_debug=True)
-        cls.client = cls.conn.deh
-        res = cls.client.create_host(
+        self.client = self.conn.deh
+        res = self.client.create_host(
             name=uuid.uuid4().hex,
             availability_zone='eu-de-01',
             host_type='general',
             quantity=1
         )
         assert len(res.dedicated_host_ids) == 1
         host_id = res.dedicated_host_ids[0]
-        cls.host = cls.client.get_host(host_id)
+        self.host = self.client.get_host(host_id)
 
-    @classmethod
-    def tearDownClass(cls):
+    def tearDown(self):
         try:
-            if cls.host.id:
-                cls.client.delete_host(cls.host)
+            if self.host.id:
+                self.client.delete_host(self.host)
         except openstack.exceptions.SDKException as e:
             _logger.warning('Got exception during clearing resources %s'
                             % e.message)

otcextensions/tests/functional/sdk/dms/v1/test_message.py

@@ -26,78 +26,76 @@ class TestMessage(base.BaseFunctionalTest):
     messages = []
     received_messages = []
 
-    @classmethod
-    def setUpClass(cls):
-        super(TestMessage, cls).setUpClass()
+    def setUp(self):
+        super(TestMessage, self).setUp()
         openstack.enable_logging(debug=True, http_debug=True)
         try:
-            cls.queue = cls.conn.dms.create_queue(
+            self.queue = self.conn.dms.create_queue(
                 name=TestMessage.QUEUE_ALIAS
             )
 
         except openstack.exceptions.BadRequestException:
-            cls.queue = cls.conn.dms.get_queue(TestMessage.QUEUE_ALIAS)
+            self.queue = self.conn.dms.get_queue(TestMessage.QUEUE_ALIAS)
 
-        cls.queues.append(cls.queue)
+        self.queues.append(self.queue)
 
         try:
-            cls.group = cls.conn.dms.create_group(
-                cls.queue, {"name": "test_group"}
+            self.group = self.conn.dms.create_group(
+                self.queue, {"name": "test_group"}
             )
 
         except openstack.exceptions.DuplicateResource:
-            cls.queue = cls.conn.dms.groups(cls.queue)
+            self.queue = self.conn.dms.groups(self.queue)
 
-        cls.groups.append(cls.group)
+        self.groups.append(self.group)
 
-    @classmethod
-    def tearDownClass(cls):
+    def tearDown(self):
         try:
-            for queue in cls.queues:
+            for queue in self.queues:
                 if queue.id:
-                    cls.conn.dms.delete_queue(queue)
+                    self.conn.dms.delete_queue(queue)
         except openstack.exceptions.SDKException as e:
             _logger.warning('Got exception during clearing resources %s'
                             % e.message)
 
-    def test_list(cls):
-        cls.queues = list(cls.conn.dms.queues())
-        cls.assertGreaterEqual(len(cls.queues), 0)
-        if len(cls.queues) > 0:
-            queue = cls.queues[0]
-            q = cls.conn.dms.get_queue(queue=queue.id)
-            cls.assertIsNotNone(q)
-
-    def test_group(cls):
-        cls.queues = list(cls.conn.dms.queues())
-        # cls.assertGreaterEqual(len(cls.queues), 0)
-        if len(cls.queues) > 0:
-            # queue = cls.queues[0]
-            # q = cls.conn.dms.get_queue(queue=queue.id)
-            # cls.assertIsNotNone(q)
+    def test_list(self):
+        self.queues = list(self.conn.dms.queues())
+        self.assertGreaterEqual(len(self.queues), 0)
+        if len(self.queues) > 0:
+            queue = self.queues[0]
+            q = self.conn.dms.get_queue(queue=queue.id)
+            self.assertIsNotNone(q)
+
+    def test_group(self):
+        self.queues = list(self.conn.dms.queues())
+        # self.assertGreaterEqual(len(self.queues), 0)
+        if len(self.queues) > 0:
+            # queue = self.queues[0]
+            # q = self.conn.dms.get_queue(queue=queue.id)
+            # self.assertIsNotNone(q)
             try:
-                cls.group = cls.conn.dms.create_group(
-                    cls.queue, {"name": "test_group"}
+                self.group = self.conn.dms.create_group(
+                    self.queue, {"name": "test_group"}
                 )
 
             except openstack.exceptions.BadRequestException:
-                cls.queue = cls.conn.dms.groups(cls.queue)
+                self.queue = self.conn.dms.groups(self.queue)
 
-            cls.groups.append(cls.group)
+            self.groups.append(self.group)
 
     # OS_TEST_TIMEOUT=60 is needed due to testbed slowness
     @classmethod
-    def test_message(cls):
-        cls.queues = list(cls.conn.dms.queues())
-        # cls.assertGreaterEqual(len(cls.queues), 0)
-        if len(cls.queues) > 0:
-            # queue = cls.queues[0]
-            # q = cls.conn.dms.get_queue(queue=queue.id)
+    def test_message(self):
+        self.queues = list(self.conn.dms.queues())
+        # self.assertGreaterEqual(len(self.queues), 0)
+        if len(self.queues) > 0:
+            # queue = self.queues[0]
+            # q = self.conn.dms.get_queue(queue=queue.id)
             time.sleep(50)
 
-            # cls.assertIsNotNone(q)
-            cls.message = cls.conn.dms.send_messages(
-                cls.queue,
+            # self.assertIsNotNone(q)
+            self.message = self.conn.dms.send_messages(
+                self.queue,
                 messages=[
                     {"body": "TEST11",
                         "attributes":
@@ -111,19 +109,19 @@ def test_message(cls):
             #            "attribute1" : "value1",
             #            "attribute2" : "value2" } }
 
-            cls.messages.append(cls.message)
+            self.messages.append(self.message)
             try:
-                cls.group = cls.conn.dms.create_group(
-                    cls.queue, {"name": "test_group2"}
+                self.group = self.conn.dms.create_group(
+                    self.queue, {"name": "test_group2"}
                 )
 
             except openstack.exceptions.BadRequestException:
-                cls.queue = cls.conn.dms.groups(cls.queue)
+                self.queue = self.conn.dms.groups(self.queue)
 
-            cls.groups.append(cls.group)
+            self.groups.append(self.group)
 
-            cls.received_messages = cls.dms.consume_message(
-                cls.queue,
-                cls.group
+            self.received_messages = self.dms.consume_message(
+                self.queue,
+                self.group
             )
-            cls.assertGreaterEqual(len(cls.received_messages), 0)
+            self.assertGreaterEqual(len(self.received_messages), 0)