[#28] Add unit test runner

Author: alanking

irods_testing_environment/context.py

@@ -130,6 +130,12 @@ def python():
     return 'python3'
 
 
+def unit_tests():
+    """Return the path to the directory containing packaged unit tests."""
+    import os
+    return os.path.join(irods_home(), 'unit_tests')
+
+
 def sanitize(repo_or_tag):
     """Sanitize the input from special characters rejected by docker-compose.
 

irods_testing_environment/test_runner.py

@@ -143,3 +143,19 @@ def execute_test(self, test, options=None):
                                             user='irods',
                                             workdir=context.irods_home(),
                                             stream_output=True)
+
+
+class test_runner_irods_unit_tests(test_runner):
+    def __init__(self, executing_container, tests=None):
+        super(test_runner_irods_unit_tests, self).__init__(executing_container, tests)
+
+
+    def execute_test(self, test):
+        """Execute `test` and return the command run and the return code."""
+        import os
+        cmd = [os.path.join(context.unit_tests(), test)]
+        return cmd, execute.execute_command(self.executor,
+                                            ' '.join(cmd),
+                                            user='irods',
+                                            workdir=context.irods_home(),
+                                            stream_output=True)

irods_testing_environment/test_utils.py

@@ -47,6 +47,28 @@ def make_output_directory(dirname, basename):
 
     return directory
 
+def run_unit_tests(containers, test_list=None, fail_fast=True):
+    """Run a set of tests from the python test suite for iRODS.
+
+    Arguments:
+    containers -- target containers on which the tests will run
+    test_list -- a list of strings of the tests to be run
+    options -- list of strings representing script options to pass to the run_tests.py script
+    fail_fast -- if True, stop running after first failure; else, runs all tests
+    """
+    tests = test_list or get_unit_test_list(containers[0])
+
+    tm = test_manager.test_manager(containers, tests, test_type='irods_unit_tests')
+
+    try:
+        tm.run(fail_fast)
+
+    finally:
+        logging.error(tm.result_string())
+
+    return tm.return_code()
+
+
 def run_specific_tests(containers, test_list=None, options=None, fail_fast=True):
     """Run a set of tests from the python test suite for iRODS.
 
@@ -68,6 +90,7 @@ def run_specific_tests(containers, test_list=None, options=None, fail_fast=True)
 
     return tm.return_code()
 
+
 def run_python_test_suite(container, options=None):
     """Run the entire python test suite for iRODS.
 
@@ -148,6 +171,20 @@ def run_test_hook_file_in_container(container, path_to_test_hook, options=None):
     return ec
 
 
+def get_unit_test_list(container):
+    """Return list of unit tests extracted from unit_tests_list.json file in `container`.
+
+    Arguments:
+    container -- target container from which test list will be extracted
+    """
+    from . import json_utils
+    return json_utils.get_json_from_file(container,
+                                         os.path.join(
+                                             context.unit_tests(),
+                                             'unit_tests_list.json')
+                                         )
+
+
 def get_test_list(container):
     """Return list of tests extracted from core_tests_list.json file in `container`.
 

run_unit_tests.py

@@ -0,0 +1,104 @@
+# grown-up modules
+import compose.cli.command
+import docker
+import logging
+import os
+
+# local modules
+from irods_testing_environment import archive
+from irods_testing_environment import context
+from irods_testing_environment import irods_config
+from irods_testing_environment import services
+from irods_testing_environment import test_utils
+
+if __name__ == "__main__":
+    import argparse
+    import textwrap
+    import time
+
+    import cli
+    from irods_testing_environment import logs
+
+    parser = argparse.ArgumentParser(description='Run iRODS tests in a consistent environment.')
+
+    cli.add_common_args(parser)
+    cli.add_compose_args(parser)
+    cli.add_database_config_args(parser)
+    cli.add_irods_package_args(parser)
+    cli.add_irods_test_args(parser)
+
+    args = parser.parse_args()
+
+    if args.package_directory and args.package_version:
+        print('--package-directory and --package-version are incompatible')
+        exit(1)
+
+    project_directory = os.path.abspath(args.project_directory or os.getcwd())
+
+    ctx = context.context(docker.from_env(),
+                          compose.cli.command.get_project(
+                              project_dir=project_directory,
+                              project_name=args.project_name))
+
+    if args.output_directory:
+        dirname = args.output_directory
+    else:
+        import tempfile
+        dirname = tempfile.mkdtemp(prefix=ctx.compose_project.name)
+
+    job_name = test_utils.job_name(ctx.compose_project.name, args.job_name)
+
+    output_directory = test_utils.make_output_directory(dirname, job_name)
+
+    logs.configure(args.verbosity, os.path.join(output_directory, 'script_output.log'))
+
+    rc = 0
+    last_command_to_fail = None
+
+    try:
+        if args.do_setup:
+            # Bring up the services
+            logging.debug('bringing up project [{}]'.format(ctx.compose_project.name))
+            consumer_count = 0
+            services.create_topologies(ctx,
+                                       zone_count=args.executor_count,
+                                       externals_directory=args.irods_externals_package_directory,
+                                       package_directory=args.package_directory,
+                                       package_version=args.package_version,
+                                       odbc_driver=args.odbc_driver,
+                                       consumer_count=consumer_count)
+
+            # Configure the containers for running iRODS automated tests
+            logging.info('configuring iRODS containers for testing')
+            irods_config.configure_irods_testing(ctx.docker_client, ctx.compose_project)
+
+        # Get the container on which the command is to be executed
+        containers = [
+            ctx.docker_client.containers.get(
+                context.container_name(ctx.compose_project.name,
+                                       context.irods_catalog_provider_service(),
+                                       service_instance=i + 1)
+                )
+            for i in range(args.executor_count)
+        ]
+
+        start_time = time.time()
+
+        rc = test_utils.run_unit_tests(containers, args.tests, args.fail_fast)
+
+        end_time = time.time()
+
+        logging.error('tests completed; time [{}] seconds, success [{}]'.format(end_time - start_time, rc is 0))
+
+    except Exception as e:
+        logging.critical(e)
+
+        raise
+
+    finally:
+        logging.warning('collecting logs [{}]'.format(output_directory))
+        logs.collect_logs(ctx.docker_client, ctx.irods_containers(), output_directory)
+
+        ctx.compose_project.down(include_volumes=True, remove_image_type=False)
+
+    exit(rc)