package services import ( "context" "encoding/json" "io" "log/slog" "net/http" "net/http/httptest" "strings" "testing" "speech-learning-api/internal/config" "speech-learning-api/internal/domain" "speech-learning-api/internal/store" ) func TestAdaptiveTechnicalContractAndPrivacy(t *testing.T) { for _, original := range store.EnglishCoursePack().Reserves { if err := ValidateAdaptiveTask(original, "en-US", original.ModuleID, original.Skill); err != nil { t.Fatalf("reserve %s: %v", original.ID, err) } data, _ := json.Marshal(original.Public(false)) if strings.Contains(string(data), "answer_key") || strings.Contains(string(data), "audio_text") { t.Fatal("private assessment leaked") } } task := store.EnglishCoursePack().Reserves[0] task.TargetLanguage = "es-ES" task.Prompt = "¿Qué significa «hermana»?" task.Options = []domain.TaskOption{{ID: "a", Label: "Schwester"}, {ID: "b", Label: "Bruder"}} task.AnswerKey = &domain.TaskKey{CorrectOptionID: "a", Rubric: []string{"Sinn verstehen"}, Explanation: "Hermanas sind Schwestern."} if err := ValidateAdaptiveTask(task, "es-ES", task.ModuleID, task.Skill); err != nil { t.Fatal(err) } task.Prompt = "ما معنى كلمة أخت؟" if err := ValidateAdaptiveTask(task, "es-ES", task.ModuleID, task.Skill); err != nil { t.Fatal("language pattern restriction:", err) } task.Options[1].Label = task.Options[0].Label if ValidateAdaptiveTask(task, "es-ES", task.ModuleID, task.Skill) == nil { t.Fatal("duplicate options accepted") } task.Options[1].Label = "Bruder" task.AnswerKey.CorrectOptionID = "missing" if ValidateAdaptiveTask(task, "es-ES", task.ModuleID, task.Skill) == nil { t.Fatal("nonexistent option accepted") } } func TestAdaptiveAnalysisUsesRealScopedEvidence(t *testing.T) { s := domain.CourseSnapshot{TargetLanguage: "es-ES", CourseVersion: domain.CourseVersion, FactsVersion: 9, Modules: store.EnglishCoursePack().Modules} makeAnalysis := func() domain.CourseAnalysis { return domain.CourseAnalysis{SchemaVersion: 2, TargetLanguage: s.TargetLanguage, CourseVersion: s.CourseVersion, Summary: "Weiter üben", RecommendedModuleID: s.Modules[0].ID, Modules: []domain.ModuleAnalysis{{ModuleID: s.Modules[0].ID, Reason: "Nachweise", Recommendation: "Weiterlernen", ReadyForCompletion: true}}} } a := makeAnalysis() if err := ValidateCourseAnalysis(&a, s); err != nil { t.Fatal(err) } if a.Modules[0].ReadyForCompletion { t.Fatal("completed without evidence") } for _, skill := range domain.CourseSkills { s.Progress = append(s.Progress, domain.SkillProgress{ModuleID: s.Modules[0].ID, Skill: skill, Attempts: 1, EvidenceID: "attempt_" + skill}) } a = makeAnalysis() a.Modules[0].EvidenceIDs = []string{"attempt_grammar"} if err := ValidateCourseAnalysis(&a, s); err != nil || !a.Modules[0].ReadyForCompletion || a.FactsVersion != 9 { t.Fatalf("real evidence rejected: %v", err) } a.Modules[0].ModuleID = s.Modules[1].ID if ValidateCourseAnalysis(&a, s) == nil { t.Fatal("cross-module evidence accepted") } a = makeAnalysis() a.Modules[0].EvidenceIDs = []string{"invented"} if ValidateCourseAnalysis(&a, s) == nil { t.Fatal("invented evidence accepted") } } func TestAdaptiveFlowiseContract(t *testing.T) { approved := false server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { var payload struct { Question string `json:"question"` Streaming bool `json:"streaming"` } if err := json.NewDecoder(r.Body).Decode(&payload); err != nil { t.Error(err) } var q struct { SchemaVersion int `json:"schema_version"` Task string `json:"task"` Input json.RawMessage `json:"input"` } if err := json.Unmarshal([]byte(payload.Question), &q); err != nil || q.SchemaVersion != 2 || len(q.Input) == 0 { t.Error("invalid question contract") } if r.Header.Get("Authorization") != "Bearer test-key" { t.Error("missing auth") } if strings.HasSuffix(r.URL.Path, "teacher") { json.NewEncoder(w).Encode(map[string]any{"text": `{"score":80,"verdict":"partial","feedback":"Fast richtig","issues":[]}`}) return } if q.Task != "generate_course_task" { t.Error("wrong generator task") } json.NewEncoder(w).Encode(map[string]any{"json": map[string]any{"schema_version": 2, "approved": approved, "tasks": []domain.AdaptiveTask{store.EnglishCoursePack().Reserves[0]}, "review_notes": "Checked"}}) })) defer server.Close() agent := NewFlowiseCourseAgent(NewFlowiseTeacher(config.Config{FlowiseBaseURL: server.URL, FlowiseCourseChatflow: "generator", FlowiseCourseTeacher: "teacher", FlowiseAPIKey: "test-key"}, slog.New(slog.NewTextHandler(io.Discard, nil)))) if _, err := agent.Generate(context.Background(), map[string]any{"count": 1}); err == nil { t.Fatal("unapproved task accepted") } approved = true if tasks, err := agent.Generate(context.Background(), map[string]any{"count": 1}); err != nil || len(tasks) != 1 { t.Fatalf("approved: %v", err) } var evaluation domain.CourseEvaluation if err := agent.Teacher(context.Background(), "evaluate_course_attempt", map[string]any{"answer": "Hola"}, &evaluation); err != nil || evaluation.Score != 80 { t.Fatalf("teacher %v", err) } if decodeAdaptiveOutput([]byte(`{"verdict":"incorrect","feedback":"Falsch","issues":[]}`), &evaluation) == nil { t.Fatal("missing score accepted") } var out struct { SchemaVersion int `json:"schema_version"` Approved bool `json:"approved"` } if err := decodeAdaptiveOutput([]byte(`{"json":{"approved":true,"unexpected":1},"text":"{\"schema_version\":2}"}`), &out); err != nil { t.Fatal(err) } if out.Approved { t.Fatal("rejected envelope contaminated accepted data") } }