Files
Speech/apps/api/internal/httpapi/course_generation_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

136 lines
5.5 KiB
Go

package httpapi
import (
"context"
"encoding/json"
"errors"
"io"
"log/slog"
"net/http"
"net/http/httptest"
"strings"
"testing"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
)
type practiceTestStore struct {
*courseTestStore
saved int
fallback int
existing bool
saveError bool
selectionError bool
}
func (s *practiceTestStore) GetUser(context.Context, string) (domain.User, error) {
return domain.User{UILanguage: "de-DE"}, nil
}
func (s *practiceTestStore) CourseModule(context.Context, string, string, string, string) (domain.CourseModuleDetail, error) {
return domain.CourseModuleDetail{Module: domain.CourseModule{ID: "a1_introductions_v1", TargetLanguage: "en-US", CEFRLevel: "A1"}}, nil
}
func (s *practiceTestStore) CoursePracticeByRequest(context.Context, string, string, string) (domain.CoursePracticeResult, error) {
if s.existing {
return domain.CoursePracticeResult{Task: domain.CourseTask{ID: "existing"}, Source: "flowise"}, nil
}
return domain.CoursePracticeResult{}, store.ErrNotFound
}
func (s *practiceTestStore) SelectCoursePractice(context.Context, string, string) (domain.CoursePracticeSelection, error) {
if s.selectionError {
return domain.CoursePracticeSelection{}, errors.New("database unavailable")
}
return domain.CoursePracticeSelection{Goal: domain.IntroductionGoals()[2], State: domain.CourseLearningState{RecentResults: []bool{}}, AvoidPrompts: []string{}}, nil
}
func (s *practiceTestStore) SaveGeneratedCourseTask(_ context.Context, user, request string, out domain.GeneratedCourseTask) (domain.CoursePracticeResult, error) {
if user != "usr_1" || request != "request_123" {
return domain.CoursePracticeResult{}, errors.New("incorrect ownership")
}
s.saved++
if s.saveError {
return domain.CoursePracticeResult{}, errors.New("save failed")
}
return domain.CoursePracticeResult{Task: domain.CourseTask{ID: "generated", Prompt: out.Prompt, Options: out.Options, Kind: out.Kind, Skill: out.Skill}, Source: "flowise"}, nil
}
func (s *practiceTestStore) CoursePracticeFallback(_ context.Context, user, seed string) (domain.CoursePracticeResult, error) {
s.fallback++
if user != "usr_1" || seed != "a1i_v1_grammar_1" {
return domain.CoursePracticeResult{}, errors.New("wrong fallback")
}
return domain.CoursePracticeResult{Task: domain.CourseTask{ID: seed}, Source: "seed"}, nil
}
type practiceGenerator struct {
err error
invalid bool
calls int
}
func (g *practiceGenerator) GenerateCourseTask(_ context.Context, in domain.GenerateCourseTaskRequest) (domain.GeneratedCourseTask, error) {
g.calls++
out := domain.GeneratedCourseTask{SchemaVersion: 1, TargetLanguage: in.TargetLanguage, CEFRLevel: in.CEFRLevel, ModuleID: in.ModuleID, LearningGoalID: in.LearningGoal.ID, Skill: in.Skill, Kind: "choice", Prompt: "Ergänze: I ___ from Germany.", Options: []string{"am", "is", "are"}, Solution: "am", Explanation: "Nach I steht am."}
if g.invalid {
out.Solution = "unknown"
}
return out, g.err
}
func TestNextCoursePracticeGenerationAndFallback(t *testing.T) {
for _, test := range []struct {
name string
generator *practiceGenerator
saveError, existing, dbError bool
status int
source string
}{
{name: "generated", generator: &practiceGenerator{}, status: 200, source: "flowise"},
{name: "disabled", status: 200, source: "seed"},
{name: "timeout", generator: &practiceGenerator{err: context.DeadlineExceeded}, status: 200, source: "seed"},
{name: "invalid", generator: &practiceGenerator{invalid: true}, status: 200, source: "seed"},
{name: "save failure", generator: &practiceGenerator{}, saveError: true, status: 200, source: "seed"},
{name: "idempotent retry", generator: &practiceGenerator{}, existing: true, status: 200, source: "flowise"},
{name: "database unavailable", generator: &practiceGenerator{}, dbError: true, status: 500},
} {
t.Run(test.name, func(t *testing.T) {
data := &practiceTestStore{courseTestStore: &courseTestStore{}, saveError: test.saveError, existing: test.existing, selectionError: test.dbError}
server := &Server{store: data, logger: slog.New(slog.NewTextHandler(io.Discard, nil))}
if test.generator != nil {
server.courseGenerator = test.generator
}
w := httptest.NewRecorder()
server.nextCoursePractice(w, courseRequest("POST", "/", `{"request_id":"request_123"}`))
if w.Code != test.status {
t.Fatalf("status %d: %s", w.Code, w.Body.String())
}
if test.status != 200 {
return
}
var result domain.CoursePracticeResult
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
if result.Source != test.source {
t.Fatalf("source %s", result.Source)
}
if strings.Contains(w.Body.String(), "solution") || strings.Contains(w.Body.String(), "explanation") {
t.Fatal("leaked key")
}
if test.existing && test.generator.calls != 0 {
t.Fatal("regenerated idempotent request")
}
if test.generator != nil && test.generator.invalid && data.saved != 0 {
t.Fatal("stored invalid task")
}
})
}
}
func TestCoursePracticeRejectsClientSelectedGoals(t *testing.T) {
server := &Server{}
for _, body := range []string{`{}`, `{"request_id":"short"}`, `{"request_id":"request_123","skill":"grammar"}`, `{"request_id":"request_123"} {}`, strings.Repeat(" ", 1100)} {
w := httptest.NewRecorder()
server.nextCoursePractice(w, courseRequest(http.MethodPost, "/", body))
if w.Code != 400 {
t.Fatalf("status %d", w.Code)
}
}
}