octavia 14.0.0.0rc1__py3-none-any.whl → 15.0.0__py3-none-any.whl

octavia/tests/functional/api/drivers/driver_agent/test_driver_agent.py

@@ -46,15 +46,13 @@ class DriverAgentTest(base.OctaviaDBTestBase):
         self.get_listener_proc.join(5)
 
     def setUp(self):
-        status_socket_file = '/tmp/octavia-{}.status.sock'.format(
-            uuidutils.generate_uuid())
-        stats_socket_file = '/tmp/octavia-{}.stats.sock'.format(
-            uuidutils.generate_uuid())
-        get_socket_file = '/tmp/octavia-{}.get.sock'.format(
-            uuidutils.generate_uuid())
-        sqlite_db_file = '/tmp/octavia-{}.sqlite.db'.format(
-            uuidutils.generate_uuid())
-        sqlite_db_connection = 'sqlite:///{}'.format(sqlite_db_file)
+        status_socket_file = (f'/tmp/octavia-{uuidutils.generate_uuid()}'
+                              f'.status.sock')
+        stats_socket_file = (f'/tmp/octavia-{uuidutils.generate_uuid()}'
+                             f'.stats.sock')
+        get_socket_file = f'/tmp/octavia-{uuidutils.generate_uuid()}.get.sock'
+        sqlite_db_file = f'/tmp/octavia-{uuidutils.generate_uuid()}.sqlite.db'
+        sqlite_db_connection = f'sqlite:///{sqlite_db_file}'
 
         # Note that because the driver agent is a multi-process
         # agent we must use a sqlite file rather than an
@@ -602,8 +600,9 @@ class DriverAgentTest(base.OctaviaDBTestBase):
         self.session.commit()
 
         result = self.driver_lib.get_member(member_dict[lib_consts.ID])
-        self.assertEqual(self.sample_data.provider_member2_dict,
-                         result.to_dict(render_unsets=True))
+        self._compare_member_dicts(
+            self.sample_data.provider_member2_dict,
+            result.to_dict(render_unsets=True))
 
         # Test deleting a member
         status = {

octavia/tests/functional/api/v2/base.py

@@ -170,10 +170,9 @@ class BaseAPITest(base_db_test.OctaviaDBTestBase):
         full_path = self._get_full_path(path)
         param_string = ""
         for k, v in params.items():
-            param_string += "{key}={value}&".format(key=k, value=v)
+            param_string += f"{k}={v}&"
         if param_string:
-            full_path = "{path}?{params}".format(
-                path=full_path, params=param_string.rstrip("&"))
+            full_path = f"{full_path}?{param_string.rstrip('&')}"
         response = self.app.delete(full_path,
                                    headers=headers,
                                    status=status,

octavia/tests/functional/api/v2/test_amphora.py

@@ -500,17 +500,17 @@ class TestAmphora(base.BaseAPITest):
         amps = self.get(self.AMPHORAE_PATH, params={
             'fields': ['id', 'role']}).json
         for amp in amps['amphorae']:
-            self.assertIn(u'id', amp)
-            self.assertIn(u'role', amp)
-            self.assertNotIn(u'ha_port_id', amp)
+            self.assertIn('id', amp)
+            self.assertIn('role', amp)
+            self.assertNotIn('ha_port_id', amp)
 
     def test_get_one_fields_filter(self):
         amp = self.get(
             self.AMPHORA_PATH.format(amphora_id=self.amp_id),
             params={'fields': ['id', 'role']}).json.get(self.root_tag)
-        self.assertIn(u'id', amp)
-        self.assertIn(u'role', amp)
-        self.assertNotIn(u'ha_port_id', amp)
+        self.assertIn('id', amp)
+        self.assertIn('role', amp)
+        self.assertNotIn('ha_port_id', amp)
 
     def test_get_all_filter(self):
         self._create_additional_amp()

octavia/tests/functional/api/v2/test_availability_zone_profiles.py

@@ -191,9 +191,9 @@ class TestAvailabilityZoneProfiles(base.BaseAPITest):
                 'fields': ['id', constants.PROVIDER_NAME]}
         ).json.get(self.root_tag)
         self.assertEqual(azp.get('id'), response.get('id'))
