Files
Speech/apps/api/internal/services/course_variants_integration_test.go
T
Eugenius Naumenko f3d42ee2b6 Mehrsprachige Bedienung und versionierte Aufgabenvarianten einführen
Übersetzungskataloge, getrennte Sprachpräferenzen und einen versionierten Aufgabenpilot ergänzen. Historische Aufgaben und Bewertungen bleiben erhalten; äquivalente Ansichten teilen Nachweise. Lokal mit Race-Tests und PostgreSQL, Vet, Web-Build, Bank-Audits und Browser-Fixtures geprüft. Dieser Stand dient als Ausgangspunkt für die anschließend beauftragte Zusammenführung zur Muttersprache.
2026-11-07 16:26:26 +00:00

219 lines
7.7 KiB
Go

package services
import (
"bytes"
"context"
"encoding/json"
"errors"
"io"
"log/slog"
"testing"
"time"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
)
func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
db, profiles := adaptiveTestDB(t)
ctx := context.Background()
user, err := profiles.CreateUser(ctx, "variants@example.test", "hash", "de-DE")
if err != nil {
t.Fatal(err)
}
if _, err = profiles.CreateLearnerProfile(ctx, user.ID, "en-US", "A1", 20); err != nil {
t.Fatal(err)
}
repo := store.NewAdaptiveStore(db)
engine := NewCourseEngine(repo, profiles, nil, slog.New(slog.NewTextHandler(io.Discard, nil)))
engine.Mode = "bank"
base, err := store.BundledBank()
if err != nil {
t.Fatal(err)
}
// Existing releases assigned ordinary task snapshots without locale metadata.
historical := func(skill string) domain.AdaptiveTask {
t.Helper()
var entry domain.BankEntry
for _, candidate := range base {
if candidate.Task.ModuleID == "a1_introductions_v1" && candidate.Task.Skill == skill && candidate.Task.Kind != "free_speech" && candidate.Task.Kind != "free_text" {
entry = candidate
break
}
}
task := entry.Task
task.ID = store.NewID("historic")
task.Source = "curated"
raw, _ := json.Marshal(task)
_, err := db.ExecContext(ctx, `INSERT INTO course_v2_tasks(id,module_id,language,version,owner_id,source,skill,kind,data,fingerprint,bank_entry_id,last_presented_at,presentation_count) VALUES($1,$2,$3,$4,$5,'curated',$6,$7,$8,$9,$10,now(),1)`, task.ID, task.ModuleID, task.TargetLanguage, task.CourseVersion, user.ID, task.Skill, task.Kind, raw, "bank:"+entry.ID, entry.ID)
if err != nil {
t.Fatal(err)
}
return task
}
old := historical("grammar")
oldSpeech := historical("speaking")
var before []byte
if err = db.QueryRowContext(ctx, `SELECT data FROM course_v2_tasks WHERE id=$1`, old.ID).Scan(&before); err != nil {
t.Fatal(err)
}
if _, _, err = engine.Submit(ctx, user.ID, "en-US", old.ID, "old-answer", old.AnswerKey.CorrectOptionID, nil); err != nil {
t.Fatal(err)
}
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "en-US"); err != nil {
t.Fatal(err)
}
run := func(skill, request string, changeAfterEnqueue bool) 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)
}
if j.InstructionLanguage != "en-US" {
t.Fatal("job did not freeze explanation language", j)
}
if changeAfterEnqueue {
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "de-DE"); err != nil {
t.Fatal(err)
}
}
j, err = repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
task, err := engine.Process(ctx, j)
if err != nil {
t.Fatal(err)
}
if err = repo.Finish(ctx, j, task, ""); err != nil {
t.Fatal(err)
}
if task.InstructionLanguage != "en-US" || task.VariantID == "" || task.ContentRevision == "" || task.Instruction == "" {
t.Fatal("incomplete frozen variant", task)
}
return *task
}
first := run("grammar", "english-grammar-first", false)
if _, _, err = engine.Submit(ctx, user.ID, "en-US", first.ID, "english-first-answer", first.AnswerKey.CorrectOptionID, nil); err != nil {
t.Fatal(err)
}
translated := run("grammar", "english-grammar-second", true)
if !translated.Review || translated.EvidenceTaskID != old.ID {
t.Fatal("translation did not reuse existing evidence", translated, old)
}
if _, _, err = engine.Submit(ctx, user.ID, "en-US", translated.ID, "english-second-answer", translated.AnswerKey.CorrectOptionID, nil); err != nil {
t.Fatal(err)
}
replay, err := repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_introductions_v1", "grammar", "", "english-grammar-second")
if err != nil || replay.TaskID != translated.ID || replay.InstructionLanguage != "en-US" {
t.Fatal("locale change altered idempotent replay", replay, err)
}
snapshot, err := repo.Snapshot(ctx, user.ID, "en-US", "de-DE")
if err != nil {
t.Fatal(err)
}
found := false
for _, p := range snapshot.Progress {
if p.Skill == "grammar" && p.ModuleID == old.ModuleID {
found = true
if p.Attempts != 3 || p.DistinctTasks != 2 {
t.Fatalf("translation inflated task evidence: %+v", p)
}
}
}
if !found {
t.Fatal("missing graded evidence")
}
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "en-US"); err != nil {
t.Fatal(err)
}
inventory, err := repo.BankInventory(ctx, user.ID, "en-US")
if err != nil {
t.Fatal(err)
}
total := 0
for _, item := range inventory {
total += item.Total
if item.ModuleID != "a1_introductions_v1" {
t.Fatal("German fallback advertised as English", item)
}
}
if total != 12 {
t.Fatal("incorrect locale inventory", inventory)
}
// Local speech fixtures exercise the real observation path; no Azure is called.
speech := domain.PronunciationResult{Provider: "azure", Method: "scripted", Locale: "en-US", Alphabet: "IPA", OverallScore: 65, WordScores: []domain.WordScore{{Word: "name", Accuracy: 65, PhonemeScores: []domain.PhonemeScore{{Phoneme: "n", Accuracy: 60}}}}}
if _, _, err = engine.Submit(ctx, user.ID, "en-US", oldSpeech.ID, "old-speech", oldSpeech.ReferenceText, &speech); err != nil {
t.Fatal(err)
}
localizedSpeech := run("speaking", "localized-speech", false)
if localizedSpeech.Kind != "free_speech" { // The existing repeat may be scheduled after the unseen free task.
if localizedSpeech.Kind != "repeat_sentence" {
t.Fatal(localizedSpeech.Kind)
}
} else {
localizedSpeech = run("speaking", "localized-repeat", false)
}
if localizedSpeech.EvidenceTaskID != oldSpeech.ID {
t.Fatal("translated repeat changed evidence identity", localizedSpeech)
}
if _, _, err = engine.Submit(ctx, user.ID, "en-US", localizedSpeech.ID, "translated-speech", localizedSpeech.ReferenceText, &speech); err != nil {
t.Fatal(err)
}
profile, err := profiles.PronunciationProfile(ctx, user.ID, "en-US", time.Now().UTC().Add(time.Second))
if err != nil {
t.Fatal(err)
}
for _, target := range profile.Targets {
if target.Tasks != 1 || target.Samples != 1 {
t.Fatalf("translation inflated pronunciation density: %+v", target)
}
}
if len(profile.Targets) == 0 {
t.Fatal("missing fixture observations")
}
if err = profiles.Init(ctx); err != nil {
t.Fatal("restart after multiple locale assignments", err)
}
var after []byte
if err = db.QueryRowContext(ctx, `SELECT data FROM course_v2_tasks WHERE id=$1`, old.ID).Scan(&after); err != nil {
t.Fatal(err)
}
if !bytes.Equal(before, after) {
t.Fatal("historical snapshot was rewritten")
}
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "fr-FR"); !errors.Is(err, store.ErrCourseVariantUnavailable) {
t.Fatal("unsupported locale accepted", err)
}
// Missing reviewed variants must not silently select a German reserve.
if _, err = repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_family_v1", "grammar", "", "missing-variants"); err != nil {
t.Fatal(err)
}
job, err := repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
if _, err = engine.Process(ctx, job); !errors.Is(err, store.ErrCourseVariantUnavailable) {
t.Fatal("wrong-language fallback", err)
}
if err = repo.Finish(ctx, job, nil, "no reviewed variants"); err != nil {
t.Fatal(err)
}
history, err := repo.History(ctx, user.ID, "en-US", "a1_family_v1", 0)
if err != nil || len(history) != 0 {
t.Fatal("unsupported request assigned German content", history, err)
}
}
func TestModelCannotSetVariantEvidence(t *testing.T) {
entries, err := store.BundledBank()
if err != nil {
t.Fatal(err)
}
task := entries[0].Task
task.EvidenceTaskID = "another-assignment"
if ValidateAdaptiveTask(task, task.TargetLanguage, task.ModuleID, task.Skill) == nil {
t.Fatal("model-owned evidence identity accepted")
}
}