Files
Speech/apps/api/internal/store/course_generation_integration_test.go
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

178 lines
6.4 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"net/url"
"os"
"strings"
"sync"
"testing"
_ "github.com/jackc/pgx/v5/stdlib"
"speech-learning-api/internal/domain"
)
// Opt-in: use only a dedicated test database. All objects are confined to a
// random schema, which is dropped after the test. No application .env is read.
func TestCourseGenerationPostgres(t *testing.T) {
dsn := os.Getenv("COURSE_TEST_DATABASE_URL")
if dsn == "" {
t.Skip("COURSE_TEST_DATABASE_URL not set; PostgreSQL integration test skipped")
}
ctx := context.Background()
admin, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatal("open test database")
}
defer admin.Close()
schema := NewID("course_test")
if _, err := admin.ExecContext(ctx, `CREATE SCHEMA `+schema); err != nil {
t.Fatal(err)
}
parsed, err := url.Parse(dsn)
if err != nil {
t.Fatal("test DSN must be a PostgreSQL URL")
}
query := parsed.Query()
query.Set("search_path", schema)
parsed.RawQuery = query.Encode()
db, err := sql.Open("pgx", parsed.String())
if err != nil {
t.Fatal(err)
}
defer func() {
db.Close()
if _, err := admin.ExecContext(ctx, `DROP SCHEMA `+schema+` CASCADE`); err != nil {
t.Error(err)
}
}()
repo := NewPostgresStore(db)
// Simulate the previous release, including an existing learner and attempt.
if _, err := db.ExecContext(ctx, schemaSQL); err != nil {
t.Fatal(err)
}
for _, stmt := range seedSQL {
if _, err := db.ExecContext(ctx, stmt); err != nil {
t.Fatal(err)
}
}
legacyCourseSchema := strings.Split(courseSchemaSQL, "ALTER TABLE course_tasks")[0] + `
CREATE TABLE course_attempts (
id TEXT PRIMARY KEY,user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
task_id TEXT NOT NULL REFERENCES course_tasks(id),answer TEXT NOT NULL,
correct BOOLEAN NOT NULL,created_at TIMESTAMPTZ NOT NULL DEFAULT now());`
if _, err := db.ExecContext(ctx, legacyCourseSchema); err != nil {
t.Fatal(err)
}
for _, stmt := range courseSeedSQL {
if _, err := db.ExecContext(ctx, stmt); err != nil {
t.Fatal(err)
}
}
owner, err := repo.CreateUser(ctx, "owner@example.test", "unused", "de-DE")
if err != nil {
t.Fatal(err)
}
other, err := repo.CreateUser(ctx, "other@example.test", "unused", "de-DE")
if err != nil {
t.Fatal(err)
}
if _, err := db.ExecContext(ctx, `INSERT INTO course_attempts(id,user_id,task_id,answer,correct) VALUES ('historic',$1,'a1i_v1_vocab_2','mit',false)`, owner.ID); err != nil {
t.Fatal(err)
}
for i := 0; i < 2; i++ {
if err := repo.Init(ctx); err != nil {
t.Fatalf("migration %d: %v", i, err)
}
}
const module = "a1_introductions_v1"
selection, err := repo.SelectCoursePractice(ctx, owner.ID, module)
if err != nil || selection.Goal.ID != "introductions.from" || selection.State.GoalAttemptCount != 1 || len(selection.State.RecentResults) != 1 || selection.State.RecentResults[0] {
t.Fatalf("historic selection %#v: %v", selection, err)
}
out := domain.GeneratedCourseTask{SchemaVersion: 1, ModuleID: module, TargetLanguage: "en-US", CEFRLevel: "A1", LearningGoalID: "introductions.from", Skill: "vocabulary", Kind: "choice", Prompt: "Was bedeutet „from“ in „I am from Spain“?", Options: []string{"aus", "mit", "bei"}, Solution: "aus", Explanation: "From nennt hier die Herkunft."}
saved, err := repo.SaveGeneratedCourseTask(ctx, owner.ID, "request_1", out)
if err != nil {
t.Fatal(err)
}
if saved.Source != "flowise" {
t.Fatal("wrong source")
}
data, _ := json.Marshal(saved)
if strings.Contains(string(data), "solution") || strings.Contains(string(data), "explanation") {
t.Fatal("leaked solution")
}
key, err := repo.CourseTaskKey(ctx, saved.Task.ID, owner.ID, "en-US", "A1")
if err != nil || key.Solution != "aus" {
t.Fatalf("key %#v: %v", key, err)
}
if _, err := repo.CourseTaskKey(ctx, saved.Task.ID, other.ID, "en-US", "A1"); !errors.Is(err, ErrNotFound) {
t.Fatalf("foreign key access: %v", err)
}
if _, err := repo.SaveCourseAttempt(ctx, other.ID, saved.Task.ID, "aus", true); !errors.Is(err, ErrNotFound) {
t.Fatalf("foreign attempt: %v", err)
}
if _, err := repo.SaveCourseAttempt(ctx, owner.ID, saved.Task.ID, "aus", true); err != nil {
t.Fatal(err)
}
detail, err := repo.CourseModule(ctx, owner.ID, "en-US", "A1", module)
if err != nil || detail.Module.TaskCount != 12 || detail.Module.AttemptedCount != 1 || detail.Module.CorrectCount != 0 {
t.Fatalf("core progress changed: %#v %v", detail.Module, err)
}
tasks, err := repo.CoursePractice(ctx, owner.ID, module)
if err != nil || len(tasks) != 1 || !tasks[0].Correct {
t.Fatalf("practice %#v %v", tasks, err)
}
foreign, err := repo.CoursePractice(ctx, other.ID, module)
if err != nil || len(foreign) != 0 {
t.Fatalf("foreign practice %#v %v", foreign, err)
}
if _, err := repo.CoursePracticeByRequest(ctx, other.ID, module, "request_1"); !errors.Is(err, ErrNotFound) {
t.Fatalf("foreign request %v", err)
}
selection, err = repo.SelectCoursePractice(ctx, owner.ID, module)
if err != nil || selection.Goal.ID != "introductions.name" {
t.Fatalf("next selection %#v %v", selection, err)
}
// Retried requests preserve the original task even if the generated text differs.
changed := out
changed.Prompt = "Was bedeutet „from“ in „I am from France“?"
retry, err := repo.SaveGeneratedCourseTask(ctx, owner.ID, "request_1", changed)
if err != nil || retry.Task.ID != saved.Task.ID || retry.Task.Prompt != out.Prompt {
t.Fatalf("retry %#v %v", retry, err)
}
if _, err := repo.SaveGeneratedCourseTask(ctx, owner.ID, "request_duplicate", out); !errors.Is(err, ErrNotFound) {
t.Fatalf("duplicate prompt %v", err)
}
if _, err := repo.SaveGeneratedCourseTask(ctx, other.ID, "request_1", out); err != nil {
t.Fatal(err)
}
// Concurrent deliveries of one request must all resolve to the same stored task.
var wg sync.WaitGroup
for i := 0; i < 4; i++ {
wg.Add(1)
go func() {
defer wg.Done()
result, err := repo.SaveGeneratedCourseTask(ctx, owner.ID, "request_parallel", changed)
if err != nil || result.Task.Prompt != changed.Prompt {
t.Errorf("parallel request: %v", err)
}
}()
}
wg.Wait()
tasks, err = repo.CoursePractice(ctx, owner.ID, module)
if err != nil || len(tasks) != 2 {
t.Fatalf("duplicate concurrent tasks: %d %v", len(tasks), err)
}
if err := repo.Init(ctx); err != nil {
t.Fatal(err)
}
tasks, err = repo.CoursePractice(ctx, owner.ID, module)
if err != nil || len(tasks) != 2 {
t.Fatal("startup changed generated tasks")
}
}