-        self.assertIn(u'id', response)
+        self.assertIn('id', response)
         self.assertIn(constants.PROVIDER_NAME, response)
-        self.assertNotIn(u'name', response)
+        self.assertNotIn('name', response)
         self.assertNotIn(constants.AVAILABILITY_ZONE_DATA, response)
 
     def test_get_authorized(self):
@@ -243,15 +243,15 @@ class TestAvailabilityZoneProfiles(base.BaseAPITest):
     def test_get_all(self):
         fp1 = self.create_availability_zone_profile(
             'test1', 'noop_driver', '{"compute_zone": "my_az_1"}')
-        ref_fp_1 = {u'availability_zone_data': u'{"compute_zone": "my_az_1"}',
-                    u'id': fp1.get('id'), u'name': u'test1',
-                    constants.PROVIDER_NAME: u'noop_driver'}
+        ref_fp_1 = {'availability_zone_data': '{"compute_zone": "my_az_1"}',
+                    'id': fp1.get('id'), 'name': 'test1',
+                    constants.PROVIDER_NAME: 'noop_driver'}
         self.assertTrue(uuidutils.is_uuid_like(fp1.get('id')))
         fp2 = self.create_availability_zone_profile(
             'test2', 'noop_driver-alt', '{"compute_zone": "my_az_1"}')
-        ref_fp_2 = {u'availability_zone_data': u'{"compute_zone": "my_az_1"}',
-                    u'id': fp2.get('id'), u'name': u'test2',
-                    constants.PROVIDER_NAME: u'noop_driver-alt'}
+        ref_fp_2 = {'availability_zone_data': '{"compute_zone": "my_az_1"}',
+                    'id': fp2.get('id'), 'name': 'test2',
+                    constants.PROVIDER_NAME: 'noop_driver-alt'}
         self.assertTrue(uuidutils.is_uuid_like(fp2.get('id')))
 
         response = self.get(self.AZPS_PATH)
@@ -273,8 +273,8 @@ class TestAvailabilityZoneProfiles(base.BaseAPITest):
         api_list = response.json.get(self.root_tag_list)
         self.assertEqual(2, len(api_list))
         for profile in api_list:
-            self.assertIn(u'id', profile)
-            self.assertIn(u'name', profile)
+            self.assertIn('id', profile)
+            self.assertIn('name', profile)
             self.assertNotIn(constants.PROVIDER_NAME, profile)
             self.assertNotIn(constants.AVAILABILITY_ZONE_DATA, profile)
 
@@ -375,8 +375,7 @@ class TestAvailabilityZoneProfiles(base.BaseAPITest):
     def _test_update_param_none(self, param_name):
         azp = self.create_availability_zone_profile(
             'test_profile', 'noop_driver', '{"x": "y"}')
-        expect_error_msg = ("None is not a valid option for %s" %
-                            param_name)
+        expect_error_msg = f"None is not a valid option for {param_name}"
         body = self._build_body({param_name: None})
         response = self.put(self.AZP_PATH.format(azp_id=azp.get('id')), body,
                             status=400)
@@ -513,7 +512,7 @@ class TestAvailabilityZoneProfiles(base.BaseAPITest):
         self.delete(self.AZP_PATH.format(azp_id=azp.get('id')))
         response = self.get(self.AZP_PATH.format(
             azp_id=azp.get('id')), status=404)
-        err_msg = "Availability Zone Profile %s not found." % azp.get('id')
+        err_msg = f"Availability Zone Profile {azp.get('id')} not found."
         self.assertEqual(err_msg, response.json.get('faultstring'))
 
     def test_delete_deleted_id(self):
