Merge pull request #1 from meilisearch/add-test

Add basic testing on every PR

Author: tpayet

.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: Test and Lint
+
+on:
+  pull_request:
+    branches: [ main ]
+  push:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'
+        
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pytest black mcp
+        pip install -e .
+        
+    - name: Format code with black
+      run: |
+        black src/
+        black tests/
+        
+    - name: Run tests
+      run: |
+        pytest tests/ -v

pyproject.toml

@@ -11,11 +11,24 @@ dependencies = [
 ]
 
 [build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
+requires = ["setuptools>=42"]
+build-backend = "setuptools.build_meta"
 
 [project.scripts]
 meilisearch-mcp = "meilisearch_mcp.server:main"
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/meilisearch_mcp"]
+packages = ["src/meilisearch_mcp"]
+
+[tool.pytest.ini_options]
+pythonpath = [
+    "."
+]
+testpaths = [
+    "tests"
+]
+
+[tool.black]
+line-length = 88
+target-version = ['py310']
+include = '\.pyi?$'

requirements-dev.txt

@@ -0,0 +1,3 @@
+pytest>=7.0.0
+black>=23.0.0
+mcp>=0.1.0 

src/meilisearch_mcp/__main__.py

@@ -1,4 +1,4 @@
 from .server import main
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    main()

src/meilisearch_mcp/client.py

@@ -13,8 +13,11 @@
 
 logger = MCPLogger()
 
+
 class MeilisearchClient:
-    def __init__(self, url: str = "http://localhost:7700", api_key: Optional[str] = None):
+    def __init__(
+        self, url: str = "http://localhost:7700", api_key: Optional[str] = None
+    ):
         """Initialize Meilisearch client"""
         self.url = url
         self.api_key = api_key
@@ -26,7 +29,7 @@ def __init__(self, url: str = "http://localhost:7700", api_key: Optional[str] =
         self.tasks = TaskManager(self.client)
         self.keys = KeyManager(self.client)
         self.monitoring = MonitoringManager(self.client)
-        
+
     async def health_check(self) -> bool:
         """Check if Meilisearch is healthy"""
         try:
@@ -43,23 +46,25 @@ async def get_stats(self) -> Dict[str, Any]:
         """Get database stats"""
         # return self.client.get_stats()
         return "This method has not yet been implemented in the Meilisearch client."
-    
+
     async def get_indexes(self) -> Dict[str, Any]:
         """Get all indexes"""
         indexes = self.client.get_indexes()
         # Convert Index objects to serializable dictionaries
         serialized_indexes = []
-        for index in indexes['results']:
-            serialized_indexes.append({
-                "uid": index.uid,
-                "primaryKey": index.primary_key,
-                "createdAt": index.created_at,
-                "updatedAt": index.updated_at
-            })
-        
+        for index in indexes["results"]:
+            serialized_indexes.append(
+                {
+                    "uid": index.uid,
+                    "primaryKey": index.primary_key,
+                    "createdAt": index.created_at,
+                    "updatedAt": index.updated_at,
+                }
+            )
+
         return {
             "results": serialized_indexes,
-            "offset": indexes['offset'],
-            "limit": indexes['limit'],
-            "total": indexes['total']
-        }
+            "offset": indexes["offset"],
+            "limit": indexes["limit"],
+            "total": indexes["total"],
+        }

src/meilisearch_mcp/documents.py

@@ -1,9 +1,10 @@
 from typing import Dict, Any, List, Optional, Union
 from meilisearch import Client
 
+
 class DocumentManager:
     """Manage documents within Meilisearch indexes"""
-    
+
     def __init__(self, client: Client):
         self.client = client
 
@@ -12,23 +13,19 @@ async def get_documents(
         index_uid: str,
         offset: Optional[int] = None,
         limit: Optional[int] = None,
-        fields: Optional[List[str]] = None
+        fields: Optional[List[str]] = None,
     ) -> Dict[str, Any]:
         """Get documents from an index"""
         try:
             index = self.client.index(index_uid)
-            return index.get_documents({
-                'offset': offset,
-                'limit': limit,
-                'fields': fields
-            })
+            return index.get_documents(
+                {"offset": offset, "limit": limit, "fields": fields}
+            )
         except Exception as e:
             raise Exception(f"Failed to get documents: {str(e)}")
 
     async def get_document(
-        self,
-        index_uid: str,
-        document_id: Union[str, int]
+        self, index_uid: str, document_id: Union[str, int]
     ) -> Dict[str, Any]:
         """Get a single document"""
         try:
@@ -41,7 +38,7 @@ async def add_documents(
         self,
         index_uid: str,
         documents: List[Dict[str, Any]],
-        primary_key: Optional[str] = None
+        primary_key: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Add documents to an index"""
         try:
@@ -51,9 +48,7 @@ async def add_documents(
             raise Exception(f"Failed to add documents: {str(e)}")
 
     async def update_documents(
-        self,
-        index_uid: str,
-        documents: List[Dict[str, Any]]
+        self, index_uid: str, documents: List[Dict[str, Any]]
     ) -> Dict[str, Any]:
         """Update documents in an index"""
         try:
@@ -63,9 +58,7 @@ async def update_documents(
             raise Exception(f"Failed to update documents: {str(e)}")
 
     async def delete_document(
-        self,
-        index_uid: str,
-        document_id: Union[str, int]
+        self, index_uid: str, document_id: Union[str, int]
     ) -> Dict[str, Any]:
         """Delete a single document"""
         try:
@@ -75,9 +68,7 @@ async def delete_document(
             raise Exception(f"Failed to delete document: {str(e)}")
 
     async def delete_documents(
-        self,
-        index_uid: str,
-        document_ids: List[Union[str, int]]
+        self, index_uid: str, document_ids: List[Union[str, int]]
     ) -> Dict[str, Any]:
         """Delete multiple documents by ID"""
         try:
@@ -86,13 +77,10 @@ async def delete_documents(
         except Exception as e:
             raise Exception(f"Failed to delete documents: {str(e)}")
 
-    async def delete_all_documents(
-        self,
-        index_uid: str
-    ) -> Dict[str, Any]:
+    async def delete_all_documents(self, index_uid: str) -> Dict[str, Any]:
         """Delete all documents in an index"""
         try:
             index = self.client.index(index_uid)
             return index.delete_all_documents()
         except Exception as e:
-            raise Exception(f"Failed to delete all documents: {str(e)}")
+            raise Exception(f"Failed to delete all documents: {str(e)}")

src/meilisearch_mcp/indexes.py

@@ -2,19 +2,24 @@
 from dataclasses import dataclass
 from meilisearch import Client
 
+
 @dataclass
 class IndexConfig:
     """Index configuration model"""
+
     uid: str
     primary_key: Optional[str] = None
-    
+
+
 class IndexManager:
     """Manage Meilisearch indexes"""
-    
+
     def __init__(self, client: Client):
         self.client = client
 
-    async def create_index(self, uid: str, primary_key: Optional[str] = None) -> Dict[str, Any]:
+    async def create_index(
+        self, uid: str, primary_key: Optional[str] = None
+    ) -> Dict[str, Any]:
         """Create a new index"""
         try:
             return self.client.create_index(uid, {"primaryKey": primary_key})
@@ -45,7 +50,7 @@ async def delete_index(self, uid: str) -> Dict[str, Any]:
     async def update_index(self, uid: str, primary_key: str) -> Dict[str, Any]:
         """Update index primary key"""
         try:
-            return self.client.update_index(uid, {'primaryKey': primary_key})
+            return self.client.update_index(uid, {"primaryKey": primary_key})
         except Exception as e:
             raise Exception(f"Failed to update index: {str(e)}")
 
@@ -54,4 +59,4 @@ async def swap_indexes(self, indexes: List[List[str]]) -> Dict[str, Any]:
         try:
             return self.client.swap_indexes(indexes)
         except Exception as e:
-            raise Exception(f"Failed to swap indexes: {str(e)}")
+            raise Exception(f"Failed to swap indexes: {str(e)}")

src/meilisearch_mcp/keys.py

@@ -2,15 +2,16 @@
 from meilisearch import Client
 from datetime import datetime
 
+
 class KeyManager:
     """Manage Meilisearch API keys"""
-    
+
     def __init__(self, client: Client):
         self.client = client
 
-    async def get_keys(self, 
-                      parameters: Optional[Dict[str, Any]] = None
-                      ) -> Dict[str, Any]:
+    async def get_keys(
+        self, parameters: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
         """Get list of API keys"""
         try:
             return self.client.get_keys(parameters)
@@ -24,19 +25,14 @@ async def get_key(self, key: str) -> Dict[str, Any]:
         except Exception as e:
             raise Exception(f"Failed to get key: {str(e)}")
 
-    async def create_key(self, 
-                        options: Dict[str, Any]
-                        ) -> Dict[str, Any]:
+    async def create_key(self, options: Dict[str, Any]) -> Dict[str, Any]:
         """Create a new API key"""
         try:
             return self.client.create_key(options)
         except Exception as e:
             raise Exception(f"Failed to create key: {str(e)}")
 
-    async def update_key(self, 
-                        key: str, 
-                        options: Dict[str, Any]
-                        ) -> Dict[str, Any]:
+    async def update_key(self, key: str, options: Dict[str, Any]) -> Dict[str, Any]:
         """Update an existing API key"""
         try:
             return self.client.update_key(key, options)
@@ -48,4 +44,4 @@ async def delete_key(self, key: str) -> None:
         try:
             return self.client.delete_key(key)
         except Exception as e:
-            raise Exception(f"Failed to delete key: {str(e)}")
+            raise Exception(f"Failed to delete key: {str(e)}")