Ty
76df8b7ab6
Add owner-safe lesson catalog, fixture-backed capability statuses, CLI, and unit tests without live OAuth or connect scripts.
298 lines
10 KiB
Python
298 lines
10 KiB
Python
"""Tests for lumina_skills.setup.lesson_catalog."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import sys
|
|
import pathlib
|
|
|
|
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[2] / "skills" / "_lib"))
|
|
|
|
from lumina_skills.setup.lesson_catalog import (
|
|
FORBIDDEN_KEYWORDS,
|
|
Lesson,
|
|
LESSON_CATALOG,
|
|
format_lesson_text,
|
|
format_all_lessons_text,
|
|
get_lesson,
|
|
get_lessons_by_area,
|
|
get_all_lessons,
|
|
is_owner_safe,
|
|
validate_lesson_owner_safe,
|
|
validate_catalog_owner_safe,
|
|
)
|
|
|
|
|
|
# ── Lesson catalog structure ──────────────────────────────────────────────
|
|
|
|
def test_catalog_has_seven_lessons():
|
|
"""Catalog must have exactly 7 lessons (matching SETUP_UX steps 1-7)."""
|
|
assert len(LESSON_CATALOG) == 7
|
|
|
|
|
|
def test_lesson_steps_are_sequential():
|
|
"""Lesson steps must be 1 through 7."""
|
|
steps = [l.step for l in LESSON_CATALOG]
|
|
assert steps == list(range(1, 8))
|
|
|
|
|
|
def test_all_lessons_returns_all():
|
|
assert len(get_all_lessons()) == 7
|
|
|
|
|
|
def test_get_lesson_by_step():
|
|
lesson = get_lesson(1)
|
|
assert lesson is not None
|
|
assert lesson.step == 1
|
|
assert "name" in lesson.title.lower() or "assistant" in lesson.title.lower()
|
|
|
|
|
|
def test_get_lesson_out_of_range():
|
|
assert get_lesson(0) is None
|
|
assert get_lesson(8) is None
|
|
assert get_lesson(-1) is None
|
|
|
|
|
|
def test_get_lessons_by_area():
|
|
channel_lessons = get_lessons_by_area("channels")
|
|
assert len(channel_lessons) >= 1
|
|
assert all(l.area == "channels" for l in channel_lessons)
|
|
|
|
|
|
def test_get_lessons_by_area_empty():
|
|
assert get_lessons_by_area("nonexistent_area") == []
|
|
|
|
|
|
# ── Lesson content ────────────────────────────────────────────────────────
|
|
|
|
def test_lesson_1_identity():
|
|
lesson = get_lesson(1)
|
|
assert lesson is not None
|
|
assert lesson.area == "identity"
|
|
|
|
|
|
def test_lesson_2_profile():
|
|
lesson = get_lesson(2)
|
|
assert lesson is not None
|
|
assert lesson.area == "profile"
|
|
|
|
|
|
def test_lesson_3_channels():
|
|
lesson = get_lesson(3)
|
|
assert lesson is not None
|
|
assert lesson.area == "channels"
|
|
|
|
|
|
def test_lesson_4_scheduling():
|
|
lesson = get_lesson(4)
|
|
assert lesson is not None
|
|
assert lesson.area == "scheduling"
|
|
|
|
|
|
def test_lesson_5_books():
|
|
lesson = get_lesson(5)
|
|
assert lesson is not None
|
|
assert lesson.area == "books"
|
|
|
|
|
|
def test_lesson_6_expectations():
|
|
lesson = get_lesson(6)
|
|
assert lesson is not None
|
|
assert lesson.area == "expectations"
|
|
|
|
|
|
def test_lesson_7_report():
|
|
lesson = get_lesson(7)
|
|
assert lesson is not None
|
|
assert lesson.area == "report"
|
|
|
|
|
|
def test_lessons_have_non_empty_fields():
|
|
"""All lessons must have non-empty title, description, and instructions."""
|
|
for lesson in LESSON_CATALOG:
|
|
assert lesson.title.strip(), f"Lesson {lesson.step} has empty title"
|
|
assert lesson.description.strip(), f"Lesson {lesson.step} has empty description"
|
|
assert lesson.instructions.strip(), f"Lesson {lesson.step} has empty instructions"
|
|
assert lesson.what_it_enables.strip(), f"Lesson {lesson.step} has empty what_it_enables"
|
|
|
|
|
|
def test_lessons_have_possible_outcomes():
|
|
"""All lessons must have at least one possible outcome."""
|
|
for lesson in LESSON_CATALOG:
|
|
assert len(lesson.possible_outcomes) >= 1, f"Lesson {lesson.step} has no outcomes"
|
|
|
|
|
|
# ── Owner-safe validation ─────────────────────────────────────────────────
|
|
|
|
def test_forbidden_keywords_not_empty():
|
|
"""FORBIDDEN_KEYWORDS must contain expected keywords."""
|
|
assert "terminal" in FORBIDDEN_KEYWORDS
|
|
assert "docker" in FORBIDDEN_KEYWORDS
|
|
assert "nano" in FORBIDDEN_KEYWORDS
|
|
assert "bash" in FORBIDDEN_KEYWORDS
|
|
assert "sudo" in FORBIDDEN_KEYWORDS
|
|
assert "shell" in FORBIDDEN_KEYWORDS
|
|
|
|
|
|
def test_is_owner_safe_clean_text():
|
|
assert is_owner_safe("Log in to your Vagaro account in your browser.") is True
|
|
assert is_owner_safe("Choose a name for your assistant.") is True
|
|
assert is_owner_safe("Share the API key with your operator.") is True
|
|
|
|
|
|
def test_is_owner_safe_forbidden_text():
|
|
assert is_owner_safe("Run docker-compose up") is False
|
|
assert is_owner_safe("Open a terminal and type") is False
|
|
assert is_owner_safe("Edit with nano") is False
|
|
assert is_owner_safe("Execute the bash script") is False
|
|
|
|
|
|
def test_is_owner_safe_multi_word_no_false_positive():
|
|
"""Multi-word keywords must not false-positive on unrelated text."""
|
|
# "brew install" should NOT match "brew installation" or "homebrew installed"
|
|
assert is_owner_safe("We use homebrew installed packages") is True
|
|
assert is_owner_safe("The brew installation completed") is True
|
|
assert is_owner_safe("I will install the app manually") is True
|
|
# "pip install" should NOT match "pip installed" or "install pip"
|
|
assert is_owner_safe("pip installed successfully") is True
|
|
assert is_owner_safe("install pip from the store") is True
|
|
# "git clone" should NOT match "clone git" (reversed)
|
|
assert is_owner_safe("clone git repository") is True
|
|
# "docker run" should NOT match "docker running" — but "docker" alone
|
|
# IS a single-word forbidden keyword, so we test the multi-word phrase
|
|
# in isolation by checking the phrase itself doesn't match a variant:
|
|
assert is_owner_safe("the container is running in background") is True
|
|
# "make install" should NOT match "make installation"
|
|
assert is_owner_safe("make installation directory") is True
|
|
# "npm install" should NOT match "npm installed"
|
|
assert is_owner_safe("npm installed globally") is True
|
|
|
|
|
|
def test_is_owner_safe_multi_word_true_positive():
|
|
"""Multi-word keywords must still match the exact phrase."""
|
|
assert is_owner_safe("brew install python") is False
|
|
assert is_owner_safe("pip install requests") is False
|
|
assert is_owner_safe("npm install express") is False
|
|
assert is_owner_safe("git clone https://example.com") is False
|
|
assert is_owner_safe("docker run nginx") is False
|
|
assert is_owner_safe("make install all") is False
|
|
assert is_owner_safe("docker exec container") is False
|
|
assert is_owner_safe("git push origin main") is False
|
|
assert is_owner_safe("git pull origin main") is False
|
|
|
|
|
|
def test_is_owner_safe_single_word_boundaries():
|
|
"""Single-word keywords use word boundaries."""
|
|
# "docker" should match standalone but not inside unrelated words
|
|
assert is_owner_safe("Use docker to containerize") is False
|
|
# "nano" should match standalone
|
|
assert is_owner_safe("Edit with nano") is False
|
|
# "bash" should match standalone
|
|
assert is_owner_safe("Run in bash") is False
|
|
|
|
|
|
def test_is_owner_safe_case_insensitive():
|
|
assert is_owner_safe("Use DOCKER to run") is False
|
|
assert is_owner_safe("Open TERMINAL") is False
|
|
|
|
|
|
def test_validate_lesson_owner_safe_clean():
|
|
"""All catalog lessons must pass owner-safe validation."""
|
|
for lesson in LESSON_CATALOG:
|
|
violations = validate_lesson_owner_safe(lesson)
|
|
assert violations == [], (
|
|
f"Lesson {lesson.step} ({lesson.title}) contains forbidden keywords: {violations}"
|
|
)
|
|
|
|
|
|
def test_validate_catalog_owner_safe():
|
|
"""Full catalog validation must return empty dict."""
|
|
violations = validate_catalog_owner_safe()
|
|
assert violations == {}, f"Catalog has violations: {violations}"
|
|
|
|
|
|
def test_validate_lesson_owner_safe_detects_forbidden():
|
|
"""Validation correctly detects forbidden keywords."""
|
|
bad_lesson = Lesson(
|
|
step=99,
|
|
title="Bad Lesson",
|
|
description="Run docker-compose up in your terminal",
|
|
instructions="Open bash and type sudo nano config.yml",
|
|
what_it_enables="Nothing",
|
|
)
|
|
violations = validate_lesson_owner_safe(bad_lesson)
|
|
assert "docker" in violations
|
|
assert "terminal" in violations
|
|
assert "bash" in violations
|
|
assert "sudo" in violations
|
|
assert "nano" in violations
|
|
|
|
|
|
def test_validate_lesson_owner_safe_includes_possible_outcomes():
|
|
"""Validation checks possible_outcomes field for forbidden keywords."""
|
|
lesson_with_bad_outcome = Lesson(
|
|
step=99,
|
|
title="Good Lesson",
|
|
description="Clean description",
|
|
instructions="Clean instructions",
|
|
what_it_enables="Clean enables",
|
|
possible_outcomes=["connected", "docker"], # "docker" in outcomes
|
|
)
|
|
violations = validate_lesson_owner_safe(lesson_with_bad_outcome)
|
|
assert "docker" in violations, "possible_outcomes should be checked"
|
|
|
|
|
|
def test_validate_lesson_owner_safe_clean_outcomes():
|
|
"""Validation passes when possible_outcomes are clean."""
|
|
clean_lesson = Lesson(
|
|
step=99,
|
|
title="Good Lesson",
|
|
description="Clean description",
|
|
instructions="Clean instructions",
|
|
what_it_enables="Clean enables",
|
|
possible_outcomes=["connected", "skipped", "later", "error"],
|
|
)
|
|
violations = validate_lesson_owner_safe(clean_lesson)
|
|
assert violations == [], f"Clean lesson should have no violations: {violations}"
|
|
|
|
|
|
# ── Formatting ─────────────────────────────────────────────────────────────
|
|
|
|
def test_format_lesson_text_includes_step():
|
|
lesson = get_lesson(1)
|
|
text = format_lesson_text(lesson)
|
|
assert "Step 1" in text
|
|
|
|
|
|
def test_format_lesson_text_includes_title():
|
|
lesson = get_lesson(1)
|
|
text = format_lesson_text(lesson)
|
|
assert lesson.title in text
|
|
|
|
|
|
def test_format_lesson_text_includes_instructions():
|
|
lesson = get_lesson(4)
|
|
text = format_lesson_text(lesson)
|
|
assert "What to do:" in text
|
|
assert lesson.instructions in text
|
|
|
|
|
|
def test_format_lesson_text_owner_safe():
|
|
"""Formatted lesson text must be owner-safe."""
|
|
for lesson in LESSON_CATALOG:
|
|
text = format_lesson_text(lesson)
|
|
assert is_owner_safe(text), (
|
|
f"Lesson {lesson.step} formatted text contains forbidden keywords"
|
|
)
|
|
|
|
|
|
def test_format_all_lessons_text_owner_safe():
|
|
"""Full lessons text must be owner-safe."""
|
|
text = format_all_lessons_text()
|
|
assert is_owner_safe(text)
|
|
|
|
|
|
def test_format_all_lessons_text_includes_all_steps():
|
|
text = format_all_lessons_text()
|
|
for i in range(1, 8):
|
|
assert f"Step {i}" in text
|