package services import ( "bytes" "context" "encoding/json" "errors" "fmt" "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", "ru-RU"); 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 != "ru-RU" { 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 != "ru-RU" || task.VariantID == "" || task.ContentRevision == "" || task.Instruction == "" { t.Fatal("incomplete frozen variant", task) } return *task } // Limit this fixture to the historical grammar goal so evidence reuse is deterministic. if _, err = db.ExecContext(ctx, `UPDATE course_v2_bank_variants v SET active=false FROM course_v2_bank b WHERE v.base_entry_id=b.id AND b.module_id='a1_introductions_v1' AND b.skill='grammar' AND b.id<>(SELECT bank_entry_id FROM course_v2_tasks WHERE id=$1)`, old.ID); err != nil { t.Fatal(err) } var translated domain.AdaptiveTask distinct := map[string]bool{old.ID: true} for n := 0; n < 2; n++ { translated = run("grammar", fmt.Sprintf("russian-grammar-%d", n), n == 1) distinct[translated.EvidenceTaskID] = true if _, _, err = engine.Submit(ctx, user.ID, "en-US", translated.ID, fmt.Sprintf("russian-answer-%d", n), translated.AnswerKey.CorrectOptionID, nil); err != nil { t.Fatal(err) } } // The translated historical task retains its canonical evidence identity. var shared int if err = db.QueryRowContext(ctx, `SELECT count(*) FROM course_v2_tasks WHERE owner_id=$1 AND data->>'evidence_task_id'=$2 AND variant_id IS NOT NULL`, user.ID, old.ID).Scan(&shared); err != nil || shared != 1 { t.Fatal("translation did not share historical evidence", shared, err) } replay, err := repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_introductions_v1", "grammar", "", "russian-grammar-1") if err != nil || replay.TaskID != translated.ID || replay.InstructionLanguage != "ru-RU" { 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 != len(distinct) { t.Fatalf("translation inflated task evidence: %+v", p) } } } if !found { t.Fatal("missing graded evidence") } if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "ru-RU"); err != nil { t.Fatal(err) } if _, err = db.ExecContext(ctx, `UPDATE course_v2_bank_variants SET active=true WHERE instruction_language='ru-RU'`); 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 total != 840 { 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) } if _, err = db.ExecContext(ctx, `UPDATE course_v2_bank_variants v SET active=false FROM course_v2_bank b WHERE v.base_entry_id=b.id AND b.module_id='a1_introductions_v1' AND b.skill='speaking' AND b.id<>(SELECT bank_entry_id FROM course_v2_tasks WHERE id=$1)`, oldSpeech.ID); err != nil { t.Fatal(err) } var localizedSpeech domain.AdaptiveTask for n := 0; n < 20; n++ { localizedSpeech = run("speaking", fmt.Sprintf("localized-speech-%d", n), false) if localizedSpeech.EvidenceTaskID == oldSpeech.ID { break } } 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, domain.ErrNativeLanguageUnsupported) { t.Fatal("unsupported locale accepted", err) } // Missing reviewed variants must not silently select a German reserve. if _, err = db.ExecContext(ctx, `UPDATE course_v2_bank_variants v SET active=false FROM course_v2_bank b WHERE v.base_entry_id=b.id AND b.module_id='a1_family_v1'`); err != nil { t.Fatal(err) } 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") } }