more tests for coverage

Author: bckohan

django_typer/__init__.py

@@ -798,7 +798,6 @@ class Command(
                     name=kwargs.pop("name", None) or cmd_module.__name__.split(".")[-1],
                     **kwargs,
                     typer_app=args[0] if args else None,
-                    inherit_extensions=True,
                 ):
                     pass
 
@@ -1830,9 +1829,6 @@ class TyperCommandMeta(type):
         in the traceback configuration setting (off by default). This allows tracebacks
         to be configured by the user on a per deployment basis in the settings file. We
         therefore do not advise hardcoding this value.
-    :param inherit_extensions: whether to inherit extensions from the parent class, that
-        is any commands or groups that were defined on the parent class after its
-        definition.
     """
 
     style: ColorStyle
@@ -1878,7 +1874,6 @@ def __new__(
             True
         ),
         pretty_exceptions_short: t.Union[DefaultPlaceholder, bool] = Default(True),
-        inherit_extensions: bool = False,
         **kwargs,
     ):
         """
@@ -1949,21 +1944,6 @@ def command_bases() -> t.Generator[t.Type[TyperCommand], None, None]:
                 **kwargs,
             )
 
-            if inherit_extensions:
-                for base in command_bases():
-                    typer_app.registered_callback = (
-                        typer_app.registered_callback
-                        or base.typer_app.registered_callback
-                    )
-                    typer_app.registered_commands = [
-                        *copy(base.typer_app.registered_commands),
-                        *typer_app.registered_commands,
-                    ]
-                    typer_app.registered_groups = [
-                        *deepcopy(base.typer_app.registered_groups),
-                        *typer_app.registered_groups,
-                    ]
-
             # move up here
             def get_ctor(attr: t.Any) -> t.Optional[t.Callable[..., t.Any]]:
                 return getattr(attr, _CACHE_KEY, None)
@@ -2553,6 +2533,8 @@ def init(self, ...):
             )
 
         def make_initializer(func: t.Callable[P, R]) -> t.Callable[P, R]:
+            # we might have to override a method defined in the base class
+            setattr(cmd, func.__name__, func)
             cmd.typer_app.callback(
                 name=name,
                 cls=type("_Initializer", (cls,), {"django_command": cmd}),
@@ -2651,6 +2633,8 @@ def new_command(self, ...):
             )
 
         def make_command(func: t.Callable[P, R]) -> t.Callable[P, R]:
+            # we might have to override a method defined in the base class
+            setattr(cmd, func.__name__, func)
             cmd.typer_app.command(
                 name=name,
                 cls=type("_Command", (cls,), {"django_command": cmd}),

django_typer/management/commands/shellcompletion.py

@@ -589,7 +589,7 @@ def get_completion() -> None:
                                 cmd_str=cmd_str
                             )
                         ) from err
-                    raise  # otherwise nowhere to go - just error out
+                    return  # otherwise nowhere to go - just empty out
 
                 if isinstance(cmd, TyperCommand):  # type: ignore[unreachable]
                     # this will exit out so no return is needed here

django_typer/tests/apps/adapter0/management/adapters/method_override.py

@@ -0,0 +1,30 @@
+from django_typer.tests.apps.test_app.management.commands.method_override import (
+    Command as MethodOverride,
+)
+
+
+@MethodOverride.initialize(invoke_without_command=True)
+def init(self):
+    """
+    Command1
+    """
+    assert self.__class__ is MethodOverride
+    return f"adapter0::init()"
+
+
+@MethodOverride.command()
+def cmd1(self):
+    """
+    Command1
+    """
+    assert self.__class__ is MethodOverride
+    return f"adapter0::cmd1()"
+
+
+@MethodOverride.command()
+def cmd2(self):
+    """
+    Command1
+    """
+    assert self.__class__ is MethodOverride
+    return f"adapter0::cmd2()"

django_typer/tests/apps/test_app/management/commands/method_override.py

