python-openstackclient 7.4.0__py3-none-any.whl → 8.1.0__py3-none-any.whl

openstackclient/tests/functional/identity/v3/test_idp.py

@@ -54,13 +54,9 @@ class IdentityProviderTests(common.IdentityTests):
         identity_provider = self._create_dummy_idp(add_clean_up=True)
         new_remoteid = data_utils.rand_name('newRemoteId')
         raw_output = self.openstack(
-            'identity provider set '
-            '%(identity-provider)s '
-            '--remote-id %(remote-id)s '
-            % {
-                'identity-provider': identity_provider,
-                'remote-id': new_remoteid,
-            }
+            f'identity provider set '
+            f'{identity_provider} '
+            f'--remote-id {new_remoteid}'
         )
         self.assertEqual(0, len(raw_output))
         raw_output = self.openstack(

openstackclient/tests/functional/identity/v3/test_limit.py

@@ -174,7 +174,7 @@ class LimitTestCase(common.IdentityTests):
         }
 
         raw_output = self.openstack(
-            'limit set' ' --description {description}' ' {limit_id}'.format(
+            'limit set --description {description} {limit_id}'.format(
                 **params
             ),
             cloud=SYSTEM_CLOUD,
@@ -188,9 +188,9 @@ class LimitTestCase(common.IdentityTests):
         params = {'resource_limit': 5, 'limit_id': limit_id}
 
         raw_output = self.openstack(
-            'limit set'
-            ' --resource-limit {resource_limit}'
-            ' {limit_id}'.format(**params),
+            'limit set --resource-limit {resource_limit} {limit_id}'.format(
+                **params
+            ),
             cloud=SYSTEM_CLOUD,
         )
         items = self.parse_show(raw_output)

openstackclient/tests/functional/identity/v3/test_project.py

@@ -30,9 +30,7 @@ class ProjectTests(common.IdentityTests):
         )
         self.addCleanup(
             self.openstack,
-            'project delete '
-            f'--domain {self.domain_name} '
-            f'{project_name}',
+            f'project delete --domain {self.domain_name} {project_name}',
         )
         items = self.parse_show(raw_output)
         show_fields = list(self.PROJECT_FIELDS)
@@ -45,7 +43,7 @@ class ProjectTests(common.IdentityTests):
     def test_project_delete(self):
         project_name = self._create_dummy_project(add_clean_up=False)
         raw_output = self.openstack(
-            'project delete ' f'--domain {self.domain_name} ' f'{project_name}'
+            f'project delete --domain {self.domain_name} {project_name}'
         )
         self.assertEqual(0, len(raw_output))
 
@@ -77,9 +75,7 @@ class ProjectTests(common.IdentityTests):
         self.assertEqual(0, len(raw_output))
         # check project details
         raw_output = self.openstack(
-            'project show '
-            f'--domain {self.domain_name} '
-            f'{new_project_name}'
+            f'project show --domain {self.domain_name} {new_project_name}'
         )
         items = self.parse_show(raw_output)
         fields = list(self.PROJECT_FIELDS)
@@ -91,17 +87,12 @@ class ProjectTests(common.IdentityTests):
         self.assertEqual('v0', project['k0'])
         # reset project to make sure it will be cleaned up
         self.openstack(
-            'project set '
-            f'--name {project_name} '
-            '--enable '
-            f'{new_project_name}'
+            f'project set --name {project_name} --enable {new_project_name}'
         )
 
     def test_project_show(self):
         raw_output = self.openstack(
-            'project show '
-            f'--domain {self.domain_name} '
-            f'{self.project_name}'
+            f'project show --domain {self.domain_name} {self.project_name}'
         )
         items = self.parse_show(raw_output)
         self.assert_show_fields(items, self.PROJECT_FIELDS)

openstackclient/tests/functional/identity/v3/test_region.py

@@ -49,9 +49,7 @@ class RegionTests(common.IdentityTests):
         self.assertEqual(region_id, region['region'])
         # update parent-region
         raw_output = self.openstack(
-            'region set '
-            f'--parent-region {new_parent_region_id} '
-            f'{region_id}'
+            f'region set --parent-region {new_parent_region_id} {region_id}'
         )
         self.assertEqual(0, len(raw_output))
         # check updated region details

openstackclient/tests/functional/identity/v3/test_registered_limit.py

@@ -25,7 +25,7 @@ class RegisteredLimitTestCase(common.IdentityTests):
 
     def test_registered_limit_create_with_service_id(self):
         service_name = self._create_dummy_service()
-        raw_output = self.openstack('service show' f' {service_name}')
+        raw_output = self.openstack(f'service show {service_name}')
         service_items = self.parse_show(raw_output)
         service_id = self._extract_value_from_items('id', service_items)
 
@@ -44,7 +44,7 @@ class RegisteredLimitTestCase(common.IdentityTests):
         registered_limit_id = self._extract_value_from_items('id', items)
         self.addCleanup(
             self.openstack,
-            'registered limit delete' f' {registered_limit_id}',
+            f'registered limit delete {registered_limit_id}',
             cloud=SYSTEM_CLOUD,
         )
 
@@ -178,7 +178,7 @@ class RegisteredLimitTestCase(common.IdentityTests):
             add_clean_up=False
         )
         raw_output = self.openstack(
-            'registered limit delete' f' {registered_limit_id}',
+            f'registered limit delete {registered_limit_id}',
             cloud=SYSTEM_CLOUD,
         )
         self.assertEqual(0, len(raw_output))

