@open-mercato/core 0.4.5-develop-2e9903a57a → 0.4.5-develop-eeccf7adf4

package/src/modules/planner/__tests__/plannerAvailabilityService.test.ts

@@ -1,89 +0,0 @@
-process.env.TZ = 'UTC'
-
-import { getMergedAvailabilityWindows, type AvailabilityRuleLike } from '../lib/availabilityMerge'
-import { DefaultPlannerAvailabilityService } from '../services/plannerAvailabilityService'
-
-function toIsoWindow(window: { start: Date; end: Date; ruleId?: string }) {
-  return {
-    start: window.start.toISOString(),
-    end: window.end.toISOString(),
-    ruleId: window.ruleId,
-  }
-}
-
-describe('DefaultPlannerAvailabilityService', () => {
-  it('delegates to getMergedAvailabilityWindows', () => {
-    const range = {
-      start: new Date('2024-01-01T00:00:00Z'),
-      end: new Date('2024-01-03T00:00:00Z'),
-    }
-    const rules: AvailabilityRuleLike[] = [
-      {
-        id: 'availability',
-        rrule: 'DTSTART:20240101T090000Z;DURATION:PT2H;FREQ=DAILY;COUNT=2',
-        kind: 'availability',
-      },
-    ]
-
-    const service = new DefaultPlannerAvailabilityService()
-    const direct = getMergedAvailabilityWindows({ rules, range }).map(toIsoWindow)
-    const viaService = service.getMergedAvailabilityWindows({ rules, range }).map(toIsoWindow)
-
-    expect(viaService).toEqual(direct)
-  })
-
-  it('merges unavailability into availability windows', () => {
-    const service = new DefaultPlannerAvailabilityService()
-    const range = {
-      start: new Date('2024-01-01T00:00:00Z'),
-      end: new Date('2024-01-02T00:00:00Z'),
-    }
-    const rules: AvailabilityRuleLike[] = [
-      {
-        id: 'availability',
-        rrule: 'DTSTART:20240101T090000Z;DURATION:PT8H;FREQ=DAILY',
-        kind: 'availability',
-      },
-      {
-        id: 'unavailability',
-        rrule: 'DTSTART:20240101T120000Z;DURATION:PT1H;FREQ=DAILY',
-        kind: 'unavailability',
-      },
-    ]
-
-    const windows = service.getMergedAvailabilityWindows({ rules, range }).map(toIsoWindow)
-
-    expect(windows).toEqual([
-      { start: '2024-01-01T09:00:00.000Z', end: '2024-01-01T12:00:00.000Z', ruleId: 'availability' },
-      { start: '2024-01-01T13:00:00.000Z', end: '2024-01-01T17:00:00.000Z', ruleId: 'availability' },
-    ])
-  })
-
-  it('respects exdates and one-off overrides', () => {
-    const service = new DefaultPlannerAvailabilityService()
-    const range = {
-      start: new Date('2024-01-02T00:00:00Z'),
-      end: new Date('2024-01-04T00:00:00Z'),
-    }
-    const rules: AvailabilityRuleLike[] = [
-      {
-        id: 'availability',
-        rrule: 'DTSTART:20240102T090000Z;DURATION:PT2H;FREQ=DAILY;COUNT=2',
-        exdates: ['2024-01-03'],
-        kind: 'availability',
-      },
-      {
-        id: 'once',
-        rrule: 'DTSTART:20240103T090000Z;DURATION:PT1H;FREQ=DAILY;COUNT=1',
-        kind: 'availability',
-      },
-    ]
-
-    const windows = service.getMergedAvailabilityWindows({ rules, range }).map(toIsoWindow)
-
-    expect(windows).toEqual([
-      { start: '2024-01-02T09:00:00.000Z', end: '2024-01-02T11:00:00.000Z', ruleId: 'availability' },
-      { start: '2024-01-03T00:00:00.000Z', end: '2024-01-04T00:00:00.000Z', ruleId: undefined },
-    ])
-  })
-})

