Muttersprache koppeln und russischen A1-Kurs ergänzen
GUI und neue Erklärungen verwenden gemeinsam native_language. Deutsch und Russisch sind die beiden Muttersprachen; Englisch bleibt die Lernsprache. Kompatibilitätsfelder werden atomar gekoppelt, widersprüchliche Eingaben abgewiesen und bestehende Profile sowie eingefrorene Inhalte erhalten. Ergänzt vollständige russische GUI-Kataloge und 840 geprüfte Aufgabenansichten in sieben Modulen einschließlich A1-Test, mit getrennten Sprachrollen für Ausgangs- und Lernmaterial. Äquivalente Ansichten teilen ihre Nachweisidentität. Stabile API-Fehlercodes, neue deterministische Hilfen und Trainingsbegründungen berücksichtigen die Muttersprache. Dokumentiert das Sprachmodell in AGENTS.md. Validierung: Go-Race-Suite mit eigener lokaler PostgreSQL-Testdatenbank, go vet, Web-Build, Offline-Bank-/Variantenaudit, Diff-Prüfung sowie lokale Browser-Smokes für Sprachen, Kurs, Administration, Aussprache und Aufnahme. Keine Live-Anbieter, Produktionsprofile, Deployment-Schritte oder historischen Neubewertungen.
This commit is contained in:
@@ -141,17 +141,17 @@ func (e *CourseEngine) Process(ctx context.Context, j domain.CourseJob) (*domain
|
||||
}
|
||||
return &t, err
|
||||
case "exam":
|
||||
if j.InstructionLanguage != "" && j.InstructionLanguage != "de-DE" {
|
||||
if j.InstructionLanguage != "" && !domain.SupportedNativeLanguage(j.InstructionLanguage) {
|
||||
return nil, store.ErrCourseVariantUnavailable
|
||||
}
|
||||
tasks, err := e.Repo.BankExam(ctx, j.UserID, j.Language, j.ModuleID)
|
||||
tasks, err := e.Repo.BankExam(ctx, j.UserID, j.Language, j.ModuleID, j.InstructionLanguage)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
tasks, err = e.Repo.ReserveExam(ctx, j.UserID, j.Language, j.ModuleID)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err = ValidateExamTasks(tasks, j.Language, j.ModuleID); err != nil {
|
||||
if err = validateReviewedExamTasks(tasks, j.Language, j.ModuleID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return nil, e.Repo.SaveExamTasks(ctx, j.UserID, j.Language, j.SubjectID, tasks)
|
||||
@@ -585,3 +585,30 @@ func (e *CourseEngine) completeBankExam(ctx context.Context, user, language, id
|
||||
}
|
||||
return e.Repo.EnsureBankExamSummary(ctx, user, id)
|
||||
}
|
||||
|
||||
// Reviewed packages carry server-owned metadata that the model contract forbids.
|
||||
// Validate their renderer/test coverage without treating trusted metadata as model output.
|
||||
func validateReviewedExamTasks(tasks []domain.AdaptiveTask, language, module string) error {
|
||||
plain := make([]domain.AdaptiveTask, len(tasks))
|
||||
for i, task := range tasks {
|
||||
task.InstructionLanguage = ""
|
||||
task.Instruction = ""
|
||||
task.Stimulus = nil
|
||||
task.VariantID = ""
|
||||
task.ContentRevision = ""
|
||||
task.CanonicalTaskID = ""
|
||||
task.EvidenceTaskID = ""
|
||||
task.Options = append([]domain.TaskOption(nil), task.Options...)
|
||||
for j := range task.Options {
|
||||
task.Options[j].Language = ""
|
||||
task.Options[j].Role = ""
|
||||
}
|
||||
if task.AnswerKey != nil {
|
||||
key := *task.AnswerKey
|
||||
key.ReferenceAnswerLanguage = ""
|
||||
task.AnswerKey = &key
|
||||
}
|
||||
plain[i] = task
|
||||
}
|
||||
return ValidateExamTasks(plain, language, module)
|
||||
}
|
||||
|
||||
@@ -631,7 +631,7 @@ func (a *AIService) NextExercise(ctx context.Context, input domain.GeneratedExer
|
||||
|
||||
// Preserve the existing non-AI feedback and demo conversation behavior.
|
||||
func (a *AIService) FeedbackForAttempt(ctx context.Context, text string, r domain.PronunciationResult, weak []domain.WordScore) (domain.TeacherResponse, error) {
|
||||
return mockFeedback(text, r), nil
|
||||
return localizedFeedback(ctx, text, r), nil
|
||||
}
|
||||
func (a *AIService) StartConversation(ctx context.Context, lang, level string) (domain.TeacherResponse, error) {
|
||||
return (&FlowiseTeacher{}).StartConversation(ctx, lang, level)
|
||||
|
||||
@@ -54,7 +54,7 @@ func (s *AuthService) Register(ctx context.Context, email, password, uiLanguage,
|
||||
uiLanguage = "de-DE"
|
||||
}
|
||||
if !domain.SupportedUILanguage(uiLanguage) {
|
||||
return AuthResult{}, errors.New("unsupported UI language")
|
||||
return AuthResult{}, domain.ErrNativeLanguageUnsupported
|
||||
}
|
||||
if targetLanguage == "" {
|
||||
targetLanguage = "en-US"
|
||||
|
||||
@@ -11,6 +11,7 @@ import (
|
||||
"speech-learning-api/internal/config"
|
||||
"speech-learning-api/internal/domain"
|
||||
"speech-learning-api/internal/store"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
)
|
||||
@@ -163,9 +164,14 @@ func TestBankPostgresSelectionAndOptionalEvaluation(t *testing.T) {
|
||||
}
|
||||
|
||||
func TestBankPostgresExamSubmissionAndLaterGrades(t *testing.T) {
|
||||
for _, native := range []string{"de-DE", "ru-RU"} {
|
||||
t.Run(native, func(t *testing.T) { testBankExamNative(t, native) })
|
||||
}
|
||||
}
|
||||
func testBankExamNative(t *testing.T, native string) {
|
||||
db, profiles := adaptiveTestDB(t)
|
||||
ctx := context.Background()
|
||||
user, err := profiles.CreateUser(ctx, store.NewID("exam-bank")+"@example.test", "hash", "de-DE")
|
||||
user, err := profiles.CreateUser(ctx, store.NewID("exam-bank")+"@example.test", "hash", native)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -195,8 +201,15 @@ func TestBankPostgresExamSubmissionAndLaterGrades(t *testing.T) {
|
||||
if err != nil || len(exam.Tasks) != 12 {
|
||||
t.Fatal(err, exam)
|
||||
}
|
||||
if err = engine.Repo.SetInstructionLanguage(ctx, user.ID, "en-US", "de-DE"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Task presentations and the final static summary retain the exam language.
|
||||
ungraded := []domain.AdaptiveAttempt{}
|
||||
for n, pub := range exam.Tasks {
|
||||
if pub.InstructionLanguage != native {
|
||||
t.Fatal("exam language not frozen", pub.InstructionLanguage, native)
|
||||
}
|
||||
if pub.AnswerKey != nil || pub.AudioText != "" {
|
||||
t.Fatal("exam key leaked")
|
||||
}
|
||||
@@ -277,7 +290,7 @@ func TestBankPostgresExamSubmissionAndLaterGrades(t *testing.T) {
|
||||
if message.Task != "evaluate_course_attempt" {
|
||||
t.Error("unexpected model action", message.Task)
|
||||
}
|
||||
json.NewEncoder(w).Encode(aiCompletion(domain.CourseEvaluation{Score: 100, Verdict: "correct", Feedback: "Richtig.", Issues: []string{}}, true))
|
||||
json.NewEncoder(w).Encode(aiCompletion(domain.CourseEvaluation{Score: 100, Verdict: "correct", Feedback: map[string]string{"de-DE": "Richtig.", "ru-RU": "Верно."}[native], Issues: []string{}}, true))
|
||||
}))
|
||||
defer server.Close()
|
||||
agent.Keys["mistral"] = "fixture-secret"
|
||||
@@ -311,6 +324,9 @@ func TestBankPostgresExamSubmissionAndLaterGrades(t *testing.T) {
|
||||
if err != nil || exam.Status != "completed" || exam.Score == nil || *exam.Score != 100 || exam.SummaryStatus != "ready" {
|
||||
t.Fatal("later grading failed", err, exam)
|
||||
}
|
||||
if native == "ru-RU" && !strings.HasPrefix(exam.Summary, "Внутренняя") {
|
||||
t.Fatal("wrong summary language", exam.Summary)
|
||||
}
|
||||
// Repair a crash after score completion without invoking a summarizing model.
|
||||
if _, err = db.Exec(`UPDATE course_v2_exams SET result=jsonb_set(result,'{summary_status}','"pending"') WHERE id=$1`, exam.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
|
||||
@@ -5,6 +5,7 @@ import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"testing"
|
||||
@@ -60,7 +61,7 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
|
||||
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 {
|
||||
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 {
|
||||
@@ -69,7 +70,7 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if j.InstructionLanguage != "en-US" {
|
||||
if j.InstructionLanguage != "ru-RU" {
|
||||
t.Fatal("job did not freeze explanation language", j)
|
||||
}
|
||||
if changeAfterEnqueue {
|
||||
@@ -88,24 +89,32 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
|
||||
if err = repo.Finish(ctx, j, task, ""); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if task.InstructionLanguage != "en-US" || task.VariantID == "" || task.ContentRevision == "" || task.Instruction == "" {
|
||||
if task.InstructionLanguage != "ru-RU" || 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 {
|
||||
|
||||
// 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)
|
||||
}
|
||||
translated := run("grammar", "english-grammar-second", true)
|
||||
if !translated.Review || translated.EvidenceTaskID != old.ID {
|
||||
t.Fatal("translation did not reuse existing evidence", translated, old)
|
||||
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)
|
||||
}
|
||||
}
|
||||
if _, _, err = engine.Submit(ctx, user.ID, "en-US", translated.ID, "english-second-answer", 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", "", "english-grammar-second")
|
||||
if err != nil || replay.TaskID != translated.ID || replay.InstructionLanguage != "en-US" {
|
||||
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")
|
||||
@@ -116,7 +125,7 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
|
||||
for _, p := range snapshot.Progress {
|
||||
if p.Skill == "grammar" && p.ModuleID == old.ModuleID {
|
||||
found = true
|
||||
if p.Attempts != 3 || p.DistinctTasks != 2 {
|
||||
if p.Attempts != 3 || p.DistinctTasks != len(distinct) {
|
||||
t.Fatalf("translation inflated task evidence: %+v", p)
|
||||
}
|
||||
}
|
||||
@@ -124,7 +133,10 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
|
||||
if !found {
|
||||
t.Fatal("missing graded evidence")
|
||||
}
|
||||
if err = repo.SetInstructionLanguage(ctx, user.ID, "en-US", "en-US"); err != nil {
|
||||
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")
|
||||
@@ -134,11 +146,9 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
|
||||
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 {
|
||||
if total != 840 {
|
||||
t.Fatal("incorrect locale inventory", inventory)
|
||||
}
|
||||
// Local speech fixtures exercise the real observation path; no Azure is called.
|
||||
@@ -146,13 +156,16 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
|
||||
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)
|
||||
|
||||
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
|
||||
}
|
||||
} else {
|
||||
localizedSpeech = run("speaking", "localized-repeat", false)
|
||||
}
|
||||
if localizedSpeech.EvidenceTaskID != oldSpeech.ID {
|
||||
t.Fatal("translated repeat changed evidence identity", localizedSpeech)
|
||||
@@ -182,10 +195,13 @@ func TestCourseVariantSnapshotsAndEvidence(t *testing.T) {
|
||||
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) {
|
||||
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)
|
||||
}
|
||||
|
||||
@@ -54,6 +54,12 @@ func (f *FlowiseTeacher) NextExercise(ctx context.Context, input domain.Generate
|
||||
ReasonForChoice: "Fallback exercise because Flowise did not return a valid exercise.",
|
||||
Source: "fallback",
|
||||
}
|
||||
if input.UILanguage == "ru-RU" {
|
||||
fallback.DisplayPrompt = "Чётко повторите предложение вслух."
|
||||
fallback.FocusPoints = []string{"ритм", "конечные звуки"}
|
||||
fallback.SuccessCriteria = []string{"точность выше 80"}
|
||||
fallback.ReasonForChoice = "Резервное упражнение: новое упражнение сейчас недоступно."
|
||||
}
|
||||
progress := compactProgressForFlowise(input.Progress)
|
||||
payload := map[string]any{
|
||||
"task": "next_exercise",
|
||||
@@ -96,20 +102,25 @@ func withoutPhonemeScores(words []domain.WordScore) []domain.WordScore {
|
||||
func (f *FlowiseTeacher) FeedbackForAttempt(ctx context.Context, targetText string, result domain.PronunciationResult, weakWords []domain.WordScore) (domain.TeacherResponse, error) {
|
||||
_ = ctx
|
||||
_ = weakWords
|
||||
return mockFeedback(targetText, result), nil
|
||||
return localizedFeedback(ctx, targetText, result), nil
|
||||
}
|
||||
|
||||
func (f *FlowiseTeacher) StartConversation(ctx context.Context, targetLanguage, cefrLevel string) (domain.TeacherResponse, error) {
|
||||
_ = ctx
|
||||
_ = targetLanguage
|
||||
_ = cefrLevel
|
||||
return domain.TeacherResponse{
|
||||
response := domain.TeacherResponse{
|
||||
ExerciseType: "conversation",
|
||||
TargetText: "Hello. What is your name?",
|
||||
TeacherFeedback: "Wir starten sehr einfach. Antworte mit: My name is ...",
|
||||
TTSText: "Hello. What is your name?",
|
||||
NextRecommendation: "Antworten: My name is ...",
|
||||
}, nil
|
||||
}
|
||||
if nativeLanguage(ctx) == "ru-RU" {
|
||||
response.TeacherFeedback = "Начнём с простого. Ответьте: My name is ..."
|
||||
response.NextRecommendation = "Ответьте: My name is ..."
|
||||
}
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (f *FlowiseTeacher) ContinueConversation(ctx context.Context, targetLanguage, cefrLevel, userText string) (domain.TeacherResponse, error) {
|
||||
@@ -117,13 +128,18 @@ func (f *FlowiseTeacher) ContinueConversation(ctx context.Context, targetLanguag
|
||||
_ = targetLanguage
|
||||
_ = cefrLevel
|
||||
_ = userText
|
||||
return domain.TeacherResponse{
|
||||
response := domain.TeacherResponse{
|
||||
ExerciseType: "conversation",
|
||||
TargetText: "Nice to meet you. Where are you from?",
|
||||
TeacherFeedback: "Gut. Jetzt uebe einen kurzen Satz mit Herkunft.",
|
||||
TTSText: "Nice to meet you. Where are you from?",
|
||||
NextRecommendation: "Antworten: I am from ...",
|
||||
}, nil
|
||||
}
|
||||
if nativeLanguage(ctx) == "ru-RU" {
|
||||
response.TeacherFeedback = "Теперь потренируйте короткое предложение о том, откуда вы."
|
||||
response.NextRecommendation = "Ответьте: I am from ..."
|
||||
}
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (f *FlowiseTeacher) askExercise(ctx context.Context, payload map[string]any, input domain.GeneratedExerciseRequest, fallback domain.GeneratedExercise) (domain.GeneratedExercise, error) {
|
||||
|
||||
@@ -19,7 +19,7 @@ func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
updated, err := profiles.UpdatePreferences(ctx, user.ID, "en-US", "", "", 0)
|
||||
updated, err := profiles.UpdatePreferences(ctx, user.ID, "ru-RU", "", "", 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -30,7 +30,7 @@ func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if loaded.UILanguage != "en-US" || loaded.InstructionLanguage != "de-DE" {
|
||||
if loaded.NativeLanguage != "ru-RU" || loaded.UILanguage != "ru-RU" || loaded.InstructionLanguage != "ru-RU" {
|
||||
t.Fatalf("language roles conflated: %+v", loaded)
|
||||
}
|
||||
_, _, err = profiles.GetPasswordHashByEmail(ctx, user.Email)
|
||||
@@ -42,7 +42,7 @@ func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if snapshot.UILanguage != "de-DE" {
|
||||
if snapshot.UILanguage != "ru-RU" {
|
||||
t.Fatalf("model instructions follow interface language: %q", snapshot.UILanguage)
|
||||
}
|
||||
if _, err = profiles.UpdatePreferences(ctx, user.ID, "unsupported", "en-US", "A1", 10); err == nil {
|
||||
@@ -60,7 +60,7 @@ func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
|
||||
t.Fatal("expected profile constraint failure")
|
||||
}
|
||||
loaded, err = profiles.GetUser(ctx, user.ID)
|
||||
if err != nil || loaded.UILanguage != "en-US" {
|
||||
if err != nil || loaded.UILanguage != "ru-RU" {
|
||||
t.Fatalf("failed update changed interface: %+v %v", loaded, err)
|
||||
}
|
||||
active, err = profiles.GetPrimaryProfile(ctx, user.ID)
|
||||
@@ -69,39 +69,48 @@ func TestLanguagePreferencesPreserveCourseAndExplanations(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestInstructionLanguageMigrationPreservesLegacyPreference(t *testing.T) {
|
||||
func TestNativeLanguageMigrationAndCompatibility(t *testing.T) {
|
||||
db, profiles := adaptiveTestDB(t)
|
||||
ctx := context.Background()
|
||||
user, err := profiles.CreateUser(ctx, "legacy-language@example.test", "hash", "fr-FR")
|
||||
user, err := profiles.CreateUser(ctx, "legacy-language@example.test", "hash", "de-DE")
|
||||
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 {
|
||||
// Simulate the old independent settings in this disposable schema only.
|
||||
if _, err = db.ExecContext(ctx, `ALTER TABLE users DROP CONSTRAINT users_native_language_coupled; ALTER TABLE users DROP COLUMN native_language; UPDATE users SET ui_language='ru-RU',instruction_language='de-DE'`); 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 != nil || loaded.NativeLanguage != "ru-RU" || loaded.UILanguage != "ru-RU" || loaded.InstructionLanguage != "ru-RU" {
|
||||
t.Fatalf("migration did not couple native language: %+v %v", loaded, err)
|
||||
}
|
||||
if _, err = profiles.UpdatePreferences(ctx, user.ID, "en-US", "", "", 0); err != nil {
|
||||
if _, err = profiles.UpdatePreferences(ctx, user.ID, "de-DE", "", "", 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)
|
||||
if err != nil || loaded.NativeLanguage != "de-DE" || loaded.UILanguage != "de-DE" || loaded.InstructionLanguage != "de-DE" {
|
||||
t.Fatalf("restart changed 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 = db.ExecContext(ctx, `UPDATE users SET instruction_language='ru-RU' WHERE id=$1`, user.ID); err == nil {
|
||||
t.Fatal("database allowed divergent language roles")
|
||||
}
|
||||
result, err := NewAuthService(profiles, "language-test-only").Register(ctx, "new-language@example.test", "test-password", "ru-RU", "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)
|
||||
if result.User.NativeLanguage != "ru-RU" || result.User.UILanguage != "ru-RU" || result.User.InstructionLanguage != "ru-RU" {
|
||||
t.Fatal(result.User)
|
||||
}
|
||||
if _, err = profiles.CreateUser(ctx, "unsupported@example.test", "hash", "en-US"); err == nil {
|
||||
t.Fatal("English native language accepted")
|
||||
}
|
||||
if _, err = domain.ResolveNativeLanguage("de-DE", "ru-RU"); err != domain.ErrNativeLanguageConflict {
|
||||
t.Fatal("conflicting aliases accepted", err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"speech-learning-api/internal/domain"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type nativeLanguageKey struct{}
|
||||
|
||||
// Request-scoped native language also applies to deterministic feedback; target
|
||||
// texts and Azure measurements are never translated by this presentation step.
|
||||
func WithNativeLanguage(ctx context.Context, language string) context.Context {
|
||||
return context.WithValue(ctx, nativeLanguageKey{}, language)
|
||||
}
|
||||
func nativeLanguage(ctx context.Context) string {
|
||||
language, _ := ctx.Value(nativeLanguageKey{}).(string)
|
||||
return language
|
||||
}
|
||||
|
||||
func localizedFeedback(ctx context.Context, text string, result domain.PronunciationResult) domain.TeacherResponse {
|
||||
if nativeLanguage(ctx) != "ru-RU" {
|
||||
return mockFeedback(text, result)
|
||||
}
|
||||
response := domain.TeacherResponse{ExerciseType: "repeat_sentence", TargetText: text, TTSText: text,
|
||||
TeacherFeedback: "Предложение стоит ещё потренировать. Повторите его вслух.", NextRecommendation: "Повторите это упражнение."}
|
||||
weakWord, phonemeWord := "", ""
|
||||
var weak domain.PhonemeScore
|
||||
for _, word := range result.WordScores {
|
||||
if word.Highlight == "weak" && weakWord == "" {
|
||||
weakWord = word.Word
|
||||
}
|
||||
if strings.EqualFold(word.ErrorType, "Omission") {
|
||||
continue
|
||||
}
|
||||
for _, phoneme := range word.PhonemeScores {
|
||||
if phoneme.Accuracy < 75 && (phonemeWord == "" || phoneme.Accuracy < weak.Accuracy) {
|
||||
weak = phoneme
|
||||
phonemeWord = word.Word
|
||||
}
|
||||
}
|
||||
}
|
||||
switch {
|
||||
case result.OverallScore >= 95 && result.AccuracyScore >= 95 && result.FluencyScore >= 95 && result.CompletenessScore >= 95:
|
||||
response.TeacherFeedback = "Отлично! Произношение этого предложения получило очень высокую оценку."
|
||||
response.NextRecommendation = "Можно перейти к новому упражнению."
|
||||
case phonemeWord != "":
|
||||
response.TeacherFeedback = fmt.Sprintf("В слове %q звук /%s/ получил %.0f из 100 баллов.", phonemeWord, weak.Phoneme, weak.Accuracy)
|
||||
response.NextRecommendation = fmt.Sprintf("Повторите предложение, уделяя внимание слову %q.", phonemeWord)
|
||||
case weakWord != "":
|
||||
response.TeacherFeedback = fmt.Sprintf("Слово %q получило невысокую оценку. Потренируйте его ещё раз в предложении.", weakWord)
|
||||
response.NextRecommendation = fmt.Sprintf("Повторите предложение, уделяя внимание слову %q.", weakWord)
|
||||
case result.OverallScore >= 85:
|
||||
response.TeacherFeedback = "Хорошо! Произношение этого предложения получило высокую оценку."
|
||||
response.NextRecommendation = "Можно перейти к новому упражнению."
|
||||
}
|
||||
return response
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"context"
|
||||
"speech-learning-api/internal/domain"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestRussianDeterministicFeedbackKeepsMeasurementsAndTarget(t *testing.T) {
|
||||
ctx := WithNativeLanguage(context.Background(), "ru-RU")
|
||||
result := domain.PronunciationResult{OverallScore: 86, WordScores: []domain.WordScore{{Word: "name", PhonemeScores: []domain.PhonemeScore{{Phoneme: "n", Accuracy: 62}}}}}
|
||||
response := localizedFeedback(ctx, "My name is Anna.", result)
|
||||
if response.TargetText != "My name is Anna." || response.TTSText != response.TargetText || !strings.Contains(response.TeacherFeedback, "/n/") || !strings.Contains(response.TeacherFeedback, "62 из 100") {
|
||||
t.Fatal(response)
|
||||
}
|
||||
if result.WordScores[0].PhonemeScores[0].Accuracy != 62 {
|
||||
t.Fatal("measurement changed")
|
||||
}
|
||||
result.WordScores[0].ErrorType = "Omission"
|
||||
response = localizedFeedback(ctx, "My name is Anna.", result)
|
||||
if strings.Contains(response.TeacherFeedback, "/n/") {
|
||||
t.Fatal("omission treated as phoneme error")
|
||||
}
|
||||
teacher := &FlowiseTeacher{}
|
||||
start, err := teacher.StartConversation(ctx, "en-US", "A1")
|
||||
if err != nil || start.TargetText != "Hello. What is your name?" || !strings.Contains(start.TeacherFeedback, "Ответьте") {
|
||||
t.Fatal(start, err)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user