openstackclient/tests/functional/identity/v3/test_role.py

@@ -23,7 +23,7 @@ class RoleTests(common.IdentityTests):
         role_name = data_utils.rand_name('TestRole')
         description = data_utils.rand_name('description')
         raw_output = self.openstack(
-            'role create ' f'--description {description} ' f'{role_name}'
+            f'role create --description {description} {role_name}'
         )
         role = self.parse_show_as_object(raw_output)
         self.addCleanup(self.openstack, 'role delete {}'.format(role['id']))

openstackclient/tests/functional/identity/v3/test_role_assignment.py

@@ -24,35 +24,25 @@ class RoleAssignmentTests(common.IdentityTests):
         username = self._create_dummy_user()
         system = 'all'
         raw_output = self.openstack(
-            'role add '
-            f'--user {username} '
-            f'--system {system} '
-            f'{role_name}'
+            f'role add --user {username} --system {system} {role_name}'
         )
         self.addCleanup(
             self.openstack,
-            'role remove '
-            f'--user {username} '
-            f'--system  {system} '
-            f'{role_name}',
+            f'role remove --user {username} --system  {system} {role_name}',
         )
         self.assertEqual(0, len(raw_output))
 
-        raw_output = self.openstack(
-            'role assignment list ' f'--user {username} '
-        )
+        raw_output = self.openstack(f'role assignment list --user {username} ')
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 
         raw_output = self.openstack(
-            'role assignment list ' f'--role {role_name} '
+            f'role assignment list --role {role_name} '
         )
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 
-        raw_output = self.openstack(
-            'role assignment list ' f'--system {system} '
-        )
+        raw_output = self.openstack(f'role assignment list --system {system} ')
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 
@@ -61,22 +51,14 @@ class RoleAssignmentTests(common.IdentityTests):
         group = self._create_dummy_group()
         system = 'all'
         raw_output = self.openstack(
-            'role add '
-            f'--group {group} '
-            f'--system {system} '
-            f'{role_name}'
+            f'role add --group {group} --system {system} {role_name}'
         )
         self.addCleanup(
             self.openstack,
-            'role remove '
-            f'--group {group} '
-            f'--system {system} '
-            f'{role_name}',
+            f'role remove --group {group} --system {system} {role_name}',
         )
         self.assertEqual(0, len(raw_output))
-        raw_output = self.openstack(
-            'role assignment list ' f'--group {group} '
-        )
+        raw_output = self.openstack(f'role assignment list --group {group} ')
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 
@@ -98,7 +80,7 @@ class RoleAssignmentTests(common.IdentityTests):
         )
         self.assertEqual(0, len(raw_output))
         raw_output = self.openstack(
-            'role assignment list ' f'--domain {self.domain_name} '
+            f'role assignment list --domain {self.domain_name} '
         )
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
@@ -121,23 +103,23 @@ class RoleAssignmentTests(common.IdentityTests):
         )
         self.assertEqual(0, len(raw_output))
         raw_output = self.openstack(
-            'role assignment list ' f'--project {self.project_name} '
+            f'role assignment list --project {self.project_name} '
         )
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 
     def test_role_assignment_list_effective(self):