@@ -560,7 +559,7 @@ class TestAvailabilityZoneProfiles(base.BaseAPITest):
         self.conf.config(group='api_settings', auth_strategy=auth_strategy)
         response = self.get(self.AZP_PATH.format(
             azp_id=azp.get('id')), status=404)
-        err_msg = "Availability Zone Profile %s not found." % azp.get('id')
+        err_msg = f"Availability Zone Profile {azp.get('id')} not found."
         self.assertEqual(err_msg, response.json.get('faultstring'))
 
     def test_delete_not_authorized(self):

octavia/tests/functional/api/v2/test_availability_zones.py

@@ -186,15 +186,15 @@ class TestAvailabilityZones(base.BaseAPITest):
         self.assertEqual(az.get('name'), response.get('name'))
         self.assertEqual(self.azp.get('id'),
                          response.get('availability_zone_profile_id'))
-        self.assertIn(u'availability_zone_profile_id', response)
-        self.assertNotIn(u'description', response)
-        self.assertNotIn(u'enabled', response)
+        self.assertIn('availability_zone_profile_id', response)
+        self.assertNotIn('description', response)
+        self.assertNotIn('enabled', response)
 
     def test_get_one_deleted_name(self):
         response = self.get(
             self.AZ_PATH.format(az_name=constants.NIL_UUID), status=404)
         self.assertEqual(
-            'Availability Zone {} not found.'.format(constants.NIL_UUID),
+            f'Availability Zone {constants.NIL_UUID} not found.',
             response.json.get('faultstring'))
 
     def test_get_authorized(self):
@@ -214,7 +214,7 @@ class TestAvailabilityZones(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_member'],
+                'roles': ['load-balancer_member', 'member'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -249,15 +249,15 @@ class TestAvailabilityZones(base.BaseAPITest):
         self.create_availability_zone(
             'name1', 'description', self.azp.get('id'), True)
         ref_az_1 = {
-            u'description': u'description', u'enabled': True,
-            u'availability_zone_profile_id': self.azp.get('id'),
-            u'name': u'name1'}
+            'description': 'description', 'enabled': True,
+            'availability_zone_profile_id': self.azp.get('id'),
+            'name': 'name1'}
         self.create_availability_zone(
             'name2', 'description', self.azp.get('id'), True)
         ref_az_2 = {
-            u'description': u'description', u'enabled': True,
-            u'availability_zone_profile_id': self.azp.get('id'),
-            u'name': u'name2'}
+            'description': 'description', 'enabled': True,
+            'availability_zone_profile_id': self.azp.get('id'),
+            'name': 'name2'}
         response = self.get(self.AZS_PATH)
         api_list = response.json.get(self.root_tag_list)
         self.assertEqual(2, len(api_list))
@@ -274,10 +274,10 @@ class TestAvailabilityZones(base.BaseAPITest):
         api_list = response.json.get(self.root_tag_list)
         self.assertEqual(2, len(api_list))
         for az in api_list:
-            self.assertIn(u'name', az)
-            self.assertNotIn(u'availability_zone_profile_id', az)
-            self.assertNotIn(u'description', az)
-            self.assertNotIn(u'enabled', az)
+            self.assertIn('name', az)
+            self.assertNotIn('availability_zone_profile_id', az)
+            self.assertNotIn('description', az)
+            self.assertNotIn('enabled', az)
 
     def test_get_all_authorized(self):
         self.create_availability_zone(
@@ -355,7 +355,7 @@ class TestAvailabilityZones(base.BaseAPITest):
             self.AZ_PATH.format(az_name=constants.NIL_UUID), body,
             status=404)
         self.assertEqual(
-            'Availability Zone {} not found.'.format(constants.NIL_UUID),
+            f'Availability Zone {constants.NIL_UUID} not found.',
             response.json.get('faultstring'))
 
     def test_update_none(self):
