Files
Eugenius Naumenko e274eaab2b Adaptiven A1-Kurs und statistisches Aussprachetraining integrieren
Direkte DeepSeek- und Mistral-Anbindung mit versionierten Aktionsprofilen,
Budgetreservierung, Tokenabrechnung und administrativen Qualitätsprüfungen
ersetzen die Flowise-Abhängigkeit im regulären Betrieb.

840 geprüfte A1-Aufgaben mit geschützter Testauswertung und konkreten offenen
Arbeitsaufträgen ergänzen den Kurs. Inhalts- und Sprachbewertung bleiben von
Azure-Aussprachewerten getrennt; historische Aufgaben und Antworten bleiben erhalten.

Echte Wort- und Phonemmessungen werden mit Herkunft, Aktualität und Nachweisdichte
gebündelt. Go bestimmt Trainingsziele und Wiederholungen, das Modell formuliert
dazu passende Nachsprechübungen. Profilansicht und Auswahlgründe werden angezeigt.

Validierung: Go-Race-Tests mit lokaler PostgreSQL-Integration, go vet,
Web-Build, Audit aller 840 Aufgaben und drei Browser-Smokes mit lokalen
Modell-/Speech-Fixtures bestanden. Keine Produktionsänderungen oder Live-Aufrufe.
2026-11-01 23:23:20 +00:00

139 lines
5.6 KiB
Go

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")
}
}