diff --git a/evennia/commands/default/tests.py b/evennia/commands/default/tests.py
index 852e4c6b2f..8ab5fa50bb 100644
--- a/evennia/commands/default/tests.py
+++ b/evennia/commands/default/tests.py
@@ -2263,3 +2263,16 @@ class TestSystemCommands(BaseEvenniaCommandTest):
         multimatch.matches = matches
 
         self.call(multimatch, "look", "")
+
+class TestPreCmdOutputTestable(BaseEvenniaCommandTest):
+    def test_pre_cmd(self):
+        class CmdTest(Command):
+            def at_pre_cmd(self):
+                self.msg("This should be testable")
+                return True
+
+            def func(self):
+                self.msg("This should never be executed")
+                return
+
+        self.call(CmdTest(), "test", "This should be testable")
\ No newline at end of file
diff --git a/evennia/utils/test_resources.py b/evennia/utils/test_resources.py
index 9aee64842a..e351367cad 100644
--- a/evennia/utils/test_resources.py
+++ b/evennia/utils/test_resources.py
@@ -433,7 +433,6 @@ class EvenniaCommandTestMixin:
         cmdobj.raw_string = raw_string if raw_string is not None else cmdobj.key + " " + input_args
         cmdobj.obj = obj or (caller if caller else self.char1)
         inputs = inputs or []
-
         # set up receivers
         receiver_mapping = {}
         if isinstance(msg, dict):
@@ -458,42 +457,40 @@ class EvenniaCommandTestMixin:
         # cmdhandler. This will have the mocked .msg be called as part of the
         # execution. Mocks remembers what was sent to them so we will be able
         # to retrieve what was sent later.
-        try:
-            if cmdobj.at_pre_cmd():
-                return
-            cmdobj.parse()
-            ret = cmdobj.func()
-
-            # handle func's with yield in them (making them generators)
-            if isinstance(ret, types.GeneratorType):
-                while True:
-                    try:
-                        inp = inputs.pop() if inputs else None
-                        if inp:
-                            try:
-                                # this mimics a user's reply to a prompt
-                                ret.send(inp)
-                            except TypeError:
+        if not cmdobj.at_pre_cmd():
+            try:
+                cmdobj.parse()
+                ret = cmdobj.func()
+                # handle func's with yield in them (making them generators)
+                if isinstance(ret, types.GeneratorType):
+                    while True:
+                        try:
+                            inp = inputs.pop() if inputs else None
+                            if inp:
+                                try:
+                                    # this mimics a user's reply to a prompt
+                                    ret.send(inp)
+                                except TypeError:
+                                    next(ret)
+                                    ret = ret.send(inp)
+                            else:
+                                # non-input yield, like yield(10). We don't pause
+                                # but fire it immediately.
                                 next(ret)
-                                ret = ret.send(inp)
-                        else:
-                            # non-input yield, like yield(10). We don't pause
-                            # but fire it immediately.
-                            next(ret)
-                    except StopIteration:
-                        break
+                        except StopIteration:
+                            break
 
-            cmdobj.at_post_cmd()
-        except StopIteration:
-            pass
-        except InterruptCommand:
-            pass
+                cmdobj.at_post_cmd()
+            except StopIteration:
+                pass
+            except InterruptCommand:
+                pass
 
-        for inp in inputs:
-            # if there are any inputs left, we may have a non-generator
-            # input to handle (get_input/ask_yes_no that uses a separate
-            # cmdset rather than a yield
-            caller.execute_cmd(inp)
+            for inp in inputs:
+                # if there are any inputs left, we may have a non-generator
+                # input to handle (get_input/ask_yes_no that uses a separate
+                # cmdset rather than a yield
+                caller.execute_cmd(inp)
 
         # At this point the mocked .msg methods on each receiver will have
         # stored all calls made to them (that's a basic function of the Mock