Files
Speech/apps/api/internal/services/course_sequences_integration_test.go
T
Eugenius Naumenko 7499491ae8 Thematische Lernwege im A1-Kurs standardmäßig empfehlen
Die bisherige Auswahl verbindet Lernbereiche nicht thematisch und kann freies
Sprechen ohne passende Vorbereitung anbieten. Der Bankbetrieb empfiehlt nun
60 redaktionell verknüpfte Themen in sechs Lernmodulen: Hören, Wortschatz,
Lesen, Nachsprechen, Grammatik, angeleitetes und freies Schreiben, freies Sprechen.

Speichert die Lernwegposition getrennt von Leistungsnachweisen. Unbeantwortete
Schritte bleiben empfohlen und sind explizit überspringbar; nach einer tatsächlich
bewerteten schwachen Antwort gibt es höchstens eine Wiederholung ohne Notensperre.
Bereichswahl, Muttersprache, historische Aufgaben und A1-Tests bleiben unabhängig.
Deutsch und Russisch zeigen Thema und Schritt; vorhandene Aufgabeninhalte und
Bewertungen werden nicht umgeschrieben. Keine zusätzlichen Modellaufrufe.

Validierung: Go-Race-Suite mit eigener lokaler PostgreSQL-Testdatenbank, go vet,
Web-Build, Bank-/Varianten-/Sequenzaudits und lokale Kurs-/Sprachen-/Admin-Smokes.
Regressionsfall: passendes Schreiben vor freiem Sprechen über zwei Freunde.
Keine Live-Anbieterprüfung oder Produktionsänderung.
2026-11-11 17:51:32 +00:00

196 lines
6.5 KiB
Go

