Allow disabling of internal TF (#3044)

Allow disabling of internal TF

Reviewed-by: gemini-code-assist[bot]
Reviewed-by: Nikola Forró

Author: centosinfra-prod-github-app[bot]

packit_service/constants.py

@@ -252,6 +252,13 @@ def from_number(number: int):
     "via `{packit_comment_command_prefix} test` comment.*",
 )
 
+INTERNAL_TF_TEMPORARILY_DISABLED = (
+    "Testing in internal Testing Farm is temporarily disabled",
+    "Testing in internal Testing Farm via Packit is temporarily disabled due to an internal issue. "
+    "For more details, see pinned messages in #team-packit Slack channel and reach out there for "
+    "any questions.",
+)
+
 INTERNAL_TF_BUILDS_AND_TESTS_NOT_ALLOWED = (
     "{actor} can't run tests (and builds) internally",
     "*As a project maintainer, you can trigger the build and test jobs manually "

packit_service/worker/checker/testing_farm.py

@@ -2,11 +2,13 @@
 # SPDX-License-Identifier: MIT
 
 import logging
+import os
 from typing import Optional
 
 from packit_service.constants import (
     DOCS_TESTING_FARM,
     INTERNAL_TF_BUILDS_AND_TESTS_NOT_ALLOWED,
+    INTERNAL_TF_TEMPORARILY_DISABLED,
     INTERNAL_TF_TESTS_NOT_ALLOWED,
     KojiTaskState,
 )
@@ -27,6 +29,28 @@
 logger = logging.getLogger(__name__)
 
 
+class IsInternalTFEnabled(Checker, GetTestingFarmJobHelperMixin):
+    """Checks if internal Testing Farm is enabled at the service level.
+
+    Internal TF may be temporarily disabled due to service issues.
+    Set DISABLE_INTERNAL_TF=true to disable internal TF and report a message to users.
+
+    By default (env var not set), internal TF is enabled.
+    """
+
+    def pre_check(self) -> bool:
+        internal_tf_disabled = os.getenv("DISABLE_INTERNAL_TF", "false").lower() == "true"
+
+        if self.job_config.use_internal_tf and internal_tf_disabled:
+            self.testing_farm_job_helper.report_status_to_tests(
+                description=INTERNAL_TF_TEMPORARILY_DISABLED[0],
+                state=BaseCommitStatus.neutral,
+                markdown_content=INTERNAL_TF_TEMPORARILY_DISABLED[1],
+            )
+            return False
+        return True
+
+
 class IsJobConfigTriggerMatching(Checker, GetTestingFarmJobHelperMixin):
     def pre_check(self) -> bool:
         return self.testing_farm_job_helper.is_job_config_trigger_matching(

packit_service/worker/handlers/testing_farm.py

@@ -56,6 +56,7 @@
     IsEventForJob,
     IsEventOk,
     IsIdentifierFromCommentMatching,
+    IsInternalTFEnabled,
     IsJobConfigTriggerMatching,
     IsLabelFromCommentMatching,
     IsUpstreamTest,
@@ -150,6 +151,7 @@ def get_checkers() -> tuple[type[Checker], ...]:
             CanActorRunJob,
             IsIdentifierFromCommentMatching,
             IsLabelFromCommentMatching,
+            IsInternalTFEnabled,
         )
 
     def _get_or_create_group(

tests/unit/test_checkers.py

@@ -1,6 +1,8 @@
 # Copyright Contributors to the Packit project.
 # SPDX-License-Identifier: MIT
 
+import os
+
 import pytest
 from flexmock import flexmock
 from ogr import PagureService
@@ -52,6 +54,7 @@
 from packit_service.worker.checker.testing_farm import (
     IsDownstreamTest,
     IsIdentifierFromCommentMatching,
+    IsInternalTFEnabled,
     IsLabelFromCommentMatching,
     IsUpstreamTest,
 )
@@ -1398,3 +1401,76 @@ def test_is_downstream_test(test_run_data, should_pass):
     checker = IsDownstreamTest(package_config, job_config, event)
 
     assert checker.pre_check() == should_pass
+
+
+@pytest.mark.parametrize(
+    "use_internal_tf, env_var_value, should_pass",
+    (
+        pytest.param(
+            True,
+            "false",
+            True,
+            id="Internal TF job, env var set to false - should pass",
+        ),
+        pytest.param(
+            True,
+            "true",
+            False,
+            id="Internal TF job, env var set to true - should be blocked",
+        ),
+        pytest.param(
+            False,
+            "true",
+            True,
+            id="Public TF job, env var set to true - should pass",
+        ),
+    ),
+)
+def test_is_internal_tf_enabled(use_internal_tf, env_var_value, should_pass):
+    """
+    Test that IsInternalTFEnabled checker correctly blocks internal TF jobs
+    when DISABLE_INTERNAL_TF env var is set to true.
+    """
+    flexmock(os).should_receive("getenv").with_args("DISABLE_INTERNAL_TF", "false").and_return(
+        env_var_value
+    )
+
+    package_config = flexmock(jobs=[])
+    job_config = flexmock(
+        type=JobType.tests,
+        trigger=JobConfigTriggerType.pull_request,
+        use_internal_tf=use_internal_tf,
+    )
+
+    event = {
+        "event_type": github.pr.Action.event_type(),
+    }
+
+    git_project = flexmock(
+        namespace="packit",
+        repo="ogr",
+    )
+    flexmock(ConfigFromEventMixin).should_receive("project").and_return(git_project)
+
+    db_project_object = flexmock(
+        job_config_trigger_type=JobConfigTriggerType.pull_request,
+        pr_id=1,
+    )
+    flexmock(EventData).should_receive("db_project_event").and_return(
+        flexmock().should_receive("get_project_event_object").and_return(db_project_object).mock(),
+    )
+
+    if not should_pass:
+        mock_helper = flexmock()
+        mock_helper.should_receive("report_status_to_tests").once()
+        flexmock(IsInternalTFEnabled).should_receive("testing_farm_job_helper").and_return(
+            mock_helper
+        )
+
+    checker = IsInternalTFEnabled(
+        package_config=package_config,
+        job_config=job_config,
+        event=event,
+    )
+
+    assert checker.pre_check() == should_pass