+
+
+
+
+
+
+
-
-
-
-
-
-
-
+
+
+
+
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
- {% if not album_locked %}
-
-
-
+
+
+
+
+
+
+
+
- {% endif %}
-
+
{% if not album_locked %}
-
- {% endif %}
+
+
+
+
-
- {% if not album_locked or multiple_locked_albums %}
-
-
-
-
- {% if not album_locked %}
-
- {% endif %}
+
{% endif %}
+
diff --git a/tests/backend/test_invoke_metadata.py b/tests/backend/test_invoke_metadata.py
index 78aff1ba..387454c5 100644
--- a/tests/backend/test_invoke_metadata.py
+++ b/tests/backend/test_invoke_metadata.py
@@ -817,3 +817,80 @@ def test_control_layer_row_skipped_when_fully_empty(self):
assert tuple_table.count("
") == 1
assert "canny" in tuple_table
assert "e.png" in tuple_table
+
+
+# ---------------------------------------------------------------------------
+# InvokeMetadataView.to_recall_payload — serialization for /api/v1/recall
+# ---------------------------------------------------------------------------
+
+
+class TestRecallPayload:
+ def test_v3_includes_core_fields_loras_controls_ip_adapters(self, v3_metadata):
+ payload = _view(v3_metadata).to_recall_payload(include_seed=True)
+ assert payload["positive_prompt"] == "a cat riding a skateboard"
+ assert payload["negative_prompt"] == "blurry, low quality"
+ assert payload["model"] == "dreamshaper"
+ assert payload["seed"] == 42
+ assert payload["loras"] == [
+ {"model_name": "detail_lora", "weight": 0.8},
+ {"model_name": "style_lora", "weight": 0.5},
+ ]
+ assert payload["ip_adapters"] == [
+ {"model_name": "ip_adapter_sd15", "image_name": "ref.png", "weight": 0.5}
+ ]
+ assert payload["control_layers"] == [
+ {
+ "model_name": "canny_sd15",
+ "image_name": "control.png",
+ "weight": 0.7,
+ }
+ ]
+
+ def test_remix_omits_seed(self, v3_metadata):
+ payload = _view(v3_metadata).to_recall_payload(include_seed=False)
+ assert "seed" not in payload
+ # Everything else still present
+ assert payload["positive_prompt"] == "a cat riding a skateboard"
+ assert payload["loras"]
+
+ def test_v5_ref_images_path(self, v5_ref_images_metadata):
+ payload = _view(v5_ref_images_metadata).to_recall_payload(include_seed=True)
+ assert payload["positive_prompt"] == "a dog in a hat"
+ assert payload["model"] == "flux-schnell"
+ assert payload["seed"] == 100
+ # disabled ref images and disabled control layers are filtered out
+ assert payload["ip_adapters"] == [
+ {"model_name": "ipa-flux", "image_name": "ref1.png", "weight": 0.7}
+ ]
+ assert payload["control_layers"] == [
+ {"model_name": "canny_flux", "image_name": "edges.png", "weight": 0.9}
+ ]
+
+ def test_empty_metadata_returns_empty_payload(self):
+ # Build a view over a near-empty v5 record so that to_recall_payload
+ # still exercises the "omit None" branches.
+ metadata = {"metadata_version": 5}
+ view = _view(metadata)
+ payload = view.to_recall_payload(include_seed=True)
+ assert payload == {}
+
+
+# ---------------------------------------------------------------------------
+# format_invoke_metadata — recall button rendering
+# ---------------------------------------------------------------------------
+
+
+class TestFormatInvokeRecallButtons:
+ def test_buttons_hidden_by_default(self, v3_metadata):
+ html = format_invoke_metadata(_slide(), v3_metadata).description
+ assert "invoke-recall-controls" not in html
+
+ def test_buttons_shown_when_enabled(self, v3_metadata):
+ html = format_invoke_metadata(
+ _slide(), v3_metadata, show_recall_buttons=True
+ ).description
+ assert 'class="invoke-recall-controls"' in html
+ assert 'data-recall-mode="recall"' in html
+ assert 'data-recall-mode="remix"' in html
+ # Asterisk SVG is present for the recall button
+ assert html.count('class="invoke-recall-btn"') == 2
diff --git a/tests/backend/test_invoke_router.py b/tests/backend/test_invoke_router.py
new file mode 100644
index 00000000..9c089f5b
--- /dev/null
+++ b/tests/backend/test_invoke_router.py
@@ -0,0 +1,243 @@
+"""Tests for the InvokeAI recall proxy router.
+
+Covers:
+
+* GET/POST ``/invokeai/config`` round-tripping via the config manager.
+* ``POST /invokeai/recall`` returning a clean error when the backend URL is
+ not configured.
+* ``POST /invokeai/recall`` happy path where we stub ``httpx.AsyncClient`` and
+ verify the payload shape that would reach the upstream InvokeAI backend.
+"""
+
+from __future__ import annotations
+
+import httpx
+import pytest
+
+from photomap.backend.config import get_config_manager
+
+
+@pytest.fixture
+def clear_invokeai_config():
+ """Ensure each test starts and ends without stale InvokeAI config."""
+ manager = get_config_manager()
+ manager.set_invokeai_settings(url=None, username=None, password=None)
+ yield
+ manager.set_invokeai_settings(url=None, username=None, password=None)
+
+
+def test_get_config_empty(client, clear_invokeai_config):
+ response = client.get("/invokeai/config")
+ assert response.status_code == 200
+ body = response.json()
+ assert body == {"url": "", "username": "", "has_password": False}
+
+
+def test_set_and_get_config(client, clear_invokeai_config):
+ response = client.post(
+ "/invokeai/config",
+ json={
+ "url": "http://localhost:9090",
+ "username": "alice",
+ "password": "secret",
+ },
+ )
+ assert response.status_code == 200
+ assert response.json() == {"success": True}
+
+ response = client.get("/invokeai/config")
+ body = response.json()
+ assert body["url"] == "http://localhost:9090"
+ assert body["username"] == "alice"
+ # Password is never echoed back — only a boolean flag.
+ assert body["has_password"] is True
+ assert "password" not in body
+
+
+def test_set_config_preserves_password_on_null(client, clear_invokeai_config):
+ # First store a password.
+ client.post(
+ "/invokeai/config",
+ json={"url": "http://localhost:9090", "password": "original"},
+ )
+ # Now update other fields without sending a password field at all.
+ client.post("/invokeai/config", json={"url": "http://other:9090"})
+
+ manager = get_config_manager()
+ manager.reload_config()
+ settings = manager.get_invokeai_settings()
+ assert settings["url"] == "http://other:9090"
+ assert settings["password"] == "original"
+
+
+def test_recall_requires_configured_url(client, clear_invokeai_config):
+ response = client.post(
+ "/invokeai/recall",
+ json={"album_key": "whatever", "index": 0, "include_seed": True},
+ )
+ assert response.status_code == 400
+ assert "not configured" in response.json()["detail"].lower()
+
+
+def test_recall_proxies_payload_to_invokeai_backend(
+ client, clear_invokeai_config, monkeypatch
+):
+ """Stub out the upstream call and verify the exact payload we forward."""
+ # Configure the backend URL.
+ client.post("/invokeai/config", json={"url": "http://localhost:9090"})
+
+ # Stub out embeddings lookup so the router receives a canned metadata dict.
+ raw_metadata = {
+ "metadata_version": 3,
+ "app_version": "3.5.0",
+ "positive_prompt": "a landscape",
+ "negative_prompt": "blurry",
+ "model": {"model_name": "dreamshaper", "base_model": "sd-1"},
+ "seed": 321,
+ "steps": 25,
+ "cfg_scale": 7.5,
+ "width": 512,
+ "height": 512,
+ }
+
+ from photomap.backend.routers import invoke as invoke_module
+
+ monkeypatch.setattr(
+ invoke_module, "_load_raw_metadata", lambda album_key, index: raw_metadata
+ )
+
+ captured = {}
+
+ class _StubResponse:
+ status_code = 200
+ text = "{}"
+
+ def json(self):
+ return {"status": "success", "updated_count": 7}
+
+ class _StubClient:
+ def __init__(self, *args, **kwargs):
+ pass
+
+ async def __aenter__(self):
+ return self
+
+ async def __aexit__(self, *args):
+ return False
+
+ async def post(self, url, json, **kwargs):
+ captured["url"] = url
+ captured["json"] = json
+ captured["params"] = kwargs.get("params")
+ captured["headers"] = kwargs.get("headers")
+ return _StubResponse()
+
+ monkeypatch.setattr(invoke_module.httpx, "AsyncClient", _StubClient)
+
+ response = client.post(
+ "/invokeai/recall",
+ json={"album_key": "any", "index": 0, "include_seed": True},
+ )
+ assert response.status_code == 200
+ body = response.json()
+ assert body["success"] is True
+ assert body["sent"]["positive_prompt"] == "a landscape"
+ assert body["sent"]["seed"] == 321
+ assert body["sent"]["steps"] == 25
+ assert body["response"]["status"] == "success"
+
+ # The request was routed to the configured backend + the documented path.
+ assert captured["url"] == "http://localhost:9090/api/v1/recall/default"
+ assert captured["json"]["seed"] == 321
+ assert captured["json"]["model"] == "dreamshaper"
+
+
+def test_recall_remix_omits_seed(client, clear_invokeai_config, monkeypatch):
+ client.post("/invokeai/config", json={"url": "http://localhost:9090"})
+
+ raw_metadata = {
+ "metadata_version": 3,
+ "app_version": "3.5.0",
+ "positive_prompt": "x",
+ "model": {"model_name": "m", "base_model": "sd-1"},
+ "seed": 12345,
+ }
+
+ from photomap.backend.routers import invoke as invoke_module
+
+ monkeypatch.setattr(
+ invoke_module, "_load_raw_metadata", lambda album_key, index: raw_metadata
+ )
+
+ captured = {}
+
+ class _StubResponse:
+ status_code = 200
+ text = "{}"
+
+ def json(self):
+ return {"status": "success"}
+
+ class _StubClient:
+ def __init__(self, *args, **kwargs):
+ pass
+
+ async def __aenter__(self):
+ return self
+
+ async def __aexit__(self, *args):
+ return False
+
+ async def post(self, url, json, **kwargs):
+ captured["json"] = json
+ return _StubResponse()
+
+ monkeypatch.setattr(invoke_module.httpx, "AsyncClient", _StubClient)
+
+ response = client.post(
+ "/invokeai/recall",
+ json={"album_key": "any", "index": 0, "include_seed": False},
+ )
+ assert response.status_code == 200
+ assert "seed" not in captured["json"]
+
+
+def test_recall_upstream_unreachable_returns_502(
+ client, clear_invokeai_config, monkeypatch
+):
+ client.post("/invokeai/config", json={"url": "http://localhost:9999"})
+
+ raw_metadata = {
+ "metadata_version": 3,
+ "app_version": "3.5.0",
+ "positive_prompt": "x",
+ "model": {"model_name": "m", "base_model": "sd-1"},
+ }
+
+ from photomap.backend.routers import invoke as invoke_module
+
+ monkeypatch.setattr(
+ invoke_module, "_load_raw_metadata", lambda album_key, index: raw_metadata
+ )
+
+ class _StubClient:
+ def __init__(self, *args, **kwargs):
+ pass
+
+ async def __aenter__(self):
+ return self
+
+ async def __aexit__(self, *args):
+ return False
+
+ async def post(self, url, json, **kwargs):
+ raise httpx.ConnectError("connection refused")
+
+ monkeypatch.setattr(invoke_module.httpx, "AsyncClient", _StubClient)
+
+ response = client.post(
+ "/invokeai/recall",
+ json={"album_key": "any", "index": 0, "include_seed": True},
+ )
+ assert response.status_code == 502
+ assert "Could not reach InvokeAI backend" in response.json()["detail"]
diff --git a/tests/frontend/invoke-recall.test.js b/tests/frontend/invoke-recall.test.js
new file mode 100644
index 00000000..a421e629
--- /dev/null
+++ b/tests/frontend/invoke-recall.test.js
@@ -0,0 +1,184 @@
+// Unit tests for invoke-recall.js — the Recall / Remix buttons wired into the
+// InvokeAI metadata drawer.
+
+import { jest, describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+
+// Mock the chain of modules pulled in by state.js so the module can load in
+// jsdom without hitting real DOM bootstraps.
+jest.unstable_mockModule("../../photomap/frontend/static/javascript/album-manager.js", () => ({
+ albumManager: { fetchAvailableAlbums: jest.fn(() => Promise.resolve([])) },
+ checkAlbumIndex: jest.fn(),
+}));
+jest.unstable_mockModule("../../photomap/frontend/static/javascript/index.js", () => ({
+ getIndexMetadata: jest.fn(() => Promise.resolve({ filename_count: 0 })),
+}));
+jest.unstable_mockModule("../../photomap/frontend/static/javascript/utils.js", () => ({
+ showSpinner: jest.fn(),
+ hideSpinner: jest.fn(),
+}));
+
+const { state } = await import("../../photomap/frontend/static/javascript/state.js");
+const { parseMetadataUrl, sendRecall } = await import("../../photomap/frontend/static/javascript/invoke-recall.js");
+
+describe("invoke-recall.js", () => {
+ describe("parseMetadataUrl", () => {
+ it("parses a relative metadata_url into album key and index", () => {
+ expect(parseMetadataUrl("get_metadata/my-album/42")).toEqual({
+ albumKey: "my-album",
+ index: 42,
+ });
+ });
+
+ it("handles absolute URLs with prefixes", () => {
+ expect(parseMetadataUrl("http://localhost:8050/get_metadata/vacation/7")).toEqual({
+ albumKey: "vacation",
+ index: 7,
+ });
+ });
+
+ it("decodes URL-encoded album keys", () => {
+ expect(parseMetadataUrl("get_metadata/my%20album/3")).toEqual({
+ albumKey: "my album",
+ index: 3,
+ });
+ });
+
+ it("returns null for malformed metadata URLs", () => {
+ expect(parseMetadataUrl("")).toBeNull();
+ expect(parseMetadataUrl(null)).toBeNull();
+ expect(parseMetadataUrl("get_metadata/onlyalbum")).toBeNull();
+ expect(parseMetadataUrl("get_metadata/album/notanumber")).toBeNull();
+ });
+ });
+
+ describe("sendRecall", () => {
+ afterEach(() => {
+ // Make sure other tests can't see leftover fetch stubs.
+ delete global.fetch;
+ });
+
+ it("POSTs album_key / index / include_seed to /invokeai/recall", async () => {
+ const fetchMock = jest.fn(() =>
+ Promise.resolve({
+ ok: true,
+ json: () => Promise.resolve({ success: true }),
+ })
+ );
+ global.fetch = fetchMock;
+
+ const result = await sendRecall({
+ albumKey: "vacation",
+ index: 3,
+ includeSeed: false,
+ });
+
+ expect(fetchMock).toHaveBeenCalledTimes(1);
+ const [url, opts] = fetchMock.mock.calls[0];
+ expect(url).toBe("invokeai/recall");
+ expect(opts.method).toBe("POST");
+ expect(JSON.parse(opts.body)).toEqual({
+ album_key: "vacation",
+ index: 3,
+ include_seed: false,
+ });
+ expect(result).toEqual({ success: true });
+ });
+
+ it("throws with the server-provided detail on non-2xx responses", async () => {
+ global.fetch = jest.fn(() =>
+ Promise.resolve({
+ ok: false,
+ status: 502,
+ json: () => Promise.resolve({ detail: "boom" }),
+ })
+ );
+ await expect(sendRecall({ albumKey: "a", index: 0, includeSeed: true })).rejects.toThrow("boom");
+ });
+ });
+
+ describe("button click handling", () => {
+ beforeEach(() => {
+ state.album = "fallback-album";
+ document.body.innerHTML = `
+
+
+
+
+
+ `;
+ });
+
+ afterEach(() => {
+ delete global.fetch;
+ document.body.innerHTML = "";
+ });
+
+ async function flushPromises() {
+ // Two ticks: one for the fetch Promise, one for the .then() chain.
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ }
+
+ it("shows a success checkmark on successful recall and forwards album/index", async () => {
+ const fetchMock = jest.fn(() =>
+ Promise.resolve({
+ ok: true,
+ json: () => Promise.resolve({ success: true }),
+ })
+ );
+ global.fetch = fetchMock;
+
+ const recallButton = document.querySelector('[data-recall-mode="recall"]');
+ recallButton.click();
+ await flushPromises();
+
+ const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+ expect(body.album_key).toBe("my-album");
+ expect(body.index).toBe(5);
+ expect(body.include_seed).toBe(true);
+
+ const status = recallButton.querySelector(".invoke-recall-status");
+ expect(status.classList.contains("success")).toBe(true);
+ expect(status.textContent).toBe("✓");
+ });
+
+ it("passes include_seed=false for the remix button", async () => {
+ const fetchMock = jest.fn(() =>
+ Promise.resolve({
+ ok: true,
+ json: () => Promise.resolve({ success: true }),
+ })
+ );
+ global.fetch = fetchMock;
+
+ document.querySelector('[data-recall-mode="remix"]').click();
+ await flushPromises();
+
+ const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+ expect(body.include_seed).toBe(false);
+ });
+
+ it("shows a red X on failure", async () => {
+ global.fetch = jest.fn(() =>
+ Promise.resolve({
+ ok: false,
+ status: 502,
+ json: () => Promise.resolve({ detail: "backend down" }),
+ })
+ );
+
+ const btn = document.querySelector('[data-recall-mode="recall"]');
+ btn.click();
+ await flushPromises();
+
+ const status = btn.querySelector(".invoke-recall-status");
+ expect(status.classList.contains("error")).toBe(true);
+ expect(status.querySelector("svg")).not.toBeNull();
+ });
+ });
+});