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.
196 lines
6.5 KiB
Go
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(¤t); 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)
|
|
}
|
|
})
|
|
}
|
|
}
|