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.
435 lines
15 KiB
Go
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")
|
|
}
|
|
}
|