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.
136 lines
5.5 KiB
Go
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)
|
|
}
|
|
}
|
|
}
|