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:
Eugenius Naumenko
2026-11-07 16:26:26 +00:00
parent 87684ba0fd
commit f3d42ee2b6
68 changed files with 3895 additions and 481 deletions
@@ -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")
}
+10 -3
View File
@@ -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
}
+3
View File
@@ -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)
}
}