Check whether architecture for TF is supported

packit_service/constants.py

@@ -1,6 +1,7 @@
 # Copyright Contributors to the Packit project.
 # SPDX-License-Identifier: MIT
 from enum import Enum
+from typing import List
 
 CONTACTS_URL = "https://packit.dev/#contact"
 DOCS_URL = "https://packit.dev/docs"
@@ -236,3 +237,16 @@ def from_number(number: int):
 )
 
 DASHBOARD_JOBS_TESTING_FARM_PATH = "/jobs/testing-farm-runs"
+
+# https://docs.testing-farm.io/general/0.1/test-environment.html#_supported_architectures
+PUBLIC_TF_ARCHITECTURE_LIST: List[str] = [
+    "aarch64",
+    "x86_64",
+]
+
+INTERNAL_TF_ARCHITECTURE_LIST: List[str] = [
+    "aarch64",
+    "ppc64le",
+    "s390x",
+    "x86_64",
+]

packit_service/worker/helpers/testing_farm.py

@@ -18,6 +18,8 @@
     TESTING_FARM_INSTALLABILITY_TEST_REF,
     TESTING_FARM_EXTRA_PARAM_MERGED_SUBTREES,
     BASE_RETRY_INTERVAL_IN_MINUTES_FOR_OUTAGES,
+    PUBLIC_TF_ARCHITECTURE_LIST,
+    INTERNAL_TF_ARCHITECTURE_LIST,
 )
 from packit_service.models import (
     CoprBuildTargetModel,
@@ -652,6 +654,37 @@ def distro2compose(self, target: str) -> Optional[str]:
 
         return compose
 
+    def _is_supported_architecture(self, target: str):
+        distro, arch = target.rsplit("-", 1)
+        supported_architectures = (
+            INTERNAL_TF_ARCHITECTURE_LIST
+            if self.job_config.use_internal_tf
+            else PUBLIC_TF_ARCHITECTURE_LIST
+        )
+        if arch not in supported_architectures:
+            msg = (
+                f"The architecture {arch} is not in the list of "
+                f"available architectures:\n{supported_architectures}. "
+            )
+            logger.error(msg)
+            msg += (
+                "Please, check the targets defined in your test job configuration. If you think"
+                f" your configuration is correct, get in touch with [us]({CONTACTS_URL})."
+            )
+            description = (
+                f"The architecture {arch} is not available in the "
+                f"{'internal' if self.job_config.use_internal_tf else 'public'} "
+                f"Testing Farm infrastructure."
+            )
+            self.report_status_to_tests_for_test_target(
+                state=BaseCommitStatus.error,
+                description=description,
+                target=target,
+                markdown_content=msg,
+            )
+            return False
+        return True
+
     def report_missing_build_chroot(self, chroot: str):
         self.report_status_to_tests_for_chroot(
             state=BaseCommitStatus.error,
@@ -794,6 +827,10 @@ def prepare_and_send_tf_request(
         """
         logger.info("Preparing testing farm request...")
 
+        if not self._is_supported_architecture(test_run.target):
+            msg = "Not supported architecture."
+            return TaskResults(success=True, details={"msg": msg})
+
         compose = self.distro2compose(test_run.target)
 
         if not compose:

tests/unit/test_testing_farm.py

@@ -1629,3 +1629,39 @@ def test_check_if_actor_can_run_job_and_report(jobs, event, should_pass):
     event.update({"actor": "actor", "project_url": "url"})
 
     assert TestingFarmHandler.pre_check(package_config, jobs[0], event) == should_pass
+
+
+@pytest.mark.parametrize(
+    "target,use_internal_tf,supported",
+    [
+        ("distro-aarch64", True, True),
+        ("distro-x86_64", True, True),
+        ("distro-aarch64", False, True),
+        ("distro-x86_64", False, True),
+        ("distro-ppc64le", True, True),
+        ("distro-s390x", True, True),
+        ("distro-ppc64le", False, False),
+        ("distro-s390x", False, False),
+    ],
+)
+def test_is_supported_architecture(target, use_internal_tf, supported):
+    job_helper = TFJobHelper(
+        service_config=ServiceConfig.get_service_config(),
+        package_config=flexmock(jobs=[]),
+        project=flexmock(),
+        metadata=flexmock(),
+        db_trigger=flexmock(),
+        job_config=JobConfig(
+            type=JobType.tests,
+            trigger=JobConfigTriggerType.pull_request,
+            packages={
+                "package": CommonPackageConfig(
+                    use_internal_tf=use_internal_tf,
+                )
+            },
+        ),
+    )
+    if not supported:
+        flexmock(TFJobHelper).should_receive("report_status_to_tests_for_test_target")
+
+    assert job_helper._is_supported_architecture(target) == supported