test, format

Author: pedroslopez

airbyte_cdk/cli/manifest_runner/_common.py

@@ -25,4 +25,4 @@ def check_manifest_runner_dependencies() -> None:
             "  poetry install --extras manifest-runner\n",
             err=True,
         )
-        sys.exit(1)
+        sys.exit(1)

airbyte_cdk/cli/manifest_runner/_info.py

@@ -24,4 +24,4 @@ def info() -> None:
         click.echo(f"   Uvicorn version: {uvicorn.__version__}")
     else:
         click.echo("❌ Manifest runner dependencies not installed")
-        click.echo("   Install with: pip install airbyte-cdk[manifest-runner]")
+        click.echo("   Install with: pip install airbyte-cdk[manifest-runner]")

airbyte_cdk/cli/manifest_runner/_start.py

@@ -35,4 +35,4 @@ def start(host: str, port: int, reload: bool) -> None:
         host=host,
         port=port,
         reload=reload,
-    )
+    )

airbyte_cdk/manifest_runner/routers/manifest.py

@@ -88,6 +88,8 @@ def discover(request: DiscoverRequest) -> DiscoverResponse:
     source = safe_build_source(request.manifest.model_dump(), request.config.model_dump())
     runner = ManifestRunner(source)
     catalog = runner.discover(request.config.model_dump())
+    if catalog is None:
+        raise HTTPException(status_code=422, detail="Connector did not return a discovered catalog")
     return DiscoverResponse(catalog=catalog)
 
 

unit_tests/manifest_runner/routers/test_manifest.py

