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.
This commit is contained in:
@@ -155,6 +155,16 @@ func courseMember(s string, values []string) bool {
|
||||
// Technical validity only. No word lists, English patterns, fixed objectives,
|
||||
// fixed distractors, or linguistic judgement live in the application.
|
||||
func ValidateAdaptiveTask(t domain.AdaptiveTask, language, module, skill string) error {
|
||||
// Locale revisions and evidence identities are assigned by Go or the reviewed
|
||||
// bank importer. Adding typed fields must not let model output claim them.
|
||||
if t.VariantID != "" || t.ContentRevision != "" || t.CanonicalTaskID != "" || t.EvidenceTaskID != "" || t.InstructionLanguage != "" || t.Instruction != "" || t.Stimulus != nil || (t.AnswerKey != nil && t.AnswerKey.ReferenceAnswerLanguage != "") {
|
||||
return errors.New("task contains server-owned variant metadata")
|
||||
}
|
||||
for _, option := range t.Options {
|
||||
if option.Language != "" || option.Role != "" {
|
||||
return errors.New("task contains server-owned option metadata")
|
||||
}
|
||||
}
|
||||
if !courseText(t.ModuleID, 200) || !courseText(t.TargetLanguage, 50) || t.SchemaVersion != 2 || t.TargetLanguage != language || t.CourseVersion != domain.CourseVersion || t.CEFRLevel != "A1" || t.ModuleID != module || !courseMember(t.Skill, domain.CourseSkills) || (skill != "" && t.Skill != skill) {
|
||||
return errors.New("task context mismatch")
|
||||
}
|
||||
|
||||
@@ -98,7 +98,11 @@ func (e *CourseEngine) snapshot(ctx context.Context, j domain.CourseJob) (domain
|
||||
if err != nil {
|
||||
return domain.CourseSnapshot{}, err
|
||||
}
|
||||
return e.Repo.Snapshot(ctx, j.UserID, j.Language, user.UILanguage)
|
||||
instructionLanguage := j.InstructionLanguage
|
||||
if instructionLanguage == "" {
|
||||
instructionLanguage = user.ExplanationLanguage()
|
||||
}
|
||||
return e.Repo.Snapshot(ctx, j.UserID, j.Language, instructionLanguage)
|
||||
}
|
||||
func (e *CourseEngine) analyze(ctx context.Context, j domain.CourseJob) (domain.CourseSnapshot, error) {
|
||||
snapshot, err := e.snapshot(ctx, j)
|
||||
@@ -137,6 +141,9 @@ func (e *CourseEngine) Process(ctx context.Context, j domain.CourseJob) (*domain
|
||||
}
|
||||
return &t, err
|
||||
case "exam":
|
||||
if j.InstructionLanguage != "" && j.InstructionLanguage != "de-DE" {
|
||||
return nil, store.ErrCourseVariantUnavailable
|
||||
}
|
||||
tasks, err := e.Repo.BankExam(ctx, j.UserID, j.Language, j.ModuleID)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
tasks, err = e.Repo.ReserveExam(ctx, j.UserID, j.Language, j.ModuleID)
|
||||
@@ -538,7 +545,7 @@ func (e *CourseEngine) finalizeExam(ctx context.Context, j domain.CourseJob) err
|
||||
var summary struct {
|
||||
Summary string `json:"summary"`
|
||||
}
|
||||
err = e.Agent.Teacher(ctx, "summarize_course_exam", map[string]any{"target_language": j.Language, "ui_language": user.UILanguage, "exam": exam}, &summary)
|
||||
err = e.Agent.Teacher(ctx, "summarize_course_exam", map[string]any{"target_language": j.Language, "ui_language": valueOr(j.InstructionLanguage, user.ExplanationLanguage()), "exam": exam}, &summary)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -548,7 +555,7 @@ func (e *CourseEngine) finalizeExam(ctx context.Context, j domain.CourseJob) err
|
||||
if err = e.Repo.ExamSummary(ctx, j.UserID, j.SubjectID, summary.Summary); err != nil {
|
||||
return err
|
||||
}
|
||||
snapshot, err := e.Repo.Snapshot(ctx, j.UserID, j.Language, user.UILanguage)
|
||||
snapshot, err := e.Repo.Snapshot(ctx, j.UserID, j.Language, user.ExplanationLanguage())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -53,6 +53,9 @@ func (s *AuthService) Register(ctx context.Context, email, password, uiLanguage,
|
||||
if uiLanguage == "" {
|
||||
uiLanguage = "de-DE"
|
||||
}
|
||||
if !domain.SupportedUILanguage(uiLanguage) {
|
||||
return AuthResult{}, errors.New("unsupported UI language")
|
||||
}
|
||||
if targetLanguage == "" {
|
||||
targetLanguage = "en-US"
|
||||
}
|
||||
|
||||
@@ -0,0 +1,218 @@
|
||||
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")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"speech-learning-api/internal/domain"
|
||||
"speech-learning-api/internal/store"
|
||||
)
|
||||
|
||||
func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
|
||||
db, profiles := adaptiveTestDB(t)
|
||||
ctx := context.Background()
|
||||
user, err := profiles.CreateUser(ctx, "languages@example.test", "hash", "de-DE")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
original, err := profiles.CreateLearnerProfile(ctx, user.ID, "es-ES", "A2", 25)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
updated, err := profiles.UpdatePreferences(ctx, user.ID, "en-US", "", "", 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if updated != original {
|
||||
t.Fatalf("interface switch changed learning profile: before=%+v after=%+v", original, updated)
|
||||
}
|
||||
loaded, err := profiles.GetUser(ctx, user.ID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if loaded.UILanguage != "en-US" || loaded.InstructionLanguage != "de-DE" {
|
||||
t.Fatalf("language roles conflated: %+v", loaded)
|
||||
}
|
||||
_, _, err = profiles.GetPasswordHashByEmail(ctx, user.Email)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
engine := NewCourseEngine(store.NewAdaptiveStore(db), profiles, nil, nil)
|
||||
snapshot, err := engine.snapshot(ctx, domain.CourseJob{UserID: user.ID, Language: "es-ES"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if snapshot.UILanguage != "de-DE" {
|
||||
t.Fatalf("model instructions follow interface language: %q", snapshot.UILanguage)
|
||||
}
|
||||
if _, err = profiles.UpdatePreferences(ctx, user.ID, "unsupported", "en-US", "A1", 10); err == nil {
|
||||
t.Fatal("unsupported interface accepted")
|
||||
}
|
||||
active, err := profiles.GetPrimaryProfile(ctx, user.ID)
|
||||
if err != nil || active != original {
|
||||
t.Fatalf("rejected update changed active profile: %+v %v", active, err)
|
||||
}
|
||||
// A failed profile write must not commit the accompanying interface change.
|
||||
if _, err = db.ExecContext(ctx, `ALTER TABLE learner_profiles ADD CONSTRAINT test_daily_limit CHECK(daily_goal_minutes<=60)`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = profiles.UpdatePreferences(ctx, user.ID, "de-DE", "en-US", "A1", 100); err == nil {
|
||||
t.Fatal("expected profile constraint failure")
|
||||
}
|
||||
loaded, err = profiles.GetUser(ctx, user.ID)
|
||||
if err != nil || loaded.UILanguage != "en-US" {
|
||||
t.Fatalf("failed update changed interface: %+v %v", loaded, err)
|
||||
}
|
||||
active, err = profiles.GetPrimaryProfile(ctx, user.ID)
|
||||
if err != nil || active != original {
|
||||
t.Fatalf("failed update changed learning profile: %+v %v", active, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInstructionLanguageMigrationPreservesLegacyPreference(t *testing.T) {
|
||||
db, profiles := adaptiveTestDB(t)
|
||||
ctx := context.Background()
|
||||
user, err := profiles.CreateUser(ctx, "legacy-language@example.test", "hash", "fr-FR")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Simulate the previous schema in this disposable test schema only.
|
||||
if _, err = db.ExecContext(ctx, `ALTER TABLE users DROP COLUMN instruction_language`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err = profiles.Init(ctx); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
loaded, err := profiles.GetUser(ctx, user.ID)
|
||||
if err != nil || loaded.InstructionLanguage != "fr-FR" {
|
||||
t.Fatalf("legacy instruction preference lost: %+v %v", loaded, err)
|
||||
}
|
||||
if _, err = profiles.UpdatePreferences(ctx, user.ID, "en-US", "", "", 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err = profiles.Init(ctx); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
loaded, err = profiles.GetUser(ctx, user.ID)
|
||||
if err != nil || loaded.UILanguage != "en-US" || loaded.InstructionLanguage != "fr-FR" {
|
||||
t.Fatalf("repeated migration changed instruction preference: %+v %v", loaded, err)
|
||||
}
|
||||
result, err := NewAuthService(profiles, "language-test-only").Register(ctx, "new-language@example.test", "test-password", "en-US", "en-US", 15)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if result.User.UILanguage != "en-US" || result.User.InstructionLanguage != "de-DE" {
|
||||
t.Fatalf("new account did not keep German course explanations: %+v", result.User)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user