Files
Speech/apps/web/tests/course-variants.e2e.cjs
T
Eugenius Naumenko f3d42ee2b6 Mehrsprachige Bedienung und versionierte Aufgabenvarianten einführen
Übersetzungskataloge, getrennte Sprachpräferenzen und einen versionierten Aufgabenpilot ergänzen. Historische Aufgaben und Bewertungen bleiben erhalten; äquivalente Ansichten teilen Nachweise. Lokal mit Race-Tests und PostgreSQL, Vet, Web-Build, Bank-Audits und Browser-Fixtures geprüft. Dieser Stand dient als Ausgangspunkt für die anschließend beauftragte Zusammenführung zur Muttersprache.
2026-11-07 16:26:26 +00:00

119 lines
9.9 KiB
JavaScript

// Local API/PostgreSQL fixture only. No paid provider calls or real microphone.
const { chromium } = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
const assert = require('node:assert/strict');
const crypto = require('node:crypto');
(async () => {
const api = process.env.AI_E2E_API, url = process.env.AI_E2E_URL, adminToken = process.env.AI_E2E_TOKEN;
assert(api && url && adminToken);
const browser = await chromium.launch({ headless: true, args: ['--no-sandbox'] });
try {
const page = await browser.newPage(); page.setDefaultTimeout(15000);
const errors = []; page.on('pageerror', error => errors.push(error.message));
const registration = await page.request.post(api + '/auth/register', { data: { email: `variants-${Date.now()}@example.test`, password: 'local-variant-test-password', ui_language: 'en-US', target_language: 'en-US' } });
assert.equal(registration.status(), 201);
const account = await registration.json(), headers = { Authorization: `Bearer ${account.token}` };
const id = () => crypto.randomUUID().replaceAll('-', '');
const get = async path => { const response = await page.request.get(api + path, { headers }); assert.equal(response.status(), 200, await response.text()); return response.json(); };
const explanation = () => page.getByRole('combobox', { name: 'Exercise explanation language' });
const exercise = page.getByRole('region', { name: 'Current course exercise' });
async function waitJob(job) {
for (let count = 0; count < 80 && ['queued', 'running'].includes(job.status); count++) {
await page.waitForTimeout(100); job = await get('/course/jobs/' + job.id);
}
return job;
}
async function next(skill) {
await page.getByRole('group', { name: 'Learning area' }).getByRole('button', { name: skill, exact: true }).click();
const response = page.waitForResponse(r => r.url().endsWith('/tasks/next') && r.request().method() === 'POST');
await page.getByRole('button', { name: 'Next exercise', exact: true }).click();
const job = await waitJob(await (await response).json()); assert.equal(job.status, 'succeeded', job.error);
const detail = await get('/course/tasks/' + job.task_id);
await exercise.getByRole('heading', { level: 2, name: detail.task.instruction, exact: true }).waitFor();
await page.getByRole('button', { name: 'Next exercise', exact: true }).waitFor();
assert.equal(detail.task.instruction_language, 'en-US'); assert(detail.task.content_revision); assert(detail.task.variant_id);
assert.equal(detail.task.answer_key, undefined); assert.equal(detail.task.audio_text, undefined); assert.equal(detail.task.evidence_task_id, undefined);
return detail.task;
}
await page.goto(url); await page.evaluate(token => localStorage.setItem('speech_token', token), account.token); await page.reload();
await page.getByRole('button', { name: 'A1 course', exact: true }).click();
await explanation().selectOption('en-US');
await page.getByText('Preferred explanation language: English.', { exact: true }).waitFor();
let catalog = await get('/course/catalog');
assert.equal(catalog.modules[0].title, 'Greetings & introductions');
assert.equal(catalog.instruction_language, 'en-US'); assert.equal(catalog.exam_available, false);
assert.equal(catalog.bank.reduce((sum, item) => sum + item.total, 0), 12);
assert(catalog.bank.every(item => item.module_id === 'a1_introductions_v1' && item.total === 2));
const grammar = await next('Grammar');
await exercise.locator('.course-passage').getByText(grammar.stimulus.text, { exact: true }).waitFor();
assert.equal(grammar.stimulus.role, 'target'); assert.equal(grammar.stimulus.language, 'en-US');
for (let n = 0; n < 2; n++) {
const task = await next('Vocabulary');
assert.equal(task.canonical_task_id, task.variant_id, 'Adapted meanings require a separate canonical identity');
assert(task.options.every(option => option.language === 'en-US' && !['hello', 'name'].includes(option.label.toLowerCase())));
assert(!task.options.some(option => ['hallo', 'tschüss', 'Name', 'Alter', 'Wohnort'].includes(option.label)));
}
await next('Reading'); await exercise.locator('.course-passage').waitFor();
const listening = await next('Listening'); assert.equal(listening.stimulus, undefined);
await exercise.getByRole('button', { name: 'Listen', exact: true }).waitFor();
assert.equal(await exercise.getByText('Listening transcript:', { exact: false }).count(), 0);
for (let n = 0; n < 2; n++) {
const task = await next('Speaking');
assert(['repeat_sentence', 'free_speech'].includes(task.kind));
await exercise.getByRole('button', { name: 'Record', exact: true }).waitFor();
assert.equal(Boolean(task.reference_text), task.kind === 'repeat_sentence');
}
const writing = await next('Writing');
assert.equal(writing.kind, 'short_text'); assert.equal(writing.canonical_task_id, writing.variant_id);
assert(!writing.instruction.toLowerCase().includes('translate')); assert.equal(writing.stimulus.role, 'context');
await exercise.getByRole('textbox', { name: 'Your answer' }).fill('I am Anna.');
await exercise.getByRole('button', { name: 'Check answer', exact: true }).click();
await exercise.getByText('Answer saved without a grade.', { exact: false }).waitFor();
let saved = await get('/course/tasks/' + writing.id);
assert.equal(saved.attempt.status, 'ungraded'); assert.equal(saved.attempt.answer, 'I am Anna.'); assert.equal(saved.attempt.evaluation, undefined);
assert.equal(saved.task.answer_key.reference_answer_language, 'en-US');
const frozen = saved.task;
await explanation().selectOption('de-DE');
await page.getByText('Preferred explanation language: German.', { exact: true }).waitFor();
await exercise.getByText('This exercise uses: English', { exact: true }).waitFor();
saved = await get('/course/tasks/' + writing.id); assert.deepEqual(saved.task, frozen);
await page.reload(); await page.getByRole('button', { name: 'A1 course', exact: true }).click();
await exercise.getByRole('heading', { name: writing.instruction, exact: true }).waitFor();
saved = await get('/course/tasks/' + writing.id); assert.equal(saved.attempt.answer, 'I am Anna.'); assert.deepEqual(saved.task, frozen);
const currentUser = await get('/me'); assert.equal(currentUser.user.ui_language, 'en-US'); assert.deepEqual(currentUser.profile, account.profile);
await explanation().selectOption('en-US');
await page.getByText('Preferred explanation language: English.', { exact: true }).waitFor();
const freeWriting = await next('Writing'); assert.equal(freeWriting.kind, 'free_text');
const modules = page.getByRole('navigation', { name: 'A1 modules' }).getByRole('button');
await modules.nth(1).click();
await page.getByText('This area has no reviewed exercises', { exact: false }).waitFor();
assert(await page.getByRole('button', { name: 'Next exercise', exact: true }).isDisabled());
const missing = await page.request.post(api + '/course/modules/a1_family_v1/tasks/next', { headers, data: { request_id: id(), skill: 'grammar' } });
assert.equal(missing.status(), 202); const failed = await waitJob(await missing.json()); assert.equal(failed.status, 'failed'); assert.equal(failed.task_id, undefined);
assert.equal((await get('/course/modules/a1_family_v1/tasks')).tasks.length, 0);
await modules.nth(6).click();
assert(await page.getByRole('button', { name: 'Start a new A1 test · 12 questions', exact: true }).isDisabled());
const unsupportedExam = await page.request.post(api + '/course/exams', { headers, data: { request_id: id() } });
assert.equal(unsupportedExam.status(), 409); assert.equal((await unsupportedExam.json()).code, 'course_variant_unavailable');
catalog = await get('/course/catalog'); assert.equal(catalog.exams.length, 0);
// Reusing an existing German test request must keep that frozen session.
await page.request.put(api + '/course/instruction-language', { headers, data: { instruction_language: 'de-DE' } });
const examRequest = id();
const germanExamResponse = await page.request.post(api + '/course/exams', { headers, data: { request_id: examRequest } });
assert.equal(germanExamResponse.status(), 202);
const germanExam = await germanExamResponse.json();
assert.equal((await waitJob(germanExam.job)).status, 'succeeded');
await page.request.put(api + '/course/instruction-language', { headers, data: { instruction_language: 'en-US' } });
const replayResponse = await page.request.post(api + '/course/exams', { headers, data: { request_id: examRequest } });
assert.equal(replayResponse.status(), 202);
const replay = await replayResponse.json(); assert.equal(replay.exam.id, germanExam.exam.id); assert.equal(replay.job.id, germanExam.job.id); assert.equal(replay.job.instruction_language, 'de-DE');
const unsupported = await page.request.put(api + '/course/instruction-language', { headers, data: { instruction_language: 'fr-FR' } });
assert.equal(unsupported.status(), 409); assert.equal((await unsupported.json()).code, 'course_variant_unavailable');
assert.equal((await get('/me')).user.instruction_language, 'en-US');
const anonymous = await page.request.put(api + '/course/instruction-language', { data: { instruction_language: 'de-DE' } }); assert.equal(anonymous.status(), 401);
const usage = await page.request.get(api + '/admin/ai/usage', { headers: { Authorization: `Bearer ${adminToken}` } }); assert.equal((await usage.json()).total, 0);
assert.deepEqual(errors, []);
console.log('PASS: explanation choice; 12 structured pilot variants; five renderers/six skills; independent UI language; adapted vocabulary/writing; frozen answers/reload; no German fallback; unavailable English exam; auth; no model calls.');
} finally { await browser.close(); }
})().catch(error => { console.error(error); process.exitCode = 1; });