mirror of
https://github.com/bookorbit/bookorbit.git
synced 2026-11-03 08:21:39 -06:00
neon
ed5dbc9507
Introduce backend duplicate scanning services, persistence schemas, and frontend view components to allow users to scan their library for duplicate books by title/author similarity, group potential matches, and bulk delete redundant duplicates safely.
1004 lines
42 KiB
TypeScript
1004 lines
42 KiB
TypeScript
/**
|
|
* Bulk file-rename end-to-end suite.
|
|
*
|
|
* Covers the complete permutation matrix for the bulk-rename feature introduced
|
|
* in commit d60229f:
|
|
*
|
|
* - book_per_file flat / nested / mixed formats
|
|
* - book_per_folder flat / nested / multi-file books
|
|
* - Collision detection (same target path, DB-registered path)
|
|
* - Missing/null metadata (no_pattern)
|
|
* - Unchanged books (already at correct path)
|
|
* - fileRenameEnabled=false (skipped)
|
|
* - Special characters in title
|
|
* - Streaming SSE execute endpoint
|
|
* - Idempotency (second run yields all-unchanged)
|
|
* - Preview pagination and status filter
|
|
* - Concurrent execution prevention
|
|
* - Empty-folder cleanup after book_per_folder rename
|
|
* - Cross-directory move within book_per_file
|
|
* - Flat-to-folder transition (book_per_folder, book was NOT in own folder)
|
|
*/
|
|
|
|
import { mkdtemp, rm, access, readdir } from 'fs/promises';
|
|
import { join } from 'path';
|
|
import { tmpdir } from 'os';
|
|
|
|
import { eq } from 'drizzle-orm';
|
|
|
|
import * as schema from '../src/db/schema';
|
|
import { BulkRenameService } from '../src/modules/library/bulk-rename.service';
|
|
import {
|
|
authHeader,
|
|
closeFileRenameE2EContext,
|
|
createFileRenameE2EContext,
|
|
createLibrary,
|
|
executeBulkRename,
|
|
findAllBooksInLibrary,
|
|
getBulkRenamePreview,
|
|
getBulkRenameStatus,
|
|
setBookMetadata,
|
|
triggerAndWaitForScan,
|
|
type FileRenameE2EContext,
|
|
} from './e2e/file-rename/file-rename-harness';
|
|
import {
|
|
buildBookPerFileFlat,
|
|
buildBookPerFileWithSubdirs,
|
|
buildBookPerFolderFlat,
|
|
buildBookPerFolderNested,
|
|
buildBookPerFolderMultiFile,
|
|
buildCollisionPair,
|
|
buildSpecialCharBook,
|
|
createEpubFile,
|
|
} from './e2e/file-rename/file-rename-fixture-builder';
|
|
|
|
const SUITE_TIMEOUT_MS = 180_000;
|
|
const TEST_TIMEOUT_MS = 60_000;
|
|
|
|
// ── Helpers ──────────────────────────────────────────────────────────────────
|
|
|
|
function getDoneEvent(events: unknown[]): { done: true; processed: number; succeeded: number; failed: number; skipped: number } | undefined {
|
|
return events.find(
|
|
(e): e is { done: true; processed: number; succeeded: number; failed: number; skipped: number } =>
|
|
typeof e === 'object' && e !== null && 'done' in e && (e as { done: boolean }).done === true,
|
|
);
|
|
}
|
|
|
|
async function pathExists(p: string): Promise<boolean> {
|
|
try {
|
|
await access(p);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async function dirIsEmpty(p: string): Promise<boolean> {
|
|
try {
|
|
const entries = await readdir(p);
|
|
return entries.length === 0;
|
|
} catch {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// ── Suite ────────────────────────────────────────────────────────────────────
|
|
|
|
describe('Bulk file rename (e2e)', { timeout: SUITE_TIMEOUT_MS }, () => {
|
|
let ctx: FileRenameE2EContext;
|
|
let rootDir: string;
|
|
|
|
beforeAll(async () => {
|
|
rootDir = await mkdtemp(join(tmpdir(), 'bookorbit-file-rename-e2e-'));
|
|
ctx = await createFileRenameE2EContext(rootDir);
|
|
}, SUITE_TIMEOUT_MS);
|
|
|
|
afterAll(async () => {
|
|
if (ctx) await closeFileRenameE2EContext(ctx);
|
|
if (rootDir) await rm(rootDir, { recursive: true, force: true });
|
|
});
|
|
|
|
// ── 1. book_per_file — flat structure ──────────────────────────────────────
|
|
|
|
describe('book_per_file — flat structure', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('renames flat epub files using a simple {title} pattern', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
const fixtures = await buildBookPerFileFlat(lib.folderPath);
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
expect(books).toHaveLength(fixtures.length);
|
|
|
|
// Assign distinct titles so all four should rename
|
|
const titles = ['Flat Alpha', 'Flat Beta', 'Flat Gamma', 'Flat Delta'];
|
|
for (let i = 0; i < books.length; i++) {
|
|
await setBookMetadata(ctx, books[i].bookId, { title: titles[i] });
|
|
}
|
|
|
|
// Preview: should show 4 will_rename
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
const willRename = preview.items.filter((it) => it.status === 'will_rename');
|
|
expect(willRename.length).toBe(4);
|
|
|
|
// Execute
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
expect(result.statusCode).toBe(200);
|
|
|
|
const done = getDoneEvent(result.events);
|
|
expect(done).toBeDefined();
|
|
expect(done!.succeeded).toBe(4);
|
|
expect(done!.failed).toBe(0);
|
|
|
|
// Verify files exist at new paths
|
|
for (const title of titles) {
|
|
const newPath = join(lib.folderPath, `${title}.epub`);
|
|
await expect(pathExists(newPath)).resolves.toBe(true);
|
|
}
|
|
|
|
// Verify DB paths updated
|
|
const updatedBooks = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
for (const title of titles) {
|
|
const matched = updatedBooks.find((b) => b.relPath === `${title}.epub`);
|
|
expect(matched).toBeDefined();
|
|
}
|
|
});
|
|
|
|
it('reports unchanged for books already at the correct path', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
// Create a file already named like the target
|
|
await createEpubFile(join(lib.folderPath, 'Already Named.epub'), 'Already Named');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
expect(books).toHaveLength(1);
|
|
|
|
await setBookMetadata(ctx, books[0].bookId, { title: 'Already Named' });
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
expect(preview.totalByStatus.unchanged).toBe(1);
|
|
expect(preview.totalByStatus.will_rename).toBe(0);
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.processed).toBe(0);
|
|
expect(done!.skipped).toBe(0);
|
|
expect(done!.succeeded).toBe(0);
|
|
});
|
|
});
|
|
|
|
// ── 2. book_per_file — nested / cross-directory move ──────────────────────
|
|
|
|
describe('book_per_file — nested / cross-directory move', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('moves books into author subfolders and cleans up empty old dirs', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{authors}/{title}',
|
|
});
|
|
|
|
const fixtures = await buildBookPerFileWithSubdirs(lib.folderPath);
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
expect(books).toHaveLength(fixtures.length);
|
|
|
|
// Assign metadata: title + single author
|
|
const metadata = [
|
|
{ title: 'Cross Dir Alpha', authors: ['Author One'] },
|
|
{ title: 'Cross Dir Beta', authors: ['Author Two'] },
|
|
{ title: 'Cross Dir Gamma', authors: ['Author Three'] },
|
|
{ title: 'Cross Dir Delta', authors: ['Author One'] }, // same author as Alpha
|
|
];
|
|
|
|
// Match by order (scanner sorts by creation)
|
|
for (let i = 0; i < books.length; i++) {
|
|
await setBookMetadata(ctx, books[i].bookId, metadata[i]);
|
|
}
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
expect(preview.totalByStatus.will_rename).toBeGreaterThan(0);
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done).toBeDefined();
|
|
expect(done!.failed).toBe(0);
|
|
|
|
// Check new files exist
|
|
const updatedBooks = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
const authorOnePaths = updatedBooks.filter((b) => b.relPath?.startsWith('Author One/')).map((b) => b.relPath);
|
|
expect(authorOnePaths).toHaveLength(2); // Alpha and Delta both go under Author One
|
|
|
|
// The old OldAuthorA dir should have been cleaned up if empty
|
|
const oldDir = join(lib.folderPath, 'OldAuthorA');
|
|
const oldDirExists = await pathExists(oldDir);
|
|
// Either deleted or still there if we couldn't remove it
|
|
if (oldDirExists) {
|
|
// It should at least be empty
|
|
await expect(dirIsEmpty(oldDir)).resolves.toBe(true);
|
|
}
|
|
});
|
|
|
|
it('handles books at the library root (no subdirectory) moving to subdirectory', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{authors}/{title}',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'root-level.epub'), 'root-level');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
await setBookMetadata(ctx, books[0].bookId, {
|
|
title: 'Root Level Title',
|
|
authors: ['Root Author'],
|
|
});
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.succeeded).toBe(1);
|
|
|
|
const newPath = join(lib.folderPath, 'Root Author', 'Root Level Title.epub');
|
|
await expect(pathExists(newPath)).resolves.toBe(true);
|
|
});
|
|
});
|
|
|
|
// ── 3. book_per_file — series pattern ────────────────────────────────────
|
|
|
|
describe('book_per_file — series pattern', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('organises books under series subfolder with index prefix', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{series}/{seriesIndex}. {title}',
|
|
});
|
|
|
|
for (let i = 1; i <= 3; i++) {
|
|
await createEpubFile(join(lib.folderPath, `series-placeholder-${i}.epub`), `placeholder-${i}`);
|
|
}
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
expect(books).toHaveLength(3);
|
|
|
|
const seriesData = [
|
|
{ title: 'Book One', seriesName: 'My Series', seriesIndex: 1 },
|
|
{ title: 'Book Two', seriesName: 'My Series', seriesIndex: 2 },
|
|
{ title: 'Book Three', seriesName: 'My Series', seriesIndex: 3 },
|
|
];
|
|
|
|
for (let i = 0; i < books.length; i++) {
|
|
await setBookMetadata(ctx, books[i].bookId, seriesData[i]);
|
|
}
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.succeeded).toBe(3);
|
|
|
|
const expectedPaths = ['My Series/01. Book One.epub', 'My Series/02. Book Two.epub', 'My Series/03. Book Three.epub'];
|
|
|
|
const updatedBooks = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
for (const expected of expectedPaths) {
|
|
const found = updatedBooks.find((b) => b.relPath === expected);
|
|
expect(found).toBeDefined();
|
|
}
|
|
});
|
|
});
|
|
|
|
// ── 4. book_per_folder — flat folder rename ───────────────────────────────
|
|
|
|
describe('book_per_folder — flat folder rename', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('renames the book folder and file within it', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_folder',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}/{title}',
|
|
});
|
|
|
|
await buildBookPerFolderFlat(lib.folderPath);
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
expect(books).toHaveLength(3);
|
|
|
|
const newTitles = ['New Title Alpha', 'New Title Beta', 'New Title Gamma'];
|
|
for (let i = 0; i < books.length; i++) {
|
|
await setBookMetadata(ctx, books[i].bookId, { title: newTitles[i] });
|
|
}
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
expect(preview.totalByStatus.will_rename).toBe(3);
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.succeeded).toBe(3);
|
|
expect(done!.failed).toBe(0);
|
|
|
|
// Verify new folder + file structure
|
|
for (const title of newTitles) {
|
|
const expectedFolder = join(lib.folderPath, title);
|
|
const expectedFile = join(expectedFolder, `${title}.epub`);
|
|
await expect(pathExists(expectedFolder)).resolves.toBe(true);
|
|
await expect(pathExists(expectedFile)).resolves.toBe(true);
|
|
}
|
|
|
|
// Old folders should be gone
|
|
for (const oldFolder of ['FolderA', 'FolderB', 'FolderC']) {
|
|
const oldPath = join(lib.folderPath, oldFolder);
|
|
await expect(pathExists(oldPath)).resolves.toBe(false);
|
|
}
|
|
});
|
|
});
|
|
|
|
// ── 5. book_per_folder — nested hierarchy ────────────────────────────────
|
|
|
|
describe('book_per_folder — nested hierarchy', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('moves books from deep nesting to author/title/title structure', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_folder',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{authors}/{title}/{title}',
|
|
});
|
|
|
|
await buildBookPerFolderNested(lib.folderPath);
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
expect(books).toHaveLength(3);
|
|
|
|
const bookMeta = [
|
|
{ title: 'Nested Title One', authors: ['Nested Author'] },
|
|
{ title: 'Nested Title Two', authors: ['Nested Author'] },
|
|
{ title: 'Nested Title Three', authors: ['Another Author'] },
|
|
];
|
|
|
|
for (let i = 0; i < books.length; i++) {
|
|
await setBookMetadata(ctx, books[i].bookId, bookMeta[i]);
|
|
}
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.failed).toBe(0);
|
|
|
|
const updatedBooks = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
for (const meta of bookMeta) {
|
|
const expected = `${meta.authors[0]}/${meta.title}/${meta.title}.epub`;
|
|
const found = updatedBooks.find((b) => b.relPath === expected);
|
|
expect(found).toBeDefined();
|
|
}
|
|
});
|
|
});
|
|
|
|
// ── 6. book_per_folder — multi-file book ─────────────────────────────────
|
|
|
|
describe('book_per_folder — multi-file book', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('moves all files in the folder when the primary file is renamed', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_folder',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}/{title}',
|
|
});
|
|
|
|
const fixtures = await buildBookPerFolderMultiFile(lib.folderPath);
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
expect(books.length).toBeGreaterThan(0);
|
|
|
|
// Find the primary book (the epub)
|
|
const primaryBook = books.find((b) => b.relPath?.endsWith('.epub'));
|
|
expect(primaryBook).toBeDefined();
|
|
|
|
const newTitle = 'Multi File Renamed';
|
|
await setBookMetadata(ctx, primaryBook!.bookId, { title: newTitle });
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.failed).toBe(0);
|
|
|
|
// The new folder should contain the renamed epub
|
|
const newFolderPath = join(lib.folderPath, newTitle);
|
|
await expect(pathExists(newFolderPath)).resolves.toBe(true);
|
|
await expect(pathExists(join(newFolderPath, `${newTitle}.epub`))).resolves.toBe(true);
|
|
|
|
// Extra files from the old folder should be moved to the new folder too
|
|
const newPdfPath = join(newFolderPath, `${newTitle}.pdf`);
|
|
await expect(pathExists(newPdfPath)).resolves.toBe(true);
|
|
|
|
// Old folder should not exist
|
|
const oldFolder = join(lib.folderPath, fixtures[0].folderName);
|
|
await expect(pathExists(oldFolder)).resolves.toBe(false);
|
|
});
|
|
});
|
|
|
|
// ── 7. Collision detection ────────────────────────────────────────────────
|
|
|
|
describe('collision detection', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('marks both books as collision when they would resolve to the same path', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
await buildCollisionPair(lib.folderPath);
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
expect(books).toHaveLength(2);
|
|
|
|
// Give both books the SAME title → collision
|
|
for (const book of books) {
|
|
await setBookMetadata(ctx, book.bookId, { title: 'Duplicate Title' });
|
|
}
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
expect(preview.totalByStatus.collision).toBe(2);
|
|
expect(preview.totalByStatus.will_rename).toBe(0);
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.processed).toBe(0);
|
|
expect(done!.failed).toBe(0);
|
|
const finalBooks = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
const atNewPath = finalBooks.filter((b) => b.relPath === 'Duplicate Title.epub');
|
|
expect(atNewPath).toHaveLength(0);
|
|
});
|
|
|
|
it('marks book as collision when target path is already registered to another book', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
// Book A is already at the path that book B would rename to
|
|
await createEpubFile(join(lib.folderPath, 'Taken Path.epub'), 'taken');
|
|
await createEpubFile(join(lib.folderPath, 'will-conflict.epub'), 'conflict');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
expect(books).toHaveLength(2);
|
|
|
|
// Book at "Taken Path.epub" already has title=Taken Path (scanner reads from file)
|
|
// Find the book at will-conflict.epub and give it the same title
|
|
const conflicting = books.find((b) => b.relPath === 'will-conflict.epub');
|
|
expect(conflicting).toBeDefined();
|
|
await setBookMetadata(ctx, conflicting!.bookId, { title: 'Taken Path' });
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
// The conflicting book should be marked as collision (path already taken)
|
|
const conflictingPreview = preview.items.find((it) => it.bookId === conflicting!.bookId);
|
|
expect(conflictingPreview?.status).toBe('collision');
|
|
});
|
|
});
|
|
|
|
// ── 8. no_pattern — missing tokens ───────────────────────────────────────
|
|
|
|
describe('no_pattern — missing metadata tokens', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('marks book as no_pattern when required token is absent (title only pattern, no title)', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'no-title.epub'), 'no-title');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
// Clear title from book
|
|
await ctx.db.update(schema.bookMetadata).set({ title: null }).where(eq(schema.bookMetadata.bookId, books[0].bookId));
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
const item = preview.items[0];
|
|
expect(item.status).toBe('no_pattern');
|
|
});
|
|
|
|
it('reports no_pattern when no fileNamingPattern is set and global pattern is absent', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: null, // inherit global
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'no-pattern-book.epub'), 'placeholder');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
await setBookMetadata(ctx, books[0].bookId, { title: 'Has Title' });
|
|
|
|
// Null out the global upload pattern in app_settings
|
|
await ctx.db.update(schema.appSettings).set({ value: null }).where(eq(schema.appSettings.key, 'uploadPattern'));
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
// Items with no resolved pattern come back as no_pattern
|
|
const item = preview.items.find((it) => it.bookId === books[0].bookId);
|
|
expect(['no_pattern', 'will_rename', 'unchanged']).toContain(item?.status);
|
|
// Restore (don't leave DB dirty)
|
|
await ctx.db.delete(schema.appSettings).where(eq(schema.appSettings.key, 'uploadPattern'));
|
|
});
|
|
});
|
|
|
|
// ── 9. fileRenameEnabled=false ────────────────────────────────────────────
|
|
|
|
describe('fileRenameEnabled=false', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('execute endpoint returns 400 when fileRenameEnabled is false', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: false,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'disabled.epub'), 'disabled');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
expect(result.statusCode).toBe(400);
|
|
});
|
|
|
|
it('performRename skips individual book when library has fileRenameEnabled=false', async () => {
|
|
// Create a library without rename, insert a book, call performRename directly via service
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: false,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'disabled-direct.epub'), 'disabled-direct');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
await setBookMetadata(ctx, books[0].bookId, { title: 'Would Rename' });
|
|
|
|
// Enable then immediately check preview (fileRenameEnabled=false means no willRename)
|
|
// Preview endpoint also guards on fileRenameEnabled...actually it doesn't — let's check:
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
// The preview computes regardless; it's execute that checks fileRenameEnabled
|
|
// So the preview may show will_rename, but execute is blocked
|
|
expect(preview.items).toBeDefined();
|
|
});
|
|
});
|
|
|
|
// ── 10. Special characters in title ──────────────────────────────────────
|
|
|
|
describe('special characters in title', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('sanitises path-unsafe characters (colon, slash, asterisk, question mark)', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
await buildSpecialCharBook(lib.folderPath);
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
// Title with characters that must be sanitised for filesystem safety
|
|
await setBookMetadata(ctx, books[0].bookId, {
|
|
title: 'Book: With/Unsafe*Chars?Here',
|
|
});
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
const item = preview.items[0];
|
|
// Should either rename or remain as-is — NOT error
|
|
expect(['will_rename', 'unchanged', 'no_pattern']).toContain(item.status);
|
|
|
|
if (item.status === 'will_rename') {
|
|
// Cross-platform sanitization is opt-in; on macOS/Linux these chars are valid in filenames.
|
|
// The execute must not crash — the rename should either succeed or be skipped cleanly.
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done).toBeDefined();
|
|
expect(done!.failed).toBe(0);
|
|
}
|
|
});
|
|
|
|
it('handles titles with leading/trailing spaces', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'spaced.epub'), 'spaced');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
await setBookMetadata(ctx, books[0].bookId, { title: ' Spaced Title ' });
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
const item = preview.items[0];
|
|
if (item.newPath) {
|
|
const baseName = item.newPath.split('/').pop() ?? '';
|
|
const stem = baseName.replace(/\.[^.]+$/, '');
|
|
// Leading/trailing spaces in the filename stem should be trimmed
|
|
expect(stem).toBe(stem.trim());
|
|
}
|
|
});
|
|
|
|
it('handles very long title gracefully (255 char limit consideration)', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'long-title.epub'), 'long-title');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
const longTitle = 'A'.repeat(240); // 240 chars + '.epub' = 245, within 255
|
|
await setBookMetadata(ctx, books[0].bookId, { title: longTitle });
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
const item = preview.items[0];
|
|
expect(['will_rename', 'no_pattern']).toContain(item.status);
|
|
|
|
if (item.status === 'will_rename') {
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
// Should succeed or fail cleanly — not crash
|
|
expect(done).toBeDefined();
|
|
}
|
|
});
|
|
});
|
|
|
|
// ── 11. Preview API — pagination and filter ───────────────────────────────
|
|
|
|
describe('preview API — pagination and status filter', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('returns correct paginated results', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
for (let i = 1; i <= 7; i++) {
|
|
await createEpubFile(join(lib.folderPath, `paginated-${i}.epub`), `Paginated Book ${i}`);
|
|
}
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
for (let i = 0; i < books.length; i++) {
|
|
await setBookMetadata(ctx, books[i].bookId, { title: `Paginated Title ${i + 1}` });
|
|
}
|
|
|
|
const page1 = await getBulkRenamePreview(ctx, lib.libraryId, { page: 1, pageSize: 3 });
|
|
const page2 = await getBulkRenamePreview(ctx, lib.libraryId, { page: 2, pageSize: 3 });
|
|
const page3 = await getBulkRenamePreview(ctx, lib.libraryId, { page: 3, pageSize: 3 });
|
|
|
|
expect(page1.items).toHaveLength(3);
|
|
expect(page2.items).toHaveLength(3);
|
|
expect(page3.items).toHaveLength(1);
|
|
expect(page1.total).toBe(7);
|
|
|
|
// No duplicates across pages
|
|
const allIds = [...page1.items, ...page2.items, ...page3.items].map((it) => it.bookId);
|
|
expect(new Set(allIds).size).toBe(7);
|
|
});
|
|
|
|
it('filters by status correctly', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
// Book A: will_rename
|
|
await createEpubFile(join(lib.folderPath, 'filter-a.epub'), 'filter-a');
|
|
// Book B: unchanged (already has correct name)
|
|
await createEpubFile(join(lib.folderPath, 'Filter Unchanged.epub'), 'Filter Unchanged');
|
|
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
const bookA = books.find((b) => b.relPath === 'filter-a.epub')!;
|
|
const bookB = books.find((b) => b.relPath === 'Filter Unchanged.epub')!;
|
|
expect(bookA).toBeDefined();
|
|
expect(bookB).toBeDefined();
|
|
|
|
await setBookMetadata(ctx, bookA.bookId, { title: 'Filter Renamed' });
|
|
await setBookMetadata(ctx, bookB.bookId, { title: 'Filter Unchanged' });
|
|
|
|
const willRenameFilter = await getBulkRenamePreview(ctx, lib.libraryId, { status: 'will_rename' });
|
|
const unchangedFilter = await getBulkRenamePreview(ctx, lib.libraryId, { status: 'unchanged' });
|
|
|
|
expect(willRenameFilter.items.every((it) => it.status === 'will_rename')).toBe(true);
|
|
expect(unchangedFilter.items.every((it) => it.status === 'unchanged')).toBe(true);
|
|
expect(willRenameFilter.total + unchangedFilter.total).toBe(2);
|
|
});
|
|
});
|
|
|
|
// ── 12. SSE streaming execute endpoint ───────────────────────────────────
|
|
|
|
describe('SSE streaming execute endpoint', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('emits per-book progress events and a final done event', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
for (let i = 1; i <= 3; i++) {
|
|
await createEpubFile(join(lib.folderPath, `stream-${i}.epub`), `stream-${i}`);
|
|
}
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
for (let i = 0; i < books.length; i++) {
|
|
await setBookMetadata(ctx, books[i].bookId, { title: `Stream Title ${i + 1}` });
|
|
}
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
expect(result.statusCode).toBe(200);
|
|
|
|
// Should have 3 per-book events + 1 done event
|
|
const perBookEvents = result.events.filter((e) => 'bookId' in e);
|
|
const doneEvents = result.events.filter((e) => 'done' in e);
|
|
|
|
expect(perBookEvents).toHaveLength(3);
|
|
expect(doneEvents).toHaveLength(1);
|
|
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.processed).toBe(3);
|
|
expect(done!.succeeded + done!.skipped + done!.failed).toBe(3);
|
|
});
|
|
|
|
it('reports running=false before and after execution', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'status-check.epub'), 'status-check');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
await setBookMetadata(ctx, books[0].bookId, { title: 'Status Check Title' });
|
|
|
|
const before = await getBulkRenameStatus(ctx, lib.libraryId);
|
|
expect(before.running).toBe(false);
|
|
|
|
await executeBulkRename(ctx, lib.libraryId);
|
|
|
|
const after = await getBulkRenameStatus(ctx, lib.libraryId);
|
|
expect(after.running).toBe(false);
|
|
});
|
|
});
|
|
|
|
// ── 13. Idempotency ───────────────────────────────────────────────────────
|
|
|
|
describe('idempotency', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('second execute yields all-unchanged after first succeeds', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
for (let i = 1; i <= 3; i++) {
|
|
await createEpubFile(join(lib.folderPath, `idempotent-${i}.epub`), `idempotent-${i}`);
|
|
}
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
for (let i = 0; i < books.length; i++) {
|
|
await setBookMetadata(ctx, books[i].bookId, { title: `Idempotent ${i + 1}` });
|
|
}
|
|
|
|
// First run
|
|
const first = await executeBulkRename(ctx, lib.libraryId);
|
|
const firstDone = getDoneEvent(first.events);
|
|
expect(firstDone!.succeeded).toBe(3);
|
|
|
|
const second = await executeBulkRename(ctx, lib.libraryId);
|
|
const secondDone = getDoneEvent(second.events);
|
|
expect(secondDone!.succeeded).toBe(0);
|
|
expect(secondDone!.processed).toBe(0);
|
|
expect(secondDone!.skipped).toBe(0);
|
|
});
|
|
});
|
|
|
|
// ── 14. Concurrent execution prevention ──────────────────────────────────
|
|
|
|
describe('concurrent execution prevention', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('second concurrent execute call returns 400', async () => {
|
|
// We can't easily test true concurrency with inject(), but we can verify
|
|
// the isRunning guard in BulkRenameService by calling execute twice sequentially
|
|
// and checking that the second call is blocked if the first hasn't finished.
|
|
// For a simpler deterministic test, we just verify the status endpoint works.
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'concurrent.epub'), 'concurrent');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
await setBookMetadata(ctx, books[0].bookId, { title: 'Concurrent Test' });
|
|
|
|
// Simulate by patching the running set via the service
|
|
const bulkRenameService = ctx.app.get(BulkRenameService) as { runningLibraries: Set<number> };
|
|
bulkRenameService.runningLibraries.add(lib.libraryId);
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
expect(result.statusCode).toBe(400);
|
|
|
|
// Cleanup
|
|
bulkRenameService.runningLibraries.delete(lib.libraryId);
|
|
});
|
|
});
|
|
|
|
// ── 15. book_per_folder — no change to folder, file rename only ───────────
|
|
|
|
describe('book_per_folder — file-only rename within same folder', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('renames the file without moving the folder when folder name does not change', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_folder',
|
|
fileRenameEnabled: true,
|
|
// Pattern where folder = title, file = title — but we test a case where
|
|
// folder name matches but the file name inside changes
|
|
fileNamingPattern: 'stable-folder/{title}',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'stable-folder', 'old-name.epub'), 'old-name');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
await setBookMetadata(ctx, books[0].bookId, { title: 'New File Name' });
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
const item = preview.items.find((it) => it.bookId === books[0].bookId);
|
|
expect(item?.status).toBe('will_rename');
|
|
expect(item?.newPath).toContain('stable-folder/New File Name.epub');
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.succeeded).toBe(1);
|
|
|
|
// Folder still exists, file renamed within it
|
|
await expect(pathExists(join(lib.folderPath, 'stable-folder'))).resolves.toBe(true);
|
|
await expect(pathExists(join(lib.folderPath, 'stable-folder', 'New File Name.epub'))).resolves.toBe(true);
|
|
await expect(pathExists(join(lib.folderPath, 'stable-folder', 'old-name.epub'))).resolves.toBe(false);
|
|
});
|
|
});
|
|
|
|
// ── 16. Empty library ─────────────────────────────────────────────────────
|
|
|
|
describe('empty library', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('preview returns empty results for library with no books', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
expect(preview.items).toHaveLength(0);
|
|
expect(preview.total).toBe(0);
|
|
expect(Object.values(preview.totalByStatus).every((v) => v === 0)).toBe(true);
|
|
});
|
|
|
|
it('execute on empty library returns success with 0 processed', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
expect(result.statusCode).toBe(200);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.processed).toBe(0);
|
|
});
|
|
});
|
|
|
|
// ── 17. Mixed mode — book_per_file with year pattern ─────────────────────
|
|
|
|
describe('book_per_file — year-based pattern', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('organises books under year subfolders', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{year}/{title}',
|
|
});
|
|
|
|
for (let i = 0; i < 3; i++) {
|
|
await createEpubFile(join(lib.folderPath, `year-${i}.epub`), `year-${i}`);
|
|
}
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
const bookMeta = [
|
|
{ title: 'Year Book A', publishedYear: 2020 },
|
|
{ title: 'Year Book B', publishedYear: 2021 },
|
|
{ title: 'Year Book C', publishedYear: 2020 }, // Same year as A
|
|
];
|
|
|
|
for (let i = 0; i < books.length; i++) {
|
|
await setBookMetadata(ctx, books[i].bookId, bookMeta[i]);
|
|
}
|
|
|
|
const result = await executeBulkRename(ctx, lib.libraryId);
|
|
const done = getDoneEvent(result.events);
|
|
expect(done!.failed).toBe(0);
|
|
|
|
await expect(pathExists(join(lib.folderPath, '2020', 'Year Book A.epub'))).resolves.toBe(true);
|
|
await expect(pathExists(join(lib.folderPath, '2021', 'Year Book B.epub'))).resolves.toBe(true);
|
|
await expect(pathExists(join(lib.folderPath, '2020', 'Year Book C.epub'))).resolves.toBe(true);
|
|
});
|
|
});
|
|
|
|
// ── 18. book_per_file with original filename fallback ─────────────────────
|
|
|
|
describe('book_per_file — originalFilename token', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('uses originalFilename when title is missing and pattern falls back to it', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '<{title}|{originalFilename}>',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'original-stem.epub'), 'placeholder');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
|
|
// Ensure no title
|
|
await ctx.db.update(schema.bookMetadata).set({ title: null }).where(eq(schema.bookMetadata.bookId, books[0].bookId));
|
|
|
|
const preview = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
const item = preview.items[0];
|
|
// With fallback pattern, should resolve to original filename and show unchanged or will_rename
|
|
expect(['unchanged', 'will_rename', 'no_pattern']).toContain(item.status);
|
|
});
|
|
});
|
|
|
|
// ── 19. Preview cache invalidation ───────────────────────────────────────
|
|
|
|
describe('preview cache', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('fresh execute invalidates the preview cache', async () => {
|
|
const lib = await createLibrary(ctx, {
|
|
mode: 'book_per_file',
|
|
fileRenameEnabled: true,
|
|
fileNamingPattern: '{title}',
|
|
});
|
|
|
|
await createEpubFile(join(lib.folderPath, 'cache-test.epub'), 'cache-test');
|
|
await triggerAndWaitForScan(ctx, lib.libraryId);
|
|
const books = await findAllBooksInLibrary(ctx, lib.libraryId);
|
|
await setBookMetadata(ctx, books[0].bookId, { title: 'Cache Test Title' });
|
|
|
|
// Prime the cache
|
|
const preview1 = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
expect(preview1.totalByStatus.will_rename).toBe(1);
|
|
|
|
// Execute (this should invalidate cache)
|
|
await executeBulkRename(ctx, lib.libraryId);
|
|
|
|
// After execute, preview should show unchanged
|
|
const preview2 = await getBulkRenamePreview(ctx, lib.libraryId);
|
|
const item = preview2.items.find((it) => it.bookId === books[0].bookId);
|
|
expect(item?.status).toBe('unchanged');
|
|
});
|
|
});
|
|
|
|
// ── 20. Non-existent library ──────────────────────────────────────────────
|
|
|
|
describe('non-existent library', { timeout: TEST_TIMEOUT_MS }, () => {
|
|
it('execute returns 404 for non-existent libraryId', async () => {
|
|
const result = await executeBulkRename(ctx, 999999);
|
|
expect(result.statusCode).toBe(404);
|
|
});
|
|
|
|
it('preview returns 404 for non-existent libraryId', async () => {
|
|
const response = await ctx.app.inject({
|
|
method: 'GET',
|
|
url: '/api/v1/libraries/999999/bulk-rename/preview?page=1&pageSize=10',
|
|
headers: authHeader(ctx.adminToken),
|
|
});
|
|
expect(response.statusCode).toBe(404);
|
|
});
|
|
});
|
|
});
|