package services import ( "context" "encoding/json" "errors" "io" "log/slog" "net/http" "net/http/httptest" "speech-learning-api/internal/config" "speech-learning-api/internal/domain" "speech-learning-api/internal/store" "sync" "testing" ) func TestBankPostgresSelectionAndOptionalEvaluation(t *testing.T) { db, profiles := adaptiveTestDB(t) ctx := context.Background() user, err := profiles.CreateUser(ctx, store.NewID("bank")+"@example.test", "hash", "de-DE") if err != nil { t.Fatal(err) } agent := NewAIService(store.NewAIStore(db), config.Config{}) engine := NewCourseEngine(store.NewAdaptiveStore(db), profiles, agent, slog.New(slog.NewTextHandler(io.Discard, nil))) engine.Mode = "bank" run := func(skill, request string) domain.AdaptiveTask { t.Helper() _, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_family_v1", skill, "", request) if err != nil { t.Fatal(err) } j, err := engine.Repo.Claim(ctx) if err != nil { t.Fatal(err) } task, err := engine.Process(ctx, j) if err != nil { t.Fatal(err) } if err = engine.Repo.Finish(ctx, j, task, ""); err != nil { t.Fatal(err) } return *task } seen := map[string]bool{} var first domain.AdaptiveTask for n := 0; n < 20; n++ { task := run("grammar", store.NewID("request")) if seen[task.ID] || task.Review || task.Source != "curated" { t.Fatal("new pool repeated", task) } seen[task.ID] = true if n == 0 { first = task wrong := task.Options[0].ID if wrong == task.AnswerKey.CorrectOptionID { wrong = task.Options[1].ID } a, _, err := engine.Submit(ctx, user.ID, "en-US", task.ID, "wrong-first", wrong, nil) if err != nil || a.Evaluation == nil || a.Evaluation.Score != 0 { t.Fatal(err, a) } } } repeat := run("grammar", "first-repeat") if !repeat.Review || repeat.ID != first.ID { t.Fatal("weak task not repeated", repeat) } if next := run("grammar", "second-repeat"); !next.Review || next.ID == repeat.ID { t.Fatal("immediate repeat", next) } // Concurrent requests get different unseen tasks, and request replay is stable. for _, r := range []string{"parallel-a", "parallel-b"} { if _, err = engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_family_v1", "vocabulary", "", r); err != nil { t.Fatal(err) } } jobs := []domain.CourseJob{} for n := 0; n < 2; n++ { j, err := engine.Repo.Claim(ctx) if err != nil { t.Fatal(err) } jobs = append(jobs, j) } var wg sync.WaitGroup ids := make(chan string, 2) errs := make(chan error, 2) for _, job := range jobs { wg.Add(1) go func(j domain.CourseJob) { defer wg.Done() task, err := engine.Process(ctx, j) if err == nil { err = engine.Repo.Finish(ctx, j, task, "") ids <- task.ID } errs <- err }(job) } wg.Wait() close(ids) close(errs) distinct := map[string]bool{} for id := range ids { distinct[id] = true } for err := range errs { if err != nil { t.Fatal(err) } } if len(distinct) != 2 { t.Fatal("concurrent duplicate", distinct) } replay, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_family_v1", "vocabulary", "", "parallel-a") if err != nil || replay.Status != "succeeded" || !distinct[replay.TaskID] { t.Fatal("request replay changed", err, replay) } other, err := profiles.CreateUser(ctx, store.NewID("other")+"@example.test", "hash", "de-DE") if err != nil { t.Fatal(err) } if _, err = engine.Repo.Task(ctx, other.ID, "en-US", first.ID); !errors.Is(err, store.ErrNotFound) { t.Fatal("task leaked", err) } inventory, err := engine.Repo.BankInventory(ctx, other.ID, "en-US") if err != nil || len(inventory) != 42 { t.Fatal(err, len(inventory)) } for _, i := range inventory { if i.Total != 20 || i.Unseen != 20 { t.Fatal("cross-user exposure", i) } } writing := run("writing", "writing") a, j, err := engine.Submit(ctx, user.ID, "en-US", writing.ID, "open-answer", "He has got a sister.", nil) if err != nil || a.Status != "ungraded" || a.Evaluation != nil || j != nil { t.Fatal("open answer falsely graded", err, a, j) } a2, _, err := engine.Submit(ctx, user.ID, "en-US", writing.ID, "open-answer", "changed replay", nil) if err != nil || a2.ID != a.ID || a2.Answer != a.Answer { t.Fatal("answer replay changed", err, a2) } var before, after string if err = db.QueryRow(`SELECT data::text FROM course_v2_tasks WHERE id=$1`, first.ID).Scan(&before); err != nil { t.Fatal(err) } if err = engine.Repo.InstallBank(ctx); err != nil { t.Fatal(err) } if err = db.QueryRow(`SELECT data::text FROM course_v2_tasks WHERE id=$1`, first.ID).Scan(&after); err != nil || before != after { t.Fatal("assigned content changed", err) } var calls, ops int db.QueryRow(`SELECT count(*) FROM ai_calls`).Scan(&calls) db.QueryRow(`SELECT count(*) FROM ai_operations`).Scan(&ops) if calls != 0 || ops != 0 { t.Fatal("bank invoked AI", calls, ops) } } func TestBankPostgresExamSubmissionAndLaterGrades(t *testing.T) { db, profiles := adaptiveTestDB(t) ctx := context.Background() user, err := profiles.CreateUser(ctx, store.NewID("exam-bank")+"@example.test", "hash", "de-DE") if err != nil { t.Fatal(err) } agent := NewAIService(store.NewAIStore(db), config.Config{}) engine := NewCourseEngine(store.NewAdaptiveStore(db), profiles, agent, slog.New(slog.NewTextHandler(io.Discard, nil))) engine.Mode = "bank" exam, err := engine.Repo.NewExam(ctx, user.ID, "en-US", "bank-exam") if err != nil { t.Fatal(err) } _, err = engine.Repo.Enqueue(ctx, user.ID, "en-US", "exam", "a1_review_test_v1", "", exam.ID, "prepare-bank-exam") if err != nil { t.Fatal(err) } j, err := engine.Repo.Claim(ctx) if err != nil { t.Fatal(err) } task, err := engine.Process(ctx, j) if err != nil { t.Fatal(err) } if err = engine.Repo.Finish(ctx, j, task, ""); err != nil { t.Fatal(err) } exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID) if err != nil || len(exam.Tasks) != 12 { t.Fatal(err, exam) } ungraded := []domain.AdaptiveAttempt{} for n, pub := range exam.Tasks { if pub.AnswerKey != nil || pub.AudioText != "" { t.Fatal("exam key leaked") } private, err := engine.Repo.Task(ctx, user.ID, "en-US", pub.ID) if err != nil { t.Fatal(err) } answer := "He has got a sister." var speech *domain.PronunciationResult if private.Kind == "choice" { answer = private.AnswerKey.CorrectOptionID } if private.Skill == "speaking" { speech = &domain.PronunciationResult{Provider: "azure", RecognizedText: answer, OverallScore: 95} } attempt, _, err := engine.Submit(ctx, user.ID, "en-US", pub.ID, store.NewID("exam-answer"), answer, speech) if err != nil { t.Fatal(n, err) } if attempt.Status == "ungraded" { ungraded = append(ungraded, attempt) } } exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID) if err != nil || exam.Status != "submitted" || exam.Score != nil || len(ungraded) != 4 { t.Fatal("submitted exam falsely completed", err, exam.Status, len(ungraded)) } for _, task := range exam.Tasks { if task.AnswerKey != nil || task.AudioText != "" { t2 := task t2.Options = nil t.Fatal("submitted test leaked", t2) } } for _, a := range exam.Attempts { if a.Evaluation != nil || a.Speech != nil { t.Fatal("partial result leaked") } } snapshot, err := engine.Repo.Snapshot(ctx, user.ID, "en-US", "de-DE") if err != nil || len(snapshot.Progress) != 0 { t.Fatal("unfinished test counted", err, snapshot.Progress) } // Recover a crash after all submissions, before the submitted status update. if _, err = db.Exec(`UPDATE course_v2_exams SET status='in_progress' WHERE id=$1`, exam.ID); err != nil { t.Fatal(err) } if err = engine.Repo.Reconcile(ctx, true); err != nil { t.Fatal(err) } recovered, err := engine.Repo.Claim(ctx) if err != nil || recovered.Kind != "exam_finalize" { t.Fatal("missing submitted-test recovery", err, recovered) } recoveredTask, err := engine.Process(ctx, recovered) if err != nil { t.Fatal(err) } if err = engine.Repo.Finish(ctx, recovered, recoveredTask, ""); err != nil { t.Fatal(err) } exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID) if err != nil || exam.Status != "submitted" { t.Fatal("submitted state not recovered", err) } // Activate a local deterministic evaluator only. No real model/key is used. server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { var body struct { Messages []struct { Content string `json:"content"` } `json:"messages"` } json.NewDecoder(r.Body).Decode(&body) var message struct { Task string `json:"task"` } json.Unmarshal([]byte(body.Messages[1].Content), &message) if message.Task != "evaluate_course_attempt" { t.Error("unexpected model action", message.Task) } json.NewEncoder(w).Encode(aiCompletion(domain.CourseEvaluation{Score: 100, Verdict: "correct", Feedback: "Richtig.", Issues: []string{}}, true)) })) defer server.Close() agent.Keys["mistral"] = "fixture-secret" agent.URLs["mistral"] = server.URL if _, err = agent.Repo.SaveProfile(ctx, user.ID, aiTestProfile("evaluate_course_attempt")); err != nil { t.Fatal(err) } if err = agent.Repo.SaveBudget(ctx, user.ID, 1000000, 0); err != nil { t.Fatal(err) } if !engine.EvaluationAvailable(ctx) { t.Fatal("configured fixture evaluator unavailable") } for _, a := range ungraded { if _, err = engine.Repo.RetryEvaluation(ctx, user.ID, "en-US", a.ID); err != nil { t.Fatal(err) } j, err := engine.Repo.Claim(ctx) if err != nil { t.Fatal(err) } task, err := engine.Process(ctx, j) if err != nil { t.Fatal(err) } if err = engine.Repo.Finish(ctx, j, task, ""); err != nil { t.Fatal(err) } } exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID) if err != nil || exam.Status != "completed" || exam.Score == nil || *exam.Score != 100 || exam.SummaryStatus != "ready" { t.Fatal("later grading failed", err, exam) } // Repair a crash after score completion without invoking a summarizing model. if _, err = db.Exec(`UPDATE course_v2_exams SET result=jsonb_set(result,'{summary_status}','"pending"') WHERE id=$1`, exam.ID); err != nil { t.Fatal(err) } if _, err = engine.Repo.Enqueue(ctx, user.ID, "en-US", "exam_finalize", "a1_review_test_v1", "", exam.ID, "repair-summary"); err != nil { t.Fatal(err) } repair, err := engine.Repo.Claim(ctx) if err != nil { t.Fatal(err) } repairTask, err := engine.Process(ctx, repair) if err != nil { t.Fatal(err) } if err = engine.Repo.Finish(ctx, repair, repairTask, ""); err != nil { t.Fatal(err) } exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID) if err != nil || exam.SummaryStatus != "ready" { t.Fatal("summary recovery failed", err) } if err = engine.Repo.ExamSummary(ctx, user.ID, exam.ID, "Historische Zusammenfassung"); err != nil { t.Fatal(err) } if err = engine.Repo.EnsureBankExamSummary(ctx, user.ID, exam.ID); err != nil { t.Fatal(err) } exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID) if err != nil || exam.Summary != "Historische Zusammenfassung" { t.Fatal("ready summary changed", err) } var calls int db.QueryRow(`SELECT count(*) FROM ai_calls`).Scan(&calls) if calls != 4 { t.Fatal("extra model calls", calls) } } func TestBankPostgresDifficultyAndCrashReplay(t *testing.T) { db, profiles := adaptiveTestDB(t) ctx := context.Background() user, err := profiles.CreateUser(ctx, store.NewID("adaptive-bank")+"@example.test", "hash", "de-DE") if err != nil { t.Fatal(err) } engine := NewCourseEngine(store.NewAdaptiveStore(db), profiles, NewAIService(store.NewAIStore(db), config.Config{}), slog.New(slog.NewTextHandler(io.Discard, nil))) engine.Mode = "bank" next := func() (domain.AdaptiveTask, int) { t.Helper() _, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_introductions_v1", "grammar", "", store.NewID("request")) if err != nil { t.Fatal(err) } j, err := engine.Repo.Claim(ctx) if err != nil { t.Fatal(err) } task, err := engine.Process(ctx, j) if err != nil { t.Fatal(err) } // Simulate a restart after assignment committed, before Finish. if err = engine.Repo.Release(ctx, j); err != nil { t.Fatal(err) } again, err := engine.Repo.Claim(ctx) if err != nil { t.Fatal(err) } replay, err := engine.Process(ctx, again) if err != nil || replay.ID != task.ID { t.Fatal("crash selected another task", err) } if err = engine.Repo.Finish(ctx, again, replay, ""); err != nil { t.Fatal(err) } var level int if err = db.QueryRow(`SELECT b.difficulty FROM course_v2_tasks t JOIN course_v2_bank b ON b.id=t.bank_entry_id WHERE t.id=$1`, task.ID).Scan(&level); err != nil { t.Fatal(err) } return *task, level } for n := 0; n < 3; n++ { task, level := next() if level != 1 { t.Fatal("initial task too difficult", level) } if _, _, err = engine.Submit(ctx, user.ID, "en-US", task.ID, store.NewID("answer"), task.AnswerKey.CorrectOptionID, nil); err != nil { t.Fatal(err) } } for n := 0; n < 3; n++ { task, level := next() if (n == 0 && level != 2) || level > 2 { t.Fatal("difficulty should rise after success, then allow easier weak-goal practice", level) } wrong := task.Options[0].ID if wrong == task.AnswerKey.CorrectOptionID { wrong = task.Options[1].ID } if _, _, err = engine.Submit(ctx, user.ID, "en-US", task.ID, store.NewID("answer"), wrong, nil); err != nil { t.Fatal(err) } } _, level := next() if level != 1 { t.Fatal("difficulty did not decrease", level) } if err = engine.Repo.Reconcile(ctx, true); err != nil { t.Fatal(err) } var count int db.QueryRow(`SELECT count(*) FROM course_v2_jobs WHERE kind='analyze'`).Scan(&count) if count != 0 { t.Fatal("bank scheduled AI analysis", count) } // A crash before deterministic choice grading must not require an evaluator. pendingTask, _ := next() pending, err := engine.Repo.Submit(ctx, user.ID, "crashed-choice", pendingTask, pendingTask.AnswerKey.CorrectOptionID, nil) if err != nil { t.Fatal(err) } if err = engine.Repo.Reconcile(ctx, true); err != nil { t.Fatal(err) } recovery, err := engine.Repo.Claim(ctx) if err != nil || recovery.Kind != "evaluate" { t.Fatal(err, recovery) } recoveredTask, err := engine.Process(ctx, recovery) if err != nil { t.Fatal(err) } if err = engine.Repo.Finish(ctx, recovery, recoveredTask, ""); err != nil { t.Fatal(err) } pending, err = engine.Repo.Attempt(ctx, user.ID, "en-US", pending.ID) if err != nil || pending.Status != "graded" || pending.Evaluation.Score != 100 { t.Fatal("choice recovery required AI", err, pending) } db.QueryRow(`SELECT count(*) FROM ai_operations`).Scan(&count) if count != 0 { t.Fatal("choice recovery created AI operation", count) } // Changing an installed immutable revision must fail without retiring templates. if _, err = db.Exec(`UPDATE course_v2_bank SET checksum='corrupt' WHERE id=(SELECT min(id) FROM course_v2_bank)`); err != nil { t.Fatal(err) } if engine.Repo.InstallBank(ctx) == nil { t.Fatal("changed revision accepted") } db.QueryRow(`SELECT count(*) FROM course_v2_bank WHERE active`).Scan(&count) if count != 840 { t.Fatal("failed import partially retired templates", count) } }