test: add regression-focused coverage for qr and history use cases

Author: Nubet

tests/integration/historyUsecases.test.ts

@@ -0,0 +1,87 @@
+import { ClearHistoryUseCase } from '@/services/usecases/history/ClearHistoryUseCase';
+import { DeleteHistoryItemUseCase } from '@/services/usecases/history/DeleteHistoryItemUseCase';
+import { GetHistoryUseCase } from '@/services/usecases/history/GetHistoryUseCase';
+import { SaveGeneratedEntryUseCase } from '@/services/usecases/history/SaveGeneratedEntryUseCase';
+import { SaveScanEntryUseCase } from '@/services/usecases/history/SaveScanEntryUseCase';
+import type { IHistoryRepository } from '@/repositories/contracts/IHistoryRepository';
+import type { HistoryEntry } from '@/types';
+
+class InMemoryHistoryRepository implements IHistoryRepository {
+  public items: HistoryEntry[] = [];
+
+  async getAll(): Promise<HistoryEntry[]> {
+    return [...this.items];
+  }
+
+  async getLatest(limit: number): Promise<HistoryEntry[]> {
+    return [...this.items].slice(0, limit);
+  }
+
+  async add(entry: HistoryEntry): Promise<void> {
+    this.items.unshift(entry);
+  }
+
+  async deleteById(id: string): Promise<void> {
+    this.items = this.items.filter((item) => item.id !== id);
+  }
+
+  async clear(): Promise<void> {
+    this.items = [];
+  }
+
+  async clearByKind(kind: HistoryEntry['kind']): Promise<void> {
+    this.items = this.items.filter((item) => item.kind !== kind);
+  }
+}
+
+describe('history use-cases integration', () => {
+  test('save, read, delete and clear operations work together', async () => {
+    const repo = new InMemoryHistoryRepository();
+    const saveScan = new SaveScanEntryUseCase(repo);
+    const saveGenerated = new SaveGeneratedEntryUseCase(repo);
+    const getHistory = new GetHistoryUseCase(repo);
+    const deleteOne = new DeleteHistoryItemUseCase(repo);
+    const clearHistory = new ClearHistoryUseCase(repo);
+
+    await saveScan.execute({
+      label: 'example.com',
+      payload: { raw: 'https://example.com', type: 'url' },
+    });
+
+    await saveGenerated.execute({
+      payload: { raw: 'mailto:test@company.com', type: 'email' },
+    });
+
+    const all = await getHistory.execute();
+    expect(all).toHaveLength(2);
+    expect(all[0].kind).toBe('generated');
+    expect(all[1].kind).toBe('scan');
+
+    await deleteOne.execute(all[0].id);
+    const afterDelete = await getHistory.execute();
+    expect(afterDelete).toHaveLength(1);
+
+    await clearHistory.execute('scan');
+    const afterKindClear = await getHistory.execute();
+    expect(afterKindClear).toHaveLength(0);
+  });
+
+  test('getLatest delegates limit path', async () => {
+    const repo = new InMemoryHistoryRepository();
+    const saveScan = new SaveScanEntryUseCase(repo);
+    const getHistory = new GetHistoryUseCase(repo);
+
+    await saveScan.execute({
+      label: 'one',
+      payload: { raw: 'https://1.com', type: 'url' },
+    });
+    await saveScan.execute({
+      label: 'two',
+      payload: { raw: 'https://2.com', type: 'url' },
+    });
+
+    const latestOne = await getHistory.execute(1);
+    expect(latestOne).toHaveLength(1);
+    expect(latestOne[0].label).toBe('two');
+  });
+});

tests/unit/qrPayloadRules.test.ts

@@ -0,0 +1,48 @@
+import {
+  detectPayloadType,
+  isValidForCreateType,
+  normalizeForCreateType,
+  stripActionPrefix,
+} from '@/services/domain/qrPayloadRules';
+
+describe('qrPayloadRules', () => {
+  test.each([
+    ['https://example.com', 'url'],
+    ['http://example.com', 'url'],
+    ['mailto:test@example.com', 'email'],
+    ['tel:+48123123123', 'phone'],
+    ['WIFI:T:WPA;S:Office;P:secret;;', 'wifi'],
+    ['plain text', 'text'],
+    ['   ', 'unknown'],
+  ] as const)('detectPayloadType(%s) -> %s', (raw, expected) => {
+    expect(detectPayloadType(raw)).toBe(expected);
+  });
+
+  test('normalizeForCreateType adds missing URL scheme', () => {
+    expect(normalizeForCreateType('example.com', 'url')).toBe('https://example.com');
+  });
+
+  test('normalizeForCreateType keeps existing prefixes', () => {
+    expect(normalizeForCreateType('mailto:a@b.com', 'email')).toBe('mailto:a@b.com');
+    expect(normalizeForCreateType('tel:+48123456789', 'phone')).toBe('tel:+48123456789');
+  });
+
+  test('stripActionPrefix removes only known prefixes', () => {
+    expect(stripActionPrefix('mailto:test@company.com', 'email')).toBe('test@company.com');
+    expect(stripActionPrefix('tel:+48123456789', 'phone')).toBe('+48123456789');
+    expect(stripActionPrefix('https://example.com', 'url')).toBe('https://example.com');
+  });
+
+  test.each([
+    ['url', 'example.com', true],
+    ['url', 'not a url', false],
+    ['email', 'a@b.com', true],
+    ['email', 'mailto:a@b.com', true],
+    ['email', 'invalid@domain', false],
+    ['phone', '+48 123 456 789', true],
+    ['phone', '12345', false],
+    ['text', 'anything', true],
+  ] as const)('isValidForCreateType(%s, %s) -> %s', (type, value, expected) => {
+    expect(isValidForCreateType(value, type)).toBe(expected);
+  });
+});

