GUI und neue Erklärungen verwenden gemeinsam native_language. Deutsch und Russisch sind die beiden Muttersprachen; Englisch bleibt die Lernsprache. Kompatibilitätsfelder werden atomar gekoppelt, widersprüchliche Eingaben abgewiesen und bestehende Profile sowie eingefrorene Inhalte erhalten. Ergänzt vollständige russische GUI-Kataloge und 840 geprüfte Aufgabenansichten in sieben Modulen einschließlich A1-Test, mit getrennten Sprachrollen für Ausgangs- und Lernmaterial. Äquivalente Ansichten teilen ihre Nachweisidentität. Stabile API-Fehlercodes, neue deterministische Hilfen und Trainingsbegründungen berücksichtigen die Muttersprache. Dokumentiert das Sprachmodell in AGENTS.md. Validierung: Go-Race-Suite mit eigener lokaler PostgreSQL-Testdatenbank, go vet, Web-Build, Offline-Bank-/Variantenaudit, Diff-Prüfung sowie lokale Browser-Smokes für Sprachen, Kurs, Administration, Aussprache und Aufnahme. Keine Live-Anbieter, Produktionsprofile, Deployment-Schritte oder historischen Neubewertungen.
487 lines
16 KiB
Go
487 lines
16 KiB
Go
package services
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"speech-learning-api/internal/config"
|
|
"speech-learning-api/internal/domain"
|
|
"speech-learning-api/internal/store"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
)
|
|
|
|
func TestBankPostgresSelectionAndOptionalEvaluation(t *testing.T) {
|
|
db, profiles := adaptiveTestDB(t)
|
|
ctx := context.Background()
|
|
user, err := profiles.CreateUser(ctx, store.NewID("bank")+"@example.test", "hash", "de-DE")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
agent := NewAIService(store.NewAIStore(db), config.Config{})
|
|
engine := NewCourseEngine(store.NewAdaptiveStore(db), profiles, agent, slog.New(slog.NewTextHandler(io.Discard, nil)))
|
|
engine.Mode = "bank"
|
|
run := func(skill, request string) domain.AdaptiveTask {
|
|
t.Helper()
|
|
_, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_family_v1", skill, "", request)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
j, err := engine.Repo.Claim(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := engine.Process(ctx, j)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = engine.Repo.Finish(ctx, j, task, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return *task
|
|
}
|
|
seen := map[string]bool{}
|
|
var first domain.AdaptiveTask
|
|
for n := 0; n < 20; n++ {
|
|
task := run("grammar", store.NewID("request"))
|
|
if seen[task.ID] || task.Review || task.Source != "curated" {
|
|
t.Fatal("new pool repeated", task)
|
|
}
|
|
seen[task.ID] = true
|
|
if n == 0 {
|
|
first = task
|
|
wrong := task.Options[0].ID
|
|
if wrong == task.AnswerKey.CorrectOptionID {
|
|
wrong = task.Options[1].ID
|
|
}
|
|
a, _, err := engine.Submit(ctx, user.ID, "en-US", task.ID, "wrong-first", wrong, nil)
|
|
if err != nil || a.Evaluation == nil || a.Evaluation.Score != 0 {
|
|
t.Fatal(err, a)
|
|
}
|
|
}
|
|
}
|
|
repeat := run("grammar", "first-repeat")
|
|
if !repeat.Review || repeat.ID != first.ID {
|
|
t.Fatal("weak task not repeated", repeat)
|
|
}
|
|
if next := run("grammar", "second-repeat"); !next.Review || next.ID == repeat.ID {
|
|
t.Fatal("immediate repeat", next)
|
|
}
|
|
// Concurrent requests get different unseen tasks, and request replay is stable.
|
|
for _, r := range []string{"parallel-a", "parallel-b"} {
|
|
if _, err = engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_family_v1", "vocabulary", "", r); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
jobs := []domain.CourseJob{}
|
|
for n := 0; n < 2; n++ {
|
|
j, err := engine.Repo.Claim(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
jobs = append(jobs, j)
|
|
}
|
|
var wg sync.WaitGroup
|
|
ids := make(chan string, 2)
|
|
errs := make(chan error, 2)
|
|
for _, job := range jobs {
|
|
wg.Add(1)
|
|
go func(j domain.CourseJob) {
|
|
defer wg.Done()
|
|
task, err := engine.Process(ctx, j)
|
|
if err == nil {
|
|
err = engine.Repo.Finish(ctx, j, task, "")
|
|
ids <- task.ID
|
|
}
|
|
errs <- err
|
|
}(job)
|
|
}
|
|
wg.Wait()
|
|
close(ids)
|
|
close(errs)
|
|
distinct := map[string]bool{}
|
|
for id := range ids {
|
|
distinct[id] = true
|
|
}
|
|
for err := range errs {
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if len(distinct) != 2 {
|
|
t.Fatal("concurrent duplicate", distinct)
|
|
}
|
|
replay, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_family_v1", "vocabulary", "", "parallel-a")
|
|
if err != nil || replay.Status != "succeeded" || !distinct[replay.TaskID] {
|
|
t.Fatal("request replay changed", err, replay)
|
|
}
|
|
other, err := profiles.CreateUser(ctx, store.NewID("other")+"@example.test", "hash", "de-DE")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = engine.Repo.Task(ctx, other.ID, "en-US", first.ID); !errors.Is(err, store.ErrNotFound) {
|
|
t.Fatal("task leaked", err)
|
|
}
|
|
inventory, err := engine.Repo.BankInventory(ctx, other.ID, "en-US")
|
|
if err != nil || len(inventory) != 42 {
|
|
t.Fatal(err, len(inventory))
|
|
}
|
|
for _, i := range inventory {
|
|
if i.Total != 20 || i.Unseen != 20 {
|
|
t.Fatal("cross-user exposure", i)
|
|
}
|
|
}
|
|
writing := run("writing", "writing")
|
|
a, j, err := engine.Submit(ctx, user.ID, "en-US", writing.ID, "open-answer", "He has got a sister.", nil)
|
|
if err != nil || a.Status != "ungraded" || a.Evaluation != nil || j != nil {
|
|
t.Fatal("open answer falsely graded", err, a, j)
|
|
}
|
|
a2, _, err := engine.Submit(ctx, user.ID, "en-US", writing.ID, "open-answer", "changed replay", nil)
|
|
if err != nil || a2.ID != a.ID || a2.Answer != a.Answer {
|
|
t.Fatal("answer replay changed", err, a2)
|
|
}
|
|
var before, after string
|
|
if err = db.QueryRow(`SELECT data::text FROM course_v2_tasks WHERE id=$1`, first.ID).Scan(&before); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = engine.Repo.InstallBank(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = db.QueryRow(`SELECT data::text FROM course_v2_tasks WHERE id=$1`, first.ID).Scan(&after); err != nil || before != after {
|
|
t.Fatal("assigned content changed", err)
|
|
}
|
|
var calls, ops int
|
|
db.QueryRow(`SELECT count(*) FROM ai_calls`).Scan(&calls)
|
|
db.QueryRow(`SELECT count(*) FROM ai_operations`).Scan(&ops)
|
|
if calls != 0 || ops != 0 {
|
|
t.Fatal("bank invoked AI", calls, ops)
|
|
}
|
|
}
|
|
|
|
func TestBankPostgresExamSubmissionAndLaterGrades(t *testing.T) {
|
|
for _, native := range []string{"de-DE", "ru-RU"} {
|
|
t.Run(native, func(t *testing.T) { testBankExamNative(t, native) })
|
|
}
|
|
}
|
|
func testBankExamNative(t *testing.T, native string) {
|
|
db, profiles := adaptiveTestDB(t)
|
|
ctx := context.Background()
|
|
user, err := profiles.CreateUser(ctx, store.NewID("exam-bank")+"@example.test", "hash", native)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
agent := NewAIService(store.NewAIStore(db), config.Config{})
|
|
engine := NewCourseEngine(store.NewAdaptiveStore(db), profiles, agent, slog.New(slog.NewTextHandler(io.Discard, nil)))
|
|
engine.Mode = "bank"
|
|
exam, err := engine.Repo.NewExam(ctx, user.ID, "en-US", "bank-exam")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = engine.Repo.Enqueue(ctx, user.ID, "en-US", "exam", "a1_review_test_v1", "", exam.ID, "prepare-bank-exam")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
j, err := engine.Repo.Claim(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := engine.Process(ctx, j)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = engine.Repo.Finish(ctx, j, task, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID)
|
|
if err != nil || len(exam.Tasks) != 12 {
|
|
t.Fatal(err, exam)
|
|
}
|
|
if err = engine.Repo.SetInstructionLanguage(ctx, user.ID, "en-US", "de-DE"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Task presentations and the final static summary retain the exam language.
|
|
ungraded := []domain.AdaptiveAttempt{}
|
|
for n, pub := range exam.Tasks {
|
|
if pub.InstructionLanguage != native {
|
|
t.Fatal("exam language not frozen", pub.InstructionLanguage, native)
|
|
}
|
|
if pub.AnswerKey != nil || pub.AudioText != "" {
|
|
t.Fatal("exam key leaked")
|
|
}
|
|
private, err := engine.Repo.Task(ctx, user.ID, "en-US", pub.ID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
answer := "He has got a sister."
|
|
var speech *domain.PronunciationResult
|
|
if private.Kind == "choice" {
|
|
answer = private.AnswerKey.CorrectOptionID
|
|
}
|
|
if private.Skill == "speaking" {
|
|
speech = &domain.PronunciationResult{Provider: "azure", RecognizedText: answer, OverallScore: 95}
|
|
}
|
|
attempt, _, err := engine.Submit(ctx, user.ID, "en-US", pub.ID, store.NewID("exam-answer"), answer, speech)
|
|
if err != nil {
|
|
t.Fatal(n, err)
|
|
}
|
|
if attempt.Status == "ungraded" {
|
|
ungraded = append(ungraded, attempt)
|
|
}
|
|
}
|
|
exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID)
|
|
if err != nil || exam.Status != "submitted" || exam.Score != nil || len(ungraded) != 4 {
|
|
t.Fatal("submitted exam falsely completed", err, exam.Status, len(ungraded))
|
|
}
|
|
for _, task := range exam.Tasks {
|
|
if task.AnswerKey != nil || task.AudioText != "" {
|
|
t2 := task
|
|
t2.Options = nil
|
|
t.Fatal("submitted test leaked", t2)
|
|
}
|
|
}
|
|
for _, a := range exam.Attempts {
|
|
if a.Evaluation != nil || a.Speech != nil {
|
|
t.Fatal("partial result leaked")
|
|
}
|
|
}
|
|
snapshot, err := engine.Repo.Snapshot(ctx, user.ID, "en-US", "de-DE")
|
|
if err != nil || len(snapshot.Progress) != 0 {
|
|
t.Fatal("unfinished test counted", err, snapshot.Progress)
|
|
}
|
|
// Recover a crash after all submissions, before the submitted status update.
|
|
if _, err = db.Exec(`UPDATE course_v2_exams SET status='in_progress' WHERE id=$1`, exam.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = engine.Repo.Reconcile(ctx, true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
recovered, err := engine.Repo.Claim(ctx)
|
|
if err != nil || recovered.Kind != "exam_finalize" {
|
|
t.Fatal("missing submitted-test recovery", err, recovered)
|
|
}
|
|
recoveredTask, err := engine.Process(ctx, recovered)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = engine.Repo.Finish(ctx, recovered, recoveredTask, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID)
|
|
if err != nil || exam.Status != "submitted" {
|
|
t.Fatal("submitted state not recovered", err)
|
|
}
|
|
// Activate a local deterministic evaluator only. No real model/key is used.
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
var body struct {
|
|
Messages []struct {
|
|
Content string `json:"content"`
|
|
} `json:"messages"`
|
|
}
|
|
json.NewDecoder(r.Body).Decode(&body)
|
|
var message struct {
|
|
Task string `json:"task"`
|
|
}
|
|
json.Unmarshal([]byte(body.Messages[1].Content), &message)
|
|
if message.Task != "evaluate_course_attempt" {
|
|
t.Error("unexpected model action", message.Task)
|
|
}
|
|
json.NewEncoder(w).Encode(aiCompletion(domain.CourseEvaluation{Score: 100, Verdict: "correct", Feedback: map[string]string{"de-DE": "Richtig.", "ru-RU": "Верно."}[native], Issues: []string{}}, true))
|
|
}))
|
|
defer server.Close()
|
|
agent.Keys["mistral"] = "fixture-secret"
|
|
agent.URLs["mistral"] = server.URL
|
|
if _, err = agent.Repo.SaveProfile(ctx, user.ID, aiTestProfile("evaluate_course_attempt")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = agent.Repo.SaveBudget(ctx, user.ID, 1000000, 0); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !engine.EvaluationAvailable(ctx) {
|
|
t.Fatal("configured fixture evaluator unavailable")
|
|
}
|
|
for _, a := range ungraded {
|
|
if _, err = engine.Repo.RetryEvaluation(ctx, user.ID, "en-US", a.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
j, err := engine.Repo.Claim(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := engine.Process(ctx, j)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = engine.Repo.Finish(ctx, j, task, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID)
|
|
if err != nil || exam.Status != "completed" || exam.Score == nil || *exam.Score != 100 || exam.SummaryStatus != "ready" {
|
|
t.Fatal("later grading failed", err, exam)
|
|
}
|
|
if native == "ru-RU" && !strings.HasPrefix(exam.Summary, "Внутренняя") {
|
|
t.Fatal("wrong summary language", exam.Summary)
|
|
}
|
|
// Repair a crash after score completion without invoking a summarizing model.
|
|
if _, err = db.Exec(`UPDATE course_v2_exams SET result=jsonb_set(result,'{summary_status}','"pending"') WHERE id=$1`, exam.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = engine.Repo.Enqueue(ctx, user.ID, "en-US", "exam_finalize", "a1_review_test_v1", "", exam.ID, "repair-summary"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
repair, err := engine.Repo.Claim(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
repairTask, err := engine.Process(ctx, repair)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = engine.Repo.Finish(ctx, repair, repairTask, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID)
|
|
if err != nil || exam.SummaryStatus != "ready" {
|
|
t.Fatal("summary recovery failed", err)
|
|
}
|
|
if err = engine.Repo.ExamSummary(ctx, user.ID, exam.ID, "Historische Zusammenfassung"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = engine.Repo.EnsureBankExamSummary(ctx, user.ID, exam.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
exam, err = engine.Repo.Exam(ctx, user.ID, "en-US", exam.ID)
|
|
if err != nil || exam.Summary != "Historische Zusammenfassung" {
|
|
t.Fatal("ready summary changed", err)
|
|
}
|
|
var calls int
|
|
db.QueryRow(`SELECT count(*) FROM ai_calls`).Scan(&calls)
|
|
if calls != 4 {
|
|
t.Fatal("extra model calls", calls)
|
|
}
|
|
}
|
|
|
|
func TestBankPostgresDifficultyAndCrashReplay(t *testing.T) {
|
|
db, profiles := adaptiveTestDB(t)
|
|
ctx := context.Background()
|
|
user, err := profiles.CreateUser(ctx, store.NewID("adaptive-bank")+"@example.test", "hash", "de-DE")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
engine := NewCourseEngine(store.NewAdaptiveStore(db), profiles, NewAIService(store.NewAIStore(db), config.Config{}), slog.New(slog.NewTextHandler(io.Discard, nil)))
|
|
engine.Mode = "bank"
|
|
next := func() (domain.AdaptiveTask, int) {
|
|
t.Helper()
|
|
_, err := engine.Repo.Enqueue(ctx, user.ID, "en-US", "next", "a1_introductions_v1", "grammar", "", store.NewID("request"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
j, err := engine.Repo.Claim(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task, err := engine.Process(ctx, j)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Simulate a restart after assignment committed, before Finish.
|
|
if err = engine.Repo.Release(ctx, j); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
again, err := engine.Repo.Claim(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
replay, err := engine.Process(ctx, again)
|
|
if err != nil || replay.ID != task.ID {
|
|
t.Fatal("crash selected another task", err)
|
|
}
|
|
if err = engine.Repo.Finish(ctx, again, replay, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var level int
|
|
if err = db.QueryRow(`SELECT b.difficulty FROM course_v2_tasks t JOIN course_v2_bank b ON b.id=t.bank_entry_id WHERE t.id=$1`, task.ID).Scan(&level); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return *task, level
|
|
}
|
|
for n := 0; n < 3; n++ {
|
|
task, level := next()
|
|
if level != 1 {
|
|
t.Fatal("initial task too difficult", level)
|
|
}
|
|
if _, _, err = engine.Submit(ctx, user.ID, "en-US", task.ID, store.NewID("answer"), task.AnswerKey.CorrectOptionID, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
for n := 0; n < 3; n++ {
|
|
task, level := next()
|
|
if (n == 0 && level != 2) || level > 2 {
|
|
t.Fatal("difficulty should rise after success, then allow easier weak-goal practice", level)
|
|
}
|
|
wrong := task.Options[0].ID
|
|
if wrong == task.AnswerKey.CorrectOptionID {
|
|
wrong = task.Options[1].ID
|
|
}
|
|
if _, _, err = engine.Submit(ctx, user.ID, "en-US", task.ID, store.NewID("answer"), wrong, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
_, level := next()
|
|
if level != 1 {
|
|
t.Fatal("difficulty did not decrease", level)
|
|
}
|
|
if err = engine.Repo.Reconcile(ctx, true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var count int
|
|
db.QueryRow(`SELECT count(*) FROM course_v2_jobs WHERE kind='analyze'`).Scan(&count)
|
|
if count != 0 {
|
|
t.Fatal("bank scheduled AI analysis", count)
|
|
}
|
|
// A crash before deterministic choice grading must not require an evaluator.
|
|
pendingTask, _ := next()
|
|
pending, err := engine.Repo.Submit(ctx, user.ID, "crashed-choice", pendingTask, pendingTask.AnswerKey.CorrectOptionID, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = engine.Repo.Reconcile(ctx, true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
recovery, err := engine.Repo.Claim(ctx)
|
|
if err != nil || recovery.Kind != "evaluate" {
|
|
t.Fatal(err, recovery)
|
|
}
|
|
recoveredTask, err := engine.Process(ctx, recovery)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = engine.Repo.Finish(ctx, recovery, recoveredTask, ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
pending, err = engine.Repo.Attempt(ctx, user.ID, "en-US", pending.ID)
|
|
if err != nil || pending.Status != "graded" || pending.Evaluation.Score != 100 {
|
|
t.Fatal("choice recovery required AI", err, pending)
|
|
}
|
|
db.QueryRow(`SELECT count(*) FROM ai_operations`).Scan(&count)
|
|
if count != 0 {
|
|
t.Fatal("choice recovery created AI operation", count)
|
|
}
|
|
// Changing an installed immutable revision must fail without retiring templates.
|
|
if _, err = db.Exec(`UPDATE course_v2_bank SET checksum='corrupt' WHERE id=(SELECT min(id) FROM course_v2_bank)`); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if engine.Repo.InstallBank(ctx) == nil {
|
|
t.Fatal("changed revision accepted")
|
|
}
|
|
db.QueryRow(`SELECT count(*) FROM course_v2_bank WHERE active`).Scan(&count)
|
|
if count != 840 {
|
|
t.Fatal("failed import partially retired templates", count)
|
|
}
|
|
}
|