Add testcase timeout cli option (#1252)

* Add CLI option for default testcase timeout

authored-by: butako <[email protected]>

Author: Pyifan

doc/en/multitest.rst

@@ -1343,6 +1343,23 @@ Similarly, ``setup`` and ``teardown`` methods in a test suite can be limited to
 
 It's useful when ``setup`` has much initialization work that takes long, e.g. connects to a server but has no response and makes program hanging. Note that this ``@timeout`` decorator can also be used for ``pre_testcase`` and ``post_testcase``, but that is not suggested because pre/post testcase methods are called everytime before/after each testcase runs, they should be written as simple as possible.
 
+Default Testcase Timeout
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Set a default timeout for testcases without explicit timeouts:
+
+.. code-block:: python
+
+    # Programmatically
+    MultiTest(name="MyTest", suites=[MySuite()], testcase_timeout=300)
+
+.. code-block:: bash
+
+    # Via CLI
+    python my_test.py --testcase-timeout 300
+
+Explicit ``@testcase(timeout=...)`` values always override the default.
+
 Hooks
 -----
 

doc/newsfragments/1241_new.testcase_timeout.rst

@@ -0,0 +1 @@
+Added ``--testcase-timeout`` CLI option to set a default timeout for testcases without explicit timeout decorators.

testplan/defaults.py

@@ -6,6 +6,7 @@
 from testplan.exporters.testing.failed_tests import FailedTestLevel
 
 TESTPLAN_TIMEOUT = 14400  # 4h
+TESTCASE_TIMEOUT = None  # No timeout by default
 
 SUMMARY_NUM_PASSING = 5
 SUMMARY_NUM_FAILING = 5

testplan/parser.py

@@ -114,6 +114,17 @@ def generate_parser(self) -> HelpParser:
             "processes. Defaults to 14400s (4h). Set to 0 to disable.",
         )
 
+        general_group.add_argument(
+            "--testcase-timeout",
+            metavar="TESTCASE_TIMEOUT",
+            default=self._default_options.get(
+                "testcase_timeout", defaults.TESTCASE_TIMEOUT
+            ),
+            type=int,
+            help="Default timeout value in seconds for testcases that don't "
+            "have an explicit timeout set. Set to 0 or omit to disable default timeout.",
+        )
+
         general_group.add_argument(
             "-i",
             "--interactive",

testplan/runnable/base.py

@@ -273,6 +273,9 @@ def get_options(cls):
             ConfigOption("timeout", default=defaults.TESTPLAN_TIMEOUT): Or(
                 None, And(int, lambda t: t >= 0)
             ),
+            ConfigOption(
+                "testcase_timeout", default=defaults.TESTCASE_TIMEOUT
+            ): Or(None, And(int, lambda t: t >= 0)),
             # active_loop_sleep impacts cpu usage in interactive mode
             ConfigOption("active_loop_sleep", default=0.05): float,
             ConfigOption(

testplan/testing/multitest/base.py

@@ -226,6 +226,9 @@ def get_options(cls):
                 ),
             ),
             config.ConfigOption("testcase_report_target", default=True): bool,
+            config.ConfigOption("testcase_timeout"): Or(
+                None, And(int, lambda t: t >= 0)
+            ),
         }
 
 
@@ -260,6 +263,10 @@ class MultiTest(testing_base.Test):
     :param testcase_report_target: Whether to mark testcases as assertions for filepath
         and line number information
     :type testcase_report_target: ``bool``
+    :param testcase_timeout: Default timeout value in seconds for testcases that don't
+        have an explicit timeout set. If not specified, testcases will have no timeout
+        by default.
+    :type testcase_timeout: ``int`` or ``NoneType``
 
     Also inherits all
     :py:class:`~testplan.testing.base.Test` options.
@@ -294,6 +301,7 @@ def __init__(
         tags=None,
         result=result.Result,
         testcase_report_target=True,
+        testcase_timeout=None,
         **options,
     ):
         self._tags_index = None
@@ -1222,6 +1230,11 @@ def _run_testcase(
                     )
 
                 time_restriction = getattr(testcase, "timeout", None)