@@ -355,3 +355,135 @@ def test_full_resolve_multiple_dynamic_stream_templates(
             template_b_streams = [s for s in dynamic_streams if "2a" in s["name"]]
             assert len(template_a_streams) == 1
             assert len(template_b_streams) == 1
+
+    def test_check_endpoint_success(self, sample_manifest, sample_config, mock_source):
+        """Test successful check endpoint call."""
+        request_data = {
+            "manifest": sample_manifest,
+            "config": sample_config,
+        }
+
+        with (
+            patch(
+                "airbyte_cdk.manifest_runner.routers.manifest.safe_build_source"
+            ) as mock_safe_build_source,
+            patch(
+                "airbyte_cdk.manifest_runner.routers.manifest.ManifestRunner"
+            ) as mock_runner_class,
+        ):
+            mock_safe_build_source.return_value = mock_source
+
+            mock_runner = Mock()
+            mock_runner.check_connection.return_value = (True, "Connection successful")
+            mock_runner_class.return_value = mock_runner
+
+            response = client.post("/v1/manifest/check", json=request_data)
+
+            assert response.status_code == 200
+            data = response.json()
+            assert data["success"] is True
+            assert data["message"] == "Connection successful"
+
+            mock_safe_build_source.assert_called_once_with(sample_manifest, sample_config)
+            mock_runner_class.assert_called_once_with(mock_source)
+            mock_runner.check_connection.assert_called_once_with(sample_config)
+
+    def test_check_endpoint_failure(self, sample_manifest, sample_config, mock_source):
+        """Test check endpoint with connection failure."""
+        request_data = {
+            "manifest": sample_manifest,
+            "config": sample_config,
+        }
+
+        with (
+            patch(
+                "airbyte_cdk.manifest_runner.routers.manifest.safe_build_source"
+            ) as mock_safe_build_source,
+            patch(
+                "airbyte_cdk.manifest_runner.routers.manifest.ManifestRunner"
+            ) as mock_runner_class,
+        ):
+            mock_safe_build_source.return_value = mock_source
+
+            mock_runner = Mock()
+            mock_runner.check_connection.return_value = (False, "Invalid API key")
+            mock_runner_class.return_value = mock_runner
+
+            response = client.post("/v1/manifest/check", json=request_data)
+
+            assert response.status_code == 200
+            data = response.json()
+            assert data["success"] is False
+            assert data["message"] == "Invalid API key"
+
+    def test_discover_endpoint_success(self, sample_manifest, sample_config, mock_source):
+        """Test successful discover endpoint call."""
+        from airbyte_protocol_dataclasses.models import AirbyteCatalog, AirbyteStream
+
+        request_data = {
+            "manifest": sample_manifest,
+            "config": sample_config,
+        }
+
+        # Create mock catalog
+        mock_catalog = AirbyteCatalog(
+            streams=[
+                AirbyteStream(
+                    name="products",
+                    json_schema={"type": "object", "properties": {"id": {"type": "integer"}}},
+                    supported_sync_modes=["full_refresh"],
+                )
+            ]
+        )
+
+        with (
+            patch(
+                "airbyte_cdk.manifest_runner.routers.manifest.safe_build_source"
+            ) as mock_safe_build_source,
+            patch(
+                "airbyte_cdk.manifest_runner.routers.manifest.ManifestRunner"
+            ) as mock_runner_class,
+        ):
+            mock_safe_build_source.return_value = mock_source
+
+            mock_runner = Mock()
+            mock_runner.discover.return_value = mock_catalog
+            mock_runner_class.return_value = mock_runner
+
+            response = client.post("/v1/manifest/discover", json=request_data)
+
+            assert response.status_code == 200
+            data = response.json()
+            assert "catalog" in data
+            assert data["catalog"]["streams"][0]["name"] == "products"
+
+            mock_safe_build_source.assert_called_once_with(sample_manifest, sample_config)
+            mock_runner_class.assert_called_once_with(mock_source)
+            mock_runner.discover.assert_called_once_with(sample_config)
+
+    def test_discover_endpoint_missing_catalog(self, sample_manifest, sample_config, mock_source):
+        """Test discover endpoint with no catalog throws 422 error."""
+        request_data = {
+            "manifest": sample_manifest,
+            "config": sample_config,
+        }
+
+        with (
+            patch(
+                "airbyte_cdk.manifest_runner.routers.manifest.safe_build_source"
+            ) as mock_safe_build_source,
+            patch(
+                "airbyte_cdk.manifest_runner.routers.manifest.ManifestRunner"
+            ) as mock_runner_class,
+        ):
+            mock_safe_build_source.return_value = mock_source
+
+            mock_runner = Mock()
+            mock_runner.discover.return_value = None  # No catalog returned
+            mock_runner_class.return_value = mock_runner
+
+            response = client.post("/v1/manifest/discover", json=request_data)
+
+            assert response.status_code == 422
+            data = response.json()
+            assert "Connector did not return a discovered catalog" in data["detail"]

unit_tests/manifest_runner/test_auth.py

@@ -25,7 +25,7 @@ def test_missing_credentials_with_secret_raises_401(self):
         with patch.dict(os.environ, {"AB_JWT_SIGNATURE_SECRET": "test-secret"}):
             with pytest.raises(HTTPException) as exc_info:
                 verify_jwt_token(None)
-            
+
             assert exc_info.value.status_code == 401
             assert exc_info.value.detail == "Bearer token required"
             assert exc_info.value.headers == {"WWW-Authenticate": "Bearer"}
@@ -34,13 +34,12 @@ def test_invalid_token_raises_401(self):
         """Test that invalid JWT tokens raise 401."""
         with patch.dict(os.environ, {"AB_JWT_SIGNATURE_SECRET": "test-secret"}):
             invalid_credentials = HTTPAuthorizationCredentials(
-                scheme="Bearer", 
-                credentials="invalid.jwt.token"
+                scheme="Bearer", credentials="invalid.jwt.token"
             )
-            
+
             with pytest.raises(HTTPException) as exc_info:
                 verify_jwt_token(invalid_credentials)
-            
+
             assert exc_info.value.status_code == 401
             assert exc_info.value.detail == "Invalid token"
             assert exc_info.value.headers == {"WWW-Authenticate": "Bearer"}
@@ -49,13 +48,12 @@ def test_malformed_token_raises_401(self):
         """Test that malformed tokens raise 401."""
         with patch.dict(os.environ, {"AB_JWT_SIGNATURE_SECRET": "test-secret"}):
             malformed_credentials = HTTPAuthorizationCredentials(
-                scheme="Bearer", 
-                credentials="not-a-jwt-token"
+                scheme="Bearer", credentials="not-a-jwt-token"
             )
-            
+
             with pytest.raises(HTTPException) as exc_info:
                 verify_jwt_token(malformed_credentials)
-            
+
             assert exc_info.value.status_code == 401
             assert exc_info.value.detail == "Invalid token"
 
@@ -65,16 +63,15 @@ def test_valid_token_passes(self):
         payload = {
             "exp": datetime.now(timezone.utc) + timedelta(hours=1),
             "iat": datetime.now(timezone.utc),
-            "sub": "test-user"
+            "sub": "test-user",
         }
         valid_token = jwt.encode(payload, secret, algorithm="HS256")
-        
+
         with patch.dict(os.environ, {"AB_JWT_SIGNATURE_SECRET": secret}):
             valid_credentials = HTTPAuthorizationCredentials(
-                scheme="Bearer", 
-                credentials=valid_token
+                scheme="Bearer", credentials=valid_token
             )
-            
+
             # Should not raise any exception
             verify_jwt_token(valid_credentials)
 
@@ -84,43 +81,41 @@ def test_expired_token_raises_401(self):
         expired_payload = {
             "exp": datetime.now(timezone.utc) - timedelta(hours=1),
             "iat": datetime.now(timezone.utc) - timedelta(hours=2),
-            "sub": "test-user"
+            "sub": "test-user",
         }
         expired_token = jwt.encode(expired_payload, secret, algorithm="HS256")
-        
+
         with patch.dict(os.environ, {"AB_JWT_SIGNATURE_SECRET": secret}):
             expired_credentials = HTTPAuthorizationCredentials(
-                scheme="Bearer", 
-                credentials=expired_token
+                scheme="Bearer", credentials=expired_token
             )
-            
+
             with pytest.raises(HTTPException) as exc_info:
                 verify_jwt_token(expired_credentials)
-            
+
             assert exc_info.value.status_code == 401
             assert exc_info.value.detail == "Invalid token"
 
     def test_wrong_secret_raises_401(self):
         """Test that tokens signed with wrong secret raise 401."""
         correct_secret = "correct-secret"
         wrong_secret = "wrong-secret"
-        
+
         payload = {
             "exp": datetime.now(timezone.utc) + timedelta(hours=1),
             "iat": datetime.now(timezone.utc),
-            "sub": "test-user"
+            "sub": "test-user",
         }
         token_with_wrong_secret = jwt.encode(payload, wrong_secret, algorithm="HS256")
-        
+
         with patch.dict(os.environ, {"AB_JWT_SIGNATURE_SECRET": correct_secret}):
             wrong_credentials = HTTPAuthorizationCredentials(
-                scheme="Bearer", 
-                credentials=token_with_wrong_secret
+                scheme="Bearer", credentials=token_with_wrong_secret
             )
-            
+
             with pytest.raises(HTTPException) as exc_info:
                 verify_jwt_token(wrong_credentials)
-            
+
             assert exc_info.value.status_code == 401
             assert exc_info.value.detail == "Invalid token"
 
@@ -136,12 +131,11 @@ def test_token_without_required_claims_passes(self):
         secret = "test-secret"
         minimal_payload = {"custom": "data"}  # No exp, iat, sub etc.
         minimal_token = jwt.encode(minimal_payload, secret, algorithm="HS256")
-        
+
         with patch.dict(os.environ, {"AB_JWT_SIGNATURE_SECRET": secret}):
             minimal_credentials = HTTPAuthorizationCredentials(
-                scheme="Bearer", 
-                credentials=minimal_token
+                scheme="Bearer", credentials=minimal_token
             )
-            
+
             # Should not raise any exception - we only verify signature
-            verify_jwt_token(minimal_credentials)
+            verify_jwt_token(minimal_credentials)