Add --version and --total-checks

Author: takishida

aci-preupgrade-validation-script.py

@@ -5217,15 +5217,12 @@ def parse_args(args):
     parser.add_argument("-t", "--tversion", action="store", type=str, help="Upgrade Target Version. Ex. 6.2(1a)")
     parser.add_argument("-c", "--cversion", action="store", type=str, help="Override Current Version. Ex. 6.1(1a)")
     parser.add_argument("-d", "--debug-function", action="store", type=str, help="Name of a single function to debug. Ex. 'apic_version_md5_check'")
-    parser.add_argument("--api-only", action="store_true", help="For built-in PUV. API Checks only. Checks using SSH are skipped.")
-    parser.add_argument("--no-cleanup", action="store_true", help="Skip all file cleanup after script execution.")
+    parser.add_argument("-a", "--api-only", action="store_true", help="For built-in PUV. API Checks only. Checks using SSH are skipped.")
+    parser.add_argument("-n", "--no-cleanup", action="store_true", help="Skip all file cleanup after script execution.")
+    parser.add_argument("-v", "--version", action="store_true", help="Show the script version.")
+    parser.add_argument("--total-checks", action="store_true", help="Show the total number of checks.")
     parsed_args = parser.parse_args(args)
-    api_only = parsed_args.api_only
-    tversion = parsed_args.tversion
-    cversion = parsed_args.cversion
-    debug_function = parsed_args.debug_function
-    no_cleanup = parsed_args.no_cleanup
-    return api_only, tversion, cversion, debug_function, no_cleanup
+    return parsed_args
 
 
 def prepare(api_only, arg_tversion, arg_cversion, total_checks):
@@ -5264,7 +5261,7 @@ def prepare(api_only, arg_tversion, arg_cversion, total_checks):
     return inputs
 
 
-def get_checks(api_only, debug_func):
+def get_checks(api_only, debug_function):
     api_checks = [
         # General Checks
         target_version_compatibility_check,
@@ -5368,8 +5365,8 @@ def get_checks(api_only, debug_func):
         observer_db_size_check,
 
     ]
-    if debug_func:
-        return [check for check in api_checks + conn_checks if check.__name__ == debug_func]
+    if debug_function:
+        return [check for check in api_checks + conn_checks if check.__name__ == debug_function]
     if api_only:
         return api_checks
     return conn_checks + api_checks
@@ -5415,12 +5412,18 @@ def wrapup(no_cleanup):
         shutil.rmtree(DIR)
 
 
-def main(args=None):
-    api_only, arg_tversion, arg_cversion, debug_func, no_cleanup = parse_args(args)
-    checks = get_checks(api_only, debug_func)
-    inputs = prepare(api_only, arg_tversion, arg_cversion, len(checks))
+def main(_args=None):
+    args = parse_args(_args)
+    if args.version:
+        prints(SCRIPT_VERSION)
+        return
+    checks = get_checks(args.api_only, args.debug_function)
+    if args.total_checks:
+        prints("Total Number of Checks: {}".format(len(checks)))
+        return
+    inputs = prepare(args.api_only, args.tversion, args.cversion, len(checks))
     run_checks(checks, inputs)
-    wrapup(no_cleanup)
+    wrapup(args.no_cleanup)
 
 
 if __name__ == "__main__":

tests/test_main.py

@@ -0,0 +1,23 @@
+import pytest
+import importlib
+import sys
+
+script = importlib.import_module("aci-preupgrade-validation-script")
+AciVersion = script.AciVersion
+
+
+def test_args_version(capsys):
+    script.main(["--version"])
+    captured = capsys.readouterr()
+    print(captured.out)
+    assert "{}\n".format(script.SCRIPT_VERSION) == captured.out
+
+
+@pytest.mark.parametrize("api_only", [False, True])
+def test_args_total_checks(capsys, api_only):
+    args = ["--total-checks", "--api-only"] if api_only else ["--total-checks"]
+    checks = script.get_checks(api_only=api_only, debug_function=None)
+    script.main(args)
+    captured = capsys.readouterr()
+    print(captured.out)
+    assert "Total Number of Checks: {}\n".format(len(checks)) == captured.out

tests/test_parse_args.py

@@ -14,24 +14,27 @@ def test_no_args():
     # To simulate the script being run without any command-line arguments,
     # we set `sys.argv[1:]` to an empty list when `args` is `None`.
     sys.argv[1:] = []
