fix(tests): failing

Author: Daniele Briggi

.pre-commit-config.yaml

@@ -15,7 +15,7 @@ repos:
   rev: v2.3.1
   hooks:
     - id: autoflake
-      args: ["--remove-all-unused-imports", "--remove-unused-variables", "--ignore-init-module-imports", "--in-place", "--recursive", "./src", "./test"]
+      args: ["--remove-all-unused-imports", "--remove-unused-variables", "--ignore-init-module-imports", "--in-place", "--recursive", "./src", "./tests"]
 - repo: https://github.com/pycqa/isort
   rev: 6.0.1
   hooks:

src/sqlite_rag/cli.py

@@ -14,35 +14,38 @@
 from .formatters import get_formatter
 from .sqliterag import SQLiteRag
 
+DEFAULT_DATABASE_PATH = "./sqliterag.sqlite"
+
 
 class RAGContext:
     """Manage CLI state and RAG object reuse"""
 
     def __init__(self):
         self.rag: Optional[SQLiteRag] = None
         self.in_repl = False
-        self.database: str = ""
+        self.database_path: str = ""
 
     def enter_repl(self):
         """Enter REPL mode"""
         self.in_repl = True
 
-    def get_rag(self, database_path: str, require_existing: bool = False) -> SQLiteRag:
+    def get_rag(self, require_existing: bool = False) -> SQLiteRag:
         """Create or reuse SQLiteRag instance"""
-        if not self.database:
+        if not self.database_path:
             raise ValueError("Database path not set. Use --database option.")
 
         if self.in_repl:
             if self.rag is None:
-                typer.echo(f"Debug: Using database path: {self.database}")
                 self.rag = SQLiteRag.create(
-                    self.database, require_existing=require_existing
+                    self.database_path, require_existing=require_existing
                 )
-                typer.echo(f"Database: {Path(self.database).resolve()}")
             return self.rag
         else:
             # Regular mode - create new instance
-            return SQLiteRag.create(database_path, require_existing=require_existing)
+            typer.echo(f"Database: {Path(self.database_path).resolve()}")
+            return SQLiteRag.create(
+                self.database_path, require_existing=require_existing
+            )
 
 
 rag_context = RAGContext()
@@ -66,28 +69,32 @@ def __call__(self, *args, **kwds):
 def main(
     ctx: typer.Context,
     database: str = typer.Option(
-        "./sqliterag.sqlite",
+        DEFAULT_DATABASE_PATH,
         "--database",
         "-db",
         help="Path to the SQLite database file",
     ),
 ):
     """SQLite RAG - Retrieval Augmented Generation with SQLite"""
     ctx.ensure_object(dict)
-    rag_context.database = database
     ctx.obj["rag_context"] = rag_context
 
+    if not rag_context.in_repl:
+        rag_context.database_path = database
+
     # If no subcommand was invoked, enter REPL mode
-    if ctx.invoked_subcommand is None:
+    if ctx.invoked_subcommand is None and not rag_context.in_repl:
         rag_context.enter_repl()
+        typer.echo(f"Database: {Path(database).resolve()}")
+
         repl_mode()
 
 
 @app.command("settings")
 def show_settings(ctx: typer.Context):
     """Show current settings"""
     rag_context = ctx.obj["rag_context"]
-    rag = rag_context.get_rag(rag_context.database, require_existing=True)
+    rag = rag_context.get_rag(require_existing=True)
     current_settings = rag.get_settings()
 
     typer.echo("Current settings:")