@@ -492,7 +492,7 @@ class TestAvailabilityZones(base.BaseAPITest):
         self.delete(self.AZ_PATH.format(az_name=az.get('name')))
         response = self.get(self.AZ_PATH.format(az_name=az.get('name')),
                             status=404)
-        err_msg = "Availability Zone %s not found." % az.get('name')
+        err_msg = f"Availability Zone {az.get('name')} not found."
         self.assertEqual(err_msg, response.json.get('faultstring'))
 
     def test_delete_nonexistent_name(self):
@@ -505,7 +505,7 @@ class TestAvailabilityZones(base.BaseAPITest):
         response = self.delete(
             self.AZ_PATH.format(az_name=constants.NIL_UUID), status=404)
         self.assertEqual(
-            'Availability Zone {} not found.'.format(constants.NIL_UUID),
+            f'Availability Zone {constants.NIL_UUID} not found.',
             response.json.get('faultstring'))
 
     def test_delete_authorized(self):
@@ -539,7 +539,7 @@ class TestAvailabilityZones(base.BaseAPITest):
         self.conf.config(group='api_settings', auth_strategy=auth_strategy)
         response = self.get(self.AZ_PATH.format(az_name=az.get('name')),
                             status=404)
-        err_msg = "Availability Zone %s not found." % az.get('name')
+        err_msg = f"Availability Zone {az.get('name')} not found."
         self.assertEqual(err_msg, response.json.get('faultstring'))
 
     def test_delete_not_authorized(self):

octavia/tests/functional/api/v2/test_flavor_profiles.py

@@ -189,9 +189,9 @@ class TestFlavorProfiles(base.BaseAPITest):
                 'fields': ['id', constants.PROVIDER_NAME]}
         ).json.get(self.root_tag)
         self.assertEqual(fp.get('id'), response.get('id'))
-        self.assertIn(u'id', response)
+        self.assertIn('id', response)
         self.assertIn(constants.PROVIDER_NAME, response)
-        self.assertNotIn(u'name', response)
+        self.assertNotIn('name', response)
         self.assertNotIn(constants.FLAVOR_DATA, response)
 
     def test_get_authorized(self):
@@ -241,15 +241,15 @@ class TestFlavorProfiles(base.BaseAPITest):
     def test_get_all(self):
         fp1 = self.create_flavor_profile('test1', 'noop_driver',
                                          '{"image": "ubuntu"}')
-        ref_fp_1 = {u'flavor_data': u'{"image": "ubuntu"}',
-                    u'id': fp1.get('id'), u'name': u'test1',
-                    constants.PROVIDER_NAME: u'noop_driver'}
+        ref_fp_1 = {'flavor_data': '{"image": "ubuntu"}',
+                    'id': fp1.get('id'), 'name': 'test1',
+                    constants.PROVIDER_NAME: 'noop_driver'}
         self.assertTrue(uuidutils.is_uuid_like(fp1.get('id')))
         fp2 = self.create_flavor_profile('test2', 'noop_driver-alt',
                                          '{"image": "ubuntu"}')
-        ref_fp_2 = {u'flavor_data': u'{"image": "ubuntu"}',
-                    u'id': fp2.get('id'), u'name': u'test2',
-                    constants.PROVIDER_NAME: u'noop_driver-alt'}
+        ref_fp_2 = {'flavor_data': '{"image": "ubuntu"}',
+                    'id': fp2.get('id'), 'name': 'test2',
+                    constants.PROVIDER_NAME: 'noop_driver-alt'}
         self.assertTrue(uuidutils.is_uuid_like(fp2.get('id')))
 
         response = self.get(self.FPS_PATH)
@@ -271,8 +271,8 @@ class TestFlavorProfiles(base.BaseAPITest):
         api_list = response.json.get(self.root_tag_list)
         self.assertEqual(2, len(api_list))
         for profile in api_list:
