Fix ci and add tests

Author: louiscb

.github/workflow/tests.yml .github/workflows/tests.yml.github/workflow/tests.yml renamed to .github/workflows/tests.yml

@@ -0,0 +1 @@
+# Tests package

tests/__init__.py

@@ -0,0 +1,170 @@
+"""
+Tests for the Semcache client.
+"""
+
+from unittest.mock import Mock, patch
+
+import pytest
+import requests
+
+from semcache import (
+    Semcache,
+    SemcacheConnectionError,
+    SemcacheTimeoutError,
+    SemcacheAPIError,
+)
+
+
+class TestSemcache:
+    """Test cases for the Semcache client."""
+
+    def test_initialization_default(self):
+        """Test client initialization with default values."""
+        client = Semcache()
+        assert client.base_url == "http://localhost:8080"
+        assert client.timeout == 30
+
+    def test_initialization_custom(self):
+        """Test client initialization with custom values."""
+        client = Semcache(base_url="http://example.com:9090", timeout=60)
+        assert client.base_url == "http://example.com:9090"
+        assert client.timeout == 60
+
+    def test_base_url_trailing_slash(self):
+        """Test that trailing slashes are removed from base URL."""
+        client = Semcache(base_url="http://localhost:8080/")
+        assert client.base_url == "http://localhost:8080"
+
+    @patch("semcache.client.requests.Session")
+    def test_put_success(self, mock_session_class):
+        """Test successful put operation."""
+        # Setup mock
+        mock_session = Mock()
+        mock_session_class.return_value = mock_session
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.raise_for_status.return_value = None
+        mock_session.put.return_value = mock_response
+
+        # Test
+        client = Semcache()
+        client.put("test key", "test data")
+
+        # Verify
+        mock_session.put.assert_called_once_with(
+            "http://localhost:8080/semcache/v1/put",
+            json={"key": "test key", "data": "test data"},
+            timeout=30,
+        )
+
+    @patch("semcache.client.requests.Session")
+    def test_get_success(self, mock_session_class):
+        """Test successful get operation."""
+        # Setup mock
+        mock_session = Mock()
+        mock_session_class.return_value = mock_session
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.raise_for_status.return_value = None
+        mock_response.text = "test data"
+        mock_session.post.return_value = mock_response
+
+        # Test
+        client = Semcache()
+        result = client.get("test key")
+
+        # Verify
+        assert result == "test data"
+        mock_session.post.assert_called_once_with(
+            "http://localhost:8080/semcache/v1/get",
+            json={"key": "test key"},
+            timeout=30,
+        )
+
+    @patch("semcache.client.requests.Session")
+    def test_get_not_found(self, mock_session_class):
+        """Test get operation when item is not found (404)."""
+        # Setup mock
+        mock_session = Mock()
+        mock_session_class.return_value = mock_session
+        mock_response = Mock()
+        mock_response.status_code = 404
+        mock_session.post.return_value = mock_response
+
+        # Test
+        client = Semcache()
+        result = client.get("test key")
+
+        # Verify
+        assert result is None
+
+    @patch("semcache.client.requests.Session")
+    def test_connection_error(self, mock_session_class):
+        """Test connection error handling."""
+        # Setup mock
+        mock_session = Mock()
+        mock_session_class.return_value = mock_session
+        mock_session.put.side_effect = requests.exceptions.ConnectionError()
+
+        # Test
+        client = Semcache()
+        with pytest.raises(SemcacheConnectionError) as exc_info:
+            client.put("test", "test")
+
+        assert "Failed to connect to Semcache server" in str(exc_info.value)
+
+    @patch("semcache.client.requests.Session")
+    def test_timeout_error(self, mock_session_class):
+        """Test timeout error handling."""
+        # Setup mock
+        mock_session = Mock()
+        mock_session_class.return_value = mock_session
+        mock_session.post.side_effect = requests.exceptions.Timeout()
+
+        # Test
+        client = Semcache()
+        with pytest.raises(SemcacheTimeoutError) as exc_info:
+            client.get("test")
+
+        assert "Request timed out after 30 seconds" in str(exc_info.value)
+
+    @patch("semcache.client.requests.Session")
+    def test_http_error(self, mock_session_class):
+        """Test HTTP error handling."""
+        # Setup mock
+        mock_session = Mock()
+        mock_session_class.return_value = mock_session
+        mock_response = Mock()
+        mock_response.status_code = 400
+        mock_response.text = "Bad Request"
+        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError()
+        mock_session.put.return_value = mock_response
+
+        # Test
+        client = Semcache()
+        with pytest.raises(SemcacheAPIError) as exc_info:
+            client.put("test", "test")
+
+        assert "HTTP 400: Bad Request" in str(exc_info.value)
+
+    def test_context_manager(self):
+        """Test context manager functionality."""
+        with patch("semcache.client.requests.Session") as mock_session_class:
+            mock_session = Mock()
+            mock_session_class.return_value = mock_session
+
+            with Semcache() as client:
+                assert isinstance(client, Semcache)
+
+            mock_session.close.assert_called_once()
+
+    def test_close_method(self):
+        """Test close method."""
+        with patch("semcache.client.requests.Session") as mock_session_class:
+            mock_session = Mock()
+            mock_session_class.return_value = mock_session
+
+            client = Semcache()
+            client.close()
+
+            mock_session.close.assert_called_once()