package/src/modules/planner/data/__tests__/validators.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import {
-  plannerAvailabilityDateSpecificReplaceSchema,
-  plannerAvailabilityRuleCreateSchema,
-  plannerAvailabilityWeeklyReplaceSchema,
-} from '../validators'
-
-const tenantId = '123e4567-e89b-12d3-a456-426614174000'
-const organizationId = '123e4567-e89b-12d3-a456-426614174001'
-
-describe('Planner validators', () => {
-  test('plannerAvailabilityRuleCreateSchema applies defaults', () => {
-    const result = plannerAvailabilityRuleCreateSchema.parse({
-      tenantId,
-      organizationId,
-      subjectType: 'member',
-      subjectId: '123e4567-e89b-12d3-a456-426614174002',
-      timezone: 'UTC',
-      rrule: 'FREQ=WEEKLY;BYDAY=MO',
-    })
-
-    expect(result.exdates).toEqual([])
-    expect(result.kind).toBe('availability')
-  })
-
-  test('plannerAvailabilityRuleCreateSchema rejects invalid exdates', () => {
-    expect(() =>
-      plannerAvailabilityRuleCreateSchema.parse({
-        tenantId,
-        organizationId,
-        subjectType: 'member',
-        subjectId: '123e4567-e89b-12d3-a456-426614174002',
-        timezone: 'UTC',
-        rrule: 'FREQ=WEEKLY;BYDAY=MO',
-        exdates: ['not-a-date'],
-      }),
-    ).toThrow()
-  })
-
-  test('plannerAvailabilityWeeklyReplaceSchema rejects invalid time windows', () => {
-    expect(() =>
-      plannerAvailabilityWeeklyReplaceSchema.parse({
-        tenantId,
-        organizationId,
-        subjectType: 'resource',
-        subjectId: '123e4567-e89b-12d3-a456-426614174003',
-        timezone: 'UTC',
-        windows: [{ weekday: 1, start: '9:00', end: '18:00' }],
-      }),
-    ).toThrow()
-  })
-
-  test('plannerAvailabilityDateSpecificReplaceSchema requires date or dates', () => {
-    expect(() =>
-      plannerAvailabilityDateSpecificReplaceSchema.parse({
-        tenantId,
-        organizationId,
-        subjectType: 'ruleset',
-        subjectId: '123e4567-e89b-12d3-a456-426614174004',
-        timezone: 'UTC',
-      }),
-    ).toThrow()
-  })
-
-  test('plannerAvailabilityDateSpecificReplaceSchema applies defaults', () => {
-    const result = plannerAvailabilityDateSpecificReplaceSchema.parse({
-      tenantId,
-      organizationId,
-      subjectType: 'ruleset',
-      subjectId: '123e4567-e89b-12d3-a456-426614174004',
-      timezone: 'UTC',
-      date: '2025-02-09',
-    })
-
-    expect(result.windows).toEqual([])
-    expect(result.isAvailable).toBe(true)
-  })
-})

package/src/modules/progress/__integration__/TC-PROG-001.spec.ts