-            self.assertIn(u'id', profile)
-            self.assertIn(u'name', profile)
+            self.assertIn('id', profile)
+            self.assertIn('name', profile)
             self.assertNotIn(constants.PROVIDER_NAME, profile)
             self.assertNotIn(constants.FLAVOR_DATA, profile)
 
@@ -373,8 +373,7 @@ class TestFlavorProfiles(base.BaseAPITest):
     def _test_update_param_none(self, param_name):
         fp = self.create_flavor_profile('test_profile', 'noop_driver',
                                         '{"x": "y"}')
-        expect_error_msg = ("None is not a valid option for %s" %
-                            param_name)
+        expect_error_msg = f"None is not a valid option for {param_name}"
         body = self._build_body({param_name: None})
         response = self.put(self.FP_PATH.format(fp_id=fp.get('id')), body,
                             status=400)
@@ -465,8 +464,8 @@ class TestFlavorProfiles(base.BaseAPITest):
         body = self._build_body(update_data)
         response = self.put(self.FP_PATH.format(fp_id=fp.get('id')), body,
                             status=409)
-        err_msg = ("Flavor profile {} is in use and cannot be "
-                   "modified.".format(fp.get('id')))
+        err_msg = (f"Flavor profile {fp.get('id')} is in use and cannot be "
+                   f"modified.")
         self.assertEqual(err_msg, response.json.get('faultstring'))
         response = self.get(
             self.FP_PATH.format(fp_id=fp.get('id'))).json.get(self.root_tag)
@@ -480,8 +479,8 @@ class TestFlavorProfiles(base.BaseAPITest):
         body = self._build_body(update_data)
         response = self.put(self.FP_PATH.format(fp_id=fp.get('id')), body,
                             status=409)
-        err_msg = ("Flavor profile {} is in use and cannot be "
-                   "modified.".format(fp.get('id')))
+        err_msg = (f"Flavor profile {fp.get('id')} is in use and cannot "
+                   f"be modified.")
         self.assertEqual(err_msg, response.json.get('faultstring'))
         response = self.get(
             self.FP_PATH.format(fp_id=fp.get('id'))).json.get(self.root_tag)
@@ -506,7 +505,7 @@ class TestFlavorProfiles(base.BaseAPITest):
         self.delete(self.FP_PATH.format(fp_id=fp.get('id')))
         response = self.get(self.FP_PATH.format(
             fp_id=fp.get('id')), status=404)
-        err_msg = "Flavor Profile %s not found." % fp.get('id')
+        err_msg = f"Flavor Profile {fp.get('id')} not found."
         self.assertEqual(err_msg, response.json.get('faultstring'))
 
     def test_delete_deleted_id(self):
@@ -552,7 +551,7 @@ class TestFlavorProfiles(base.BaseAPITest):
         self.conf.config(group='api_settings', auth_strategy=auth_strategy)
         response = self.get(self.FP_PATH.format(
             fp_id=fp.get('id')), status=404)
-        err_msg = "Flavor Profile %s not found." % fp.get('id')
+        err_msg = f"Flavor Profile {fp.get('id')} not found."
         self.assertEqual(err_msg, response.json.get('faultstring'))
 
     def test_delete_not_authorized(self):
@@ -578,8 +577,8 @@ class TestFlavorProfiles(base.BaseAPITest):
         self.create_flavor('name1', 'description', fp.get('id'), True)
         response = self.delete(self.FP_PATH.format(fp_id=fp.get('id')),
                                status=409)
-        err_msg = ("Flavor profile {} is in use and cannot be "
-                   "modified.".format(fp.get('id')))
+        err_msg = (f"Flavor profile {fp.get('id')} is in use and cannot be "
+                   f"modified.")
         self.assertEqual(err_msg, response.json.get('faultstring'))
         response = self.get(
             self.FP_PATH.format(fp_id=fp.get('id'))).json.get(self.root_tag)

octavia/tests/functional/api/v2/test_flavors.py

