add testing for main_funcs

Signed-off-by: Zen <[email protected]>

Author: desultory

src/zenlib/util/main_funcs.py

@@ -2,28 +2,47 @@
 Functions to help with the main()
 """
 
-__version__ = '1.1.1'
-__author__ = 'desultory'
+__version__ = "1.2.0"
+__author__ = "desultory"
 
 
-BASE_ARGS = [{'flags': ['-d', '--debug'], 'action': 'store_true', 'help': 'enable debug mode (level 10)'},
-             {'flags': ['-dd', '--trace'], 'action': 'store_true', 'help': 'enable trace debug mode (level 5)'},
-             {'flags': ['-v', '--version'], 'action': 'store_true', 'help': 'print the version and exit'},
-             {'flags': ['--log-file'], 'type': str, 'help': 'set the path to the log file'},
-             {'flags': ['--log-level'], 'type': str, 'help': 'set the log level'},
-             {'flags': ['--log-time'], 'action': 'store_true', 'help': 'enable log timestamps'},
-             {'flags': ['--no-log-color'], 'action': 'store_true', 'help': 'disable log color'}]
+def get_base_args():
+    return [
+        {"flags": ["-d", "--debug"], "action": "store_true", "help": "enable debug mode (level 10)"},
+        {"flags": ["-dd", "--trace"], "action": "store_true", "help": "enable trace debug mode (level 5)"},
+        {"flags": ["-v", "--version"], "action": "store_true", "help": "print the version and exit"},
+        {"flags": ["--log-file"], "type": str, "help": "set the path to the log file"},
+        {"flags": ["--log-level"], "type": str, "help": "set the log level"},
+        {"flags": ["--log-time"], "action": "store_true", "help": "enable log timestamps"},
+        {"flags": ["--no-log-color"], "action": "store_true", "help": "disable log color"},
+    ]
+
+
+def init_logger(name=None):
+    """Initialize the logger with a name"""
+    from logging import getLogger
+
+    name = name or __name__
+    return getLogger(name)
+
+
+def init_argparser(prog=None, description=None):
+    """Initialize an argparser with common options."""
+    from argparse import ArgumentParser
+
+    argparser = ArgumentParser(prog=prog, description=description)
+    return argparser
 
 
 def get_kwargs_from_args(args, logger=None, base_kwargs={}, drop_base=True):
-    """ Get kwargs from argparser args.
-    Drop base doesn't add init_argparser args. """
+    """Get kwargs from argparser args.
+    Drop base doesn't add init_argparser args."""
     kwargs = base_kwargs.copy()
     if logger is not None:
-        kwargs['logger'] = logger
+        kwargs["logger"] = logger
 
     for arg in vars(args):
-        if drop_base and arg in ['debug', 'trace', 'version', 'log_file', 'log_level', 'log_time', 'no_log_color']:
+        if drop_base and arg in ["debug", "trace", "version", "log_file", "log_level", "log_time", "no_log_color"]:
             continue
         value = getattr(args, arg)
 
@@ -34,28 +53,17 @@ def get_kwargs_from_args(args, logger=None, base_kwargs={}, drop_base=True):
     return kwargs
 
 
-def init_logger(name=None):
-    """ Initialize the logger with a name"""
-    from logging import getLogger
-    name = name or __name__
-    return getLogger(name)
-
-
-def init_argparser(prog=None, description=None):
-    """ Initialize an argparser with common options. """
-    from argparse import ArgumentParser
-    argparser = ArgumentParser(prog=prog, description=description)
-    return argparser
-
-
 def process_args(argparser, logger=None):
-    """ Process argparser args, optionally configuring a logger. """
+    """Process argparser args, optionally configuring a logger."""
     from logging import Formatter
+
     from zenlib.logging import ColorLognameFormatter
+
     args = argparser.parse_args()
     if args.version:
         package = argparser.prog
         from importlib.metadata import version
+
         print(f"{package} {version(package)}")
         exit(0)
 
@@ -70,54 +78,61 @@ def process_args(argparser, logger=None):
             log_level = 20
         logger.setLevel(log_level)
 
-        format_str = '%(asctime)s | ' if args.log_time else ''
+        format_str = "%(asctime)s | " if args.log_time else ""
         if log_level < 20:
-            format_str += '%(levelname)s | %(name)-42s | %(message)s'
+            format_str += "%(levelname)s | %(name)-42s | %(message)s"
         else:
-            format_str += '%(levelname)s | %(message)s'
+            format_str += "%(levelname)s | %(message)s"
         formatter = ColorLognameFormatter(format_str) if not args.no_log_color else Formatter(format_str)
 
         # Add the formatter to the first handler, or add a new handler
         for handler in logger.handlers:
             handler.setFormatter(formatter)
             break
         else:
-            from logging import StreamHandler, FileHandler
+            from logging import FileHandler, StreamHandler
+
             handler = StreamHandler() if args.log_file is None else FileHandler(args.log_file)
             handler.setFormatter(formatter)
             logger.addHandler(handler)
 
     return args
 
 
-def dump_args_for_autocomplete(args):
-    """ Dump args for autocomplete """
+def dump_args_for_autocomplete(args, test=False):
+    """Dump args for autocomplete"""
+    out_str = ""
     for arg in args:
-        if arg.get('action') not in ['store_true', 'store_false']:
+        if arg.get("action") not in ["store_true", "store_false"]:
             continue
