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.
This commit is contained in:
@@ -0,0 +1,434 @@
|
||||
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")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user