80b2ae2676
Increase timeouts for export and navigation tests to 60 seconds to prevent flakiness. Remove brittle assertions checking for visible overlays in setup helpers to ensure more stable test execution.
523 lines
20 KiB
TypeScript
523 lines
20 KiB
TypeScript
import { test, expect, Page } from '@playwright/test';
|
|
import fs from 'fs';
|
|
import os from 'os';
|
|
import path from 'path';
|
|
import util from 'util';
|
|
import { execFile } from 'child_process';
|
|
import { setupTest, uploadAndDisplay } from './helpers';
|
|
|
|
const execFileAsync = util.promisify(execFile);
|
|
|
|
async function getBookIdFromUrl(page: Page, expectedPrefix: 'pdf' | 'epub') {
|
|
const url = new URL(page.url());
|
|
const segments = url.pathname.split('/').filter(Boolean);
|
|
expect(segments[0]).toBe(expectedPrefix);
|
|
const bookId = segments[1];
|
|
expect(bookId).toBeTruthy();
|
|
return bookId;
|
|
}
|
|
|
|
async function openExportModal(page: Page) {
|
|
const exportButton = page.getByRole('button', { name: 'Open audiobook export' });
|
|
await expect(exportButton).toBeVisible({ timeout: 15_000 });
|
|
await exportButton.click();
|
|
await expect(page.getByRole('heading', { name: 'Export Audiobook' })).toBeVisible({ timeout: 15_000 });
|
|
}
|
|
|
|
async function setContainerFormatToMP3(page: Page) {
|
|
const formatTrigger = page.getByRole('button', { name: /M4B|MP3/i });
|
|
await expect(formatTrigger).toBeVisible({ timeout: 15_000 });
|
|
await formatTrigger.click();
|
|
await page.getByRole('option', { name: 'MP3' }).click();
|
|
}
|
|
|
|
async function startGeneration(page: Page) {
|
|
const startButton = page.getByRole('button', { name: 'Start Generation' });
|
|
await expect(startButton).toBeVisible({ timeout: 15_000 });
|
|
await startButton.click();
|
|
}
|
|
|
|
async function waitForChaptersHeading(page: Page) {
|
|
await expect(page.getByRole('heading', { name: 'Chapters' })).toBeVisible({ timeout: 60_000 });
|
|
}
|
|
|
|
type DownloadedAudiobook = {
|
|
filePath: string;
|
|
suggestedFilename: string;
|
|
cleanup: () => Promise<void>;
|
|
};
|
|
|
|
async function downloadFullAudiobook(page: Page, timeoutMs = 60_000): Promise<DownloadedAudiobook> {
|
|
const fullDownloadButton = page.getByRole('button', { name: /Full Download/i });
|
|
await expect(fullDownloadButton).toBeVisible({ timeout: timeoutMs });
|
|
const [download] = await Promise.all([
|
|
page.waitForEvent('download', { timeout: timeoutMs }),
|
|
fullDownloadButton.click(),
|
|
]);
|
|
const failure = await download.failure();
|
|
expect(failure).toBeNull();
|
|
|
|
const suggestedFilename = download.suggestedFilename();
|
|
let createdTempDir: string | null = null;
|
|
let filePath = await download.path();
|
|
|
|
// Some environments/browsers may not expose a stable download path; fall back to saving
|
|
// into a temp directory outside the repo (and clean up after assertions).
|
|
if (!filePath) {
|
|
createdTempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'openreader-audiobook-'));
|
|
const name = suggestedFilename || `download_${Date.now()}.mp3`;
|
|
filePath = path.join(createdTempDir, name);
|
|
await download.saveAs(filePath);
|
|
}
|
|
|
|
expect(fs.existsSync(filePath)).toBeTruthy();
|
|
const stats = fs.statSync(filePath);
|
|
expect(stats.size).toBeGreaterThan(0);
|
|
return {
|
|
filePath,
|
|
suggestedFilename,
|
|
cleanup: async () => {
|
|
try {
|
|
await fs.promises.unlink(filePath);
|
|
} catch {
|
|
// ignore
|
|
}
|
|
if (createdTempDir) {
|
|
await fs.promises.rm(createdTempDir, { recursive: true, force: true });
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
async function getAudioDurationSeconds(filePath: string) {
|
|
const { stdout } = await execFileAsync('ffprobe', [
|
|
'-v',
|
|
'error',
|
|
'-show_entries',
|
|
'format=duration',
|
|
'-of',
|
|
'csv=p=0',
|
|
filePath,
|
|
]);
|
|
return parseFloat(stdout.trim());
|
|
}
|
|
|
|
async function expectChaptersBackendState(page: Page, bookId: string) {
|
|
const res = await page.request.get(`/api/audiobook/status?bookId=${bookId}`);
|
|
expect(res.ok()).toBeTruthy();
|
|
const json = await res.json();
|
|
return json;
|
|
}
|
|
|
|
async function withDownloadedFullAudiobook<T>(
|
|
page: Page,
|
|
fn: (args: { filePath: string; suggestedFilename: string }) => Promise<T>,
|
|
timeoutMs = 60_000
|
|
): Promise<T> {
|
|
const dl = await downloadFullAudiobook(page, timeoutMs);
|
|
try {
|
|
return await fn({ filePath: dl.filePath, suggestedFilename: dl.suggestedFilename });
|
|
} finally {
|
|
await dl.cleanup();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Poll the backend until the chapter count stops changing for `stableMs` milliseconds.
|
|
* This helps avoid race conditions where in-flight TTS requests complete after cancellation.
|
|
*/
|
|
async function waitForStableChapterCount(
|
|
page: Page,
|
|
bookId: string,
|
|
{ stableMs = 2000, timeoutMs = 30000 } = {}
|
|
): Promise<{ count: number; json: ReturnType<typeof expectChaptersBackendState> extends Promise<infer T> ? T : never }> {
|
|
const startTime = Date.now();
|
|
let lastCount = -1;
|
|
let lastStableTime = Date.now();
|
|
let lastJson: Awaited<ReturnType<typeof expectChaptersBackendState>> | null = null;
|
|
|
|
while (Date.now() - startTime < timeoutMs) {
|
|
const json = await expectChaptersBackendState(page, bookId);
|
|
const currentCount = json.chapters?.length ?? 0;
|
|
lastJson = json;
|
|
|
|
if (currentCount !== lastCount) {
|
|
lastCount = currentCount;
|
|
lastStableTime = Date.now();
|
|
} else if (Date.now() - lastStableTime >= stableMs) {
|
|
// Count has been stable for stableMs
|
|
return { count: currentCount, json };
|
|
}
|
|
|
|
await page.waitForTimeout(200);
|
|
}
|
|
|
|
// Timeout reached, return whatever we have
|
|
return { count: lastCount, json: lastJson! };
|
|
}
|
|
|
|
async function resetAudiobookById(page: Page, bookId: string) {
|
|
const res = await page.request.delete(`/api/audiobook?bookId=${bookId}`);
|
|
expect(res.ok() || res.status() === 404).toBeTruthy();
|
|
}
|
|
|
|
async function resetAudiobookIfPresent(page: Page) {
|
|
const resetButtons = page.getByRole('button', { name: 'Reset' });
|
|
const count = await resetButtons.count();
|
|
|
|
if (count === 0) {
|
|
return;
|
|
}
|
|
|
|
const resetButton = resetButtons.first();
|
|
await resetButton.click();
|
|
|
|
await expect(page.getByRole('heading', { name: 'Reset Audiobook' })).toBeVisible({ timeout: 15_000 });
|
|
const confirmReset = page.getByRole('button', { name: 'Reset' }).last();
|
|
await confirmReset.click();
|
|
|
|
await expect(page.getByRole('button', { name: 'Start Generation' })).toBeVisible({ timeout: 60_000 });
|
|
}
|
|
|
|
test('exports full MP3 audiobook for PDF using mocked 10s TTS sample', async ({ page }, testInfo) => {
|
|
// Ensure TTS is mocked and app is ready
|
|
await setupTest(page, testInfo);
|
|
|
|
// Upload and open the sample PDF in the viewer
|
|
await uploadAndDisplay(page, 'sample.pdf');
|
|
|
|
// Capture the generated document/book id from the /pdf/[id] URL
|
|
const bookId = await getBookIdFromUrl(page, 'pdf');
|
|
await resetAudiobookById(page, bookId);
|
|
|
|
// Open the audiobook export modal from the header button
|
|
await openExportModal(page);
|
|
|
|
// While there are no chapters yet, we can still switch the container format.
|
|
// Choose MP3 so we can validate MP3 duration end-to-end.
|
|
await setContainerFormatToMP3(page);
|
|
|
|
// Start generation; this will call the mocked /api/tts which returns a 10s sample.mp3 per page
|
|
await startGeneration(page);
|
|
|
|
// Wait for chapters list to appear and populate at least two items (Pages 1 and 2)
|
|
await waitForChaptersHeading(page);
|
|
const chapterActionsButtons = page.getByRole('button', { name: 'Chapter actions' });
|
|
await expect(chapterActionsButtons).toHaveCount(2, { timeout: 60_000 });
|
|
|
|
// Trigger full download from the FRONTEND button and capture via Playwright's download API.
|
|
// The button label can be "Full Download (MP3)" or "Full Download (M4B)" depending on
|
|
// the server-side detected format, so match more loosely on the accessible name.
|
|
await withDownloadedFullAudiobook(page, async ({ filePath }) => {
|
|
// Use ffprobe (same toolchain as the server) to validate the combined audio duration.
|
|
// The TTS route is mocked to return a 10s sample.mp3 for each page, so with at least
|
|
// two chapters we should be close to ~20 seconds of audio.
|
|
const durationSeconds = await getAudioDurationSeconds(filePath);
|
|
// Duration must be within a reasonable window around 20 seconds to allow
|
|
// for encoding variations and container overhead.
|
|
expect(durationSeconds).toBeGreaterThan(18);
|
|
expect(durationSeconds).toBeLessThan(22);
|
|
});
|
|
|
|
// Also check the chapter metadata API for consistency
|
|
const json = await expectChaptersBackendState(page, bookId);
|
|
expect(json.exists).toBe(true);
|
|
expect(Array.isArray(json.chapters)).toBe(true);
|
|
expect(json.chapters.length).toBeGreaterThanOrEqual(2);
|
|
for (const ch of json.chapters) {
|
|
expect(ch.duration).toBeGreaterThan(0);
|
|
}
|
|
|
|
await resetAudiobookIfPresent(page);
|
|
});
|
|
|
|
test('exports partial MP3 audiobook for EPUB using mocked 10s TTS sample', async ({ page }, testInfo) => {
|
|
test.setTimeout(120_000);
|
|
|
|
await setupTest(page, testInfo);
|
|
|
|
// Upload and open the sample EPUB in the viewer
|
|
await uploadAndDisplay(page, 'sample.epub');
|
|
|
|
// URL should now be /epub/[id]
|
|
const bookId = await getBookIdFromUrl(page, 'epub');
|
|
await resetAudiobookById(page, bookId);
|
|
|
|
// Open the audiobook export modal from the header button
|
|
await openExportModal(page);
|
|
|
|
// Set container format to MP3
|
|
await setContainerFormatToMP3(page);
|
|
|
|
// Start generation
|
|
await startGeneration(page);
|
|
|
|
// Progress card should appear with a Cancel button while chapters are being generated
|
|
const generationCard = page.locator('div', { hasText: 'Generating Audiobook' }).first();
|
|
const cancelButton = generationCard.getByRole('button', { name: 'Cancel' });
|
|
await expect(cancelButton).toBeVisible({ timeout: 60_000 });
|
|
|
|
await expect(page.getByRole('heading', { name: 'Chapters' })).toBeVisible({ timeout: 60_000 });
|
|
|
|
// Wait until at least 3 chapters are listed in the UI; record the exact count at the
|
|
// moment we decide to cancel, and assert that no additional chapters are added afterward.
|
|
const chapterActionsButtons = page.getByRole('button', { name: 'Chapter actions' });
|
|
await expect(chapterActionsButtons.nth(2)).toBeVisible({ timeout: 120_000 });
|
|
const chapterCountBeforeCancel = await chapterActionsButtons.count();
|
|
expect(chapterCountBeforeCancel).toBeGreaterThanOrEqual(3);
|
|
|
|
// Now cancel the in-flight generation
|
|
await cancelButton.click();
|
|
|
|
// Cancellation is asynchronous: wait for generation to settle before asserting
|
|
// that the inline progress card has disappeared.
|
|
await expect(page.getByRole('button', { name: 'Resume' })).toBeVisible({ timeout: 30_000 });
|
|
await expect(generationCard).toHaveCount(0, { timeout: 30_000 });
|
|
|
|
// After cancellation, wait for the chapter count to stabilize. In-flight TTS
|
|
// requests may still complete after we click cancel, so we poll until the
|
|
// count stops changing for a brief period.
|
|
const { count: chapterCountAfterCancel, json: jsonAfterCancel } = await waitForStableChapterCount(
|
|
page,
|
|
bookId,
|
|
{ stableMs: 2000, timeoutMs: 30000 }
|
|
);
|
|
expect(jsonAfterCancel.exists).toBe(true);
|
|
expect(Array.isArray(jsonAfterCancel.chapters)).toBe(true);
|
|
expect(chapterCountAfterCancel).toBeGreaterThanOrEqual(chapterCountBeforeCancel);
|
|
|
|
// UI refresh can lag behind backend stabilization after cancellation; require at
|
|
// least the pre-cancel chapter count instead of exact backend parity.
|
|
await expect
|
|
.poll(async () => chapterActionsButtons.count(), { timeout: 60_000 })
|
|
.toBeGreaterThanOrEqual(chapterCountBeforeCancel);
|
|
|
|
// The Full Download button should still be available for the partially generated audiobook
|
|
await withDownloadedFullAudiobook(page, async ({ filePath }) => {
|
|
const durationSeconds = await getAudioDurationSeconds(filePath);
|
|
expect(durationSeconds).toBeGreaterThan(25);
|
|
expect(durationSeconds).toBeLessThan(300);
|
|
});
|
|
|
|
// Backend should still reflect the same number of chapters as when we first
|
|
// observed the stabilized post-cancellation state.
|
|
const json = await expectChaptersBackendState(page, bookId);
|
|
expect(json.exists).toBe(true);
|
|
expect(Array.isArray(json.chapters)).toBe(true);
|
|
expect(json.chapters.length).toBe(chapterCountAfterCancel);
|
|
|
|
await resetAudiobookIfPresent(page);
|
|
});
|
|
|
|
test('exports a single MP3 audiobook PDF page via chapters menu', async ({ page }, testInfo) => {
|
|
await setupTest(page, testInfo);
|
|
await uploadAndDisplay(page, 'sample.pdf');
|
|
|
|
const bookId = await getBookIdFromUrl(page, 'pdf');
|
|
await resetAudiobookById(page, bookId);
|
|
|
|
await openExportModal(page);
|
|
await setContainerFormatToMP3(page);
|
|
await startGeneration(page);
|
|
|
|
await waitForChaptersHeading(page);
|
|
|
|
// Wait for at least one chapter row to appear (one "Chapter actions" button)
|
|
const chapterActionsButtons = page.getByRole('button', { name: 'Chapter actions' });
|
|
await expect(chapterActionsButtons.first()).toBeVisible({ timeout: 90_000 });
|
|
|
|
// Download via frontend button
|
|
await withDownloadedFullAudiobook(page, async ({ filePath }) => {
|
|
const durationSeconds = await getAudioDurationSeconds(filePath);
|
|
// For EPUB we just assert a sane non-trivial duration; at least one 10s mocked chapter.
|
|
expect(durationSeconds).toBeGreaterThan(9);
|
|
expect(durationSeconds).toBeLessThan(300);
|
|
});
|
|
|
|
await resetAudiobookIfPresent(page);
|
|
});
|
|
|
|
test('resets all MP3 audiobook PDF pages', async ({ page }, testInfo) => {
|
|
await setupTest(page, testInfo);
|
|
await uploadAndDisplay(page, 'sample.pdf');
|
|
|
|
const bookId = await getBookIdFromUrl(page, 'pdf');
|
|
await resetAudiobookById(page, bookId);
|
|
|
|
await openExportModal(page);
|
|
await setContainerFormatToMP3(page);
|
|
await startGeneration(page);
|
|
|
|
await waitForChaptersHeading(page);
|
|
|
|
// Wait for Reset button to become visible, indicating resumable/generated state
|
|
const resetButton = page.getByRole('button', { name: 'Reset' });
|
|
await expect(resetButton).toBeVisible({ timeout: 120_000 });
|
|
|
|
await resetButton.click();
|
|
|
|
// Confirm in the Reset Audiobook dialog
|
|
await expect(page.getByRole('heading', { name: 'Reset Audiobook' })).toBeVisible({ timeout: 15000 });
|
|
const confirmReset = page.getByRole('button', { name: 'Reset' }).last();
|
|
await confirmReset.click();
|
|
|
|
// After reset, generation should be startable again
|
|
await expect(page.getByRole('button', { name: 'Start Generation' })).toBeVisible({ timeout: 60_000 });
|
|
|
|
// Backend should report no existing chapters for this bookId
|
|
const res = await page.request.get(`/api/audiobook/status?bookId=${bookId}`);
|
|
expect(res.ok()).toBeTruthy();
|
|
const json = await res.json();
|
|
expect(json.exists).toBe(false);
|
|
expect(Array.isArray(json.chapters)).toBe(true);
|
|
expect(json.chapters.length).toBe(0);
|
|
});
|
|
|
|
test('regenerates a single MP3 audiobook PDF page and exports full audiobook', async ({ page }, testInfo) => {
|
|
test.setTimeout(60_000);
|
|
await setupTest(page, testInfo);
|
|
await uploadAndDisplay(page, 'sample.pdf');
|
|
|
|
// Extract bookId from /pdf/[id] URL (for backend verification later)
|
|
const bookId = await getBookIdFromUrl(page, 'pdf');
|
|
await resetAudiobookById(page, bookId);
|
|
|
|
// Open Export Audiobook modal
|
|
await openExportModal(page);
|
|
|
|
// Set container format to MP3
|
|
await setContainerFormatToMP3(page);
|
|
|
|
// Start generation
|
|
await startGeneration(page);
|
|
|
|
// Wait for chapters to appear
|
|
await waitForChaptersHeading(page);
|
|
|
|
const chapterActionsButtons = page.getByRole('button', { name: 'Chapter actions' });
|
|
// Ensure we have at least two chapters for this PDF
|
|
await expect(chapterActionsButtons.nth(1)).toBeVisible({ timeout: 60_000 });
|
|
const chapterCountBefore = await chapterActionsButtons.count();
|
|
expect(chapterCountBefore).toBeGreaterThanOrEqual(2);
|
|
|
|
// Open the actions menu for the first chapter and trigger Regenerate
|
|
const firstChapterActions = chapterActionsButtons.first();
|
|
await firstChapterActions.click();
|
|
|
|
// In the headlessui Menu, each option is a menuitem. Use that role instead of button.
|
|
const regenerateMenuItem = page.getByRole('menuitem', { name: /Regenerate/i });
|
|
await expect(regenerateMenuItem).toBeVisible({ timeout: 15000 });
|
|
await regenerateMenuItem.click();
|
|
|
|
// During regeneration, the row may show a "Regenerating" label; wait for any such
|
|
// indicator to disappear, signaling completion.
|
|
const regeneratingLabel = page.getByText(/Regenerating/);
|
|
await expect(regeneratingLabel).toHaveCount(0, { timeout: 120_000 });
|
|
|
|
// After regeneration completes in the UI, verify backend chapter state is fully updated
|
|
// before triggering a full download to avoid races with ffmpeg concat on Alpine.
|
|
const backendStateAfterRegenerate = await expectChaptersBackendState(page, bookId);
|
|
expect(backendStateAfterRegenerate.exists).toBe(true);
|
|
expect(Array.isArray(backendStateAfterRegenerate.chapters)).toBe(true);
|
|
expect(backendStateAfterRegenerate.chapters.length).toBe(chapterCountBefore);
|
|
for (const ch of backendStateAfterRegenerate.chapters) {
|
|
expect(ch.duration).toBeGreaterThan(0);
|
|
}
|
|
|
|
// Chapter count should remain exactly the same after regeneration (no duplicates)
|
|
await expect(chapterActionsButtons).toHaveCount(chapterCountBefore, { timeout: 20_000 });
|
|
|
|
// Full Download should still work and produce a valid combined audiobook
|
|
await withDownloadedFullAudiobook(page, async ({ filePath }) => {
|
|
const durationSeconds = await getAudioDurationSeconds(filePath);
|
|
// With two mocked 10s chapters we expect roughly 20s; allow a small window.
|
|
expect(durationSeconds).toBeGreaterThan(18);
|
|
expect(durationSeconds).toBeLessThan(22);
|
|
});
|
|
|
|
// Backend should still report the same number of chapters and valid durations
|
|
const json = await expectChaptersBackendState(page, bookId);
|
|
expect(json.exists).toBe(true);
|
|
expect(Array.isArray(json.chapters)).toBe(true);
|
|
expect(json.chapters.length).toBe(chapterCountBefore);
|
|
for (const ch of json.chapters) {
|
|
expect(ch.duration).toBeGreaterThan(0);
|
|
}
|
|
|
|
await resetAudiobookIfPresent(page);
|
|
});
|
|
|
|
test('resumes audiobook when a chapter is missing and full download succeeds (PDF)', async ({ page }, testInfo) => {
|
|
await setupTest(page, testInfo);
|
|
await uploadAndDisplay(page, 'sample.pdf');
|
|
|
|
const bookId = await getBookIdFromUrl(page, 'pdf');
|
|
await resetAudiobookById(page, bookId);
|
|
|
|
await openExportModal(page);
|
|
await setContainerFormatToMP3(page);
|
|
await startGeneration(page);
|
|
|
|
await waitForChaptersHeading(page);
|
|
const chapterActionsButtons = page.getByRole('button', { name: 'Chapter actions' });
|
|
await expect(chapterActionsButtons).toHaveCount(2, { timeout: 60_000 });
|
|
|
|
// Delete the first chapter via the backend API so the audiobook has a missing index (0).
|
|
// This is more reliable than clicking through the chapter actions menu in headless runs.
|
|
const deleteRes = await page.request.delete(`/api/audiobook/chapter?bookId=${bookId}&chapterIndex=0`);
|
|
expect(deleteRes.ok()).toBeTruthy();
|
|
|
|
// Wait for backend to reflect only one remaining chapter (index 1).
|
|
await expect
|
|
.poll(async () => {
|
|
const json = await expectChaptersBackendState(page, bookId);
|
|
return json.chapters?.length ?? 0;
|
|
}, { timeout: 30_000 })
|
|
.toBe(1);
|
|
|
|
const jsonAfterDelete = await expectChaptersBackendState(page, bookId);
|
|
expect(jsonAfterDelete.exists).toBe(true);
|
|
expect(Array.isArray(jsonAfterDelete.chapters)).toBe(true);
|
|
expect(jsonAfterDelete.chapters.length).toBe(1);
|
|
expect(jsonAfterDelete.chapters[0]?.index).toBe(1);
|
|
|
|
// Close and reopen the modal to ensure "resume" loads the missing placeholder from the backend.
|
|
await page.getByRole('button', { name: 'Close' }).click();
|
|
await expect(page.getByRole('heading', { name: 'Export Audiobook' })).toHaveCount(0);
|
|
await openExportModal(page);
|
|
|
|
await waitForChaptersHeading(page);
|
|
await expect(page.getByText(/Missing •/)).toHaveCount(1, { timeout: 15_000 });
|
|
await expect(page.getByRole('button', { name: 'Resume' })).toBeVisible({ timeout: 15_000 });
|
|
|
|
// Resume should regenerate the missing chapter and allow a full download to succeed.
|
|
await page.getByRole('button', { name: 'Resume' }).click();
|
|
|
|
// Wait for backend to have both chapters again.
|
|
await expect
|
|
.poll(async () => {
|
|
const json = await expectChaptersBackendState(page, bookId);
|
|
return json.chapters?.length ?? 0;
|
|
}, { timeout: 120_000 })
|
|
.toBe(2);
|
|
|
|
// UI should also stop showing a missing placeholder after resume completes.
|
|
await expect(page.getByText(/Missing •/)).toHaveCount(0, { timeout: 120_000 });
|
|
|
|
await withDownloadedFullAudiobook(page, async ({ filePath }) => {
|
|
const durationSeconds = await getAudioDurationSeconds(filePath);
|
|
expect(durationSeconds).toBeGreaterThan(18);
|
|
expect(durationSeconds).toBeLessThan(22);
|
|
});
|
|
|
|
const jsonAfterResume = await expectChaptersBackendState(page, bookId);
|
|
expect(jsonAfterResume.exists).toBe(true);
|
|
expect(Array.isArray(jsonAfterResume.chapters)).toBe(true);
|
|
expect(jsonAfterResume.chapters.length).toBe(2);
|
|
expect(jsonAfterResume.chapters.map((c: { index: number }) => c.index).sort()).toEqual([0, 1]);
|
|
for (const ch of jsonAfterResume.chapters) {
|
|
expect(ch.duration).toBeGreaterThan(0);
|
|
}
|
|
|
|
await resetAudiobookIfPresent(page);
|
|
});
|