@@ -1,67 +0,0 @@
-import { test, expect } from '@playwright/test';
-import { getAuthToken, apiRequest } from '@open-mercato/core/modules/core/__integration__/helpers/api';
-
-/**
- * TC-PROG-001: Progress Job Lifecycle
- * Covers: create, list active, update progress, cancel
- */
-test.describe('TC-PROG-001: Progress Job Lifecycle', () => {
-  test('should create, list, update, and cancel a progress job', async ({ request }) => {
-    let token: string | null = null;
-    let jobId: string | null = null;
-
-    try {
-      token = await getAuthToken(request);
-
-      // 1. Create a job via POST /api/progress/jobs
-      const createRes = await apiRequest(request, 'POST', '/api/progress/jobs', {
-        token,
-        data: {
-          jobType: 'integration-test',
-          name: `QA TC-PROG-001 ${Date.now()}`,
-          totalCount: 200,
-          cancellable: true,
-        },
-      });
-      expect(createRes.status()).toBe(201);
-      const createBody = await createRes.json();
-      expect(createBody.id).toBeTruthy();
-      jobId = createBody.id;
-
-      // 2. Verify it appears in GET /api/progress/active
-      const activeRes = await apiRequest(request, 'GET', '/api/progress/active', { token });
-      expect(activeRes.ok()).toBeTruthy();
-      const activeBody = await activeRes.json();
-      const activeIds = activeBody.active.map((j: { id: string }) => j.id);
-      expect(activeIds).toContain(jobId);
-
-      // 3. Update progress via PUT /api/progress/jobs/:id
-      const updateRes = await apiRequest(request, 'PUT', `/api/progress/jobs/${jobId}`, {
-        token,
-        data: { processedCount: 80, totalCount: 200 },
-      });
-      expect(updateRes.ok()).toBeTruthy();
-      const updateBody = await updateRes.json();
-      expect(updateBody.ok).toBe(true);
-      expect(updateBody.progressPercent).toBe(40);
-
-      // 4. Cancel job via DELETE /api/progress/jobs/:id
-      const cancelRes = await apiRequest(request, 'DELETE', `/api/progress/jobs/${jobId}`, { token });
-      expect(cancelRes.ok()).toBeTruthy();
-      const cancelBody = await cancelRes.json();
-      expect(cancelBody.ok).toBe(true);
-
-      // 5. Verify the job is now cancelled (pending jobs cancel immediately)
-      const detailRes = await apiRequest(request, 'GET', `/api/progress/jobs/${jobId}`, { token });
-      expect(detailRes.ok()).toBeTruthy();
-      const detailBody = await detailRes.json();
-      expect(detailBody.status).toBe('cancelled');
-    } finally {
-      // Jobs are soft state — no explicit cleanup needed.
-      // If the test created a job that wasn't cancelled, cancel it to keep state clean.
-      if (token && jobId) {
-        await apiRequest(request, 'DELETE', `/api/progress/jobs/${jobId}`, { token }).catch(() => {});
-      }
-    }
-  });
-});

package/src/modules/progress/__tests__/progressService.test.ts

