Add integration tests for RFDetr models (#2673)

Author: PawelPeczek-Roboflow

tests/inference/hosted_platform_tests/conftest.py

@@ -90,6 +90,8 @@ class PlatformEnvironment(Enum):
         "multi_class_classification": "vehicle-classification-eapcd/2",
         "yolov8n-640": "yolov8n-640",
         "yolov8n-pose-640": "yolov8n-pose-640",
+        "rfdetr-od": "rfdetr-nano",
+        "rfdetr-is": "rfdetr-seg-nano",
     },
     PlatformEnvironment.ROBOFLOW_STAGING_LAMBDA: {
         "object-detection": "eye-detection/35",
@@ -98,6 +100,8 @@ class PlatformEnvironment(Enum):
         "multi_class_classification": "car-classification/23",
         "yolov8n-640": "microsoft-coco-obj-det/8",
         "yolov8n-pose-640": "microsoft-coco-pose/1",
+        "rfdetr-od": "rfdetr-nano",
+        "rfdetr-is": "asl-instance-seg/160",
     },
 }
 MODELS_TO_BE_USED[PlatformEnvironment.ROBOFLOW_STAGING_SERVERLESS] = MODELS_TO_BE_USED[
@@ -217,6 +221,16 @@ def segmentation_model_id(platform_environment: PlatformEnvironment) -> str:
     return MODELS_TO_BE_USED[platform_environment]["instance-segmentation"]
 
 
+@pytest.fixture(scope="session")
+def rfdetr_od_model_id(platform_environment: PlatformEnvironment) -> str:
+    return MODELS_TO_BE_USED[platform_environment]["rfdetr-od"]
+
+
+@pytest.fixture(scope="session")
+def rfdetr_is_model_id(platform_environment: PlatformEnvironment) -> str:
+    return MODELS_TO_BE_USED[platform_environment]["rfdetr-is"]
+
+
 @pytest.fixture(scope="session")
 def target_project(platform_environment: PlatformEnvironment) -> str:
     return TARGET_PROJECTS_TO_BE_USED[platform_environment]

tests/inference/hosted_platform_tests/test_rfdetr_models.py

@@ -0,0 +1,48 @@
+import pytest
+
+from inference_sdk import InferenceHTTPClient
+from tests.inference.hosted_platform_tests.conftest import IMAGE_URL, ROBOFLOW_API_KEY
+
+
+@pytest.mark.flaky(retries=4, delay=1)
+def test_infer_from_rfdetr_object_detection_model_when_valid_response_expected(
+    object_detection_service_url: str,
+    rfdetr_od_model_id: str,
+) -> None:
+    # given
+    client = InferenceHTTPClient(
+        api_url=object_detection_service_url,
+        api_key=ROBOFLOW_API_KEY,
+    ).select_api_v0()
+
+    # when
+    response = client.infer(IMAGE_URL, model_id=rfdetr_od_model_id)
+
+    # then
+    assert isinstance(response, dict), "Expected dict as response"
+    assert "predictions" in response, "Expected 'predictions' key in response"
+    assert (
+        len(response["predictions"]) > 0
+    ), f"Expected at least one instance detected in {IMAGE_URL}"
+
+
+@pytest.mark.flaky(retries=4, delay=1)
+def test_infer_from_rfdetr_instance_segmentation_model_when_valid_response_expected(
+    instance_segmentation_service_url: str,
+    rfdetr_is_model_id: str,
+) -> None:
+    # given
+    client = InferenceHTTPClient(
+        api_url=instance_segmentation_service_url,
+        api_key=ROBOFLOW_API_KEY,
+    ).select_api_v0()
+
+    # when
+    response = client.infer(IMAGE_URL, model_id=rfdetr_is_model_id)
+
+    # then
+    assert isinstance(response, dict), "Expected dict as response"
+    assert "predictions" in response, "Expected 'predictions' key in response"
+    assert (
+        len(response["predictions"]) > 0
+    ), f"Expected at least one instance detected in {IMAGE_URL}"

tests/inference/integration_tests/test_rfdetr_models.py

@@ -0,0 +1,129 @@
+import os
+
+import pytest
+import requests
+
+api_key = os.environ.get("API_KEY")
+port = os.environ.get("PORT", 9001)
+base_url = os.environ.get("BASE_URL", "http://localhost")
+
+DOG_IMAGE_URL = "https://media.roboflow.com/dog.jpeg"
+
+# Keep in sync with RFDETR_ALIASES in inference/models/aliases.py.
+# The legacy /{dataset_id}/{version_id} route cannot carry a slash-less alias —
+# clients (inference_sdk) resolve aliases before calling the server — so the
+# legacy tests hit the resolved model IDs, while the v1 /infer/* tests pass the
+# raw alias to exercise server-side alias resolution.
+RFDETR_DETECTION_ALIASES = {
+    "rfdetr-base": "coco/36",
+    "rfdetr-nano": "coco/38",
+    "rfdetr-small": "coco/39",
+    "rfdetr-medium": "coco/40",
+    "rfdetr-large": "coco/50",
+    "rfdetr-xlarge": "coco/47",
+    "rfdetr-2xlarge": "coco/48",
+}
+RFDETR_SEGMENTATION_ALIASES = {
+    "rfdetr-seg-preview": "coco-dataset-vdnr1/26",
+    "rfdetr-seg-nano": "coco-dataset-vdnr1/41",
+    "rfdetr-seg-small": "coco-dataset-vdnr1/36",
+    "rfdetr-seg-medium": "coco-dataset-vdnr1/37",
+    "rfdetr-seg-large": "coco-dataset-vdnr1/38",
+    "rfdetr-seg-xlarge": "coco-dataset-vdnr1/39",
+    "rfdetr-seg-2xlarge": "coco-dataset-vdnr1/40",
+}
+
+
+def bool_env(val):
+    if isinstance(val, bool):
+        return val
+    return val.lower() in ["true", "1", "t", "y", "yes"]
+
+
+pytestmark = pytest.mark.skipif(
+    bool_env(os.getenv("SKIP_RFDETR_TEST", False)),
+    reason="Skipping RFDETR test",
+)
+
+
+def assert_instances_detected(response: requests.Response) -> None:
+    response.raise_for_status()
+    data = response.json()
+    assert "predictions" in data, f"Response lacks 'predictions' key: {data}"
+    assert (
+        len(data["predictions"]) > 0
+    ), f"Expected at least one instance detected in {DOG_IMAGE_URL}"
+
+
+@pytest.mark.parametrize("alias", list(RFDETR_DETECTION_ALIASES))
+def test_rfdetr_detection_via_v1_endpoint(
+    alias: str, clean_loaded_models_every_test_fixture
+) -> None:
+    payload = {
+        "model_id": alias,
+        "image": {"type": "url", "value": DOG_IMAGE_URL},
+        "api_key": api_key,
+    }
+
+    response = requests.post(
+        f"{base_url}:{port}/infer/object_detection",
+        json=payload,
+    )
+
+    assert_instances_detected(response)
+
+
+@pytest.mark.parametrize(
+    "model_id",
+    list(RFDETR_DETECTION_ALIASES.values()),
+    ids=list(RFDETR_DETECTION_ALIASES),
+)
+def test_rfdetr_detection_via_legacy_endpoint(
+    model_id: str, clean_loaded_models_every_test_fixture
+) -> None:
+    response = requests.post(
+        f"{base_url}:{port}/{model_id}",
+        params={
+            "api_key": api_key,
+            "image": DOG_IMAGE_URL,
+        },
+    )
+
+    assert_instances_detected(response)
+
+
+@pytest.mark.parametrize("alias", list(RFDETR_SEGMENTATION_ALIASES))
+def test_rfdetr_segmentation_via_v1_endpoint(
+    alias: str, clean_loaded_models_every_test_fixture
+) -> None:
+    payload = {
+        "model_id": alias,
+        "image": {"type": "url", "value": DOG_IMAGE_URL},
+        "api_key": api_key,
+    }
+
+    response = requests.post(
+        f"{base_url}:{port}/infer/instance_segmentation",
+        json=payload,
+    )
+
+    assert_instances_detected(response)
+
+
+@pytest.mark.parametrize(
+    "model_id",
+    list(RFDETR_SEGMENTATION_ALIASES.values()),
+    ids=list(RFDETR_SEGMENTATION_ALIASES),
+)
+def test_rfdetr_segmentation_via_legacy_endpoint(
+    model_id: str, clean_loaded_models_every_test_fixture
+) -> None:
+    response = requests.post(
+        f"{base_url}:{port}/{model_id}",
+        params={
+            "api_key": api_key,
+            "image": DOG_IMAGE_URL,
+        },
+    )
+
+    assert_instances_detected(response)