Files
Speech/apps/api/internal/services/pronunciation_statistics_integration_test.go
T
Eugenius Naumenko e274eaab2b Adaptiven A1-Kurs und statistisches Aussprachetraining integrieren
Direkte DeepSeek- und Mistral-Anbindung mit versionierten Aktionsprofilen,
Budgetreservierung, Tokenabrechnung und administrativen Qualitätsprüfungen
ersetzen die Flowise-Abhängigkeit im regulären Betrieb.

840 geprüfte A1-Aufgaben mit geschützter Testauswertung und konkreten offenen
Arbeitsaufträgen ergänzen den Kurs. Inhalts- und Sprachbewertung bleiben von
Azure-Aussprachewerten getrennt; historische Aufgaben und Antworten bleiben erhalten.

Echte Wort- und Phonemmessungen werden mit Herkunft, Aktualität und Nachweisdichte
gebündelt. Go bestimmt Trainingsziele und Wiederholungen, das Modell formuliert
dazu passende Nachsprechübungen. Profilansicht und Auswahlgründe werden angezeigt.

Validierung: Go-Race-Tests mit lokaler PostgreSQL-Integration, go vet,
Web-Build, Audit aller 840 Aufgaben und drei Browser-Smokes mit lokalen
Modell-/Speech-Fixtures bestanden. Keine Produktionsänderungen oder Live-Aufrufe.
2026-11-01 23:23:20 +00:00

212 lines
8.3 KiB
Go