tests/unit/qrUsecases.test.ts

@@ -0,0 +1,35 @@
+import { BuildQrPreviewUseCase } from '@/services/usecases/qr/BuildQrPreview';
+import { ValidateQrInputUseCase } from '@/services/usecases/qr/ValidateQrInput';
+
+describe('QR create use-cases', () => {
+  const validate = new ValidateQrInputUseCase();
+  const buildPreview = new BuildQrPreviewUseCase();
+
+  test('validate input reports empty and too_long errors', () => {
+    const empty = validate.execute('   ', 'text');
+    expect(empty.isValid).toBe(false);
+    expect(empty.reason).toBe('empty');
+
+    const tooLong = validate.execute('a'.repeat(2049), 'text');
+    expect(tooLong.isValid).toBe(false);
+    expect(tooLong.reason).toBe('too_long');
+  });
+
+  test('validate input reports url/email/phone reasons', () => {
+    expect(validate.execute('x', 'url').reason).toBe('invalid_url');
+    expect(validate.execute('x@x', 'email').reason).toBe('invalid_email');
+    expect(validate.execute('123', 'phone').reason).toBe('invalid_phone');
+  });
+
+  test('build preview returns encoded external QR URL', () => {
+    const preview = buildPreview.execute('https://example.com/path?a=1&b=2');
+    expect(preview.sourceUrl).toContain('https://api.qrserver.com/v1/create-qr-code/');
+    expect(preview.sourceUrl).toContain('data=https%3A%2F%2Fexample.com%2Fpath%3Fa%3D1%26b%3D2');
+    expect(preview.payload.type).toBe('url');
+  });
+
+  test('build preview uses fallback for empty input', () => {
+    const preview = buildPreview.execute('   ');
+    expect(preview.payload.raw).toBe('https://example.com');
+  });
+});

tests/unit/scannerUsecases.test.ts

@@ -0,0 +1,32 @@
+import { BuildScanResultViewModelUseCase } from '@/services/usecases/scanner/BuildScanResultViewModel';
+import { ResolveScannedActionUseCase } from '@/services/usecases/scanner/ResolveScannedAction';
+import type { QrPayload } from '@/types';
+
+describe('scanner use-cases', () => {
+  const resolveAction = new ResolveScannedActionUseCase();
+  const buildViewModel = new BuildScanResultViewModelUseCase();
+
+  test.each([
+    [{ raw: 'https://example.com', type: 'url' }, 'open_url'],
+    [{ raw: 'mailto:test@example.com', type: 'email' }, 'compose_email'],
+    [{ raw: 'tel:+48123456789', type: 'phone' }, 'call_phone'],
+    [{ raw: 'WIFI:T:WPA;S:Net;P:pass;;', type: 'wifi' }, 'copy_text'],
+    [{ raw: 'hello', type: 'text' }, 'copy_text'],
+    [{ raw: '', type: 'unknown' }, 'unsupported'],
+  ] as const)('resolveAction for %o', (payload, expectedKind) => {
+    expect(resolveAction.execute(payload as QrPayload).kind).toBe(expectedKind);
+  });
+
+  test('url view model extracts domain', () => {
+    const vm = buildViewModel.execute({ raw: 'https://sub.example.com/p/a/t/h', type: 'url' });
+    expect(vm.kicker).toBe('Link detected');
+    expect(vm.title).toBe('sub.example.com');
+  });
+
+  test('email and phone view model remove action prefixes', () => {
+    const email = buildViewModel.execute({ raw: 'mailto:test@company.com', type: 'email' });
+    const phone = buildViewModel.execute({ raw: 'tel:+48123456789', type: 'phone' });
+    expect(email.subtitle).toBe('test@company.com');
+    expect(phone.subtitle).toBe('+48123456789');
+  });
+});