-        for flag in arg['flags']:
-            print(f"{flag} {arg.get('help')}")
+        for flag in arg["flags"]:
+            out_str += f"{flag} {arg.get('help')}\n"
+    if test:
+        return out_str
+    print(out_str)
     exit(0)
 
 
 def get_args_n_logger(package, description: str, arguments=[], drop_default=False):
-    """ Takes a package name and description
+    """Takes a package name and description
     If arguments are passed, they are added to argparser.
     Returns the parsed args and logger.
     """
-    arguments = BASE_ARGS + arguments
+    arguments = get_base_args() + arguments
     from sys import argv
-    if '--dump_args' in argv:
+
+    if "--dump_args" in argv:
         dump_args_for_autocomplete(arguments)
 
     from argparse import Namespace
+
     argparser = init_argparser(prog=package, description=description)
     logger = init_logger(package)
 
     for arg in arguments:
-        dest = arg.pop('flags')
+        dest = arg.pop("flags")
         if drop_default:
-            arg['default'] = None
+            arg["default"] = None
         argparser.add_argument(*dest, **arg)
 
     args = process_args(argparser, logger=logger)
@@ -129,6 +144,6 @@ def get_args_n_logger(package, description: str, arguments=[], drop_default=Fals
 
 
 def get_kwargs(package, description: str, arguments=[], base_kwargs={}, drop_default=False, drop_base=True):
-    """ Like get_args_n_logger, but only returns kwargs """
+    """Like get_args_n_logger, but only returns kwargs"""
     args, logger = get_args_n_logger(package, description, arguments, drop_default=drop_default)
     return get_kwargs_from_args(args, logger=logger, base_kwargs=base_kwargs, drop_base=drop_base)

tests/test_main_funcs.py

@@ -0,0 +1,81 @@
+from argparse import ArgumentParser, Namespace
+from logging import Logger
+from unittest import TestCase, expectedFailure, main
+
+from zenlib.util import get_args_n_logger, get_kwargs, get_kwargs_from_args, init_argparser, init_logger
+from zenlib.util.main_funcs import dump_args_for_autocomplete, get_base_args
+
+DEFAULT_ARGS = ["debug", "trace", "version", "log_time", "no_log_color"]
+
+
+def get_test_args():
+    return [{"flags": ["arg1"], "action": "store"}, {"flags": ["arg2"], "action": "store"}]
+
+
+class TestMainFuncs(TestCase):
+    def test_init_logger(self):
+        self.assertIsInstance(init_logger(), Logger)
+
+    def test_init_argparser(self):
+        self.assertIsInstance(init_argparser(), ArgumentParser)
+
+    def test_named_init_argparser(self):
+        parser = init_argparser("test", "test description")
+        self.assertEqual(parser.prog, "test")
+        self.assertEqual(parser.description, "test description")
+
+    def test_get_args_n_logger(self):
+        args, logger = get_args_n_logger("test", "test description", get_test_args())
+        self.assertIsInstance(args, Namespace)
+        self.assertIsInstance(logger, Logger)
+
+        self.assertEqual(args.arg1, "discover")
+        self.assertEqual(args.arg2, "tests")
+
+    def test_get_args_n_logger_no_default(self):
+        args, logger = get_args_n_logger("test", "test description", get_test_args(), drop_default=True)
+        self.assertIsInstance(args, Namespace)
+        self.assertIsInstance(logger, Logger)
+
+        for arg in DEFAULT_ARGS:
+            self.assertFalse(hasattr(args, arg))
+
+    def test_get_kwargs_from_args(self):
+        args, logger = get_args_n_logger("test", "test description", get_test_args())
+        kwargs = get_kwargs_from_args(args, logger)
+        self.assertIsInstance(kwargs, dict)
+        self.assertEqual(kwargs["arg1"], "discover")
+        self.assertEqual(kwargs["arg2"], "tests")
+        self.assertEqual(kwargs["logger"], logger)
+
+    def test_not_drop_base(self):
+        args, logger = get_args_n_logger("test", "test description", get_test_args())
+        kwargs = get_kwargs_from_args(args, logger, drop_base=False)
+        self.assertIsInstance(kwargs, dict)
+        self.assertEqual(kwargs["arg1"], "discover")
+        self.assertEqual(kwargs["arg2"], "tests")
+        self.assertEqual(kwargs["logger"], logger)
+        for arg in DEFAULT_ARGS:
+            self.assertTrue(arg in kwargs)
+
+    def test_get_kwargs(self):
+        kwargs = get_kwargs("test", "test description", get_test_args())
+        self.assertIsInstance(kwargs, dict)
+        self.assertEqual(kwargs["arg1"], "discover")
+        self.assertEqual(kwargs["arg2"], "tests")
+        self.assertTrue("logger" in kwargs)
+
+    @expectedFailure  # This exits so should fail
+    def test_dump_args_for_autocomplete(self):
+        dump_args_for_autocomplete(get_test_args())
+
+    def test_dump_args_for_autocomplete_no_exit(self):
+        self.assertEqual(dump_args_for_autocomplete(get_test_args(), test=True), "")
+        self.assertEqual(
+            dump_args_for_autocomplete(get_base_args(), test=True),
+            "-d enable debug mode (level 10)\n--debug enable debug mode (level 10)\n-dd enable trace debug mode (level 5)\n--trace enable trace debug mode (level 5)\n-v print the version and exit\n--version print the version and exit\n--log-time enable log timestamps\n--no-log-color disable log color\n",
+        )
+
+
+if __name__ == "__main__":
+    main()