@@ -168,7 +175,7 @@ def configure_settings(
         show_settings(ctx)
         return
 
-    conn = Database.new_connection(rag_context.database)
+    conn = Database.new_connection(rag_context.database_path)
     settings_manager = SettingsManager(conn)
     settings_manager.configure(updates)
 
@@ -199,7 +206,7 @@ def add(
     rag_context = ctx.obj["rag_context"]
     start_time = time.time()
 
-    rag = rag_context.get_rag(rag_context.database)
+    rag = rag_context.get_rag()
     rag.add(
         path,
         recursive=recursive,
@@ -225,7 +232,7 @@ def add_text(
 ):
     """Add a text to the database"""
     rag_context = ctx.obj["rag_context"]
-    rag = rag_context.get_rag(rag_context.database)
+    rag = rag_context.get_rag()
     rag.add_text(text, uri=uri, metadata=json.loads(metadata or "{}"))
     typer.echo("Text added.")
 
@@ -234,7 +241,7 @@ def add_text(
 def list_documents(ctx: typer.Context):
     """List all documents in the database"""
     rag_context = ctx.obj["rag_context"]
-    rag = rag_context.get_rag(rag_context.database, require_existing=True)
+    rag = rag_context.get_rag(require_existing=True)
     documents = rag.list_documents()
 
     if not documents:
@@ -266,7 +273,7 @@ def remove(
 ):
     """Remove document by path or UUID"""
     rag_context = ctx.obj["rag_context"]
-    rag = rag_context.get_rag(rag_context.database, require_existing=True)
+    rag = rag_context.get_rag(require_existing=True)
 
     # Find the document first
     document = rag.find_document(identifier)
@@ -311,7 +318,7 @@ def rebuild(
 ):
     """Rebuild embeddings and full-text index"""
     rag_context = ctx.obj["rag_context"]
-    rag = rag_context.get_rag(rag_context.database, require_existing=True)
+    rag = rag_context.get_rag(require_existing=True)
 
     typer.echo("Rebuild process...")
 
@@ -331,7 +338,7 @@ def reset(
 ):
     """Reset/clear the entire database"""
     rag_context = ctx.obj["rag_context"]
-    rag = rag_context.get_rag(rag_context.database, require_existing=True)
+    rag = rag_context.get_rag(require_existing=True)
 
     # Show warning and ask for confirmation unless -y flag is used
     if not yes:
@@ -374,7 +381,7 @@ def search(
     rag_context = ctx.obj["rag_context"]
     start_time = time.time()
 
-    rag = rag_context.get_rag(rag_context.database, require_existing=True)
+    rag = rag_context.get_rag(require_existing=True)
     results = rag.search(query, top_k=limit)
 
     search_time = time.time() - start_time
@@ -397,7 +404,7 @@ def quantize(
 ):
     """Quantize vectors for faster search or clean up quantization structures"""
     rag_context = ctx.obj["rag_context"]
-    rag = rag_context.get_rag(rag_context.database, require_existing=True)
+    rag = rag_context.get_rag(require_existing=True)
 
     if cleanup:
         typer.echo("Cleaning up quantization structures...")

tests/integration/test_cli.py

@@ -1,105 +1,114 @@
-import os
 import tempfile
 from pathlib import Path
 
-from pytest import fixture
 from typer.testing import CliRunner
 
 from sqlite_rag.cli import app
 from sqlite_rag.settings import Settings
 
 
-@fixture
-def temp_dir():
-    """Change the current working directory in order to create
-    the default database in a temporary location."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        original_cwd = os.getcwd()
-        try:
-            os.chdir(tmpdir)
-            yield tmpdir
-        finally:
-            os.chdir(original_cwd)
-
-
 class TestCLI:
     def test_search_exact_match(self):
-        # Use SQLiteRag to set up the test data directly
-        with tempfile.TemporaryDirectory() as tmpdir:
-            doc1_content = "The quick brown fox jumps over the lazy dog"
-            doc2_content = (
-                "How much wood would a woodchuck chuck if a woodchuck could chuck wood?"
-            )
+        """Test adding documents and searching for an exact match."""
+        doc1_content = "The quick brown fox jumps over the lazy dog"
+        doc2_content = (
+            "How much wood would a woodchuck chuck if a woodchuck could chuck wood?"
+        )
+
+        with tempfile.NamedTemporaryFile(suffix=".tempdb") as tmp_db:
 
             runner = CliRunner()
 
             model_path = Path(Settings().model_path).absolute()
 
-            # Change to the temporary directory so CLI finds the database
-            original_cwd = os.getcwd()
-            try:
-                os.chdir(tmpdir)
-                # CWD has changed so the model must be referenced by absolute path
-                result = runner.invoke(
-                    app,
-                    [
-                        "set",
-                        "--model-path-or-name",
-                        str(model_path),
-                        "--other-vector-options",
-                        "distance=cosine",
-                    ],
-                )
-                assert result.exit_code == 0
-
-                # Add
-                result = runner.invoke(
-                    app,
-                    [
-                        "add-text",
-                        doc1_content,
-                    ],
-                )
-                assert result.exit_code == 0
-
-                result = runner.invoke(
-                    app,
-                    [
-                        "add-text",
-                        doc2_content,
-                    ],
-                )
-                assert result.exit_code == 0
-
-                # Search
-                result = runner.invoke(
-                    app, ["search", doc1_content, "--debug", "--limit", "1"]
-                )
-            finally:
-                os.chdir(original_cwd)
+            result = runner.invoke(
+                app,
+                [
+                    "--database",
+                    tmp_db.name,
+                    "configure",
+                    "--model-path",
+                    str(model_path),
+                    "--other-vector-options",
+                    "distance=cosine",
+                ],
+            )
+            assert result.exit_code == 0
+
+            # Add
+            result = runner.invoke(
+                app,
+                [
+                    "--database",
+                    tmp_db.name,
+                    "add-text",
+                    doc1_content,
+                ],
+            )
+            assert result.exit_code == 0
+
+            result = runner.invoke(
+                app,
+                [
+                    "--database",
+                    tmp_db.name,
+                    "add-text",
+                    doc2_content,
+                ],
+            )
+            assert result.exit_code == 0
+
+            # Search
+            result = runner.invoke(
+                app,
+                [
+                    "--database",
+                    tmp_db.name,
+                    "search",
+                    doc1_content,
+                    "--debug",
+                    "--limit",
+                    "1",
+                ],
+            )
 
             # Assert CLI command executed successfully
             assert result.exit_code == 0
-            assert "Found 1 documents" in result.stdout
+            assert "Search Results (1 matches)" in result.stdout
             # For exact match with cosine distance, we expect distance close to 0.0
-            assert "0.000000" in result.stdout or "0.00000" in result.stdout
-
-    def test_set_settings(self, temp_dir):
-        runner = CliRunner()
-
-        model_path = "mypath/mymodel.gguf"
-
-        result = runner.invoke(
-            app,
-            [
-                "set",
-                "--model-path-or-name",
-                model_path,
-                "--other-vector-options",
-                "distance=L2",
-            ],
-        )
-        assert result.exit_code == 0
+            assert "Vector: 0.000000" in result.stdout or "0.00000" in result.stdout
+
+    def test_set_settings(self):
+        with tempfile.NamedTemporaryFile(suffix=".tempdb") as tmp_db:
+            runner = CliRunner()
+
+            model_path = "mypath/mymodel.gguf"
+
+            result = runner.invoke(
+                app,
+                [
+                    "--database",
+                    tmp_db.name,
+                    "configure",
+                    "--model-path",
+                    model_path,
+                    "--other-vector-options",
+                    "distance=L2",
+                ],
+            )
+            assert result.exit_code == 0
+
+            assert f"model_path: {model_path}" in result.stdout
+            assert "other_vector_options: distance=L2" in result.stdout
+
+    def test_change_database_path(self):
+        with tempfile.NamedTemporaryFile(suffix=".tempdb") as tmp_db:
+            runner = CliRunner()
+
+            result = runner.invoke(
+                app,
+                ["--database", tmp_db.name, "settings"],
+            )
+            assert result.exit_code == 0
 
-        assert f"model_path: {model_path}" in result.stdout
-        assert "other_vector_options: distance=L2" in result.stdout
+            assert f"Database: {tmp_db.name}" in result.stdout

tests/test_engine.py

@@ -91,7 +91,7 @@ def test_search_semantic_result(self, db_conn):
         engine.quantize()
 
         # Act
-        results = engine.search("lumberjack", limit=5)
+        results = engine.search("about lumberjack", limit=5)
 
         assert len(results) > 0
         assert doc3_id == results[0].document.id