package services import ( "context" "encoding/json" "io" "log/slog" "net/http" "net/http/httptest" "strings" "testing" "speech-learning-api/internal/config" "speech-learning-api/internal/domain" ) func TestFeedbackForPerfectPronunciationRecommendsNextExercise(t *testing.T) { result := domain.PronunciationResult{ OverallScore: 100, AccuracyScore: 100, FluencyScore: 100, CompletenessScore: 100, WordScores: []domain.WordScore{{Word: "water", Accuracy: 100, Highlight: "good"}}, } feedback := mockFeedback("I drink water.", result) if strings.Contains(feedback.TeacherFeedback, "noch einmal") || strings.Contains(feedback.NextRecommendation, "Wiederhole") { t.Fatalf("perfect pronunciation should not require repetition: %#v", feedback) } if !strings.Contains(feedback.NextRecommendation, "neuen Übung") { t.Fatalf("expected recommendation to continue: %#v", feedback) } } func TestFeedbackForWeakWordNamesObservedProblem(t *testing.T) { result := domain.PronunciationResult{ OverallScore: 78, WordScores: []domain.WordScore{{Word: "water", Accuracy: 61, Highlight: "weak"}}, } feedback := mockFeedback("I drink water.", result) if !strings.Contains(feedback.TeacherFeedback, "water") || !strings.Contains(feedback.NextRecommendation, "Wiederhole") { t.Fatalf("expected focused repetition: %#v", feedback) } } func TestFlowiseNextExerciseSendsSessionAndParsesResponse(t *testing.T) { var requestBody map[string]json.RawMessage server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path != "/api/v1/prediction/chatflow-id" { t.Fatalf("unexpected path %q", r.URL.Path) } if err := json.NewDecoder(r.Body).Decode(&requestBody); err != nil { t.Fatalf("decode request body: %v", err) } response := domain.GeneratedExercise{ ID: "flowise-controlled-id", ExerciseType: "repeat_sentence", TargetLanguage: "en-US", CEFRLevel: "A1", ReferenceText: "I live in Berlin.", DisplayPrompt: "Sprich den Satz klar nach.", TTSText: "I live in Berlin.", FocusPoints: []string{"live"}, SuccessCriteria: []string{"accuracy above 80"}, ReasonForChoice: "Uebt einen kurzen A1-Satz.", } responseText, err := json.Marshal(response) if err != nil { t.Fatalf("marshal response: %v", err) } if err := json.NewEncoder(w).Encode(map[string]string{"text": string(responseText)}); err != nil { t.Fatalf("encode response: %v", err) } })) defer server.Close() teacher := NewFlowiseTeacher(config.Config{ FlowiseBaseURL: server.URL, FlowiseChatflow: "chatflow-id", }, slog.New(slog.NewTextHandler(io.Discard, nil))) exercise, err := teacher.NextExercise(context.Background(), domain.GeneratedExerciseRequest{ UserID: "usr_1", TargetLanguage: "en-US", CEFRLevel: "A1", SessionID: "usr_1:en-US:practice", AvoidReferenceText: "I would like some water.", AvoidReferenceTexts: []string{"Can I have some water, please?", "I would like some water."}, }) if err != nil { t.Fatalf("NextExercise: %v", err) } if exercise.ReferenceText != "I live in Berlin." { t.Fatalf("unexpected reference text %q", exercise.ReferenceText) } if exercise.Source != "flowise" { t.Fatalf("unexpected source %q", exercise.Source) } if exercise.ID != "" { t.Fatalf("Flowise must not assign exercise IDs, got %q", exercise.ID) } var override struct { SessionID string `json:"sessionId"` } if err := json.Unmarshal(requestBody["overrideConfig"], &override); err != nil { t.Fatalf("decode overrideConfig: %v", err) } if override.SessionID != "usr_1:en-US:practice" { t.Fatalf("unexpected sessionId %q", override.SessionID) } var question map[string]any if err := json.Unmarshal(requestBody["question"], &question); err == nil { t.Fatalf("expected question to be a JSON string, got object %#v", question) } var questionText string if err := json.Unmarshal(requestBody["question"], &questionText); err != nil { t.Fatalf("decode question text: %v", err) } if err := json.Unmarshal([]byte(questionText), &question); err != nil { t.Fatalf("decode question payload: %v", err) } if question["task"] != "next_exercise" { t.Fatalf("unexpected task %#v", question["task"]) } if question["avoid_reference_text"] != "I would like some water." { t.Fatalf("unexpected avoid_reference_text %#v", question["avoid_reference_text"]) } if texts, ok := question["avoid_reference_texts"].([]any); !ok || len(texts) != 2 { t.Fatalf("unexpected avoid_reference_texts %#v", question["avoid_reference_texts"]) } } func TestValidGeneratedExerciseRejectsEarlierRecentSentence(t *testing.T) { exercise := domain.GeneratedExercise{ ExerciseType: "repeat_sentence", TargetLanguage: "en-US", CEFRLevel: "A1", ReferenceText: "Can I have some water, please?", DisplayPrompt: "Sprich den Satz nach.", TTSText: "Can I have some water, please?", FocusPoints: []string{"water"}, SuccessCriteria: []string{"Sprich den Satz verständlich nach."}, ReasonForChoice: "Übung mit water.", } input := domain.GeneratedExerciseRequest{ TargetLanguage: "en-US", CEFRLevel: "A1", AvoidReferenceTexts: []string{"Can I have some water, please?", "I would like some water."}, } if validGeneratedExercise(exercise, input) { t.Fatal("an earlier recent sentence was accepted") } exercise.ReferenceText = "Please pass me the water." exercise.TTSText = exercise.ReferenceText if !validGeneratedExercise(exercise, input) { t.Fatal("a new sentence was rejected") } } func TestFlowiseNextExerciseRetriesRepeatedSentence(t *testing.T) { calls := 0 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { calls++ var request struct { Question string `json:"question"` } if err := json.NewDecoder(r.Body).Decode(&request); err != nil { t.Errorf("decode request: %v", err) return } var question map[string]any if err := json.Unmarshal([]byte(request.Question), &question); err != nil { t.Errorf("decode question: %v", err) return } if calls == 2 && question["retry_instruction"] == nil { t.Error("second request lacks retry instruction") } reference := "Can I have some water, please?" if calls == 2 { reference = "I drink water every day." } response := domain.GeneratedExercise{ ExerciseType: "repeat_sentence", TargetLanguage: "en-US", CEFRLevel: "A1", ReferenceText: reference, DisplayPrompt: "Sprich den Satz nach.", TTSText: reference, FocusPoints: []string{"water"}, SuccessCriteria: []string{"Sprich den Satz verständlich nach."}, ReasonForChoice: "Übt das Wort water.", } _ = json.NewEncoder(w).Encode(response) })) defer server.Close() teacher := NewFlowiseTeacher(config.Config{FlowiseBaseURL: server.URL, FlowiseChatflow: "chatflow-id"}, slog.New(slog.NewTextHandler(io.Discard, nil))) exercise, err := teacher.NextExercise(context.Background(), domain.GeneratedExerciseRequest{ TargetLanguage: "en-US", CEFRLevel: "A1", AvoidReferenceTexts: []string{"Can I have some water, please?"}, }) if err != nil { t.Fatalf("NextExercise: %v", err) } if calls != 2 || exercise.Source != "flowise" || exercise.ReferenceText != "I drink water every day." { t.Fatalf("expected a new Flowise sentence after one retry, got calls=%d exercise=%#v", calls, exercise) } } func TestFlowiseNextExerciseRejectsInvalidResponse(t *testing.T) { valid := domain.GeneratedExercise{ ExerciseType: "repeat_sentence", TargetLanguage: "en-US", CEFRLevel: "A1", ReferenceText: "Can I have water, please?", DisplayPrompt: "Sprich den Satz nach.", TTSText: "Can I have water, please?", FocusPoints: []string{"water"}, SuccessCriteria: []string{"clear final sounds"}, ReasonForChoice: "Practice a weak word.", } tests := []struct { name string change func(*domain.GeneratedExercise) }{ {"unsupported type", func(e *domain.GeneratedExercise) { e.ExerciseType = "short_dialogue" }}, {"wrong language", func(e *domain.GeneratedExercise) { e.TargetLanguage = "es-ES" }}, {"wrong level", func(e *domain.GeneratedExercise) { e.CEFRLevel = "B2" }}, {"empty reference", func(e *domain.GeneratedExercise) { e.ReferenceText = "" }}, {"empty prompt", func(e *domain.GeneratedExercise) { e.DisplayPrompt = "" }}, {"control character", func(e *domain.GeneratedExercise) { e.ReferenceText = "Hello\nWorld" }}, {"missing focus", func(e *domain.GeneratedExercise) { e.FocusPoints = nil }}, {"same previous sentence", func(e *domain.GeneratedExercise) { e.ReferenceText = " can I HAVE water, please? " }}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { response := valid tt.change(&response) server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if err := json.NewEncoder(w).Encode(response); err != nil { t.Errorf("encode response: %v", err) } })) defer server.Close() teacher := NewFlowiseTeacher(config.Config{FlowiseBaseURL: server.URL, FlowiseChatflow: "chatflow-id"}, slog.New(slog.NewTextHandler(io.Discard, nil))) exercise, err := teacher.NextExercise(context.Background(), domain.GeneratedExerciseRequest{TargetLanguage: "en-US", CEFRLevel: "A1", AvoidReferenceText: "Can I have water, please?"}) if err != nil { t.Fatalf("NextExercise: %v", err) } if exercise.Source != "fallback" { t.Fatalf("invalid response was accepted: %#v", exercise) } }) } } func TestFlowiseNextExerciseUsesFallbackOnServerError(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusServiceUnavailable) })) defer server.Close() teacher := NewFlowiseTeacher(config.Config{FlowiseBaseURL: server.URL, FlowiseChatflow: "chatflow-id"}, slog.New(slog.NewTextHandler(io.Discard, nil))) exercise, err := teacher.NextExercise(context.Background(), domain.GeneratedExerciseRequest{TargetLanguage: "en-US", CEFRLevel: "A1"}) if err != nil { t.Fatalf("NextExercise: %v", err) } if exercise.Source != "fallback" { t.Fatalf("server error did not use fallback: %#v", exercise) } } func TestParseGeneratedExerciseEnvelope(t *testing.T) { body := []byte(`{"text":"{\"exercise_type\":\"repeat_sentence\",\"target_language\":\"en-US\",\"cefr_level\":\"A1\",\"reference_text\":\"I live in Berlin.\",\"display_prompt\":\"Sprich den Satz klar nach.\",\"tts_text\":\"I live in Berlin.\",\"focus_points\":[\"live\"],\"success_criteria\":[\"accuracy above 80\"],\"reason_for_choice\":\"Practise /l/.\"}"}`) exercise, ok := parseGeneratedExerciseEnvelope(body) if !ok { t.Fatal("expected generated exercise to parse") } if exercise.ReferenceText != "I live in Berlin." { t.Fatalf("unexpected reference text %q", exercise.ReferenceText) } if len(exercise.FocusPoints) != 1 || exercise.FocusPoints[0] != "live" { t.Fatalf("unexpected focus points %#v", exercise.FocusPoints) } } func TestParseGeneratedExerciseEnvelopeWithStructuredText(t *testing.T) { body := []byte(`{"text":{"exercise_type":"repeat_sentence","target_language":"en-US","cefr_level":"A1","reference_text":"Please pass me the water.","display_prompt":"Sprich den Satz nach.","tts_text":"Please pass me the water.","focus_points":["water"],"success_criteria":["Sprich den Satz verständlich nach."],"reason_for_choice":"Übt ein Alltagswort."}}`) exercise, ok := parseGeneratedExerciseEnvelope(body) if !ok || exercise.ReferenceText != "Please pass me the water." { t.Fatalf("structured Flowise text was not parsed: %#v, %v", exercise, ok) } }