-        raw_output = self.openstack('role assignment list ' '--effective')
+        raw_output = self.openstack('role assignment list --effective')
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 
     def test_role_assignment_list_auth_user(self):
-        raw_output = self.openstack('role assignment list ' '--auth-user')
+        raw_output = self.openstack('role assignment list --auth-user')
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 
     def test_role_assignment_list_auth_project(self):
-        raw_output = self.openstack('role assignment list ' '--auth-project')
+        raw_output = self.openstack('role assignment list --auth-project')
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, self.ROLE_ASSIGNMENT_LIST_HEADERS)
 

openstackclient/tests/functional/identity/v3/test_service_provider.py

@@ -52,13 +52,9 @@ class ServiceProviderTests(common.IdentityTests):
         service_provider = self._create_dummy_sp(add_clean_up=True)
         new_description = data_utils.rand_name('newDescription')
         raw_output = self.openstack(
-            'service provider set '
-            '%(service-provider)s '
-            '--description %(description)s '
-            % {
-                'service-provider': service_provider,
-                'description': new_description,
-            }
+            f'service provider set '
+            f'{service_provider} '
+            f'--description {new_description}'
         )
         updated_value = self.parse_show_as_object(raw_output)
         self.assertEqual(new_description, updated_value.get('description'))

openstackclient/tests/functional/identity/v3/test_user.py

@@ -22,7 +22,7 @@ class UserTests(common.IdentityTests):
     def test_user_delete(self):
         username = self._create_dummy_user(add_clean_up=False)
         raw_output = self.openstack(
-            'user delete ' f'--domain {self.domain_name} ' f'{username}'
+            f'user delete --domain {self.domain_name} {username}'
         )
         self.assertEqual(0, len(raw_output))
 
@@ -34,19 +34,19 @@ class UserTests(common.IdentityTests):
     def test_user_set(self):
         username = self._create_dummy_user()
         raw_output = self.openstack(
-            'user show ' f'--domain {self.domain_name} ' f'{username}'
+            f'user show --domain {self.domain_name} {username}'
         )
         user = self.parse_show_as_object(raw_output)
         new_username = data_utils.rand_name('NewTestUser')
         new_email = data_utils.rand_name() + '@example.com'
         raw_output = self.openstack(
-            'user set ' '--email {email} ' '--name {new_name} ' '{id}'.format(
+            'user set --email {email} --name {new_name} {id}'.format(
                 email=new_email, new_name=new_username, id=user['id']
             )
         )
         self.assertEqual(0, len(raw_output))
         raw_output = self.openstack(
-            'user show ' f'--domain {self.domain_name} ' f'{new_username}'
+            f'user show --domain {self.domain_name} {new_username}'
         )
         updated_user = self.parse_show_as_object(raw_output)
         self.assertEqual(user['id'], updated_user['id'])
@@ -57,7 +57,7 @@ class UserTests(common.IdentityTests):
         project_name = self._create_dummy_project()
         # get original user details
         raw_output = self.openstack(
-            'user show ' f'--domain {self.domain_name} ' f'{username}'
+            f'user show --domain {self.domain_name} {username}'
         )
         user = self.parse_show_as_object(raw_output)
         # update user
@@ -74,12 +74,12 @@ class UserTests(common.IdentityTests):
         self.assertEqual(0, len(raw_output))
         # get updated user details
         raw_output = self.openstack(
-            'user show ' f'--domain {self.domain_name} ' f'{username}'
+            f'user show --domain {self.domain_name} {username}'
         )
         updated_user = self.parse_show_as_object(raw_output)
         # get project details
         raw_output = self.openstack(
-            'project show ' f'--domain {self.domain_name} ' f'{project_name}'
+            f'project show --domain {self.domain_name} {project_name}'
         )
         project = self.parse_show_as_object(raw_output)
         # check updated user details
@@ -89,7 +89,7 @@ class UserTests(common.IdentityTests):
     def test_user_show(self):
         username = self._create_dummy_user()
         raw_output = self.openstack(
-            'user show ' f'--domain {self.domain_name} ' f'{username}'
+            f'user show --domain {self.domain_name} {username}'
         )
         items = self.parse_show(raw_output)
         self.assert_show_fields(items, self.USER_FIELDS)

openstackclient/tests/functional/network/v2/common.py

@@ -33,7 +33,7 @@ class NetworkTests(base.TestCase):
 class NetworkTagTests(NetworkTests):
     """Functional tests with tag operation"""
 
-    base_command = None
+    base_command: str
 
     def test_tag_operation(self):
         # Get project IDs
@@ -56,7 +56,7 @@ class NetworkTagTests(NetworkTests):
             'set', name1, '--tag red --tag green', ['red', 'green']
         )
 
