Added tests for app module

pytest.ini

@@ -0,0 +1,5 @@
+[pytest]
+pythonpath = .
+markers =
+    unit: Marks unit tests
+    integration: Marks integration tests

tests/test_api.py

@@ -0,0 +1,62 @@
+import pytest
+from fastapi.testclient import TestClient
+from app.api import app
+
+
+# Mock the most_similar function for testing
+def mock_most_similar(query, n):
+    if query == "error":
+        raise Exception("Test exception")
+    return [[0.9, "Result 1"], [0.8, "Result 2"]][:n]
+
+
+# Initialize the FastAPI test client
+client = TestClient(app)
+
+
+@pytest.fixture(autouse=True)
+def setup_mock_search_engine():
+    # Replace the app's search engine with a mock that uses the mock_most_similar function
+    app.state.search_engine = type(
+        "MockSearchEngine",
+        (object,),
+        {"most_similar": mock_most_similar}
+    )
+
+
+@pytest.mark.unit
+def test_search_valid_input():
+    response = client.get("/search", params={"query": "test", "n": 2})
+    assert response.status_code == 200
+    assert response.json() == {
+        "query": "test",
+        "results": [[0.9, "Result 1"], [0.8, "Result 2"]]
+    }
+
+
+@pytest.mark.unit
+def test_search_empty_query():
+    response = client.get("/search", params={"query": "", "n": 2})
+    assert response.status_code == 400
+    assert response.json()["detail"] == "Query cannot be empty."
+
+
+@pytest.mark.unit
+def test_search_invalid_n():
+    response = client.get("/search", params={"query": "test", "n": 0})
+    assert response.status_code == 422
+
+
+@pytest.mark.unit
+def test_search_engine_error():
+    response = client.get("/search", params={"query": "error", "n": 2})
+    assert response.status_code == 500
+    assert "An unexpected error occurred: Test exception" in response.json()["detail"]
+
+
+@pytest.mark.unit
+def test_search_no_engine():
+    app.state.search_engine = None  # Simulate uninitialized search engine
+    response = client.get("/search", params={"query": "test", "n": 2})
+    assert response.status_code == 500
+    assert response.json()["detail"] == "Search engine not initialized."

tests/test_engine.py

@@ -0,0 +1,66 @@
+import pytest
+import numpy as np
+from unittest.mock import MagicMock
+from app.engine import PromptSearchEngine
+
+
+@pytest.fixture
+def mock_prompts():
+    return ["prompt 1", "prompt 2", "prompt 3"]
+
+
+@pytest.fixture
+def mock_model():
+    model = MagicMock()
+    model.encode = MagicMock(return_value=np.array([
+        [0.1, 0.2, 0.3],
+        [0.4, 0.5, 0.6],
+        [0.7, 0.8, 0.9]
+    ]))
+    return model
+
+
+@pytest.mark.unit
+def test_engine_initialization(mock_prompts, mock_model, monkeypatch):
+    # SentenceTransformer is mocked to return the mock model
+    monkeypatch.setattr("app.engine.SentenceTransformer", MagicMock(return_value=mock_model))
+    engine = PromptSearchEngine(mock_prompts)
+    # Verify that the engine initializes correctly with the mock prompts and vectors
+    assert engine.prompts == mock_prompts
+    assert engine.corpus_vectors.shape == (3, 3)
+    assert np.array_equal(
+        engine.corpus_vectors,
+        np.array([[0.1, 0.2, 0.3], [0.4, 0.5, 0.6], [0.7, 0.8, 0.9]])
+    )
+
+
+@pytest.mark.unit
+def test_most_similar_valid_query(mock_prompts, mock_model, monkeypatch):
+    monkeypatch.setattr("app.engine.SentenceTransformer", MagicMock(return_value=mock_model))
+    engine = PromptSearchEngine(mock_prompts)
+    # Mock the vectorizer's transform method to return a single query vector
+    engine.vectorizer.transform = MagicMock(return_value=np.array([[0.1, 0.2, 0.3]]))
+    results = engine.most_similar("test query", n=2)
+    assert len(results) == 2
+    assert all(isinstance(score, float) and isinstance(prompt, str) for score, prompt in results)
+
+
+@pytest.mark.unit
+def test_most_similar_exceeding_n(mock_prompts, mock_model, monkeypatch):
+    monkeypatch.setattr("app.engine.SentenceTransformer", MagicMock(return_value=mock_model))
+    engine = PromptSearchEngine(mock_prompts)
+    engine.vectorizer.transform = MagicMock(return_value=np.array([[0.1, 0.2, 0.3]]))
+    # Call most_similar with n greater than the number of prompts
+    results = engine.most_similar("test query", n=10)
+    assert len(results) == len(mock_prompts)  # Should return at most the number of prompts
+    assert all(isinstance(score, float) and isinstance(prompt, str) for score, prompt in results)
+
+
+@pytest.mark.integration
+def test_most_similar_integration(mock_prompts):
+    engine = PromptSearchEngine(mock_prompts)
+    results = engine.most_similar("prompt 1", n=2)
+    # Verify that the results include the expected number of matches and correct types
+    assert len(results) == 2
+    assert all(isinstance(score, float) and isinstance(prompt, str) for score, prompt in results)
+    assert results[0][1] == "prompt 1"

