Files
Speech/apps/api/internal/services/course_bank_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

471 lines
15 KiB
Go

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