typing: Add hints to base functional test

We have no intention of typing the entire test suite, but this will
catch some obvious boo-boos.

Change-Id: I923b45c713862e1bd07d5cbd2543e6bcba65add8
Signed-off-by: Stephen Finucane <stephenfin@redhat.com>

Author: stephenfin

openstackclient/tests/functional/base.py

@@ -10,11 +10,13 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from collections.abc import Iterable, Mapping, Sequence
 import json
 import logging
 import os
 import shlex
 import subprocess
+from typing import Any, Literal, cast, overload
 
 from tempest.lib.cli import output_parser
 from tempest.lib import exceptions
@@ -24,7 +26,7 @@
 LOG = logging.getLogger(__name__)
 
 
-def execute(cmd, *, fail_ok=False):
+def execute(cmd: str, *, fail_ok: bool = False) -> str:
     """Executes specified command for the given action."""
     LOG.debug('Executing: %s', cmd)
     cmdlist = shlex.split(cmd)
@@ -53,15 +55,37 @@ def execute(cmd, *, fail_ok=False):
 
 
 class TestCase(testtools.TestCase):
+    @overload
     @classmethod
     def openstack(
         cls,
-        cmd,
+        cmd: str,
         *,
-        cloud=ADMIN_CLOUD,
-        fail_ok=False,
-        parse_output=False,
-    ):
+        cloud: str | None = ADMIN_CLOUD,
+        fail_ok: bool = False,
+        parse_output: Literal[False] = False,
+    ) -> str: ...
+
+    @overload
+    @classmethod
+    def openstack(
+        cls,
+        cmd: str,
+        *,
+        cloud: str | None = ADMIN_CLOUD,
+        fail_ok: bool = False,
+        parse_output: Literal[True] = ...,
+    ) -> Any: ...
+
+    @classmethod
+    def openstack(
+        cls,
+        cmd: str,
+        *,
+        cloud: str | None = ADMIN_CLOUD,
+        fail_ok: bool = False,
+        parse_output: bool = False,
+    ) -> str | Any:
         """Executes openstackclient command for the given action
 
         :param cmd: A string representation of the command to execute.
@@ -106,7 +130,9 @@ def openstack(
             return output
 
     @classmethod
-    def is_service_enabled(cls, service, version=None):
+    def is_service_enabled(
+        cls, service: str, version: str | None = None
+    ) -> bool:
         """Ask client cloud if service is available
 
         :param service: The service name or type. This should be either an
@@ -126,7 +152,9 @@ def is_service_enabled(cls, service, version=None):
         return bool(ret)
 
     @classmethod
