Files
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

169 lines
7.6 KiB
Go

package pronunciation
import (
"fmt"
"math"
"speech-learning-api/internal/domain"
"testing"
"time"
)
var testNow = time.Date(2026, 10, 29, 12, 0, 0, 0, time.UTC)
func evidence(id, task, word, symbol string, score float64, at time.Time) []domain.PronunciationObservation {
return Observe(id, task, "en-US", at, domain.PronunciationResult{Provider: "azure", Locale: "en-US", Alphabet: "IPA", WordScores: []domain.WordScore{{Word: word, Accuracy: score, PhonemeScores: []domain.PhonemeScore{{Phoneme: symbol, Accuracy: score}}}}})
}
func sound(t *testing.T, p domain.PronunciationProfile, symbol string) domain.PronunciationTarget {
t.Helper()
for _, x := range p.Targets {
if x.Kind == "phoneme" && x.Symbol == symbol {
return x
}
}
t.Fatal("sound missing", symbol)
return domain.PronunciationTarget{}
}
func TestProfileBundlesDifferentWordsAndSeparatesLanguages(t *testing.T) {
obs := []domain.PronunciationObservation{}
for i, w := range []string{"cat", "cup", "school"} {
obs = append(obs, evidence(fmt.Sprint(i), fmt.Sprint(i), w, "k", float64(30+i*10), testNow.Add(-time.Duration(i)*time.Hour))...)
}
// Neither another locale nor a similar IPA symbol can change /k/.
x := evidence("foreign", "foreign", "Katze", "k", 99, testNow)
for i := range x {
x[i].Language = "de-DE"
x[i].Locale = "de-DE"
}
obs = append(obs, x...)
obs = append(obs, evidence("other", "other", "thing", "θ", 99, testNow)...)
p := Build("en-US", testNow, obs)
k := sound(t, p, "k")
if k.Words != 3 || k.Samples != 3 || k.State != "needs_practice" || math.Abs(k.Mean-40) > .01 {
t.Fatalf("wrong grouping: %+v", k)
}
}
func TestProfileCapsSameTaskDayAndRepeatedSound(t *testing.T) {
obs := evidence("old", "task", "cook", "k", 1, testNow.Add(-time.Hour))
r := domain.PronunciationResult{Locale: "en-US", Alphabet: "IPA", WordScores: []domain.WordScore{{Word: "cook", Accuracy: 70, PhonemeScores: []domain.PhonemeScore{{Phoneme: "k", Accuracy: 20}, {Phoneme: "k", Accuracy: 80}}}}}
obs = append(obs, Observe("latest", "task", "en-US", testNow, r)...)
k := sound(t, Build("en-US", testNow, obs), "k")
if k.Samples != 1 || k.Mean != 50 || k.State != "limited" {
t.Fatalf("repeat inflated or worst-score used: %+v", k)
}
}
func TestProfileBalancesWordsAndWeightsNewEvidence(t *testing.T) {
obs := []domain.PronunciationObservation{}
for i := 0; i < 10; i++ {
obs = append(obs, evidence(fmt.Sprint(i), fmt.Sprint(i), "cat", "k", 100, testNow.Add(-time.Duration(i)*time.Hour))...)
}
obs = append(obs, evidence("cup", "cup", "cup", "k", 0, testNow)...)
k := sound(t, Build("en-US", testNow, obs), "k")
if math.Abs(k.Mean-50) > .00001 {
t.Fatalf("frequent word drowned other context: %f", k.Mean)
}
obs = append(evidence("older", "older", "cat", "k", 0, testNow.AddDate(0, 0, -14)), evidence("newer", "newer", "cat", "k", 100, testNow)...)
k = sound(t, Build("en-US", testNow, obs), "k")
if math.Abs(k.Mean-100.0/1.5) > .01 {
t.Fatalf("wrong decay: %f", k.Mean)
}
}
func TestProfileSpacedReviewAndRelapse(t *testing.T) {
obs := []domain.PronunciationObservation{}
start := testNow.AddDate(0, 0, -30)
for i, w := range []string{"cat", "cup", "cat"} {
obs = append(obs, evidence(fmt.Sprint(i), fmt.Sprint(i), w, "k", 90, start.Add(time.Duration(i)*time.Hour))...)
}
p := Build("en-US", start.Add(2*time.Hour), obs)
k := sound(t, p, "k")
if k.State != "improved" || k.NextReview == nil || !k.NextReview.Equal(start.Add(26*time.Hour)) {
t.Fatalf("improvement schedule: %+v", k)
}
// 1,3,7,14 day review intervals, each anchored to the actual measurement.
due := *k.NextReview
for i, days := range []int{3, 7, 14, 30} {
obs = append(obs, evidence(fmt.Sprint("review", i), fmt.Sprint("review", i), "cup", "k", 95, due)...)
k = sound(t, Build("en-US", due, obs), "k")
if k.NextReview == nil || !k.NextReview.Equal(due.AddDate(0, 0, days)) {
t.Fatalf("review %d: %+v", i, k)
}
due = *k.NextReview
}
if k.State != "stable" {
t.Fatal("stable state not reached", k.State)
}
obs = append(obs, evidence("relapse", "relapse", "cup", "k", 40, due.Add(-time.Hour))...)
k = sound(t, Build("en-US", due, obs), "k")
if k.State == "stable" || k.NextReview != nil {
t.Fatalf("relapse ignored: %+v", k)
}
}
func TestProfileDoesNotInventPhonemesOrErasePatternWithOneSuccess(t *testing.T) {
no := false
r := domain.PronunciationResult{Locale: "en-US", Alphabet: "IPA", WordScores: []domain.WordScore{
{Word: "missing", Accuracy: 0, AccuracyMeasured: &no},
{Word: "omitted", Accuracy: 0, ErrorType: "Omission", PhonemeScores: []domain.PhonemeScore{{Phoneme: "x", Accuracy: 0}}},
{Word: "invalid", Accuracy: math.NaN()},
}}
p := Build("en-US", testNow, Observe("a", "a", "en-US", testNow, r))
if len(p.Targets) != 1 || p.Targets[0].Kind != "omission" {
t.Fatalf("bad evidence included: %+v", p.Targets)
}
obs := append(evidence("a", "a", "cat", "k", 20, testNow.Add(-3*time.Hour)), evidence("b", "b", "cup", "k", 25, testNow.Add(-2*time.Hour))...)
obs = append(obs, evidence("c", "c", "cat", "k", 95, testNow)...)
if k := sound(t, Build("en-US", testNow, obs), "k"); k.State != "needs_practice" {
t.Fatalf("single success erased pattern: %+v", k)
}
}
func TestProfileWindowAndTrend(t *testing.T) {
obs := evidence("ancient", "ancient", "cat", "k", 0, testNow.AddDate(0, 0, -91))
for i := 0; i < 35; i++ {
v := 40.0
if i >= 30 {
v = 95
}
obs = append(obs, evidence(fmt.Sprint(i), fmt.Sprint(i), "cat", "k", v, testNow.Add(time.Duration(i-35)*time.Hour))...)
}
k := sound(t, Build("en-US", testNow, obs), "k")
if k.Samples != 30 || k.Trend != "improving" {
t.Fatalf("wrong window/trend: %+v", k)
}
}
func TestSelectionMixTransferAndNonRepetition(t *testing.T) {
due := testNow.Add(-time.Hour)
p := domain.PronunciationProfile{Algorithm: domain.PronunciationAlgorithm, Language: "en-US", Targets: []domain.PronunciationTarget{
{Key: "weak", Kind: "phoneme", Symbol: "k", Samples: 5, Words: 3, State: "needs_practice", Mean: 40, Priority: .9, Examples: []domain.PronunciationExample{{Word: "cat", Mean: 40}}},
{Key: "review", Kind: "phoneme", Symbol: "s", Samples: 5, Words: 3, State: "improved", Mean: 90, Priority: .1, ReviewDue: true, NextReview: &due, Examples: []domain.PronunciationExample{{Word: "sits", Mean: 90}}},
}}
history := []domain.PronunciationPlan{}
counts := map[string]int{}
for i := 0; i < 20; i++ {
h := Select(p, history, testNow)
counts[h.Category]++
history = append([]domain.PronunciationPlan{h}, history...)
}
if counts["targeted"] != 12 || counts["review"] != 5 || counts["explore"] != 3 {
t.Fatalf("wrong mix: %v", counts)
}
transfer := Select(p, []domain.PronunciationPlan{{Category: "targeted"}, {Category: "targeted"}, {Category: "targeted"}, {Category: "targeted"}, {Category: "review"}}, testNow)
if transfer.Mode != "transfer" || len(transfer.RequiredWords) != 0 || transfer.TransferStatus != "unconfirmed" {
t.Fatalf("no transfer: %+v", transfer)
}
h := domain.PronunciationPlan{Target: &p.Targets[0], Category: "targeted"}
next := Select(p, []domain.PronunciationPlan{h, h}, testNow)
if next.Target != nil && next.Target.Key == "weak" {
t.Fatal("same sound three times")
}
}
func TestSuccessfulWordsResolveOmissionsWithoutInventingPhonemes(t *testing.T) {
absent := domain.PronunciationResult{Locale: "en-US", Alphabet: "IPA", WordScores: []domain.WordScore{{Word: "cat", ErrorType: "Omission", Accuracy: 0}}}
obs := Observe("old", "task", "en-US", testNow.Add(-time.Hour), absent)
obs = append(obs, evidence("new", "task", "cat", "k", 95, testNow)...)
p := Build("en-US", testNow, obs)
for _, target := range p.Targets {
if target.Kind == "omission" {
t.Fatal("same-day correction left perpetual omission", target)
}
}
}