Files
Speech/apps/api/internal/services/adaptive_integration_test.go
T
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

435 lines
15 KiB
Go

package services
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"io"
"log/slog"
"net/url"
"os"
"testing"
"time"
_ "github.com/jackc/pgx/v5/stdlib"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
)
func adaptiveTestDB(t *testing.T) (*sql.DB, *store.PostgresStore) {
t.Helper()
dsn := os.Getenv("COURSE_TEST_DATABASE_URL")
if dsn == "" {
t.Skip("COURSE_TEST_DATABASE_URL not set")
}
admin, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatal(err)
}
schema := store.NewID("adaptive_test")
if _, err = admin.Exec(`CREATE SCHEMA ` + schema); err != nil {
t.Fatal(err)
}
u, err := url.Parse(dsn)
if err != nil {
t.Fatal(err)
}
q := u.Query()
q.Set("search_path", schema)
u.RawQuery = q.Encode()
db, err := sql.Open("pgx", u.String())
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { db.Close(); admin.Exec(`DROP SCHEMA ` + schema + ` CASCADE`); admin.Close() })
repo := store.NewPostgresStore(db)
if err = repo.Init(context.Background()); err != nil {
t.Fatal(err)
}
return db, repo
}
type adaptiveFakeAgent struct {
repo *store.AdaptiveStore
user string
plannedSkill string
generated int
analyses int
fail bool
briefSeen bool
lastFacts int64
}
func (a *adaptiveFakeAgent) Teacher(ctx context.Context, kind string, input, out any) error {
if a.fail {
return errors.New("offline")
}
switch kind {
case "analyze_course_progress":
s := input.(domain.CourseSnapshot)
a.analyses++
a.lastFacts = s.FactsVersion
*out.(*domain.CourseAnalysis) = domain.CourseAnalysis{SchemaVersion: 2, TargetLanguage: s.TargetLanguage, CourseVersion: s.CourseVersion, Summary: fmt.Sprintf("Analyse nach %d Antworten", s.FactsVersion), RecommendedModuleID: s.Modules[0].ID, Modules: []domain.ModuleAnalysis{}}
case "plan_course_task":
in := input.(map[string]any)
s := in["snapshot"].(domain.CourseSnapshot)
skill := in["requested_skill"].(string)
if skill == "" {
skill = "grammar"
}
a.plannedSkill = skill
kind := "choice"
if skill == "writing" {
kind = "free_text"
}
*out.(*domain.CourseBrief) = domain.CourseBrief{SchemaVersion: 2, ModuleID: in["module_id"].(string), TargetLanguage: s.TargetLanguage, CourseVersion: s.CourseVersion, Skill: skill, Kind: kind, Objective: "Adapt to the last answer", Difficulty: "A1", Reason: "Based on saved progress"}
case "evaluate_course_attempt":
*out.(*domain.CourseEvaluation) = domain.CourseEvaluation{Score: 75, Verdict: "partial", Feedback: "Verständlich, noch üben", Issues: []string{"Satzbau"}}
case "summarize_course_exam":
json.Unmarshal([]byte(`{"summary":"Deine sechs Bereiche wurden bewertet."}`), out)
default:
return errors.New("unknown teacher operation")
}
return nil
}
func (a *adaptiveFakeAgent) Generate(ctx context.Context, input any) ([]domain.AdaptiveTask, error) {
if a.fail {
return nil, errors.New("offline")
}
in := input.(map[string]any)
b := in["brief"].(domain.CourseBrief)
saved, err := a.repo.Brief(ctx, a.user, b.ID)
if err != nil {
return nil, err
}
a.briefSeen = saved.ID == b.ID && b.ID != ""
a.generated++
task := store.EnglishCoursePack().Reserves[1]
task.ID = ""
task.ModuleID = b.ModuleID
task.TargetLanguage = b.TargetLanguage
task.Skill = b.Skill
task.Kind = b.Kind
task.Prompt = fmt.Sprintf("Freie, fachlich geprüfte Aufgabe %d", a.generated)
if task.Kind != "choice" {
task.Options = nil
task.AnswerKey.CorrectOptionID = ""
}
return []domain.AdaptiveTask{task}, nil
}
func TestAdaptivePostgresEngineAndIsolation(t *testing.T) {
db, profiles := adaptiveTestDB(t)
ctx := context.Background()
repo := store.NewAdaptiveStore(db)
user, err := profiles.CreateUser(ctx, "adaptive@example.test", "hash", "de-DE")
if err != nil {
t.Fatal(err)
}
other, _ := profiles.CreateUser(ctx, "other@example.test", "hash", "de-DE")
if _, err = profiles.CreateLearnerProfile(ctx, user.ID, "en-US", "A1", 10); err != nil {
t.Fatal(err)
}
agent := &adaptiveFakeAgent{repo: repo, user: user.ID}
engine := NewCourseEngine(repo, profiles, agent, slog.New(slog.NewTextHandler(io.Discard, nil)))
runNext := func(skill, request string) domain.AdaptiveTask {
t.Helper()
j, err := repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_introductions_v1", skill, "", request)
if err != nil {
t.Fatal(err)
}
duplicate, err := repo.Enqueue(ctx, user.ID, "en-US", "next", j.ModuleID, skill, "", request)
if err != nil || j.ID != duplicate.ID {
t.Fatal("job idempotence", err)
}
claimed, err := repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
if claimed.ID != j.ID {
t.Fatalf("wrong job %s: expected %s", claimed.Kind, j.ID)
}
task, err := engine.Process(ctx, claimed)
if err != nil {
t.Fatal(err)
}
// Simulate losing the worker after its durable task write, before Finish.
again, err := engine.Process(ctx, func() domain.CourseJob { v, _ := repo.Job(ctx, user.ID, "en-US", j.ID); return v }())
if err != nil || again.ID != task.ID {
t.Fatal("restart duplicated task", err)
}
if err = repo.Finish(ctx, claimed, task, ""); err != nil {
t.Fatal(err)
}
return *task
}
task := runNext("grammar", "first")
if !agent.briefSeen || agent.generated != 1 {
t.Fatal("generator did not receive persisted brief")
}
if _, err = repo.Task(ctx, other.ID, "en-US", task.ID); !errors.Is(err, store.ErrNotFound) {
t.Fatal("cross-user task access", err)
}
if _, err = repo.Task(ctx, user.ID, "es-ES", task.ID); !errors.Is(err, store.ErrNotFound) {
t.Fatal("cross-language task access", err)
}
a, _, err := engine.Submit(ctx, user.ID, "en-US", task.ID, "answer-one", "o2", nil)
if err != nil || a.Evaluation.Score != 0 {
t.Fatal("choice grading", err)
}
dup, _, err := engine.Submit(ctx, user.ID, "en-US", task.ID, "answer-one", "o1", nil)
if err != nil || dup.ID != a.ID || dup.Evaluation.Score != 0 {
t.Fatal("answer overwritten", err)
}
snap, err := repo.Snapshot(ctx, user.ID, "en-US", "de-DE")
if err != nil || snap.FactsVersion != 1 || len(snap.RecentTasks) != 1 {
t.Fatal("snapshot", err)
}
// Run the queued analysis, then request another task from its saved result.
j, err := repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
if _, err = engine.Process(ctx, j); err != nil {
t.Fatal(err)
}
repo.Finish(ctx, j, nil, "")
task = runNext("writing", "second")
if agent.lastFacts != 1 || agent.analyses != 2 {
t.Fatal("analysis did not use saved answer")
}
pending, job, err := engine.Submit(ctx, user.ID, "en-US", task.ID, "written", "My name Anna", nil)
if err != nil || pending.Status != "pending" || job == nil {
t.Fatal("open answer not queued", err)
}
j, err = repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
agent.fail = true
if _, err = engine.Process(ctx, j); err == nil {
t.Fatal("agent outage not reported")
}
repo.FailAttempt(ctx, user.ID, pending.ID)
repo.Finish(ctx, j, nil, "offline")
if _, err = repo.RetryEvaluation(ctx, user.ID, "en-US", pending.ID); err != nil {
t.Fatal(err)
}
agent.fail = false
j, err = repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
if _, err = engine.Process(ctx, j); err != nil {
t.Fatal(err)
}
repo.Finish(ctx, j, nil, "")
graded, err := repo.Attempt(ctx, user.ID, "en-US", pending.ID)
if err != nil || graded.Evaluation.Score != 75 {
t.Fatal("retry lost answer", err)
}
// A second pack uses identical module keys and independent reserve IDs.
pack := store.EnglishCoursePack()
pack.TargetLanguage = "es-ES"
for i := range pack.Modules {
pack.Modules[i].TargetLanguage = "es-ES"
}
for i := range pack.Reserves {
pack.Reserves[i].TargetLanguage = "es-ES"
pack.Reserves[i].ID = "es_fixture_" + pack.Reserves[i].ID
}
if err = repo.InstallPack(ctx, pack); err != nil {
t.Fatal(err)
}
if _, err = profiles.UpdatePreferences(ctx, user.ID, "de-DE", "es-ES", "A1", 10); err != nil {
t.Fatal(err)
}
active, err := profiles.GetPrimaryProfile(ctx, user.ID)
if err != nil || active.TargetLanguage != "es-ES" {
t.Fatal("active language", err)
}
spanish, err := repo.Snapshot(ctx, user.ID, "es-ES", "de-DE")
if err != nil || spanish.FactsVersion != 0 || len(spanish.Progress) != 0 || spanish.PreviousAnalysis != nil {
t.Fatal("mixed language progress", err)
}
reserve, err := repo.Reserve(ctx, user.ID, "es-ES", pack.Modules[2].ID, "listening")
if err != nil || reserve.TargetLanguage != "es-ES" {
t.Fatal("reserve language", err)
}
if _, err = profiles.UpdatePreferences(ctx, user.ID, "de-DE", "en-US", "A1", 10); err != nil {
t.Fatal(err)
}
for i := 0; i < 2; i++ {
if err = profiles.Init(ctx); err != nil {
t.Fatal("repeat migration", err)
}
}
restored, err := repo.Snapshot(ctx, user.ID, "en-US", "de-DE")
if err != nil || restored.FactsVersion != 2 {
t.Fatalf("lost progress: %d %v", restored.FactsVersion, err)
}
}
func TestAdaptivePostgresExamFreezeAndVisibility(t *testing.T) {
db, profiles := adaptiveTestDB(t)
ctx := context.Background()
repo := store.NewAdaptiveStore(db)
user, err := profiles.CreateUser(ctx, "exam@example.test", "hash", "de-DE")
if err != nil {
t.Fatal(err)
}
profiles.CreateLearnerProfile(ctx, user.ID, "en-US", "A1", 10)
agent := &adaptiveFakeAgent{repo: repo, user: user.ID}
engine := NewCourseEngine(repo, profiles, agent, slog.New(slog.NewTextHandler(io.Discard, nil)))
exam, err := repo.NewExam(ctx, user.ID, "en-US", "exam-request")
if err != nil {
t.Fatal(err)
}
repeat, err := repo.NewExam(ctx, user.ID, "en-US", "exam-request")
if err != nil || repeat.ID != exam.ID {
t.Fatal("duplicate exam", err)
}
tasks, err := repo.ReserveExam(ctx, user.ID, "en-US", "a1_review_test_v1")
if err != nil {
t.Fatal(err)
}
if err = ValidateExamTasks(tasks, "en-US", "a1_review_test_v1"); err != nil {
t.Fatal(err)
}
if err = repo.SaveExamTasks(ctx, user.ID, "en-US", exam.ID, tasks); err != nil {
t.Fatal(err)
}
exam, err = repo.Exam(ctx, user.ID, "en-US", exam.ID)
if err != nil || len(exam.Tasks) != 12 {
t.Fatal(err)
}
for _, task := range exam.Tasks {
if task.AnswerKey != nil || task.AudioText != "" {
t.Fatal("exam leaked solutions")
}
}
changed := append([]domain.AdaptiveTask{}, tasks...)
changed[0].Prompt = "Changed after start"
if err = repo.SaveExamTasks(ctx, user.ID, "en-US", exam.ID, changed); err != nil {
t.Fatal(err)
}
frozen, _ := repo.Exam(ctx, user.ID, "en-US", exam.ID)
if frozen.Tasks[0].Prompt == changed[0].Prompt {
t.Fatal("exam changed after start")
}
for i, public := range exam.Tasks {
task, err := repo.Task(ctx, user.ID, "en-US", public.ID)
if err != nil {
t.Fatal(err)
}
attempt, err := repo.Submit(ctx, user.ID, fmt.Sprintf("exam-answer-%d", i), task, "saved answer", nil)
if err != nil {
t.Fatal(err)
}
second, err := repo.Submit(ctx, user.ID, fmt.Sprintf("duplicate-answer-%d", i), task, "changed answer", nil)
if err != nil || second.ID != attempt.ID || second.Answer != "saved answer" {
t.Fatal("exam answer overwritten", err)
}
score := float64(i * 8)
evaluation := domain.CourseEvaluation{Score: score, Verdict: "partial", Feedback: "Saved feedback", Issues: []string{}}
if err = repo.Grade(ctx, user.ID, "en-US", attempt.ID, evaluation); err != nil {
t.Fatal(err)
}
if err = repo.Grade(ctx, user.ID, "en-US", attempt.ID, evaluation); err != nil {
t.Fatal(err)
}
graded, _ := repo.Attempt(ctx, user.ID, "en-US", attempt.ID)
safe, err := engine.PublicAttempt(ctx, user.ID, "en-US", graded)
if err != nil || safe.Evaluation != nil {
t.Fatal("premature exam feedback", err)
}
if i < 11 {
done, err := repo.CompleteExam(ctx, user.ID, "en-US", exam.ID)
if err != nil || done {
t.Fatal("exam completed early", err)
}
}
}
before, err := repo.Snapshot(ctx, user.ID, "en-US", "de-DE")
if err != nil || len(before.Progress) > 0 || len(before.RecentAttempts) > 0 {
t.Fatal("unfinished exam entered learning evidence", err)
}
complete, err := repo.CompleteExam(ctx, user.ID, "en-US", exam.ID)
if err != nil || !complete {
t.Fatal("exam did not complete", err)
}
exam, err = repo.Exam(ctx, user.ID, "en-US", exam.ID)
if err != nil || exam.Score == nil || *exam.Score != 44 || len(exam.Scores) != 6 {
t.Fatalf("wrong equal-weight result %#v: %v", exam, err)
}
for _, task := range exam.Tasks {
if task.AnswerKey == nil {
t.Fatal("completed exam missing feedback")
}
}
for _, attempt := range exam.Attempts {
if attempt.Evaluation == nil {
t.Fatal("completed exam missing evaluation")
}
}
after, err := repo.Snapshot(ctx, user.ID, "en-US", "de-DE")
if err != nil || after.FactsVersion != 12 || len(after.Progress) != 6 {
t.Fatal("exam facts/idempotence", err)
}
for _, version := range []int64{12, 2} {
if err = repo.SaveAnalysis(ctx, user.ID, domain.CourseAnalysis{TargetLanguage: "en-US", CourseVersion: domain.CourseVersion, FactsVersion: version, Summary: fmt.Sprint(version)}); err != nil {
t.Fatal(err)
}
}
analysis, err := repo.LatestAnalysis(ctx, user.ID, "en-US")
if err != nil || analysis.FactsVersion != 12 {
t.Fatal("stale analysis won", err)
}
}
func TestAdaptivePostgresFallbackAndLeaseRecovery(t *testing.T) {
db, profiles := adaptiveTestDB(t)
ctx := context.Background()
repo := store.NewAdaptiveStore(db)
user, _ := profiles.CreateUser(ctx, "offline@example.test", "hash", "de-DE")
profiles.CreateLearnerProfile(ctx, user.ID, "en-US", "A1", 10)
engine := NewCourseEngine(repo, profiles, &adaptiveFakeAgent{fail: true}, slog.New(slog.NewTextHandler(io.Discard, nil)))
job, err := repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_food_shopping_v1", "listening", "", "offline")
if err != nil {
t.Fatal(err)
}
claimed, err := repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
if _, err = repo.Claim(ctx); !errors.Is(err, store.ErrNotFound) {
t.Fatal("live job claimed twice", err)
}
if _, err = db.Exec(`UPDATE course_v2_jobs SET lease_until=now()-interval '1 second' WHERE id=$1`, job.ID); err != nil {
t.Fatal(err)
}
recovered, err := repo.Claim(ctx)
if err != nil || recovered.ID != job.ID || recovered.Lease == claimed.Lease {
t.Fatal("lease not recovered", err)
}
if repo.Stage(ctx, claimed, "obsolete") == nil {
t.Fatal("stale worker still owns job")
}
task, err := engine.Process(ctx, recovered)
if err != nil || task.Source != "seed" || task.Skill != "listening" || task.ModuleID != job.ModuleID || task.TargetLanguage != "en-US" {
t.Fatal("fallback changed requested scope", err)
}
expired, cancel := context.WithDeadline(ctx, time.Now().Add(-time.Second))
defer cancel()
if fallback, err := engine.Process(expired, recovered); err != nil || fallback.Source != "seed" {
t.Fatal("agent timeout cancelled reserve lookup", err)
}
if err = repo.Finish(ctx, recovered, task, ""); err != nil {
t.Fatal(err)
}
stored, _ := repo.Job(ctx, user.ID, "en-US", job.ID)
if stored.Source != "seed" || stored.Status != "succeeded" {
t.Fatal("fallback source not visible")
}
}