+                # Use default testcase timeout from config if no explicit timeout is set
+                if time_restriction is None and getattr(
+                    self.cfg, "testcase_timeout", None
+                ):
+                    time_restriction = self.cfg.testcase_timeout
                 if time_restriction:
                     # pylint: disable=unbalanced-tuple-unpacking
                     executed, execution_result = timing.timeout(

tests/functional/testplan/testing/multitest/test_default_testcase_timeout.py

@@ -0,0 +1,114 @@
+"""Test for default testcase timeout feature (--testcase-timeout CLI option)."""
+
+import time
+
+from testplan.testing.multitest import MultiTest, testsuite, testcase
+from testplan.common.utils.testing import check_report
+from testplan.report import (
+    Status,
+    TestReport,
+    TestGroupReport,
+    TestCaseReport,
+    ReportCategories,
+)
+
+
+@testsuite
+class SuiteWithoutTimeout:
+    """Testsuite with testcases that don't have explicit timeout."""
+
+    @testcase
+    def test_passes_quickly(self, env, result):
+        """This test should pass."""
+        result.log("Test completes quickly")
+
+    @testcase
+    def test_takes_time(self, env, result):
+        """This test takes 3 seconds but should timeout with default of 2s."""
+        result.log("Test will sleep for 3 seconds")
+        time.sleep(3)
+
+
+@testsuite
+class SuiteWithExplicitTimeout:
+    """Testsuite with testcases that have explicit timeout."""
+
+    @testcase(timeout=5)
+    def test_with_explicit_timeout(self, env, result):
+        """This test has explicit timeout that should override default."""
+        result.log("Test will sleep for 1 second with 5s timeout")
+        time.sleep(1)
+
+
+def test_default_testcase_timeout_from_config(mockplan):
+    """Test that default testcase timeout from config works."""
+    # Create MultiTest with explicit testcase_timeout
+    multitest = MultiTest(
+        name="TestDefaultTimeout",
+        suites=[SuiteWithoutTimeout()],
+        testcase_timeout=2,  # 2 seconds default timeout
+    )
+    mockplan.add(multitest)
+    mockplan.run()
+
+    # First test should pass (completes quickly)
+    assert mockplan.report.status == Status.ERROR
+    test_report = mockplan.report["TestDefaultTimeout"]["SuiteWithoutTimeout"]
+    assert test_report["test_passes_quickly"].status == Status.PASSED
+    # Second test should timeout and have ERROR status
+    assert test_report["test_takes_time"].status == Status.ERROR
+
+
+def test_explicit_timeout_overrides_default(mockplan):
+    """Test that explicit testcase timeout overrides the default."""
+    multitest = MultiTest(
+        name="TestExplicitOverride",
+        suites=[SuiteWithExplicitTimeout()],
+        testcase_timeout=1,  # 1 second default, but test has 5s explicit
+    )
+    mockplan.add(multitest)
+    mockplan.run()
+
+    # Test should pass because explicit timeout (5s) overrides default (1s)
+    assert mockplan.report.status == Status.PASSED
+    test_report = mockplan.report["TestExplicitOverride"][
+        "SuiteWithExplicitTimeout"
+    ]
+    assert test_report["test_with_explicit_timeout"].status == Status.PASSED
+
+
+def test_no_default_timeout(mockplan):
+    """Test that testcases work normally without default timeout."""
+    multitest = MultiTest(
+        name="TestNoDefault",
+        suites=[SuiteWithoutTimeout()],
+        # No testcase_timeout specified
+    )
+    mockplan.add(multitest)
+    mockplan.run()
+
+    # Both tests should pass without any timeout
+    assert mockplan.report.status == Status.PASSED
+    test_report = mockplan.report["TestNoDefault"]["SuiteWithoutTimeout"]
+    assert test_report["test_passes_quickly"].status == Status.PASSED
+    assert test_report["test_takes_time"].status == Status.PASSED
+
+
+def test_testcase_timeout_inheritance_from_parent(mockplan):
+    """Test that testcase_timeout is inherited from parent config."""
+    # Set testcase_timeout in parent (mockplan) config
+    mockplan.cfg.set_local("testcase_timeout", 2)
+
+    # Create MultiTest without explicit testcase_timeout
+    multitest = MultiTest(
+        name="TestInheritance",
+        suites=[SuiteWithoutTimeout()],
+    )
+    mockplan.add(multitest)
+    mockplan.run()
+
+    # First test should pass, second should timeout
+    assert mockplan.report.status == Status.ERROR
+    test_report = mockplan.report["TestInheritance"]["SuiteWithoutTimeout"]
+    assert test_report["test_passes_quickly"].status == Status.PASSED
+    assert test_report["test_takes_time"].status == Status.ERROR