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