-    def is_extension_enabled(cls, alias, *, service='network'):
+    def is_extension_enabled(
+        cls, alias: str, *, service: str = 'network'
+    ) -> bool:
         """Ask client cloud if extension is enabled"""
         extensions = cls.openstack(
             f'extension list --{service}',
@@ -135,38 +163,44 @@ def is_extension_enabled(cls, alias, *, service='network'):
         return alias in [x['Alias'] for x in extensions]
 
     @classmethod
-    def get_openstack_configuration_value(cls, configuration):
+    def get_openstack_configuration_value(cls, configuration: str) -> str:
         opts = cls.get_opts([configuration])
         return cls.openstack('configuration show ' + opts)
 
     @classmethod
-    def get_opts(cls, fields, output_format='value'):
+    def get_opts(cls, fields: list[str], output_format: str = 'value') -> str:
         return ' -f {} {}'.format(
             output_format, ' '.join(['-c ' + it for it in fields])
         )
 
     @classmethod
-    def assertOutput(cls, expected, actual):
+    def assertOutput(cls, expected: str, actual: str) -> None:
         if expected != actual:
             raise Exception(expected + ' != ' + actual)
 
     @classmethod
-    def assertInOutput(cls, expected, actual):
+    def assertInOutput(cls, expected: str, actual: str) -> None:
         if expected not in actual:
             raise Exception(expected + ' not in ' + actual)
 
     @classmethod
-    def assertsOutputNotNone(cls, observed):
+    def assertsOutputNotNone(cls, observed: Any) -> None:
         if observed is None:
             raise Exception('No output observed')
 
-    def assert_table_structure(self, items, field_names):
+    def assert_table_structure(
+        self, items: Iterable[Mapping[str, Any]], field_names: Sequence[str]
+    ) -> None:
         """Verify that all items have keys listed in field_names."""
         for item in items:
             for field in field_names:
                 self.assertIn(field, item)
 
-    def assert_show_fields(self, show_output, field_names):
+    def assert_show_fields(
+        self,
+        show_output: Iterable[Mapping[str, Any]],
+        field_names: Sequence[str],
+    ) -> None:
         """Verify that all items have keys listed in field_names."""
 
         # field_names = ['name', 'description']
@@ -186,17 +220,18 @@ def parse_show_as_object(self, raw_output):
             o.update(item)
         return o
 
-    def parse_show(self, raw_output):
+    def parse_show(self, raw_output: str) -> list[dict[str, Any]]:
         """Return list of dicts with item values parsed from cli output."""
 
         items = []
         table_ = output_parser.table(raw_output)
         for row in table_['values']:
             item = {}
-            item[row[0]] = row[1]
+            item[str(row[0])] = row[1]
             items.append(item)
         return items
 
-    def parse_listing(self, raw_output):
+    def parse_listing(self, raw_output: str) -> list[dict[str, Any]]:
         """Return list of dicts with basic item parsed from cli output."""
-        return output_parser.listing(raw_output)
+        # need to add hints to tempest
+        return cast(list[dict[str, Any]], output_parser.listing(raw_output))

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

@@ -12,6 +12,7 @@
 #
 
 import time
+from typing import cast
 import uuid
 
 from tempest.lib import exceptions
@@ -35,37 +36,36 @@ def setUp(self):
 
     @classmethod
     def get_flavor(cls) -> str:
+        valid_flavors = ['m1.tiny', 'cirros256']
         # NOTE(rtheis): Get cirros256 or m1.tiny flavors since functional
         #               tests may create other flavors.
         flavors = cls.openstack("flavor list", parse_output=True)
-        server_flavor = None
         for flavor in flavors:
             if flavor['Name'] in ['m1.tiny', 'cirros256']:
-                server_flavor = flavor['Name']
-                break
-
-        assert server_flavor is not None
+                return cast(str, flavor['Name'])
 
-        return server_flavor
+        raise Exception(
+            f'Failed to find a suitable flavor. Required one of: '
+            f'{", ".join(valid_flavors)}'
+        )
 
     @classmethod
     def get_image(cls) -> str:
         # NOTE(rtheis): Get first Cirros image since functional tests may
         #               create other images.  Image may be named '-uec' or
         #               '-disk'.
         images = cls.openstack("image list", parse_output=True)
-        server_image = None
         for image in images:
             if image['Name'].startswith('cirros-') and (
                 image['Name'].endswith('-uec')
                 or image['Name'].endswith('-disk')
             ):
-                server_image = image['Name']
-                break
+                return cast(str, image['Name'])
 
-        assert server_image is not None
-
-        return server_image
+        raise Exception(
+            'Failed to find a suitable image. Required one matching one of '
+            'the following patterns: cirros-*-uec, cirros-*-disk'
+        )
 
     @classmethod
     def get_network(cls) -> str:
@@ -78,7 +78,8 @@ def get_network(cls) -> str:
             )
         except exceptions.CommandFailed:
             return ''
-        return '--nic net-id=' + cmd_output['id']
+
+        return '='.join(('--nic net-id', cmd_output['id']))
 
     def server_create(self, name=None, cleanup=True):
         """Create server, with cleanup"""