@@ -184,16 +184,16 @@ class TestFlavors(base.BaseAPITest):
                 'fields': ['id', 'flavor_profile_id']}).json.get(self.root_tag)
         self.assertEqual(flavor.get('id'), response.get('id'))
         self.assertEqual(self.fp.get('id'), response.get('flavor_profile_id'))
-        self.assertIn(u'id', response)
-        self.assertIn(u'flavor_profile_id', response)
-        self.assertNotIn(u'name', response)
-        self.assertNotIn(u'description', response)
-        self.assertNotIn(u'enabled', response)
+        self.assertIn('id', response)
+        self.assertIn('flavor_profile_id', response)
+        self.assertNotIn('name', response)
+        self.assertNotIn('description', response)
+        self.assertNotIn('enabled', response)
 
     def test_get_one_deleted_id(self):
         response = self.get(
             self.FLAVOR_PATH.format(flavor_id=constants.NIL_UUID), status=404)
-        self.assertEqual('Flavor {} not found.'.format(constants.NIL_UUID),
+        self.assertEqual(f'Flavor {constants.NIL_UUID} not found.',
                          response.json.get('faultstring'))
 
     def test_get_authorized(self):
@@ -214,7 +214,7 @@ class TestFlavors(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_member'],
+                'roles': ['load-balancer_member', 'member'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -251,18 +251,18 @@ class TestFlavors(base.BaseAPITest):
                                      True)
         self.assertTrue(uuidutils.is_uuid_like(flavor1.get('id')))
         ref_flavor_1 = {
-            u'description': u'description', u'enabled': True,
-            u'flavor_profile_id': self.fp.get('id'),
-            u'id': flavor1.get('id'),
-            u'name': u'name1'}
+            'description': 'description', 'enabled': True,
+            'flavor_profile_id': self.fp.get('id'),
+            'id': flavor1.get('id'),
+            'name': 'name1'}
         flavor2 = self.create_flavor('name2', 'description', self.fp.get('id'),
                                      True)
         self.assertTrue(uuidutils.is_uuid_like(flavor2.get('id')))
         ref_flavor_2 = {
-            u'description': u'description', u'enabled': True,
-            u'flavor_profile_id': self.fp.get('id'),
-            u'id': flavor2.get('id'),
-            u'name': u'name2'}
+            'description': 'description', 'enabled': True,
+            'flavor_profile_id': self.fp.get('id'),
+            'id': flavor2.get('id'),
+            'name': 'name2'}
         response = self.get(self.FLAVORS_PATH)
         api_list = response.json.get(self.root_tag_list)
         self.assertEqual(2, len(api_list))
@@ -281,11 +281,11 @@ class TestFlavors(base.BaseAPITest):
         api_list = response.json.get(self.root_tag_list)
         self.assertEqual(2, len(api_list))
         for flavor in api_list:
