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) } } }