Merge pull request #47 from jethronap/39_testing

39 testing

Author: jethronap

local_test_pipeline.sh

@@ -20,6 +20,11 @@ pytest tests/agents/test_scraper_agent.py
 echo "Done..."
 echo "==============================================="
 
+echo "Running analyzer agent tests"
+pytest tests/agents/test_analyzer_agent.py
+echo "Done..."
+echo "==============================================="
+
 echo "Running llm wrapper tests"
 pytest tests/tools/test_llm_wrapper.py
 echo "Done..."
@@ -30,13 +35,19 @@ pytest tests/tools/test_ollama_client.py
 echo "Done..."
 echo "==============================================="
 
+
+echo "Running io tools tests"
+pytest tests/tools/test_io_tools.py
+echo "Done..."
+echo "==============================================="
+
 echo "Running memory store tests"
 pytest tests/memory/test_memory_store.py
 echo "Done..."
 echo "==============================================="
 
-echo "Running with_retry decorator tests"
-pytest tests/utils/test_retry.py
+echo "Running decorator tests"
+pytest tests/utils/test_decorators.py
 echo "Done..."
 echo "==============================================="
 

main.py

@@ -1,4 +1,4 @@
-from src.agents.analyser_agent import AnalyzerAgent
+from src.agents.analyzer_agent import AnalyzerAgent
 
 from src.config.settings import DatabaseSettings
 from src.memory.store import MemoryStore

src/agents/analyser_agent.py renamed to src/agents/analyzer_agent.py

@@ -14,10 +14,10 @@ class OllamaSettings(BaseSettings):
         default="http://localhost:11434/api/generate", description="The Ollama base url"
     )
     timeout_seconds: float = Field(
-        default=None, description="Timeout for calling Ollama"
+        default=30.0, description="Timeout for calling Ollama"
     )
     stream: bool = Field(default=False, description="Flag to denote chunked streaming.")
