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.
178 lines
6.4 KiB
Go
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")
|
|
}
|
|
}
|