@@ -1,377 +0,0 @@
-import { createProgressService } from '../lib/progressServiceImpl'
-import { PROGRESS_EVENTS } from '../lib/events'
-import { calculateEta, calculateProgressPercent } from '../lib/progressService'
-import type { ProgressJob } from '../data/entities'
-
-const baseCtx = {
-  tenantId: '7f4c85ef-f8f7-4e53-9df1-42e95bd8d48e',
-  organizationId: null,
-  userId: '2d4a4c33-9c4b-4e39-8e15-0a3cd9a7f432',
-}
-
-const buildEm = () => {
-  const em = {
-    create: jest.fn(),
-    persistAndFlush: jest.fn().mockResolvedValue(undefined),
-    flush: jest.fn().mockResolvedValue(undefined),
-    findOne: jest.fn(),
-    findOneOrFail: jest.fn(),
-    find: jest.fn(),
-  }
-  return em
-}
-
-describe('progress service', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('createJob — creates entity, persists, emits JOB_CREATED', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    em.create.mockImplementation((_entity, data) => ({ id: 'job-1', ...data }))
-
-    const service = createProgressService(em as never, eventBus)
-
-    const input = { jobType: 'import', name: 'Import contacts', totalCount: 100, cancellable: true }
-    const job = await service.createJob(input, baseCtx)
-
-    expect(job.id).toBe('job-1')
-    expect(job.status).toBe('pending')
-    expect(job.jobType).toBe('import')
-    expect(job.cancellable).toBe(true)
-    expect(em.persistAndFlush).toHaveBeenCalledWith(job)
-    expect(eventBus.emit).toHaveBeenCalledWith(
-      PROGRESS_EVENTS.JOB_CREATED,
-      expect.objectContaining({
-        jobId: 'job-1',
-        jobType: 'import',
-        name: 'Import contacts',
-        tenantId: baseCtx.tenantId,
-      })
-    )
-  })
-
-  it('startJob — sets running status, timestamps, emits JOB_STARTED', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const job = { id: 'job-1', status: 'pending', jobType: 'import' } as ProgressJob
-    em.findOneOrFail.mockResolvedValue(job)
-
-    const service = createProgressService(em as never, eventBus)
-    const result = await service.startJob('job-1', baseCtx)
-
-    expect(result.status).toBe('running')
-    expect(result.startedAt).toBeInstanceOf(Date)
-    expect(result.heartbeatAt).toBeInstanceOf(Date)
-    expect(em.flush).toHaveBeenCalled()
-    expect(eventBus.emit).toHaveBeenCalledWith(
-      PROGRESS_EVENTS.JOB_STARTED,
-      expect.objectContaining({ jobId: 'job-1', jobType: 'import', tenantId: baseCtx.tenantId })
-    )
-  })
-
-  it('updateProgress — auto-calculates progressPercent and ETA', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const job = {
-      id: 'job-1',
-      jobType: 'import',
-      processedCount: 0,
-      totalCount: 100,
-      progressPercent: 0,
-      startedAt: new Date(Date.now() - 10_000),
-      meta: null,
-    } as unknown as ProgressJob
-    em.findOneOrFail.mockResolvedValue(job)
-
-    const service = createProgressService(em as never, eventBus)
-    const result = await service.updateProgress('job-1', { processedCount: 50 }, baseCtx)
-
-    expect(result.processedCount).toBe(50)
-    expect(result.progressPercent).toBe(50)
-    expect(result.etaSeconds).toBeGreaterThan(0)
-    expect(result.heartbeatAt).toBeInstanceOf(Date)
-    expect(em.flush).toHaveBeenCalled()
-    expect(eventBus.emit).toHaveBeenCalledWith(
-      PROGRESS_EVENTS.JOB_UPDATED,
-      expect.objectContaining({ jobId: 'job-1', processedCount: 50, progressPercent: 50 })
-    )
-  })
-
-  it('updateProgress — uses explicit progressPercent when provided', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const job = {
-      id: 'job-1',
-      jobType: 'import',
-      processedCount: 0,
-      totalCount: 100,
-      progressPercent: 0,
-      startedAt: new Date(),
-      meta: null,
-    } as unknown as ProgressJob
-    em.findOneOrFail.mockResolvedValue(job)
-
-    const service = createProgressService(em as never, eventBus)
-    const result = await service.updateProgress('job-1', { processedCount: 50, progressPercent: 75 }, baseCtx)
-
-    expect(result.progressPercent).toBe(75)
-  })
-
-  it('updateProgress — merges meta instead of replacing', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const job = {
-      id: 'job-1',
-      jobType: 'import',
-      processedCount: 0,
-      totalCount: null,
-      progressPercent: 0,
-      startedAt: null,
-      meta: { existing: 'value' },
-    } as unknown as ProgressJob
-    em.findOneOrFail.mockResolvedValue(job)
-
-    const service = createProgressService(em as never, eventBus)
-    await service.updateProgress('job-1', { meta: { added: 'new' } }, baseCtx)
-
-    expect(job.meta).toEqual({ existing: 'value', added: 'new' })
-  })
-
-  it('incrementProgress — adds delta, recalculates percent, emits JOB_UPDATED', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const job = {
-      id: 'job-1',
-      jobType: 'import',
-      processedCount: 40,
-      totalCount: 100,
-      progressPercent: 40,
-      startedAt: new Date(Date.now() - 10_000),
-    } as unknown as ProgressJob
-    em.findOneOrFail.mockResolvedValue(job)
-
-    const service = createProgressService(em as never, eventBus)
-    const result = await service.incrementProgress('job-1', 10, baseCtx)
-
-    expect(result.processedCount).toBe(50)
-    expect(result.progressPercent).toBe(50)
-    expect(result.heartbeatAt).toBeInstanceOf(Date)
-    expect(em.flush).toHaveBeenCalled()
-    expect(eventBus.emit).toHaveBeenCalledWith(
-      PROGRESS_EVENTS.JOB_UPDATED,
-      expect.objectContaining({ jobId: 'job-1', processedCount: 50, progressPercent: 50 })
-    )
-  })
-
-  it('completeJob — sets completed status, progress 100%, emits JOB_COMPLETED', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const job = {
-      id: 'job-1',
-      jobType: 'import',
-      status: 'running',
-      progressPercent: 80,
-      etaSeconds: 5,
-      tenantId: baseCtx.tenantId,
-    } as unknown as ProgressJob
-    em.findOne.mockResolvedValue(job)
-
-    const service = createProgressService(em as never, eventBus)
-    const result = await service.completeJob('job-1', { resultSummary: { imported: 100 } }, baseCtx)
-
-    expect(result.status).toBe('completed')
-    expect(result.progressPercent).toBe(100)
-    expect(result.etaSeconds).toBe(0)
-    expect(result.finishedAt).toBeInstanceOf(Date)
-    expect(result.resultSummary).toEqual({ imported: 100 })
-    expect(em.flush).toHaveBeenCalled()
-    expect(em.findOne).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ id: 'job-1', tenantId: baseCtx.tenantId })
-    )
-    expect(eventBus.emit).toHaveBeenCalledWith(
-      PROGRESS_EVENTS.JOB_COMPLETED,
-      expect.objectContaining({ jobId: 'job-1', jobType: 'import', tenantId: baseCtx.tenantId })
-    )
-  })
-
-  it('failJob — sets failed status, records error, emits JOB_FAILED', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const job = {
-      id: 'job-1',
-      jobType: 'import',
-      status: 'running',
-      tenantId: baseCtx.tenantId,
-    } as unknown as ProgressJob
-    em.findOne.mockResolvedValue(job)
-
-    const service = createProgressService(em as never, eventBus)
-    const result = await service.failJob('job-1', { errorMessage: 'Network error', errorStack: 'stack...' }, baseCtx)
-
-    expect(result.status).toBe('failed')
-    expect(result.finishedAt).toBeInstanceOf(Date)
-    expect(result.errorMessage).toBe('Network error')
-    expect(result.errorStack).toBe('stack...')
-    expect(em.flush).toHaveBeenCalled()
-    expect(em.findOne).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ id: 'job-1', tenantId: baseCtx.tenantId })
-    )
-    expect(eventBus.emit).toHaveBeenCalledWith(
-      PROGRESS_EVENTS.JOB_FAILED,
-      expect.objectContaining({ jobId: 'job-1', errorMessage: 'Network error', tenantId: baseCtx.tenantId })
-    )
-  })
-
-  it('cancelJob (pending) — sets cancelled status immediately', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const job = {
-      id: 'job-1',
-      jobType: 'import',
-      status: 'pending',
-      cancellable: true,
-    } as unknown as ProgressJob
-    em.findOneOrFail.mockResolvedValue(job)
-
-    const service = createProgressService(em as never, eventBus)
-    const result = await service.cancelJob('job-1', baseCtx)
-
-    expect(result.status).toBe('cancelled')
-    expect(result.finishedAt).toBeInstanceOf(Date)
-    expect(result.cancelRequestedAt).toBeInstanceOf(Date)
-    expect(result.cancelledByUserId).toBe(baseCtx.userId)
-    expect(em.flush).toHaveBeenCalled()
-    expect(eventBus.emit).toHaveBeenCalledWith(
-      PROGRESS_EVENTS.JOB_CANCELLED,
-      expect.objectContaining({ jobId: 'job-1', tenantId: baseCtx.tenantId })
-    )
-  })
-
-  it('cancelJob (running) — sets cancelRequestedAt but keeps running status', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const job = {
-      id: 'job-1',
-      jobType: 'import',
-      status: 'running',
-      cancellable: true,
-    } as unknown as ProgressJob
-    em.findOneOrFail.mockResolvedValue(job)
-
-    const service = createProgressService(em as never, eventBus)
-    const result = await service.cancelJob('job-1', baseCtx)
-
-    expect(result.status).toBe('running')
-    expect(result.cancelRequestedAt).toBeInstanceOf(Date)
-    expect(result.cancelledByUserId).toBe(baseCtx.userId)
-    expect(result.finishedAt).toBeUndefined()
-    expect(eventBus.emit).toHaveBeenCalledWith(
-      PROGRESS_EVENTS.JOB_CANCELLED,
-      expect.objectContaining({ jobId: 'job-1' })
-    )
-  })
-
-  it('markStaleJobsFailed — marks stale jobs as failed, emits per job', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const staleJob1 = { id: 'stale-1', jobType: 'export', status: 'running', tenantId: baseCtx.tenantId } as unknown as ProgressJob
-    const staleJob2 = { id: 'stale-2', jobType: 'import', status: 'running', tenantId: baseCtx.tenantId } as unknown as ProgressJob
-    em.find.mockResolvedValue([staleJob1, staleJob2])
-
-    const service = createProgressService(em as never, eventBus)
-    const count = await service.markStaleJobsFailed(baseCtx.tenantId, 60)
-
-    expect(count).toBe(2)
-    expect(staleJob1.status).toBe('failed')
-    expect(staleJob1.finishedAt).toBeInstanceOf(Date)
-    expect(staleJob1.errorMessage).toContain('no heartbeat for 60 seconds')
-    expect(staleJob2.status).toBe('failed')
-    expect(em.flush).toHaveBeenCalled()
-    expect(em.find).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ tenantId: baseCtx.tenantId })
-    )
-    expect(eventBus.emit).toHaveBeenCalledTimes(2)
-    expect(eventBus.emit).toHaveBeenCalledWith(
-      PROGRESS_EVENTS.JOB_FAILED,
-      expect.objectContaining({ jobId: 'stale-1', stale: true })
-    )
-    expect(eventBus.emit).toHaveBeenCalledWith(
-      PROGRESS_EVENTS.JOB_FAILED,
-      expect.objectContaining({ jobId: 'stale-2', stale: true })
-    )
-  })
-
-  it('getRecentlyCompletedJobs — queries completed/failed jobs with tenant scope', async () => {
-    const em = buildEm()
-    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
-
-    const completedJob = { id: 'done-1', status: 'completed', tenantId: baseCtx.tenantId } as unknown as ProgressJob
-    em.find.mockResolvedValue([completedJob])
-
-    const service = createProgressService(em as never, eventBus)
-    const result = await service.getRecentlyCompletedJobs(baseCtx)
-
-    expect(result).toEqual([completedJob])
-    expect(em.find).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({
-        tenantId: baseCtx.tenantId,
-        status: { $in: ['completed', 'failed'] },
-        parentJobId: null,
-      }),
-      expect.objectContaining({ orderBy: { finishedAt: 'DESC' }, limit: 10 })
-    )
-  })
-})
-
-describe('calculateProgressPercent', () => {
-  it('returns correct percentage', () => {
-    expect(calculateProgressPercent(50, 100)).toBe(50)
-    expect(calculateProgressPercent(1, 3)).toBe(33)
-    expect(calculateProgressPercent(2, 3)).toBe(67)
-  })
-
-  it('clamps at 100', () => {
-    expect(calculateProgressPercent(150, 100)).toBe(100)
-  })
-
-  it('returns 0 for null or zero totalCount', () => {
-    expect(calculateProgressPercent(50, null)).toBe(0)
-    expect(calculateProgressPercent(50, 0)).toBe(0)
-  })
-})
-
-describe('calculateEta', () => {
-  it('returns null when processedCount is zero', () => {
-    expect(calculateEta(0, 100, new Date())).toBeNull()
-  })
-
-  it('returns null when totalCount is zero', () => {
-    expect(calculateEta(50, 0, new Date())).toBeNull()
-  })
-
-  it('calculates remaining seconds correctly', () => {
-    const startedAt = new Date(Date.now() - 10_000)
-    const eta = calculateEta(50, 100, startedAt)
-
-    expect(eta).not.toBeNull()
-    expect(eta!).toBeGreaterThan(0)
-    expect(eta!).toBeLessThanOrEqual(11)
-  })
-})