tests/test_scorer.py

@@ -0,0 +1,85 @@
+import pytest
+import numpy as np
+from app.scorer import cosine_similarity, DimensionalityMismatchError, ZeroVectorError, EmptyInputError
+
+
+@pytest.fixture
+def valid_input():
+    query_vector = np.array([[1, 0]])
+    corpus_vectors = np.array([[1, 0], [0, 1], [1, 1]])
+    return query_vector, corpus_vectors
+
+
+@pytest.fixture
+def zero_query_vector():
+    query_vector = np.array([[0, 0]])
+    corpus_vectors = np.array([[1, 0], [0, 1]])
+    return query_vector, corpus_vectors
+
+
+@pytest.fixture
+def corpus_with_zero_vector():
+    query_vector = np.array([[1, 1]])
+    corpus_vectors = np.array([[1, 0], [0, 1], [0, 0]])
+    return query_vector, corpus_vectors
+
+
+@pytest.fixture
+def dimensionality_mismatch():
+    query_vector = np.array([[1, 0]])
+    corpus_vectors = np.array([[1, 0, 0], [0, 1, 0]])
+    return query_vector, corpus_vectors
+
+
+@pytest.fixture
+def empty_input():
+    query_vector = np.array([[]])
+    corpus_vectors = np.array([[]])
+    return query_vector, corpus_vectors
+
+
+@pytest.mark.unit
+def test_cosine_similarity_valid_input(valid_input):
+    query_vector, corpus_vectors = valid_input
+    similarities = cosine_similarity(query_vector, corpus_vectors)
+    assert isinstance(similarities, np.ndarray)
+    assert similarities.shape == (3,)
+    assert similarities[0] == pytest.approx(1.0)  # Same direction
+    assert similarities[1] == pytest.approx(0.0)  # Orthogonal
+    assert similarities[2] == pytest.approx(1 / np.sqrt(2))  # Diagonal similarity
+
+
+@pytest.mark.unit
+def test_cosine_similarity_zero_query_vector(zero_query_vector):
+    query_vector, corpus_vectors = zero_query_vector
+    with pytest.raises(ZeroVectorError):
+        cosine_similarity(query_vector, corpus_vectors)
+
+
+@pytest.mark.unit
+def test_cosine_similarity_corpus_with_zero_vector(corpus_with_zero_vector):
+    query_vector, corpus_vectors = corpus_with_zero_vector
+    with pytest.raises(ZeroVectorError):
+        cosine_similarity(query_vector, corpus_vectors)
+
+
+@pytest.mark.unit
+def test_cosine_similarity_dimensionality_mismatch(dimensionality_mismatch):
+    query_vector, corpus_vectors = dimensionality_mismatch
+    with pytest.raises(DimensionalityMismatchError):
+        cosine_similarity(query_vector, corpus_vectors)
+
+
+@pytest.mark.unit
+def test_cosine_similarity_empty_inputs(empty_input):
+    query_vector, corpus_vectors = empty_input
+    with pytest.raises(EmptyInputError):
+        cosine_similarity(query_vector, corpus_vectors)
+
+
+@pytest.mark.integration
+def test_cosine_similarity_output_range(valid_input):
+    query_vector, corpus_vectors = valid_input
+    similarities = cosine_similarity(query_vector, corpus_vectors)
+    assert np.all(similarities >= -1)
+    assert np.all(similarities <= 1)