@@ -0,0 +1,24 @@
+from django_typer import TyperCommand, initialize, command
+
+
+class Command(TyperCommand):
+    @initialize(invoke_without_command=True)
+    def init(self):
+        assert self.__class__ is Command
+        return f"test_app::init()"
+
+    @command()
+    def cmd1(self):
+        """
+        Command1
+        """
+        assert self.__class__ is Command
+        return f"test_app::cmd1()"
+
+    @TyperCommand.command()  # overly verbose but tolerated
+    def cmd2(self):
+        """
+        Command2
+        """
+        assert self.__class__ is Command
+        return f"test_app::cmd2()"

django_typer/tests/apps/test_app2/management/commands/interference_ext_init.py

@@ -0,0 +1,10 @@
+from django_typer import initialize, command, group
+from .interference_ext import Command as InterferenceExt
+
+
+class Command(InterferenceExt):
+    help = "Inherited and extend interference - test classmethod initialize()"
+
+    @InterferenceExt.initialize(invoke_without_command=True)
+    def init(self, arg: int = 5):
+        return f"test_app2::interference_ext_init::init({arg})"

django_typer/tests/test_interface.py

@@ -152,7 +152,6 @@ def test_typercommandmeta_interface_matches(self):
         from django_typer import TyperCommandMeta
 
         typer_command_params = set(get_named_arguments(TyperCommandMeta.__new__))
-        typer_command_params.remove("inherit_extensions")
         typer_params = set(get_named_arguments(typer.Typer.__init__))
         typer_params.remove("add_completion")
         typer_params.remove("cls")

django_typer/tests/test_interference.py

@@ -182,3 +182,76 @@ def test_inherit_initialize_interference(self):
         self.assertEqual(
             call_command("interference_ext"), "test_app2::interference::init(True)"
         )
+
+    def test_initialize_classmethod_run(self):
+        stdout, stderr, returncode = run_command(
+            "interference_ext_init",
+            "--settings",
+            "django_typer.tests.settings.override",
+        )
+        self.assertEqual(returncode, 0, msg=stderr)
+        self.assertEqual(stdout.strip(), "test_app2::interference_ext_init::init(5)")
+
+        stdout, stderr, returncode = run_command(
+            "method_override",
+            "--settings",
+            "django_typer.tests.settings.adapted",
+        )
+        self.assertEqual(returncode, 0, msg=stderr)
+        self.assertEqual(stdout.strip(), "adapter0::init()")
+
+    def test_initialize_classmethod_call(self):
+        self.assertEqual(
+            call_command("interference_ext_init"),
+            "test_app2::interference_ext_init::init(5)",
+        )
+
+        self.assertEqual(
+            call_command("method_override"),
+            "adapter0::init()",
+        )
+
+    def test_initialize_classmethod_direct(self):
+        from django_typer import TyperCommand
+
+        command = get_command("interference_ext_init", TyperCommand)
+        self.assertEqual(command.init(), "test_app2::interference_ext_init::init(5)")
+
+        command = get_command("method_override", TyperCommand)
+        self.assertEqual(command.init(), "adapter0::init()")
+
+    def test_command_classmethod_run(self):
+        stdout, stderr, returncode = run_command(
+            "method_override",
+            "--settings",
+            "django_typer.tests.settings.adapted",
+            "cmd1",
+        )
+        self.assertEqual(returncode, 0, msg=stderr)
+        self.assertEqual(stdout.strip(), "adapter0::cmd1()")
+
+        stdout, stderr, returncode = run_command(
+            "method_override",
+            "--settings",
+            "django_typer.tests.settings.adapted",
+            "cmd2",
+        )
+        self.assertEqual(returncode, 0, msg=stderr)
+        self.assertEqual(stdout.strip(), "adapter0::cmd2()")
+
+    def test_command_classmethod_call(self):
+        self.assertEqual(
+            call_command("method_override", "cmd1"),
+            "adapter0::cmd1()",
+        )
+        self.assertEqual(
+            call_command("method_override", "cmd2"),
+            "adapter0::cmd2()",
+        )
+
+    def test_command_classmethod_direct(self):
+        from django_typer import TyperCommand
+
+        command = get_command("method_override", TyperCommand)
+        self.assertEqual(command.cmd1(), "adapter0::cmd1()")
+        self.assertEqual(command.cmd2(), "adapter0::cmd2()")