-            self.assertIn(u'id', flavor)
-            self.assertIn(u'name', flavor)
-            self.assertNotIn(u'flavor_profile_id', flavor)
-            self.assertNotIn(u'description', flavor)
-            self.assertNotIn(u'enabled', flavor)
+            self.assertIn('id', flavor)
+            self.assertIn('name', flavor)
+            self.assertNotIn('flavor_profile_id', flavor)
+            self.assertNotIn('description', flavor)
+            self.assertNotIn('enabled', flavor)
 
     def test_get_all_authorized(self):
         flavor1 = self.create_flavor('name1', 'description', self.fp.get('id'),
@@ -308,7 +308,7 @@ class TestFlavors(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_member'],
+                'roles': ['load-balancer_member', 'member'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -368,7 +368,7 @@ class TestFlavors(base.BaseAPITest):
         response = self.put(
             self.FLAVOR_PATH.format(flavor_id=constants.NIL_UUID), body,
             status=404)
-        self.assertEqual('Flavor {} not found.'.format(constants.NIL_UUID),
+        self.assertEqual(f'Flavor {constants.NIL_UUID} not found.',
                          response.json.get('faultstring'))
 
     def test_update_none(self):
@@ -510,7 +510,7 @@ class TestFlavors(base.BaseAPITest):
         self.delete(self.FLAVOR_PATH.format(flavor_id=flavor.get('id')))
         response = self.get(self.FLAVOR_PATH.format(
             flavor_id=flavor.get('id')), status=404)
-        err_msg = "Flavor %s not found." % flavor.get('id')
+        err_msg = f"Flavor {flavor.get('id')} not found."
         self.assertEqual(err_msg, response.json.get('faultstring'))
 
     def test_delete_nonexistent_id(self):
@@ -522,7 +522,7 @@ class TestFlavors(base.BaseAPITest):
     def test_delete_deleted_id(self):
         response = self.delete(
             self.FLAVOR_PATH.format(flavor_id=constants.NIL_UUID), status=404)
-        self.assertEqual('Flavor {} not found.'.format(constants.NIL_UUID),
+        self.assertEqual(f'Flavor {constants.NIL_UUID} not found.',
                          response.json.get('faultstring'))
 
     def test_delete_authorized(self):
@@ -557,7 +557,7 @@ class TestFlavors(base.BaseAPITest):
         self.conf.config(group='api_settings', auth_strategy=auth_strategy)
         response = self.get(self.FLAVOR_PATH.format(
             flavor_id=flavor.get('id')), status=404)
-        err_msg = "Flavor %s not found." % flavor.get('id')
+        err_msg = f"Flavor {flavor.get('id')} not found."
         self.assertEqual(err_msg, response.json.get('faultstring'))
 
     def test_delete_not_authorized(self):

octavia/tests/functional/api/v2/test_health_monitor.py

@@ -137,7 +137,7 @@ class TestHealthMonitor(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_member'],
+                'roles': ['load-balancer_member', 'member'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -293,7 +293,7 @@ class TestHealthMonitor(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_member'],
+                'roles': ['load-balancer_member', 'member'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -688,9 +688,9 @@ class TestHealthMonitor(base.BaseAPITest):
         hms = self.get(self.HMS_PATH, params={
             'fields': ['id', 'project_id']}).json
         for hm in hms['healthmonitors']:
-            self.assertIn(u'id', hm)
-            self.assertIn(u'project_id', hm)
-            self.assertNotIn(u'description', hm)
+            self.assertIn('id', hm)
+            self.assertIn('project_id', hm)
+            self.assertNotIn('description', hm)
 
     def test_get_one_fields_filter(self):
         pool1 = self.create_pool(
@@ -709,9 +709,9 @@ class TestHealthMonitor(base.BaseAPITest):
         hm = self.get(
             self.HM_PATH.format(healthmonitor_id=hm1.get('id')),
             params={'fields': ['id', 'project_id']}).json.get(self.root_tag)
-        self.assertIn(u'id', hm)
-        self.assertIn(u'project_id', hm)
-        self.assertNotIn(u'description', hm)
+        self.assertIn('id', hm)
+        self.assertIn('project_id', hm)
+        self.assertNotIn('description', hm)
 
     def test_get_all_filter(self):
         pool1 = self.create_pool(
@@ -1258,7 +1258,7 @@ class TestHealthMonitor(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_member'],
+                'roles': ['load-balancer_member', 'member'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -1323,7 +1323,7 @@ class TestHealthMonitor(base.BaseAPITest):
                                provisioning_status=constants.ERROR)
         api_hm = self.create_health_monitor(
             pool1_id, constants.HEALTH_MONITOR_HTTP, 1, 1, 1, 1, status=409)
-        ref_msg = 'Pool %s is immutable and cannot be updated.' % pool1_id
+        ref_msg = f'Pool {pool1_id} is immutable and cannot be updated.'
         self.assertEqual(ref_msg, api_hm.get('faultstring'))
 
     def test_create_with_listener(self):
@@ -1714,7 +1714,7 @@ class TestHealthMonitor(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_member'],
+                'roles': ['load-balancer_member', 'member'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,
@@ -1782,6 +1782,24 @@ class TestHealthMonitor(base.BaseAPITest):
             pool_prov_status=constants.PENDING_UPDATE,
             hm_prov_status=constants.PENDING_UPDATE)
 
+    def test_update_udp_case_with_udp_hm(self):
+        api_hm = self.create_health_monitor(
+            self.udp_pool_with_listener_id,
+            constants.HEALTH_MONITOR_UDP_CONNECT, 3, 1, 1, 1).get(
+            self.root_tag)
+        self.set_lb_status(self.udp_lb_id)
+        new_hm = {'timeout': 2}
+        self.put(
+            self.HM_PATH.format(healthmonitor_id=api_hm.get('id')),
+            self._build_body(new_hm))
+        self.assert_correct_status(
+            lb_id=self.udp_lb_id, listener_id=self.udp_listener_id,
+            pool_id=self.udp_pool_with_listener_id, hm_id=api_hm.get('id'),
+            lb_prov_status=constants.PENDING_UPDATE,
+            listener_prov_status=constants.PENDING_UPDATE,
+            pool_prov_status=constants.PENDING_UPDATE,
+            hm_prov_status=constants.PENDING_UPDATE)
+
     def test_negative_update_udp_case(self):
         api_hm = self.create_health_monitor(
             self.udp_pool_with_listener_id,
@@ -1834,8 +1852,7 @@ class TestHealthMonitor(base.BaseAPITest):
                                             1, 1, 1, 1).get(self.root_tag)
         new_hm = {constants.DELAY: None}
         self.set_lb_status(self.lb_id)
-        expect_error_msg = ("None is not a valid option for %s" %
-                            constants.DELAY)
+        expect_error_msg = f"None is not a valid option for {constants.DELAY}"
         res = self.put(self.HM_PATH.format(healthmonitor_id=api_hm.get('id')),
                        self._build_body(new_hm), status=400)
         self.assertEqual(expect_error_msg, res.json['faultstring'])
@@ -1846,8 +1863,8 @@ class TestHealthMonitor(base.BaseAPITest):
                                             1, 1, 1, 1).get(self.root_tag)
         new_hm = {constants.MAX_RETRIES: None}
         self.set_lb_status(self.lb_id)
-        expect_error_msg = ("None is not a valid option for %s" %
-                            constants.MAX_RETRIES)
+        expect_error_msg = (f"None is not a valid option for "
+                            f"{constants.MAX_RETRIES}")
         res = self.put(self.HM_PATH.format(healthmonitor_id=api_hm.get('id')),
                        self._build_body(new_hm), status=400)
         self.assertEqual(expect_error_msg, res.json['faultstring'])
@@ -1858,8 +1875,8 @@ class TestHealthMonitor(base.BaseAPITest):
                                             1, 1, 1, 1).get(self.root_tag)
         new_hm = {constants.TIMEOUT: None}
         self.set_lb_status(self.lb_id)
-        expect_error_msg = ("None is not a valid option for %s" %
-                            constants.TIMEOUT)
+        expect_error_msg = (f"None is not a valid option for "
+                            f"{constants.TIMEOUT}")
         res = self.put(self.HM_PATH.format(healthmonitor_id=api_hm.get('id')),
                        self._build_body(new_hm), status=400)
         self.assertEqual(expect_error_msg, res.json['faultstring'])
@@ -2047,7 +2064,7 @@ class TestHealthMonitor(base.BaseAPITest):
                 'is_admin_project': True,
                 'service_project_domain_id': None,
                 'service_project_id': None,
-                'roles': ['load-balancer_member'],
+                'roles': ['load-balancer_member', 'member'],
                 'user_id': None,
                 'is_admin': False,
                 'service_user_domain_id': None,