tests/test_vectorizer.py

@@ -0,0 +1,73 @@
+import pytest
+import numpy as np
+from unittest.mock import MagicMock
+from app.engine import PromptSearchEngine
+
+
+@pytest.fixture
+def mock_prompts():
+    return ["prompt 1", "prompt 2", "prompt 3"]
+
+
+@pytest.fixture
+def mock_model():
+    embedding_dim = 384  # Correct embedding dimensionality for SentenceTransformer
+    model = MagicMock()
+    model.encode = MagicMock(return_value=np.random.rand(3, embedding_dim))
+    return model
+
+
+@pytest.mark.unit
+def test_engine_initialization(mock_prompts, mock_model):
+    # Mock the vectorizer to use the mock model
+    PromptSearchEngine.vectorizer = MagicMock()
+    PromptSearchEngine.vectorizer.transform = MagicMock(return_value=mock_model.encode(mock_prompts))
+    # Initialize the engine
+    engine = PromptSearchEngine(mock_prompts)
+    assert engine.prompts == mock_prompts
+    assert engine.corpus_vectors.shape == (3, 384)  # Correct dimensionality
+
+
+@pytest.mark.unit
+def test_most_similar_valid_query(mock_prompts, mock_model):
+    # Mock the vectorizer and its transform method
+    embedding_dim = 384
+    query_embedding = np.random.rand(1, embedding_dim)
+    PromptSearchEngine.vectorizer = MagicMock()
+    PromptSearchEngine.vectorizer.transform = MagicMock(return_value=query_embedding)
+    # Initialize the engine
+    engine = PromptSearchEngine(mock_prompts)
+    engine.vectorizer = MagicMock()
+    engine.vectorizer.transform = MagicMock(return_value=query_embedding)
+    results = engine.most_similar("test query", n=2)
+    assert len(results) == 2
+    assert all(isinstance(score, float) and isinstance(prompt, str) for score, prompt in results)
+
+
+@pytest.mark.unit
+def test_most_similar_empty_query(mock_prompts):
+    # Mock the vectorizer to raise a ValueError for empty input
+    engine = PromptSearchEngine(mock_prompts)
+    engine.vectorizer = MagicMock()
+    engine.vectorizer.transform = MagicMock(side_effect=ValueError("Invalid query"))
+    with pytest.raises(ValueError):
+        engine.most_similar("", n=2)
+
+
+@pytest.mark.unit
+def test_most_similar_exceeding_n(mock_prompts, mock_model):
+    # Initialize the engine
+    PromptSearchEngine.vectorizer = MagicMock()
+    engine = PromptSearchEngine(mock_prompts)
+    # Call most_similar with n greater than the number of prompts
+    results = engine.most_similar("test query", n=10)
+    assert len(results) == len(mock_prompts)  # Should return at most the number of prompts
+
+
+@pytest.mark.integration
+def test_most_similar_integration(mock_prompts):
+    engine = PromptSearchEngine(mock_prompts)
+    results = engine.most_similar("prompt 1", n=2)
+    assert len(results) == 2
+    assert all(isinstance(score, float) and isinstance(prompt, str) for score, prompt in results)
+    assert results[0][1] == "prompt 1"