package services
import (
"context"
"encoding/json"
"fmt"
"testing"
"time"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
)
func statisticalResult(word string, score float64) domain.PronunciationResult {
return domain.PronunciationResult{Provider: "azure", Locale: "en-US", Alphabet: "IPA", Method: "scripted", MeasurementVersion: "azure-rest-v1", RecognizedText: word, OverallScore: score, WordScores: []domain.WordScore{{Word: word, Accuracy: score, PhonemeScores: []domain.PhonemeScore{{Phoneme: "k", Accuracy: score}}}}}
}
func profileSound(t *testing.T, p domain.PronunciationProfile) domain.PronunciationTarget {
t.Helper()
for _, x := range p.Targets {
if x.Kind == "phoneme" && x.Symbol == "k" {
return x
}
}
t.Fatalf("/k/ missing: %+v", p)
return domain.PronunciationTarget{}
}
func TestPronunciationStatisticsPostgresPracticePlansAndTransfer(t *testing.T) {
db, repo := adaptiveTestDB(t)
ctx := context.Background()
user, err := repo.CreateUser(ctx, "statistical@example.test", "hash", "de-DE")
if err != nil {
t.Fatal(err)
}
other, err := repo.CreateUser(ctx, "statistical-other@example.test", "hash", "de-DE")
if err != nil {
t.Fatal(err)
}
if _, err = repo.SaveAttempt(ctx, domain.Attempt{UserID: user.ID, ExerciseID: "ex_a1_water", TargetLanguage: "en-US", WordScores: []domain.WordScore{{Word: "legacy", Accuracy: 0}}}); err != nil {
t.Fatal(err)
}
mock := statisticalResult("mock", 1)
mock.Provider = "mock"
if _, err = repo.SaveAttempt(ctx, domain.Attempt{UserID: user.ID, ExerciseID: "ex_a1_water", TargetLanguage: "en-US", Measurement: &mock}); err != nil {
t.Fatal(err)
}
for i, w := range []string{"cat", "cup", "school"} {
_, ex, err := repo.SaveGeneratedExercise(ctx, user.ID, domain.GeneratedExercise{TargetLanguage: "en-US", CEFRLevel: "A1", ReferenceText: fmt.Sprintf("I see %s.", w), Source: "ai"})
if err != nil {
t.Fatal(err)
}
r := statisticalResult(w, float64(30+i*10))
if _, err = repo.SaveAttempt(ctx, domain.Attempt{UserID: user.ID, ExerciseID: ex.ID, TargetLanguage: "en-US", WordScores: r.WordScores, Measurement: &r}); err != nil {
t.Fatal(err)
}
}
now := time.Now().UTC().Add(time.Second)
p, err := repo.PronunciationProfile(ctx, user.ID, "en-US", now)
if err != nil {
t.Fatal(err)
}
k := profileSound(t, p)
if k.Samples != 3 || k.Words != 3 || k.State != "needs_practice" || p.UnverifiedHistory != 1 {
t.Fatalf("bad profile: %+v %+v", p, k)
}
isolated, err := repo.PronunciationProfile(ctx, other.ID, "en-US", now)
if err != nil || len(isolated.Targets) != 0 {
t.Fatal("user isolation", err, isolated)
}
isolated, err = repo.PronunciationProfile(ctx, user.ID, "de-DE", now)
if err != nil || len(isolated.Targets) != 0 {
t.Fatal("language isolation", err, isolated)
}
plan, err := repo.PlanPronunciation(ctx, user.ID, "en-US", now)
if err != nil {
t.Fatal(err)
}
if plan.Target == nil || plan.Target.Symbol != "k" || plan.RequiredWords[0] != "cat" {
t.Fatalf("not a bundled target: %+v", plan)
}
generated := domain.GeneratedExercise{TargetLanguage: "en-US", CEFRLevel: "A1", ReferenceText: "My cat is very small.", Source: "ai", TrainingPlan: &plan}
_, ex, err := repo.SaveGeneratedExercise(ctx, user.ID, generated)
if err != nil {
t.Fatal(err)
}
_, again, err := repo.SaveGeneratedExercise(ctx, user.ID, generated)
if err != nil || again.ID != ex.ID || again.TrainingReason == "" {
t.Fatal("assignment replay", err, again)
}
// A transfer stays unconfirmed until the expected symbol is actually measured.
transfer := plan
transfer.ID = store.NewID("transfer")
transfer.Mode = "transfer"
transfer.Category = "explore"
transfer.RequiredWords = []string{}
transfer.CandidateWord = "kite"
transfer.TransferStatus = "unconfirmed"
raw, _ := json.Marshal(transfer)
if _, err = db.Exec(`INSERT INTO pronunciation_plans(id,user_id,language,data,status) VALUES($1,$2,'en-US',$3,'pending')`, transfer.ID, user.ID, raw); err != nil {
t.Fatal(err)
}
generated.ReferenceText = "I see a kite."
generated.TrainingPlan = &transfer
_, ex, err = repo.SaveGeneratedExercise(ctx, user.ID, generated)
if err != nil {
t.Fatal(err)
}
r := statisticalResult("kite", 80)
if _, err = repo.SaveAttempt(ctx, domain.Attempt{UserID: user.ID, ExerciseID: ex.ID, TargetLanguage: "en-US", WordScores: r.WordScores, Measurement: &r}); err != nil {
t.Fatal(err)
}
if err = db.QueryRow(`SELECT data->>'transfer_status' FROM pronunciation_plans WHERE id=$1`, transfer.ID).Scan(&transfer.TransferStatus); err != nil || transfer.TransferStatus != "confirmed" {
t.Fatal("transfer not verified", err, transfer)
}
var count int
db.QueryRow(`SELECT count(*) FROM pronunciation_assessments`).Scan(&count)
if err = repo.Init(ctx); err != nil {
t.Fatal(err)
}
var after int
db.QueryRow(`SELECT count(*) FROM pronunciation_assessments`).Scan(&after)
if after != count {
t.Fatal("restart duplicated evidence", count, after)
}
// Unknown historical raw values are never silently promoted.
p, err = repo.PronunciationProfile(ctx, user.ID, "en-US", time.Now().Add(time.Minute))
if err != nil || p.UnverifiedHistory != 1 {
t.Fatal(err, p)
}
}
func TestPronunciationStatisticsPostgresCourseProvenanceAndExamPrivacy(t *testing.T) {
db, repo := adaptiveTestDB(t)
ctx := context.Background()
user, err := repo.CreateUser(ctx, "stat-course@example.test", "hash", "de-DE")
if err != nil {
t.Fatal(err)
}
adaptive := store.NewAdaptiveStore(db)
insert := func(kind, exam string) domain.AdaptiveTask {
t.Helper()
task := domain.AdaptiveTask{SchemaVersion: 2, ID: store.NewID("stat_task"), ModuleID: "a1_family_v1", TargetLanguage: "en-US", CourseVersion: domain.CourseVersion, CEFRLevel: "A1", Skill: "speaking", Kind: kind, ReferenceText: "My cat is small.", Source: "curated", ExamID: exam}
raw, _ := json.Marshal(task)
_, err := db.Exec(`INSERT INTO course_v2_tasks(id,module_id,language,version,owner_id,source,skill,kind,data,fingerprint,exam_id) VALUES($1,$2,$3,$4,$5,'curated','speaking',$6,$7,$1,NULLIF($8,''))`, task.ID, task.ModuleID, task.TargetLanguage, task.CourseVersion, user.ID, kind, raw, exam)
if err != nil {
t.Fatal(err)
}
return task
}
r := statisticalResult("cat", 30)
task := insert("repeat_sentence", "")
attempt, err := adaptive.Submit(ctx, user.ID, "same-request", task, "My cat is small.", &r)
if err != nil {
t.Fatal(err)
}
if _, err = adaptive.Submit(ctx, user.ID, "same-request", task, "ignored", &r); err != nil {
t.Fatal(err)
}
// An ungraded content answer still contains a real pronunciation measurement.
if _, err = db.Exec(`UPDATE course_v2_attempts SET status='ungraded' WHERE id=$1`, attempt.ID); err != nil {
t.Fatal(err)
}
free := insert("free_speech", "")
r.Method = "unscripted"
if _, err = adaptive.Submit(ctx, user.ID, "free-request", free, "My cat is small.", &r); err != nil {
t.Fatal(err)
}
r.Method = "scripted"
exam := store.NewID("stat_exam")
if _, err = db.Exec(`INSERT INTO course_v2_exams(id,user_id,language,version,status,request_id) VALUES($1,$2,'en-US',$3,'in_progress',$1)`, exam, user.ID, domain.CourseVersion); err != nil {
t.Fatal(err)
}
exTask := insert("repeat_sentence", exam)
if _, err = adaptive.Submit(ctx, user.ID, "exam-request", exTask, "My cat is small.", &r); err != nil {
t.Fatal(err)
}
now := time.Now().Add(time.Minute)
p, err := repo.PronunciationProfile(ctx, user.ID, "en-US", now)
if err != nil {
t.Fatal(err)
}
if k := profileSound(t, p); k.Samples != 1 {
t.Fatalf("duplicates/free speech/unfinished exam counted: %+v", k)
}
if _, err = db.Exec(`UPDATE course_v2_exams SET status='completed' WHERE id=$1`, exam); err != nil {
t.Fatal(err)
}
p, err = repo.PronunciationProfile(ctx, user.ID, "en-US", now)
if err != nil {
t.Fatal(err)
}
if k := profileSound(t, p); k.Samples != 2 {
t.Fatal("finished exam not counted", k)
}
// Rebuild confirmed course evidence; archived copies must never be counted twice.
if _, err = db.Exec(`DELETE FROM pronunciation_assessments WHERE source='course'`); err != nil {
t.Fatal(err)
}
if err = repo.BackfillPronunciation(ctx); err != nil {
t.Fatal(err)
}
if err = repo.BackfillPronunciation(ctx); err != nil {
t.Fatal(err)
}
p, err = repo.PronunciationProfile(ctx, user.ID, "en-US", now)
if err != nil {
t.Fatal(err)
}
if k := profileSound(t, p); k.Samples != 2 {
t.Fatal("backfill lost/duplicated evidence", k)
}
}