- ← {{ t.back_methods }}
+ ← {{ t.back_methods }}
{{ t.experience }} · {{ data.title }}
diff --git a/src/powercontext/server/dashboard/templates/methods.html b/src/powercontext/server/dashboard/templates/methods.html
index 5846a03983..bb3027c1cb 100644
--- a/src/powercontext/server/dashboard/templates/methods.html
+++ b/src/powercontext/server/dashboard/templates/methods.html
@@ -29,10 +29,10 @@
{% from 'components/search.html' import search_form with context %}
{{ page_heading(t.methods, t.methods_subtitle) }}
-{% if method_kind == 'skill' %}{{ search_form(t.search_skills, 2000, 'skill') }}{% endif %}
-{% if collection.get('search_limited') %}{{ data.experience.lesson }}
{{ t.skills_limit }}
{% endif %} +{{ search_form(t.search_experiences if method_kind == 'experience' else t.search_skills, 2000, method_kind) }} +{% if collection.get('search_limited') %}{{ t.experiences_limit if method_kind == 'experience' else t.skills_limit }}
{% endif %} {% from 'components/read-error.html' import read_error with context %} {% if errors.get(family) %}{{ read_error(errors[family], t[family]) }}{% endif %}
{{ t[family] }} · {{ t.revision }} {{ record.revision }}
-
{{ (record.lesson if family == 'experience' else record.name)|truncate(80, true) }}
+{{ (record.lesson if family == 'experience' else record.name)|truncate(80, true) }}
{{ (record.situation if family == 'experience' else record.description)|truncate(160, true) }}
- {{ t.read_experience if family == 'experience' else t.read_skill }} + {{ t.read_experience if family == 'experience' else t.read_skill }}{% if search_query and family == 'skill' %}
{{ t.skills_no_match }}
{% else %}{{ t.experience_empty if family == 'experience' else t.skills_empty }}
{% endif %}{% if search_query %}
{{ t.experiences_no_match if family == 'experience' else t.skills_no_match }}
{% else %}{{ t.experience_empty if family == 'experience' else t.skills_empty }}
{% endif %}
- ← {{ t.back_methods }}
+ ← {{ t.back_methods }}
{{ t.skill_reading }} · {{ data.title }} · {{ t.revision }} {{ data.skill.revision }}
]*href="([^"]+)"[^>]*>[^<]*' + re.escape(label) + r"[^<]*", html)
+ assert match is not None
+ return unescape(match[1])
+
+
+def detail_link(html: str, family: str) -> str:
+ return next(
+ unescape(value)
+ for value in re.findall(r'href="([^"]+)"', html)
+ if urlsplit(unescape(value)).path == f"/dashboard/{family}"
+ )
+
+
+def alert_retry(html: str) -> str:
+ alert = re.search(r'.*? ', html, re.S)
+ assert alert is not None
+ match = re.search(r'href="([^"]+)"[^>]*>' + re.escape(LABELS["retry"]) + "", alert[0])
+ assert match is not None
+ return unescape(match[1])
+
+
def test_scope_selection_default_and_unknown_scope(dashboard: TestClient) -> None:
parent = create_scope(dashboard, "Project")
child = create_scope(dashboard, "Documentation", parent["scope_id"])
@@ -598,6 +674,369 @@ def test_method_pagination_returns_to_the_previous_records(dashboard: TestClient
assert collect_pages(dashboard, first.text, f"/dashboard/{family}", "artifact") == expected
+@pytest.mark.parametrize("language", ["zh", "en"])
+def test_experience_search_filters_results_and_restores_browsing(dashboard: TestClient, language: str) -> None:
+ labels = CATALOGS[language]
+ scope = create_scope(dashboard, f"Experience search {language}")["scope_id"]
+ source = capture_source(dashboard, scope, "Search the dashboard experiences.")
+ create_experience(
+ dashboard, scope, source, situation="Adding dashboard search", lesson="Deploy the dashboard search form"
+ )
+ create_experience(
+ dashboard, scope, source, situation="Rotating the signing key", lesson="Never reuse a retired signing key"
+ )
+
+ browsing = dashboard.get("/dashboard/methods", params={"scope": scope, "kind": "experience", "lang": language})
+ assert browsing.status_code == 200
+ assert labels["search_experiences"] in browsing.text
+ assert "Deploy the dashboard search form" in browsing.text
+ assert "Never reuse a retired signing key" in browsing.text
+
+ searched = dashboard.get(
+ "/dashboard/methods", params={"scope": scope, "kind": "experience", "q": "dashboard", "lang": language}
+ )
+ assert searched.status_code == 200
+ assert 'value="dashboard"' in searched.text
+ assert "Deploy the dashboard search form" in searched.text
+ assert "Never reuse a retired signing key" not in searched.text
+
+ cleared = dashboard.get(page_link(searched.text, labels["clear_search"]))
+ assert cleared.status_code == 200
+ assert cleared.url.params["kind"] == "experience"
+ assert "Never reuse a retired signing key" in cleared.text
+ assert 'value="dashboard"' not in cleared.text
+
+ empty = dashboard.get(
+ "/dashboard/methods",
+ params={"scope": scope, "kind": "experience", "q": "absent-token", "lang": language},
+ )
+ assert empty.status_code == 200
+ assert labels["experiences_no_match"] in empty.text
+ assert labels["experience_empty"] not in empty.text
+
+
+def test_experience_search_preserves_query_and_page_through_detail_and_back(dashboard: TestClient) -> None:
+ scope = create_scope(dashboard, "Experience search paging")["scope_id"]
+ source = capture_source(dashboard, scope, "Page through the matching experiences.")
+ for index in range(7):
+ create_experience(
+ dashboard,
+ scope,
+ source,
+ situation=f"Reviewing needle {index}",
+ lesson=f"Keep needle note {index} documented",
+ )
+ first = dashboard.get("/dashboard/methods", params={"scope": scope, "kind": "experience", "q": "needle"})
+ assert first.status_code == 200
+ assert len(record_links(first.text, "/dashboard/experience", "artifact")) == 6
+ following = page_link(first.text, LABELS["next_page"])
+ assert parse_qs(urlsplit(following).query)["q"] == ["needle"]
+ second = dashboard.get(following)
+ assert second.status_code == 200
+ page_records = record_links(second.text, "/dashboard/experience", "artifact")
+ assert len(page_records) == 1
+ detail_url = detail_link(second.text, "experience")
+ return_to = parse_qs(urlsplit(detail_url).query)["return_to"][0]
+ assert parse_qs(urlsplit(return_to).query)["q"] == ["needle"]
+ assert parse_qs(urlsplit(return_to).query)["experience_page"] == ["2"]
+ detail = dashboard.get(detail_url)
+ assert detail.status_code == 200
+ restored = dashboard.get(labelled_link(detail.text, LABELS["back_methods"]))
+ assert restored.status_code == 200
+ assert restored.url.params["q"] == "needle"
+ assert restored.url.params["experience_page"] == "2"
+ assert restored.url.params["kind"] == "experience"
+ assert record_links(restored.text, "/dashboard/experience", "artifact") == page_records
+
+
+def test_skill_search_preserves_the_result_page_through_detail_and_back(dashboard: TestClient) -> None:
+ scope = create_scope(dashboard, "Skill search paging")["scope_id"]
+ source = capture_source(dashboard, scope, "Page through the matching skills.")
+ for index in range(7):
+ create_skill(dashboard, scope, source, f"needle-skill-{index}")
+ second = dashboard.get(
+ "/dashboard/methods", params={"scope": scope, "kind": "skill", "q": "needle", "skill_page": "2"}
+ )
+ assert second.status_code == 200
+ page_records = record_links(second.text, "/dashboard/skill", "artifact")
+ assert len(page_records) == 1
+ detail_url = detail_link(second.text, "skill")
+ detail = dashboard.get(detail_url)
+ assert detail.status_code == 200
+ restored = dashboard.get(labelled_link(detail.text, LABELS["back_methods"]))
+ assert restored.status_code == 200
+ assert restored.url.params["q"] == "needle"
+ assert restored.url.params["skill_page"] == "2"
+ assert restored.url.params["kind"] == "skill"
+ assert record_links(restored.text, "/dashboard/skill", "artifact") == page_records
+
+
+@pytest.mark.parametrize("family", ["experience", "skill"])
+def test_methods_return_uses_the_current_language(dashboard: TestClient, family: str) -> None:
+ scope = create_scope(dashboard, f"{family} language return")["scope_id"]
+ source = capture_source(dashboard, scope, f"Keep the {family} language searchable.")
+ if family == "experience":
+ create_experience(dashboard, scope, source, situation="needle situation", lesson="Keep the needle lesson")
+ else:
+ create_skill(dashboard, scope, source, "needle-skill")
+ searched = dashboard.get("/dashboard/methods", params={"scope": scope, "kind": family, "q": "needle", "lang": "en"})
+ assert searched.status_code == 200
+ detail_url = detail_link(searched.text, family)
+ return_to = parse_qs(urlsplit(detail_url).query)["return_to"][0]
+ assert parse_qs(urlsplit(return_to).query)["lang"] == ["en"]
+ detail = dashboard.get(detail_url)
+ assert detail.status_code == 200
+ switched = dashboard.get(f"{detail_url}&lang=zh")
+ assert switched.status_code == 200
+ restored = dashboard.get(labelled_link(switched.text, LABELS["back_methods"]))
+ assert restored.status_code == 200
+ assert restored.url.params["lang"] == "zh"
+ assert restored.url.params["q"] == "needle"
+ assert restored.url.params["kind"] == family
+ assert ("搜索经验" if family == "experience" else "搜索技能") in restored.text
+
+
+def test_methods_return_to_accepts_supported_text() -> None:
+ scope = "scp_demo"
+ for query in ("needle\\path", "needle & path = 100% #1", "中" * 2000):
+ raw = "/dashboard/methods?" + urlencode({
+ "scope": scope,
+ "period": "7d",
+ "kind": "experience",
+ "q": query,
+ "experience_page": "2",
+ })
+ result = collection_return(raw, scope, page="methods")
+ assert result is not None
+ params = parse_qs(urlsplit(result).query)
+ assert params["q"] == [query]
+ assert params["experience_page"] == ["2"]
+
+
+@pytest.mark.parametrize(
+ "raw",
+ [
+ "/dashboard/methods?scope=other&kind=experience&q=needle",
+ "/dashboard/handoff?scope=scp_demo&cursor=next",
+ "/dashboard/methods?scope=scp_demo&kind=all&q=needle",
+ "/dashboard/methods?scope=scp_demo&kind=experience&q=needle&experience_page=1%5C2",
+ "/dashboard/methods?scope=scp_demo&kind=experience&q=needle%0D%0ASet-Cookie",
+ ],
+)
+def test_methods_return_to_rejects_unsupported_context(raw: str) -> None:
+ assert collection_return(raw, "scp_demo", page="methods") is None
+
+
+def test_methods_return_to_rejects_oversized_context() -> None:
+ raw = "/dashboard/methods?scope=scp_demo&kind=experience&q=" + "a" * (33 * 1024)
+ assert collection_return(raw, "scp_demo", page="methods") is None
+
+
+@pytest.mark.parametrize(
+ ("query", "text"),
+ [
+ ("needle\\path", "Keep the needle path"),
+ ("needle & path = 100% #1", "Keep special characters"),
+ ("经验 " * 460, "经验 long query"),
+ ],
+ ids=["backslash", "special", "long"],
+)
+def test_experience_search_accepts_edge_query_text(dashboard: TestClient, query: str, text: str) -> None:
+ scope = create_scope(dashboard, "Experience edge queries")["scope_id"]
+ source = capture_source(dashboard, scope, "Keep edge queries searchable.")
+ create_experience(dashboard, scope, source, situation="needle path", lesson="Keep the needle path")
+ create_experience(dashboard, scope, source, situation="needle & path = 100% #1", lesson="Keep special characters")
+ create_experience(dashboard, scope, source, situation="经验 long query", lesson="经验 " * 460)
+ searched = dashboard.get("/dashboard/methods", params={"scope": scope, "kind": "experience", "q": query})
+ assert searched.status_code == 200
+ assert text in searched.text
+ detail_url = detail_link(searched.text, "experience")
+ detail = dashboard.get(detail_url)
+ assert detail.status_code == 200
+ restored = dashboard.get(labelled_link(detail.text, LABELS["back_methods"]))
+ assert restored.status_code == 200
+ assert restored.url.params["q"] == query
+
+
+def test_experience_detail_rejects_a_foreign_return_to(dashboard: TestClient) -> None:
+ scope = create_scope(dashboard, "Experience return boundary")["scope_id"]
+ other = create_scope(dashboard, "Other experience return")["scope_id"]
+ source = capture_source(dashboard, scope, "Keep the return inside its scope.")
+ artifact = create_experience(dashboard, scope, source, situation="Reviewing", lesson="Stay in the scope")
+ detail = dashboard.get(
+ "/dashboard/experience",
+ params={
+ "scope": scope,
+ "artifact": artifact,
+ "revision": "1",
+ "return_to": f"/dashboard/methods?scope={other}&kind=experience&q=needle",
+ },
+ )
+ assert detail.status_code == 200
+ restored = dashboard.get(labelled_link(detail.text, LABELS["back_methods"]))
+ assert restored.status_code == 200
+ assert restored.url.params["scope"] == scope
+ assert "q" not in restored.url.params
+
+
+def test_experience_search_state_survives_compare_and_rollback(dashboard: TestClient) -> None:
+ scope = create_scope(dashboard, "Experience search history")["scope_id"]
+ content = {
+ "situation": "Reviewing the needle search",
+ "action": "Keep the search origin",
+ "outcome": "The result page survives detail navigation",
+ "lesson": "Keep the needle search state",
+ }
+ created = dashboard.post(f"/v1/scopes/{scope}/artifacts", json={"family": "experience", "content": content})
+ assert created.status_code == 201, created.text
+ artifact = created.json()["artifact_id"]
+ current = dashboard.get(f"/v1/scopes/{scope}/artifacts/experience/{artifact}")
+ revised = dashboard.put(
+ f"/v1/scopes/{scope}/artifacts/experience/{artifact}",
+ json={"content": {**content, "lesson": "A later needle lesson"}},
+ headers={"If-Match": current.headers["etag"]},
+ )
+ assert revised.status_code == 200, revised.text
+
+ searched = dashboard.get("/dashboard/methods", params={"scope": scope, "kind": "experience", "q": "needle"})
+ assert searched.status_code == 200
+ detail_url = detail_link(searched.text, "experience")
+ return_to = parse_qs(urlsplit(detail_url).query)["return_to"][0]
+ revision = dashboard.get(
+ "/dashboard/experience",
+ params={
+ "scope": scope,
+ "artifact": artifact,
+ "revision": "1",
+ "compare": "2",
+ "return_to": return_to,
+ },
+ )
+ assert revision.status_code == 200, revision.text
+ assert 'action="/dashboard/rollback"' in revision.text
+ compare_form = re.search(
+ r'',
+ revision.text,
+ re.S,
+ )
+ assert compare_form is not None
+ assert 'name="return_to"' in compare_form[0]
+ rollback_form = re.search(
+ r'', revision.text, re.S
+ )
+ assert rollback_form is not None
+ assert 'name="return_to"' in rollback_form[0]
+
+ restored = dashboard.post(
+ "/dashboard/rollback",
+ data={
+ "scope": scope,
+ "family": "experience",
+ "artifact_id": artifact,
+ "source_revision": "1",
+ "expected_revision": "2",
+ "reason": "Restore the searched revision",
+ "return_to": return_to,
+ },
+ headers={"Origin": "http://testserver"},
+ )
+ assert restored.status_code == 200, restored.text
+ assert restored.url.params["return_to"] == return_to
+ back = dashboard.get(labelled_link(restored.text, LABELS["back_methods"]))
+ assert back.status_code == 200
+ assert back.url.params["q"] == "needle"
+ assert back.url.params["kind"] == "experience"
+
+
+def test_experience_search_retry_keeps_the_result_page(dashboard: TestClient, monkeypatch) -> None:
+ scope = create_scope(dashboard, "Experience retry page")["scope_id"]
+ search_path = f"/v1/scopes/{scope}/artifacts/experience/search"
+ read = DashboardAPI.read
+
+ async def failing(api, path, payload=None):
+ if path == search_path:
+ raise ReadError(503, "service_unavailable")
+ return await read(api, path, payload)
+
+ monkeypatch.setattr(DashboardAPI, "read", failing)
+ response = dashboard.get(
+ "/dashboard/methods",
+ params={"scope": scope, "kind": "experience", "q": "needle", "experience_page": "2"},
+ )
+ assert response.status_code == 200
+ retry = alert_retry(response.text)
+ params = parse_qs(urlsplit(retry).query)
+ assert params["q"] == ["needle"]
+ assert params["experience_page"] == ["2"]
+ assert params["kind"] == ["experience"]
+ form = re.search(r'
{{ data.skill.name }}
{{ data.skill.description }}
{{ t.skill_instructions }}
{{ data.skill.instructions or t.skill_body_unavailable }}