Ü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.
219 lines
7.7 KiB
Go
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")
|
|
}
|
|
}
|