Azure-Phonemwerte in Versuchen sichern, schwache Laute im Fortschritt und Flowise-Kontext auswerten und die Web-Anzeige ergänzen. README dokumentiert Datenfluss, Betrieb und Grenzen der Funktion.
312 lines
13 KiB
Go
312 lines
13 KiB
Go
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 TestFeedbackNamesMeasuredWeakPhoneme(t *testing.T) {
|
|
result := domain.PronunciationResult{
|
|
OverallScore: 79,
|
|
WordScores: []domain.WordScore{{
|
|
Word: "water", Accuracy: 72, Highlight: "weak",
|
|
PhonemeScores: []domain.PhonemeScore{{Phoneme: "w", Accuracy: 90}, {Phoneme: "t", Accuracy: 58}},
|
|
}},
|
|
}
|
|
feedback := mockFeedback("I drink water.", result)
|
|
if !strings.Contains(feedback.TeacherFeedback, "/t/") || !strings.Contains(feedback.TeacherFeedback, "58") {
|
|
t.Fatalf("expected measured phoneme in feedback, got %#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",
|
|
Progress: domain.ProgressSummary{
|
|
WeakPhonemes: []domain.WeakPhoneme{{Word: "water", Phoneme: "t", Accuracy: 58}},
|
|
RecentAttempts: []domain.Attempt{{WordScores: []domain.WordScore{{
|
|
Word: "water", Accuracy: 70, PhonemeScores: []domain.PhonemeScore{{Phoneme: "t", Accuracy: 58}},
|
|
}}}},
|
|
},
|
|
RecentWeakWords: []domain.WordScore{{Word: "water", Accuracy: 70, PhonemeScores: []domain.PhonemeScore{{Phoneme: "t", Accuracy: 58}}}},
|
|
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"])
|
|
}
|
|
if phonemes, ok := question["recent_weak_phonemes"].([]any); !ok || len(phonemes) != 1 {
|
|
t.Fatalf("weak phonemes were not sent to Flowise: %#v", question["recent_weak_phonemes"])
|
|
}
|
|
if strings.Contains(questionText, "phoneme_scores") {
|
|
t.Fatal("raw phoneme scores should be summarized before sending progress to Flowise")
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|