🐛 Bug fixing

app.py

@@ -10,7 +10,7 @@ from typing import List, Dict, Optional
 from fastapi import FastAPI, Header, HTTPException
 from pydantic import BaseModel, Field
 
-from predict import predict
+from predict import predict as predict_func
 
 API_KEY = os.getenv("API_KEY")  # set via Space Secrets
 
@@ -42,6 +42,6 @@ def predict(request: Request, authorization: str = Header(default="")):
     if not API_KEY or authorization != f"Bearer {API_KEY}":
         raise HTTPException(status_code=401, detail="Unauthorized")
 
-    predictions = predict(request.smiles)
+    predictions = predict_func(request.smiles)
     return {"predictions": predictions, "model_info": {"name":"random_clf", "version":"1.0.0"}}
 

predict.py

@@ -6,7 +6,7 @@ SMILES and target names as keys.
 
 #---------------------------------------------------------------------------------------
 # Dependencies
-from Literal import List
+from typing import List
 import random
 from collections import defaultdict
 #---------------------------------------------------------------------------------------

requirements.txt

@@ -1,2 +1,4 @@
 fastapi
 uvicorn[standard]
+pytest
+httpx

tests/test_app.py

@@ -0,0 +1,100 @@
+"""
+Tests for the FastAPI application
+"""
+
+import pytest
+from fastapi.testclient import TestClient
+from unittest.mock import patch
+import os
+
+from app import app
+
+
+@pytest.fixture
+def client():
+    return TestClient(app)
+
+
+class TestMetadataEndpoint:
+    
+    def test_metadata(self, client):
+        response = client.get("/metadata")
+        assert response.status_code == 200
+        data = response.json()
+        
+        assert data["name"] == "AwesomeTox"
+        assert data["version"] == "1.0.0"
+        assert data["max_batch_size"] == 256
+        assert data["tox_endpoints"] == ["mutagenicity", "hepatotoxicity"]
+
+
+class TestHealthzEndpoint:
+    
+    def test_healthz(self, client):
+        response = client.get("/healthz")
+        assert response.status_code == 200
+        assert response.json() == {"ok": True}
+
+
+class TestPredictEndpoint:
+    
+    @patch.dict(os.environ, {"API_KEY": "test-key"})
+    def test_predict_with_valid_auth(self, client):
+        headers = {"Authorization": "Bearer test-key"}
+        data = {"smiles": ["CCO"]}
+        
+        response = client.post("/predict", json=data, headers=headers)
+        assert response.status_code == 200
+        
+        result = response.json()
+        assert "predictions" in result
+        assert "model_info" in result
+        assert result["model_info"]["name"] == "random_clf"
+        assert result["model_info"]["version"] == "1.0.0"
+    
+    @patch.dict(os.environ, {"API_KEY": "test-key"})
+    def test_predict_without_auth(self, client):
+        data = {"smiles": ["CCO"]}
+        
+        response = client.post("/predict", json=data)
+        assert response.status_code == 401
+        assert response.json()["detail"] == "Unauthorized"
+    
+    @patch.dict(os.environ, {"API_KEY": "test-key"})
+    def test_predict_with_invalid_auth(self, client):
+        headers = {"Authorization": "Bearer wrong-key"}
+        data = {"smiles": ["CCO"]}
+        
+        response = client.post("/predict", json=data, headers=headers)
+        assert response.status_code == 401
+    
+    @patch.dict(os.environ, {"API_KEY": "test-key"})
+    def test_predict_empty_smiles_list(self, client):
+        headers = {"Authorization": "Bearer test-key"}
+        data = {"smiles": []}
+        
+        response = client.post("/predict", json=data, headers=headers)
+        assert response.status_code == 422  # Validation error due to min_items=1
+    
+    @patch.dict(os.environ, {"API_KEY": "test-key"})
+    def test_predict_too_many_smiles(self, client):
+        headers = {"Authorization": "Bearer test-key"}
+        data = {"smiles": ["CCO"] * 1001}  # Exceeds max_items=1000
+        
+        response = client.post("/predict", json=data, headers=headers)
+        assert response.status_code == 422  # Validation error due to max_items=1000
+    
+    @patch.dict(os.environ, {"API_KEY": "test-key"})
+    def test_predict_multiple_smiles(self, client):
+        headers = {"Authorization": "Bearer test-key"}
+        data = {"smiles": ["CCO", "CCN", "CCC"]}
+        
+        response = client.post("/predict", json=data, headers=headers)
+        assert response.status_code == 200
+        
+        result = response.json()
+        predictions = result["predictions"]
+        
+        for smiles in data["smiles"]:
+            assert smiles in predictions
+            assert len(predictions[smiles]) == 12

tests/test_predict.py

@@ -0,0 +1,65 @@
+"""
+Tests for the predict.py module
+"""
+
+from predict import predict, Tox21RandomClassifier
+
+
+class TestTox21RandomClassifier:
+    
+    def test_init(self):
+        classifier = Tox21RandomClassifier()
+        assert len(classifier.target_names) == 12
+        expected_targets = [
+            "NR-AR", "NR-AR-LBD", "NR-AhR", "NR-Aromatase", 
+            "NR-ER", "NR-ER-LBD", "NR-PPAR-gamma", 
+            "SR-ARE", "SR-ATAD5", "SR-HSE", "SR-MMP", "SR-p53"
+        ]
+        assert classifier.target_names == expected_targets
+    
+    def test_predict_single_smiles(self):
+        classifier = Tox21RandomClassifier()
+        smiles_list = ["CCO"]
+        result = classifier.predict(smiles_list)
+        
+        assert "CCO" in result
+        assert len(result["CCO"]) == 12
+        
+        for target in classifier.target_names:
+            assert target in result["CCO"]
+            assert 0 <= result["CCO"][target] <= 1
+    
+    def test_predict_multiple_smiles(self):
+        classifier = Tox21RandomClassifier()
+        smiles_list = ["CCO", "CCN", "CCC"]
+        result = classifier.predict(smiles_list)
+        
+        assert len(result) == 3
+        for smiles in smiles_list:
+            assert smiles in result
+            assert len(result[smiles]) == 12
+            
+            for target in classifier.target_names:
+                assert target in result[smiles]
+                assert 0 <= result[smiles][target] <= 1
+    
+    def test_predict_empty_list(self):
+        classifier = Tox21RandomClassifier()
+        result = classifier.predict([])
+        assert result == {}
+
+
+class TestPredictFunction:
+    
+    def test_predict_function(self):
+        smiles_list = ["CCO", "CCN"]
+        result = predict(smiles_list)
+        
+        assert len(result) == 2
+        for smiles in smiles_list:
+            assert smiles in result
+            assert len(result[smiles]) == 12
+    
+    def test_predict_function_empty(self):
+        result = predict([])
+        assert result == {}