package services
import (
"bytes"
"context"
"testing"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
)
func TestThematicLearningPathAndFrozenProgress(t *testing.T) {
for _, native := range []string{"de-DE", "ru-RU"} {
t.Run(native, func(t *testing.T) {
db, profiles := adaptiveTestDB(t)
ctx := context.Background()
user, err := profiles.CreateUser(ctx, store.NewID("sequence")+"@example.test", "hash", native)
if err != nil {
t.Fatal(err)
}
if _, err = profiles.CreateLearnerProfile(ctx, user.ID, "en-US", "A1", 17); err != nil {
t.Fatal(err)
}
engine := NewCourseEngine(store.NewAdaptiveStore(db), profiles, nil, nil)
engine.Mode = "bank"
module := "a1_introductions_v1"
requests := map[string]string{}
run := func(skill, skip string) (domain.AdaptiveTask, domain.CourseJob) {
t.Helper()
request := store.NewID("sequence-request")
job, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", module, skill, skip, request)
if err != nil {
t.Fatal(err)
}
job, err = engine.Repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
task, err := engine.Process(ctx, job)
if err != nil {
t.Fatal(err)
}
if err = engine.Repo.Finish(ctx, job, task, ""); err != nil {
t.Fatal(err)
}
saved, err := engine.Repo.Job(ctx, user.ID, "en-US", job.ID)
if err != nil {
t.Fatal(err)
}
requests[saved.ID] = request
return *task, saved
}
answer := func(task domain.AdaptiveTask, correct bool) domain.AdaptiveAttempt {
t.Helper()
text := task.AnswerKey.ReferenceAnswer
if task.Kind == "choice" {
text = task.AnswerKey.CorrectOptionID
if !correct {
for _, o := range task.Options {
if o.ID != text {
text = o.ID
break
}
}
}
}
var speech *domain.PronunciationResult
if task.Skill == "speaking" {
speech = &domain.PronunciationResult{Provider: "azure", RecognizedText: text, OverallScore: 90}
}
attempt, _, err := engine.Submit(ctx, user.ID, "en-US", task.ID, store.NewID("sequence-answer"), text, speech)
if err != nil {
t.Fatal(err)
}
return attempt
}
first, job := run("", "")
if first.Skill != "listening" || first.InstructionLanguage != native || job.Recommendation == nil || job.Recommendation.Step != 1 {
t.Fatal(first, job)
}
var frozen []byte
if err = db.QueryRowContext(ctx, `SELECT data FROM course_v2_tasks WHERE id=$1`, first.ID).Scan(&frozen); err != nil {
t.Fatal(err)
}
again, _ := run("", "")
if again.ID != first.ID {
t.Fatal("unanswered step silently bypassed")
}
// A graded mistake offers one bounded review, even with an unchanged task ID.
answer(first, false)
repeated, reviewJob := run("", "")
if repeated.ID != first.ID || !reviewJob.Recommendation.Review {
t.Fatal("missing bounded review", reviewJob)
}
blocked, _ := run("", "")
if blocked.ID != first.ID {
t.Fatal("old answer passed the new review")
}
answer(repeated, false)
next, nextJob := run("", "")
if next.ID == first.ID || nextJob.Recommendation.Step != 2 {
t.Fatal("grade became a permanent gate", nextJob)
}
// Manual free speaking remains available and never moves the thematic cursor.
before, _ := engine.Repo.SequenceRecommendation(ctx, user.ID, "en-US", module, native)
manual, _ := run("speaking", "")
if manual.Skill != "speaking" {
t.Fatal(manual)
}
after, _ := engine.Repo.SequenceRecommendation(ctx, user.ID, "en-US", module, native)
if before.Step != after.Step || before.SequenceID != after.SequenceID {
t.Fatal("manual choice moved path")
}
// Explicit skipping is separate from evidence and replaying a request is stable.
skipped, skipJob := run("", next.ID)
if skipJob.Recommendation.SkippedSteps != 1 || skipJob.Recommendation.Step != 3 {
t.Fatal(skipJob)
}
replayed, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", module, "", next.ID, requests[skipJob.ID])
if err != nil || replayed.TaskID != skipped.ID || replayed.Recommendation.Step != 3 {
t.Fatal("request replay advanced path", err)
}
wrong, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", module, "", "another-users-task", store.NewID("skip-other"))
if err != nil {
t.Fatal(err)
}
wrong, err = engine.Repo.Claim(ctx)
if err != nil {
t.Fatal(err)
}
if _, err = engine.Process(ctx, wrong); err == nil {
t.Fatal("stale/foreign skip accepted")
}
if err = engine.Repo.Finish(ctx, wrong, nil, "expected conflict"); err != nil {
t.Fatal(err)
}
// Changing native language preserves the thematic position and frozen content.
other := "de-DE"
if native == other {
other = "ru-RU"
}
if _, err = profiles.UpdatePreferences(ctx, user.ID, other, "", "", 0); err != nil {
t.Fatal(err)
}
changed, err := engine.Repo.SequenceRecommendation(ctx, user.ID, "en-US", module, other)
if err != nil || changed.Step != 3 || changed.SkippedSteps != 1 || changed.Title == before.Title {
t.Fatal(changed, err)
}
if err = profiles.Init(ctx); err != nil {
t.Fatal(err)
}
var current []byte
if err = db.QueryRowContext(ctx, `SELECT data FROM course_v2_tasks WHERE id=$1`, first.ID).Scan(&current); err != nil {
t.Fatal(err)
}
if !bytes.Equal(frozen, current) {
t.Fatal("frozen task edited")
}
// Finish the path through the reported two-friends speaking task. Every free
// speech task follows a submitted, matching free-writing task, not a score gate.
task := skipped
seenCompose := map[string]bool{}
foundFriends := false
for n := 0; n < 110; n++ {
if task.Kind == "free_speech" {
key := task.AnswerKey.ReferenceAnswer
if !seenCompose[key] {
t.Fatal("speaking without related writing", task.CanonicalTaskID)
}
if task.CanonicalTaskID == "a1bank_en_v2_introductions_speaking_14" {
foundFriends = true
break
}
}
attempt := answer(task, true)
if task.Kind == "free_text" {
if attempt.Status != "ungraded" {
t.Fatal("missing model fabricated a writing grade", attempt)
}
seenCompose[task.AnswerKey.ReferenceAnswer] = true
}
task, _ = run("", "")
}
if !foundFriends {
t.Fatal("two-friends sequence was not reached")
}
var calls int
if err = db.QueryRowContext(ctx, `SELECT count(*) FROM ai_calls`).Scan(&calls); err != nil || calls != 0 {
t.Fatal("sequence spent model budget", calls, err)
}
})
}
}