-        list_expected = (
+        list_expected: tuple[tuple[str, list[str]], ...] = (
             (name1, ['red', 'green']),
             (name2, ['red', 'blue']),
             (name3, []),
@@ -93,7 +93,11 @@ class NetworkTagTests(NetworkTests):
             parse_output=True,
         )
 
-    def _create_resource_and_tag_check(self, args, expected):
+    def _create_resource_and_tag_check(
+        self,
+        args: str,
+        expected: list[str],
+    ) -> str:
         name = uuid.uuid4().hex
         cmd_output = self._create_resource_for_tag_test(name, args)
         self.addCleanup(self.openstack, f'{self.base_command} delete {name}')

openstackclient/tests/functional/network/v2/test_address_group.py

@@ -75,6 +75,10 @@ class AddressGroupTests(common.NetworkTests):
         self.assertNotEqual(admin_project_id, demo_project_id)
         self.assertEqual(admin_project_id, auth_project_id)
 
+        # type narrow
+        assert admin_project_id is not None
+        assert demo_project_id is not None
+
         name1 = uuid.uuid4().hex
         cmd_output = self.openstack(
             'address group create ' + name1,

openstackclient/tests/functional/network/v2/test_l3_conntrack_helper.py

@@ -69,8 +69,7 @@ class L3ConntrackHelperTests(common.NetworkTests):
         ct_ids = " ".join([ct['id'] for ct in created_helpers])
 
         raw_output = self.openstack(
-            f'--debug network l3 conntrack helper delete {router_id} '
-            f'{ct_ids}'
+            f'--debug network l3 conntrack helper delete {router_id} {ct_ids}'
         )
         self.assertOutput('', raw_output)
 
@@ -95,9 +94,14 @@ class L3ConntrackHelperTests(common.NetworkTests):
             self.assertIn(ct, expected_helpers)
 
     def test_l3_conntrack_helper_set_and_show(self):
-        helper = {'helper': 'tftp', 'protocol': 'udp', 'port': 69}
+        helper = 'tftp'
+        proto = 'udp'
+        port = 69
         router_id = self._create_router()
-        created_helper = self._create_helpers(router_id, [helper])[0]
+        created_helper = self._create_helpers(
+            router_id,
+            [{'helper': helper, 'protocol': proto, 'port': port}],
+        )[0]
         output = self.openstack(
             'network l3 conntrack helper show {router_id} {ct_id} '
             '-f json'.format(
@@ -106,16 +110,16 @@ class L3ConntrackHelperTests(common.NetworkTests):
             ),
             parse_output=True,
         )
-        self.assertEqual(helper['helper'], output['helper'])
-        self.assertEqual(helper['protocol'], output['protocol'])
-        self.assertEqual(helper['port'], output['port'])
+        self.assertEqual(port, output['port'])
+        self.assertEqual(helper, output['helper'])
+        self.assertEqual(proto, output['protocol'])
 
         raw_output = self.openstack(
             'network l3 conntrack helper set {router_id} {ct_id} '
             '--port {port} '.format(
                 router_id=router_id,
                 ct_id=created_helper['id'],
-                port=helper['port'] + 1,
+                port=port + 1,
             )
         )
         self.assertOutput('', raw_output)
@@ -128,6 +132,6 @@ class L3ConntrackHelperTests(common.NetworkTests):
             ),
             parse_output=True,
         )