-    api_only, tversion, cversion, debug_function, no_cleanup = script.parse_args(args=None)
-    assert api_only is False
-    assert tversion is None
-    assert cversion is None
-    assert debug_function is None
-    assert no_cleanup is False
+    args = script.parse_args(args=None)
+    assert args.api_only is False
+    assert args.tversion is None
+    assert args.cversion is None
+    assert args.debug_function is None
+    assert args.no_cleanup is False
+    assert args.version is False
+    assert args.total_checks is False
 
 
 @pytest.mark.parametrize(
     "args, expected_result",
     [
         ([], False),
+        (["-a"], True),
         (["--api-only"], True),
     ],
 )
 def test_api_only(args, expected_result):
-    api_only, tversion, cversion, debug_function, no_cleanup = script.parse_args(args)
-    assert api_only == expected_result
+    args = script.parse_args(args)
+    assert args.api_only == expected_result
 
 
 @pytest.mark.parametrize(
@@ -43,13 +46,14 @@ def test_api_only(args, expected_result):
         (["-t", "n9000-16.2(1a).bin"], "n9000-16.2(1a).bin"),
         (["-t", "aci-apic-dk9.6.2.1a.bin"], "aci-apic-dk9.6.2.1a.bin"),
         (["-t", "invalid_version"], "invalid_version"),
+        (["--tversion", "6.2(1a)"], "6.2(1a)"),
     ],
 )
 def test_tversion(args, expected_result):
-    api_only, tversion, cversion, debug_function, no_cleanup = script.parse_args(args)
-    if tversion is not None:
-        assert isinstance(tversion, str)
-    assert str(tversion) == str(expected_result)
+    args = script.parse_args(args)
+    if args.tversion is not None:
+        assert isinstance(args.tversion, str)
+    assert str(args.tversion) == str(expected_result)
 
 
 @pytest.mark.parametrize(
@@ -61,13 +65,14 @@ def test_tversion(args, expected_result):
         (["-c", "n9000-16.2(1a).bin"], "n9000-16.2(1a).bin"),
         (["-c", "aci-apic-dk9.6.2.1a.bin"], "aci-apic-dk9.6.2.1a.bin"),
         (["-c", "invalid_version"], "invalid_version"),
+        (["--cversion", "6.2(1a)"], "6.2(1a)"),
     ],
 )
 def test_cversion(args, expected_result):
-    api_only, tversion, cversion, debug_function, no_cleanup = script.parse_args(args)
-    if cversion is not None:
-        assert isinstance(cversion, str)
-    assert str(cversion) == str(expected_result)
+    args = script.parse_args(args)
+    if args.cversion is not None:
+        assert isinstance(args.cversion, str)
+    assert str(args.cversion) == str(expected_result)
 
 
 @pytest.mark.parametrize(
@@ -76,10 +81,49 @@ def test_cversion(args, expected_result):
         ([], None),
         (["-d", "pbr_high_scale_check"], "pbr_high_scale_check"),
         (["-d", "made_up_func"], "made_up_func"),
+        (["--debug-func", "pbr_high_scale_check"], "pbr_high_scale_check"),
     ],
 )
 def test_debug_func(args, expected_result):
-    api_only, tversion, cversion, debug_function, no_cleanup = script.parse_args(args)
-    if debug_function is not None:
-        assert isinstance(debug_function, str)
-    assert str(debug_function) == str(expected_result)
+    args = script.parse_args(args)
+    if args.debug_function is not None:
+        assert isinstance(args.debug_function, str)
+    assert str(args.debug_function) == str(expected_result)
+
+
+@pytest.mark.parametrize(
+    "args, expected_result",
+    [
+        ([], False),
+        (["-n"], True),
+        (["--no-cleanup"], True),
+    ],
+)
+def test_no_cleanup(args, expected_result):
+    args = script.parse_args(args)
+    assert args.no_cleanup == expected_result
+
+
+@pytest.mark.parametrize(
+    "args, expected_result",
+    [
+        ([], False),
+        (["-v"], True),
+        (["--version"], True),
+    ],
+)
+def test_version(args, expected_result):
+    args = script.parse_args(args)
+    assert args.version == expected_result
+
+
+@pytest.mark.parametrize(
+    "args, expected_result",
+    [
+        ([], False),
+        (["--total-checks"], True),
+    ],
+)
+def test_total_checks(args, expected_result):
+    args = script.parse_args(args)
+    assert args.total_checks == expected_result