tests/test_client.py

@@ -0,0 +1,89 @@
+"""
+Integration tests for Semcache client.
+
+These tests require a running Semcache server at http://localhost:8080.
+Run with: pytest tests/test_integration.py -v -s
+"""
+
+import time
+
+import pytest
+
+from semcache import Semcache, SemcacheConnectionError
+
+
+class TestSemcacheIntegration:
+    @pytest.fixture
+    def client(self):
+        client = Semcache(base_url="http://localhost:8080")
+        yield client
+        client.close()
+
+    @pytest.fixture(autouse=True)
+    def check_server_available(self, client):
+        """Skip tests if Semcache server is not available."""
+        try:
+            # Try a simple operation to check if server is running
+            # This should return None or a string, but not raise ConnectionError
+            _ = client.get("test")
+        except SemcacheConnectionError:
+            pytest.skip("Semcache server not available at http://localhost:8080")
+
+    def test_put_and_get(self, client):
+        client.put("What is Python?", "Python is a programming language")
+
+        time.sleep(0.1)
+
+        result = client.get("What is Python?")
+        assert result == "Python is a programming language"
+
+    def test_semantic_similarity(self, client):
+        client.put("What is the capital of France?", "Paris is the capital of France")
+
+        time.sleep(0.1)
+
+        # Try similar keys
+        similar_keys = [
+            "What's the capital city of France?",
+            "Tell me the capital of France",
+            "France's capital is?",
+        ]
+
+        for key in similar_keys:
+            result = client.get(key)
+            assert result == "Paris is the capital of France", f"Failed for key: {key}"
+
+    def test_get_nonexistent(self, client):
+        result = client.get("This key definitely doesn't exist in the cache")
+        assert result is None
+
+    def test_overwrite_value(self, client):
+        client.put("test key", "initial value")
+        time.sleep(0.1)
+
+        client.put("test key", "updated value")
+        time.sleep(0.1)
+
+        # Verify new value is returned
+        result = client.get("test key")
+        assert result == "updated value"
+
+    def test_unicode_content(self, client):
+        unicode_key = "What is café?"
+        unicode_data = "Café is coffee in French ☕"
+
+        client.put(unicode_key, unicode_data)
+        time.sleep(0.1)
+
+        result = client.get(unicode_key)
+        assert result == unicode_data
+
+    def test_large_content(self, client):
+        large_data = "x" * 10000  # 10KB of text
+
+        client.put("large content test", large_data)
+        time.sleep(0.1)
+
+        result = client.get("large content test")
+        assert result == large_data
+        assert len(result) == 10000