-        self.assertEqual(helper['port'] + 1, output['port'])
-        self.assertEqual(helper['helper'], output['helper'])
-        self.assertEqual(helper['protocol'], output['protocol'])
+        self.assertEqual(port + 1, output['port'])
+        self.assertEqual(helper, output['helper'])
+        self.assertEqual(proto, output['protocol'])

openstackclient/tests/functional/network/v2/test_local_ip.py

@@ -77,6 +77,10 @@ class LocalIPTests(common.NetworkTests):
         self.assertNotEqual(admin_project_id, demo_project_id)
         self.assertEqual(admin_project_id, auth_project_id)
 
+        # type narrow
+        assert admin_project_id is not None
+        assert demo_project_id is not None
+
         name1 = uuid.uuid4().hex
         cmd_output = self.openstack(
             'local ip create ' + name1,

openstackclient/tests/functional/network/v2/test_network_meter_rule.py

@@ -22,8 +22,8 @@ from openstackclient.tests.functional.network.v2 import common
 class TestMeterRule(common.NetworkTests):
     """Functional tests for meter rule"""
 
-    METER_ID = None
-    METER_RULE_ID = None
+    METER_ID: str
+    METER_RULE_ID: str
 
     @classmethod
     def setUpClass(cls):

openstackclient/tests/functional/network/v2/test_network_ndp_proxy.py

@@ -31,7 +31,7 @@ class L3NDPProxyTests(common.NetworkTests):
         self.created_ndp_proxies = []
 
         json_output = self.openstack(
-            'address scope create --ip-version 6 ' f'{self.ADDR_SCOPE_NAME}',
+            f'address scope create --ip-version 6 {self.ADDR_SCOPE_NAME}',
             parse_output=True,
         )
         self.assertIsNotNone(json_output['id'])
@@ -88,8 +88,7 @@ class L3NDPProxyTests(common.NetworkTests):
         self.assertIsNotNone(json_output['id'])
         self.INT_SUB_ID = json_output['id']
         json_output = self.openstack(
-            f'port create --network {self.INT_NET_ID} '
-            f'{self.INT_PORT_NAME}',
+            f'port create --network {self.INT_NET_ID} {self.INT_PORT_NAME}',
             parse_output=True,
         )
         self.assertIsNotNone(json_output['id'])

openstackclient/tests/functional/network/v2/test_network_rbac.py

@@ -18,8 +18,8 @@ from openstackclient.tests.functional.network.v2 import common
 class NetworkRBACTests(common.NetworkTests):
     """Functional tests for network rbac"""
 
-    OBJECT_ID = None
-    ID = None
+    OBJECT_ID: str
+    ID: str
     HEADERS = ['ID']
     FIELDS = ['id']
 

openstackclient/tests/functional/network/v2/test_network_trunk.py

@@ -80,7 +80,7 @@ class NetworkTrunkTests(common.NetworkTests):
         self.addCleanup(self.openstack, 'network trunk delete ' + trunk_name)
         self.assertEqual(trunk_name, json_output['name'])
 
-        self.openstack('network trunk set ' '--enable ' + trunk_name)
+        self.openstack('network trunk set --enable ' + trunk_name)
 
         json_output = json.loads(
             self.openstack('network trunk show -f json ' + trunk_name)

openstackclient/tests/functional/network/v2/test_port.py

@@ -12,6 +12,8 @@
 
 import uuid
 
+from tempest.lib import exceptions as tempest_exc
+
 from openstackclient.tests.functional.network.v2 import common
 
 
@@ -162,8 +164,16 @@ class PortTests(common.NetworkTagTests):
         id_list = [p['ID'] for p in json_output]
         self.assertIn(id1, id_list)
         self.assertIn(id2, id_list)
-        # Check an unknown field exists
-        self.assertIn('device_id', json_output[0])
+        # Check an unknown field does not exist
+        self.assertNotIn('device_id', json_output[0])
+
+        # Test list with only unknown fields
+        exc = self.assertRaises(
+            tempest_exc.CommandFailed,
+            self.openstack,
+            'port list -c device_id',
+        )
+        self.assertIn("No recognized column names in ['device_id']", str(exc))
 
     def test_port_set(self):
         """Test create, set, show, delete"""
@@ -209,7 +219,7 @@ class PortTests(common.NetworkTagTests):
     def test_port_admin_set(self):
         """Test create, set (as admin), show, delete"""
         json_output = self.openstack(
-            'port create ' f'--network {self.NETWORK_NAME} {self.NAME}',
+            f'port create --network {self.NETWORK_NAME} {self.NAME}',
             parse_output=True,
         )
         id_ = json_output.get('id')
@@ -257,7 +267,7 @@ class PortTests(common.NetworkTagTests):
         self.assertEqual([sg_id1], json_output.get('security_group_ids'))
 
         raw_output = self.openstack(
-            'port set ' f'--security-group {sg_name2} {name}'
+            f'port set --security-group {sg_name2} {name}'
         )
         self.assertOutput('', raw_output)
 
@@ -296,17 +306,17 @@ class PortTests(common.NetworkTagTests):
         sport2 = uuid.uuid4().hex
         trunk = uuid.uuid4().hex
         json_output = self.openstack(
-            'port create ' f'--network {self.NETWORK_NAME} {pport}',
+            f'port create --network {self.NETWORK_NAME} {pport}',
             parse_output=True,
         )
         pport_id = json_output.get('id')
         json_output = self.openstack(
-            'port create ' f'--network {self.NETWORK_NAME} {sport1}',
+            f'port create --network {self.NETWORK_NAME} {sport1}',
             parse_output=True,
         )
         sport1_id = json_output.get('id')
         json_output = self.openstack(
-            'port create ' f'--network {self.NETWORK_NAME} {sport2}',
+            f'port create --network {self.NETWORK_NAME} {sport2}',
             parse_output=True,
         )
         sport2_id = json_output.get('id')

openstackclient/tests/functional/network/v2/test_router.py

@@ -44,6 +44,44 @@ class RouterTests(common.NetworkTagTests):
         del_output = self.openstack('router delete ' + name1 + ' ' + name2)
         self.assertOutput('', del_output)
 
+    def test_router_create_with_external_gateway(self):
+        network_name = uuid.uuid4().hex
+        subnet_name = uuid.uuid4().hex
+        qos_policy = uuid.uuid4().hex
+        router_name = uuid.uuid4().hex
+
+        cmd_net = self.openstack(
+            f'network create --external {network_name}', parse_output=True
+        )
+        self.addCleanup(self.openstack, f'network delete {network_name}')
+        network_id = cmd_net['id']
+
+        self.openstack(
+            f'subnet create {subnet_name} '
+            f'--network {network_name} --subnet-range 10.0.0.0/24'
+        )
+
+        cmd_qos = self.openstack(
+            f'network qos policy create {qos_policy}', parse_output=True
+        )
+        self.addCleanup(
+            self.openstack, f'network qos policy delete {qos_policy}'
+        )
+        qos_id = cmd_qos['id']
+
+        self.openstack(
+            f'router create --external-gateway {network_name} '
+            f'--qos-policy {qos_policy} {router_name}'
+        )
+        self.addCleanup(self.openstack, f'router delete {router_name}')
+
+        cmd_output = self.openstack(
+            f'router show {router_name}', parse_output=True
+        )
+        gw_info = cmd_output['external_gateway_info']
+        self.assertEqual(network_id, gw_info['network_id'])
+        self.assertEqual(qos_id, gw_info['qos_policy_id'])
+
     def test_router_list(self):
         """Test create, list filter"""
         # Get project IDs
@@ -68,6 +106,10 @@ class RouterTests(common.NetworkTagTests):
         self.assertNotEqual(admin_project_id, demo_project_id)
         self.assertEqual(admin_project_id, auth_project_id)
 
+        # type narrow
+        assert admin_project_id is not None
+        assert demo_project_id is not None
+
         name1 = uuid.uuid4().hex
         name2 = uuid.uuid4().hex
         cmd_output = self.openstack(

openstackclient/tests/functional/network/v2/test_subnet_pool.py

@@ -63,6 +63,10 @@ class SubnetPoolTests(common.NetworkTagTests):
         self.assertNotEqual(admin_project_id, demo_project_id)
         self.assertEqual(admin_project_id, auth_project_id)
 
+        # type narrow
+        assert admin_project_id is not None
+        assert demo_project_id is not None
+
         name1 = uuid.uuid4().hex
         name2 = uuid.uuid4().hex