-    model: str = Field(default=None, description="Ollama model name.")
+    model: str = Field(default="qwen2.5", description="Ollama model name.")
 
     model_config = SettingsConfigDict(
         env_file=".env", env_prefix="OLLAMA_", extra="allow"
@@ -42,17 +42,17 @@ class LoggingSettings(BaseSettings):
     Configuration for Loguru logging sinks.
     """
 
-    level: str = Field(default=None, description="The log level")
+    level: str = Field(default="DEBUG", description="The log level")
     console: bool = Field(default=True, description="Show logs in console")
     enable_file: bool = Field(
         default=False, description="Flag to denote persistence of logs"
     )
     filepath: Optional[Path] = Field(
-        default=None, description="Optional file path for logs"
+        default="logs/agents.log", description="Optional file path for logs"
     )
-    rotation: str = Field(default=None, description="Roll log after this size")
+    rotation: str = Field(default="10 MB", description="Roll log after this size")
     retention: str = Field(
-        default=None, description="Keep logs for this amount of time"
+        default="7 days", description="Keep logs for this amount of time"
     )
     compression: str = Field(default="zip", description="Compress old logs")
 

src/config/settings.py

@@ -0,0 +1,87 @@
+import json
+from pathlib import Path
+import pytest
+
+from src.agents.analyzer_agent import AnalyzerAgent
+from src.utils.db import payload_hash
+from tests.conftest import make_raw_dump, set_stub_response
+
+
+def test_first_run_creates_files(tmp_path, mem_fake):
+    """
+    • LLM is called once.
+    • enriched + geojson are written.
+    • stats are returned.
+    """
+    raw_path, raw = make_raw_dump(tmp_path)
+
+    # what the LLM should spit back for each element
+    set_stub_response(
+        {
+            "public": False,
+            "sensitive": False,
+            "camera_type": None,
+            "mount_type": None,
+        }
+    )
+
+    agent = AnalyzerAgent("AnalyzerAgent", memory=mem_fake)
+    ctx = agent.achieve_goal({"path": str(raw_path)})
+
+    # -------- assertions ----------
+    enr = Path(ctx["output_path"])
+    gj = Path(ctx["geojson_path"])
+
+    assert enr.exists() and gj.exists()
+    # enriched has our analysis field
+    loaded = json.loads(enr.read_text())["elements"][0]["analysis"]
+    assert loaded["public"] is False
+
+    # GeoJSON features == 1
+    assert len(json.loads(gj.read_text())["features"]) == 1
+
+    # stats present & sensible
+    stats = ctx["stats"]
+    assert stats.get("total") == 1
+    assert stats.get("sensitive_count") == 0
+
+    # memory got a cache entry
+    assert any(r.step == "enriched_cache" for r in mem_fake.rows)
+
+
+def test_second_run_hits_cache(tmp_path, mem_fake, monkeypatch):
+    """
+    Pre-seed cache & existing files – LLM must **not** be invoked.
+    """
+    raw_path, raw = make_raw_dump(tmp_path)
+
+    # Pretend previous run already produced these
+    enriched_p = raw_path.with_name("lund_enriched.json")
+    geojson_p = enriched_p.with_suffix(".geojson")
+    enriched_p.write_text(json.dumps({"elements": []}), encoding="utf-8")
+    geojson_p.write_text(
+        json.dumps({"type": "FeatureCollection", "features": []}), "utf-8"
+    )
+
+    # cache row
+    raw_hash = payload_hash(raw)
+    mem_fake.store(
+        "AnalyzerAgent",
+        "enriched_cache",
+        f"{raw_hash}|{enriched_p}|{geojson_p}",
+    )
+
+    # make LLM blow up if ever called
+    from src.tools.llm_wrapper import LocalLLM
+
+    monkeypatch.setattr(
+        LocalLLM,
+        "generate_response",
+        lambda *_a, **_kw: pytest.fail("LLM should not be called"),
+    )
+
+    agent = AnalyzerAgent("AnalyzerAgent", memory=mem_fake)
+    ctx = agent.achieve_goal({"path": str(raw_path)})
+
+    assert ctx["output_path"] == str(enriched_p)
+    assert ctx["geojson_path"] == str(geojson_p)

tests/agents/test_analyzer_agent.py

@@ -4,7 +4,9 @@
 import pytest
 import requests
 
+from src.agents.analyzer_agent import AnalyzerAgent
 from src.config.settings import OllamaSettings, DatabaseSettings, OverpassSettings
+from src.utils.decorators import log_action
 
 
 @pytest.fixture
@@ -119,3 +121,94 @@ def load(self, agent_id: str):
 @pytest.fixture
 def mem_fake():
     return MemoryStoreFake()
+
+
+class DummyLogger:
+    def __init__(self):
+        self.infos = []
+        self.debugs = []
+        self.exceptions = []
+
+    def info(self, msg):
+        self.infos.append(msg)
+
+    def debug(self, msg):
+        self.debugs.append(msg)
+
+    def exception(self, msg):
+        self.exceptions.append(msg)
+
+
+@pytest.fixture(autouse=True)
+def swap_logger(monkeypatch):
+    stub = DummyLogger()
+    # patch both logger and any module-local imports
+    monkeypatch.setattr("src.config.logger.logger", stub)
+    monkeypatch.setattr("src.utils.decorators.logger", stub)
+    return stub
+
+
+class DummyAgent:
+    name = "MyAgent"
+
+    @log_action
+    def simple(self, x, context=None):
+        """just return x * 2"""
+        return x * 2
+
+    @log_action
+    def make_list(self, n):
+        return list(range(n))
+
+    @log_action
+    def save_file(self, path: str):
+        return f"{path}.json"
+
+    @log_action
+    def blows_up(self):
+        raise ValueError("oops")
+
+
+@pytest.fixture(autouse=True)
+def patch_prompt_template(monkeypatch):
+    """
+    AnalyzerAgent expects a prompt template on disk; for tests we just
+    give it a minimal one in-memory so _load_template() never touches FS.
+    """
+    dummy = "DUMMY TEMPLATE -- tags: {{ tags }}"
+
+    monkeypatch.setattr(
+        AnalyzerAgent, "_load_template", lambda self: dummy, raising=True
+    )
+
+
+# -------------------- Helpers for testing Analyzer agent --------------------#
+def make_raw_dump(tmp_path):
+    """Return Path to a tiny overpass dump with one element."""
+    raw = {
+        "elements": [
+            {
+                "type": "node",
+                "id": 1,
+                "lat": 55.0,
+                "lon": 13.0,
+                "tags": {"man_made": "surveillance"},
+            }
+        ]
+    }
+    p = tmp_path / "lund.json"
+    p.write_text(json.dumps(raw), encoding="utf-8")
+    return p, raw
+
+
+def set_stub_response(data):
+    """
+    Tell StubClient (patched in conftest) to return a canned Ollama reply.
+    """
+    # from tests.conftest import StubClient
+
+    StubClient._response = {
+        # LocalLLM expects either {"response": "<json>"} …
+        "response": json.dumps(data, separators=(",", ":")),
+        # … or {"choices": […]} – we use the first form.
+    }

tests/conftest.py

@@ -0,0 +1,76 @@
+import json
+from pathlib import Path
+
+from src.tools.io_tools import (
+    load_overpass_elements,
+    save_enriched_elements,
+    to_geojson,
+)
+
+ELEMENTS = [
+    {"id": 1, "lat": 10.0, "lon": 20.0, "tags": {"foo": "bar"}, "analysis": {"a": 1}},
+    {"id": 2},  # should be skipped by to_geojson (no lat/lon)
+    {"id": 3, "lat": 0.0, "lon": 0.0, "tags": {}, "analysis": {}},
+]
+
+
+def test_load_overpass_elements(tmp_path):
+    # prepare a dump with a few elements
+    dump = {"elements": [{"id": "x"}, {"id": "y"}]}
+    dump_path = tmp_path / "dump.json"
+    dump_path.write_text(json.dumps(dump), encoding="utf-8")
+
+    loaded = load_overpass_elements(dump_path)
+    assert isinstance(loaded, list)
+    assert loaded == dump["elements"]
+
+
+def test_save_enriched_elements(tmp_path):
+    # create a fake source file so save_enriched_elements can build its name
+    source = tmp_path / "city.json"
+    source.write_text("{}", encoding="utf-8")
+
+    enriched = [{"id": 42}, {"id": 43}]
+    out = save_enriched_elements(enriched, source)
+    out_path = Path(out)
+
+    # file should exist and contain exactly {"elements": enriched}
+    assert out_path.exists()
+    text = out_path.read_text(encoding="utf-8")
+    parsed = json.loads(text)
+    assert parsed == {"elements": enriched}
+
+
+def test_to_geojson_without_writing(tmp_path):
+    # write an enriched JSON file with ELEMENTS
+    enriched = {"elements": ELEMENTS}
+    enriched_path = tmp_path / "in.json"
+    enriched_path.write_text(json.dumps(enriched), encoding="utf-8")
+
+    geo = to_geojson(enriched_path)
+    # should be a FeatureCollection
+    assert geo["type"] == "FeatureCollection"
+    # only two elements have both lat and lon
+    assert len(geo["features"]) == 2
+
+    # check geometry & properties merging
+    feat = geo["features"][0]
+    assert feat["geometry"] == {"type": "Point", "coordinates": [20.0, 10.0]}
+    # props should include both tags and analysis
+    assert feat["properties"]["foo"] == "bar"
+    assert feat["properties"]["a"] == 1
+
+
+def test_to_geojson_with_writing(tmp_path):
+    enriched = {"elements": ELEMENTS}
+    enriched_path = tmp_path / "data.json"
+    enriched_path.write_text(json.dumps(enriched), encoding="utf-8")
+    out_geojson = tmp_path / "out.geojson"
+
+    geo = to_geojson(enriched_path, out_geojson)
+    # file was written
+    assert out_geojson.exists()
+    # contents match returned dict
+    written = json.loads(out_geojson.read_text(encoding="utf-8"))
+    assert written == geo
+    assert written["type"] == "FeatureCollection"