kunit: tool: factor exec + parse steps into a function

Currently this code is copy-pasted between the normal "run" subcommand
and the "exec" subcommand.

Given we don't have any interest in just executing the tests without
giving the user any indication what happened (i.e. parsing the output),
make a function that does both this things and can be reused.

This will be useful when we allow more complicated ways of running
tests, e.g. invoking the kernel multiple times instead of just once,
etc.

We remove input_data from the ParseRequest so the callers don't have to
pass in a dummy value for this field. Named tuples are also immutable,
so if they did pass in a dummy, exec_tests() would need to make a copy
to call parse_tests().

Removing it also makes KunitParseRequest match the other *Request types,
as they only contain user arguments/flags, not data.

Signed-off-by: Daniel Latypov <dlatypov@google.com>
Reviewed-by: David Gow <davidgow@google.com>
Acked-by: Brendan Higgins <brendanhiggins@google.com>
Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>

diff --git a/tools/testing/kunit/kunit.py b/tools/testing/kunit/kunit.py
index 62fc5a999d545442ec43c5b52108c523144c096d..116ce7a8a18fc2a62db5b9ca00536989fd48e756 100755 (executable)
--- a/tools/testing/kunit/kunit.py
+++ b/tools/testing/kunit/kunit.py
@@ -33,7 +33,7 @@ KunitExecRequest = namedtuple('KunitExecRequest',
                               ['timeout', 'build_dir', 'alltests',
                                'filter_glob', 'kernel_args'])
 KunitParseRequest = namedtuple('KunitParseRequest',
-                              ['raw_output', 'input_data', 'build_dir', 'json'])
+                              ['raw_output', 'build_dir', 'json'])
 KunitRequest = namedtuple('KunitRequest', ['raw_output','timeout', 'jobs',
                                           'build_dir', 'alltests', 'filter_glob',
                                           'kernel_args', 'json', 'make_options'])
@@ -90,23 +90,25 @@ def build_tests(linux: kunit_kernel.LinuxSourceTree,
                           'built kernel successfully',
                           build_end - build_start)
 
-def exec_tests(linux: kunit_kernel.LinuxSourceTree,
-              request: KunitExecRequest) -> KunitResult:
+def exec_tests(linux: kunit_kernel.LinuxSourceTree, request: KunitExecRequest,
+              parse_request: KunitParseRequest) -> KunitResult:
        kunit_parser.print_with_timestamp('Starting KUnit Kernel ...')
        test_start = time.time()
-       result = linux.run_kernel(
+       run_result = linux.run_kernel(
                args=request.kernel_args,
                timeout=None if request.alltests else request.timeout,
-                filter_glob=request.filter_glob,
+               filter_glob=request.filter_glob,
                build_dir=request.build_dir)
 
        test_end = time.time()
+       exec_time = test_end - test_start
 
-       return KunitResult(KunitStatus.SUCCESS,
-                          result,
-                          test_end - test_start)
+       # Named tuples are immutable, so we rebuild them here manually
+       result = parse_tests(parse_request, run_result)
+
+       return KunitResult(status=result.status, result=result.result, elapsed_time=exec_time)
 
-def parse_tests(request: KunitParseRequest) -> KunitResult:
+def parse_tests(request: KunitParseRequest, input_data: Iterable[str]) -> KunitResult:
        parse_start = time.time()
 
        test_result = kunit_parser.TestResult(kunit_parser.TestStatus.SUCCESS,
@@ -114,7 +116,7 @@ def parse_tests(request: KunitParseRequest) -> KunitResult:
                                              'Tests not Parsed.')
 
        if request.raw_output:
-               output: Iterable[str] = request.input_data
+               output: Iterable[str] = input_data
                if request.raw_output == 'all':
                        pass
                elif request.raw_output == 'kunit':
@@ -125,7 +127,7 @@ def parse_tests(request: KunitParseRequest) -> KunitResult:
                        print(line.rstrip())
 
        else:
-               test_result = kunit_parser.parse_run_tests(request.input_data)
+               test_result = kunit_parser.parse_run_tests(input_data)
        parse_end = time.time()
 
        if request.json:
@@ -164,15 +166,11 @@ def run_tests(linux: kunit_kernel.LinuxSourceTree,
        exec_request = KunitExecRequest(request.timeout, request.build_dir,
                                 request.alltests, request.filter_glob,
                                 request.kernel_args)
-       exec_result = exec_tests(linux, exec_request)
-       if exec_result.status != KunitStatus.SUCCESS:
-               return exec_result
-
        parse_request = KunitParseRequest(request.raw_output,
-                                         exec_result.result,
                                          request.build_dir,
                                          request.json)
-       parse_result = parse_tests(parse_request)
+
+       exec_result = exec_tests(linux, exec_request, parse_request)
 
        run_end = time.time()
 
@@ -183,7 +181,7 @@ def run_tests(linux: kunit_kernel.LinuxSourceTree,
                                config_result.elapsed_time,
                                build_result.elapsed_time,
                                exec_result.elapsed_time))
-       return parse_result
+       return exec_result
 
 # Problem:
 # $ kunit.py run --json
@@ -400,15 +398,12 @@ def main(argv, linux=None):
                                                cli_args.alltests,
                                                cli_args.filter_glob,
                                                cli_args.kernel_args)
-               exec_result = exec_tests(linux, exec_request)
                parse_request = KunitParseRequest(cli_args.raw_output,
-                                                 exec_result.result,
                                                  cli_args.build_dir,
                                                  cli_args.json)
-               result = parse_tests(parse_request)
+               result = exec_tests(linux, exec_request, parse_request)
                kunit_parser.print_with_timestamp((
-                       'Elapsed time: %.3fs\n') % (
-                               exec_result.elapsed_time))
+                       'Elapsed time: %.3fs\n') % (result.elapsed_time))
                if result.status != KunitStatus.SUCCESS:
                        sys.exit(1)
        elif cli_args.subcommand == 'parse':
@@ -418,10 +413,9 @@ def main(argv, linux=None):
                        with open(cli_args.file, 'r') as f:
                                kunit_output = f.read().splitlines()
                request = KunitParseRequest(cli_args.raw_output,
-                                           kunit_output,
                                            None,
                                            cli_args.json)
-               result = parse_tests(request)
+               result = parse_tests(request, kunit_output)
                if result.status != KunitStatus.SUCCESS:
                        sys.exit(1)
        else: