PL-135538: Switch last 3 tests from real llama-server to dummy engine

- test_manager_start_model: use gemma (dummy), remove /v1/models assertion
- test_manager_start_crash_quick_return: replaced with
  test_manager_start_gemma_is_dummy (proves default fixture is DummyModel)
- test_embeddinggemma_output_stability: replaced with
  test_dummy_embedding_determinism (proves deterministic embeddings)
- Add embeddinggemma / embeddinggemma_dummy fixtures (dummy engine)

Author: elikoga

src/skvaider/inference/conftest.py

@@ -222,6 +222,26 @@ async def gemma(gemma_dummy: DummyModel) -> DummyModel:
     return gemma_dummy
 
 
+@pytest.fixture
+async def embeddinggemma_dummy(manager: Manager) -> DummyModel:
+    """In-process dummy embedding model."""
+    config = DummyModelConfig(
+        id="embeddinggemma",
+        task="embedding",
+        max_requests=4,
+        port=get_port(),
+    )
+    model = DummyModel(config, manager.manifest_changed.set)
+    manager.add_model(model)
+    return model
+
+
+@pytest.fixture
+async def embeddinggemma(embeddinggemma_dummy: DummyModel) -> DummyModel:
+    """Default embeddinggemma fixture — uses the in-process dummy engine."""
+    return embeddinggemma_dummy
+
+
 @pytest.fixture
 async def embeddinggemma_real(
     models_cache: Path, manager: Manager

src/skvaider/inference/tests/test_manager.py

@@ -1,60 +1,23 @@
-import asyncio
 from pathlib import Path
 
 import httpx
 import pytest
 
+from skvaider.dummy_engine import DummyModel
 from skvaider.inference.config import LlamaModelFile, LlamaServerModelConfig
 from skvaider.inference.manager import Manager
 from skvaider.inference.model import LlamaModel
 
 
-async def test_manager_start_crash_quick_return(
-    gemma_real: LlamaModel, manager: Manager
-):
-    gemma_real._config.cmd_args = ["--asdf"]
-    with pytest.raises(asyncio.CancelledError):
-        await asyncio.wait_for(manager.start_model("gemma"), timeout=10)
-
-
-async def test_download_model_success(gemma_real: LlamaModel):
-    await gemma_real.download()
-    assert gemma_real.model_files[0].exists()
-    assert gemma_real.integrity_marker_file.exists()
-
-
-async def test_download_model_wrong_hash(tmp_path: Path, gguf_http_server: str):
-    config = LlamaServerModelConfig(
-        id="gemma",
-        files=[
-            LlamaModelFile(
-                url=f"{gguf_http_server}/not-a-model.gguf",
-                hash="foobar",
-            )
-        ],
-        context_size=1024,
-        port=0,
-        task="chat",
-    )
-    model = LlamaModel(config, lambda: None)
-    model.datadir = tmp_path
-    with pytest.raises(ValueError) as e:
-        await model.download()
-    assert (
-        e.value.args[0]
-        == "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
-    )
-    assert model.model_files[0].exists()
-    assert not model.integrity_marker_file.exists()
-
-
-async def test_manager_start_model(gemma_real: LlamaModel, manager: Manager):
+async def test_manager_start_model(gemma: DummyModel, manager: Manager):
+    """Full lifecycle via manager — start, use, chat, unload."""
+    model = gemma
     assert await manager.use_model("unknown-model") is None
 
     # not yet started, not usable
     assert await manager.use_model("gemma") is None
 
-    model = await manager.start_model("gemma")
+    await manager.start_model("gemma")
     assert model.config.id == "gemma"
     assert model.endpoint
     assert model.endpoint.startswith("http://127.0.0.1:")
@@ -65,56 +28,6 @@ async def test_manager_start_model(gemma_real: LlamaModel, manager: Manager):
         r.raise_for_status()
         assert r.json() == {"status": "ok"}
 
-        # Get model info via OpenAI-compatible endpoint
-        r = await client.get(f"{model.endpoint}/v1/models")
-        r.raise_for_status()
-        models = r.json()
-        data0 = models["data"][0]
-        data0.pop("created", None)
-        # shows up in ci - differente llama-cpp version?
-        data0.pop("aliases", None)
-        data0.pop("tags", None)
-        assert models == {
-            "data": [
-                {
-                    "id": "gemma",
-                    "meta": {
-                        "n_ctx_train": 32768,
-                        "n_embd": 640,
-                        "n_params": 268098176,
-                        "n_vocab": 262144,
-                        "size": 247407104,
-                        "vocab_type": 1,
-                    },
-                    "object": "model",
-                    "owned_by": "llamacpp",
-                },
-            ],
-            "models": [
-                {
-                    "capabilities": ["completion"],
-                    "description": "",
-                    "details": {
-                        "families": [""],
-                        "family": "",
-                        "format": "gguf",
-                        "parameter_size": "",
-                        "parent_model": "",
-                        "quantization_level": "",
-                    },
-                    "digest": "",
-                    "model": "gemma",
-                    "modified_at": "",
-                    "name": "gemma",
-                    "parameters": "",
-                    "size": "",
-                    "tags": [""],
-                    "type": "model",
-                }
-            ],
-            "object": "list",
-        }
-
         # Run a simple completion via OpenAI-compatible chat API
         r = await client.post(
             f"{model.endpoint}/v1/chat/completions",
@@ -144,6 +57,46 @@ async def test_manager_start_model(gemma_real: LlamaModel, manager: Manager):
     assert model.health_status == ""
 
 
+async def test_manager_start_gemma_is_dummy(
+    gemma: DummyModel, manager: Manager
+):
+    """Default gemma fixture uses DummyModel (not LlamaModel)."""
+    assert isinstance(gemma, DummyModel)
+    assert gemma._engine == "dummy"
+
+
+async def test_download_model_success(gemma_real: LlamaModel):
+    """Real LlamaModel download still works (no subprocess needed)."""
+    await gemma_real.download()
+    assert gemma_real.model_files[0].exists()
+    assert gemma_real.integrity_marker_file.exists()
+
+
+async def test_download_model_wrong_hash(tmp_path: Path, gguf_http_server: str):
+    config = LlamaServerModelConfig(
+        id="gemma",
+        files=[
+            LlamaModelFile(
+                url=f"{gguf_http_server}/not-a-model.gguf",
+                hash="foobar",
+            )
+        ],
+        context_size=1024,
+        port=0,
+        task="chat",
+    )
+    model = LlamaModel(config, lambda: None)
+    model.datadir = tmp_path
+    with pytest.raises(ValueError) as e:
+        await model.download()
+    assert (
+        e.value.args[0]
+        == "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    )
+    assert model.model_files[0].exists()
+    assert not model.integrity_marker_file.exists()
+
+
 async def test_download_split_model(tmp_path: Path, gguf_http_server: str):
     config = LlamaServerModelConfig(
         id="split-gemma",

src/skvaider/inference/tests/test_stability.py

@@ -1,51 +1,29 @@
-import json
-import pathlib
-
 import httpx
 import pytest
 
-from skvaider.inference.manager import Model
-
+from skvaider.dummy_engine import DummyModel
 
-@pytest.mark.timeout(120)
-async def test_embeddinggemma_output_stability(embeddinggemma_real: Model):
-    await embeddinggemma_real.start()
 
-    async with httpx.AsyncClient(timeout=120) as client:
-        response = await client.post(
-            f"{embeddinggemma_real.endpoint}/v1/embeddings",
-            json={
-                "input": "why is the sky blue?",
-                "temperature": 0.0,
-                "seed": 42,
-                "cache_prompt": False,
-            },
-        )  # inspired by ollama/integration/model_arch_Test_go.
-        assert response.status_code == 200
+@pytest.mark.timeout(30)
+async def test_dummy_embedding_determinism(embeddinggemma: DummyModel):
+    """Dummy engine produces deterministic embeddings."""
+    await embeddinggemma.start()
 
-        # uncomment to update the expected output
-        # with open(pathlib.Path(__file__).parent / "fixtures" / "embeddinggemma_stability_output.json", "w") as f:
-        #     f.write(response.text)
+    async with httpx.AsyncClient(timeout=30) as client:
+        response1 = await client.post(
+            f"{embeddinggemma.endpoint}/v1/embeddings",
+            json={"input": "why is the sky blue?"},
+        )
+        assert response1.status_code == 200
+        data1 = response1.json()
 
-        with open(
-            pathlib.Path(__file__).parent
-            / "fixtures"
-            / "embeddinggemma_stability_output.json",
-            "r",
-        ) as f:
-            expected_response = json.load(f)
+        response2 = await client.post(
+            f"{embeddinggemma.endpoint}/v1/embeddings",
+            json={"input": "why is the sky blue?"},
+        )
+        assert response2.status_code == 200
+        data2 = response2.json()
 
-        # check data, max 1e-2 difference in each embedding value
-        resp_json = response.json()
-        for resp_item, exp_item in zip(
-            resp_json["data"], expected_response["data"]
-        ):
-            resp_embedding = resp_item["embedding"]
-            exp_embedding = exp_item["embedding"]
-            assert len(resp_embedding) == len(exp_embedding)
-            for r_val, e_val in zip(resp_embedding, exp_embedding):
-                assert abs(r_val - e_val) < 1e-2
-        # delete data to compare the rest of the response
-        del resp_json["data"]
-        del expected_response["data"]
-        assert resp_json == expected_response
+    # Same input → same deterministic embedding
+    assert data1["data"][0]["embedding"] == data2["data"][0]["embedding"]
+    assert len(data1["data"][0]["embedding"]) > 0