@tumbaland/backend-core 1.44.0 → 1.46.0

package/src/entitlements/usage.test.ts

@@ -1,314 +0,0 @@
-/**
- * Integration tests against a real MongoDB, not mocks.
- *
- * `tickerPriceHistory.service.test.ts` reports 100% line coverage while mocking
- * Mongoose entirely, and a real upsert bug survived it. Quota code has the same
- * failure mode with worse consequences: a mocked `$inc` always looks correct,
- * and a broken one either gives the product away or bills people for capacity
- * they cannot use. The concurrency tests below are meaningless without a real
- * server — they are the whole reason the atomic reserve is written the way it is.
- */
-import mongoose from 'mongoose';
-import { MongoMemoryServer } from 'mongodb-memory-server';
-
-jest.mock('../logging/logger', () => ({
-  __esModule: true,
-  default: { error: jest.fn(), warn: jest.fn(), info: jest.fn(), debug: jest.fn(), http: jest.fn() }
-}));
-
-import logger from '../logging/logger';
-import { UsageMeter, currentPeriod } from './UsageMeter';
-import { checkQuota, consumeQuota, getUsage, getUsageSnapshot, recordUsage, releaseQuota, setUsage } from './usage';
-import { Entitlements } from './types';
-import { UNLIMITED, normalizeLimits } from './definitions';
-
-jest.setTimeout(120_000);
-
-let mongod: MongoMemoryServer;
-
-const ORIGINAL_ENV = process.env;
-
-function entitlements(overrides: Partial<Entitlements> = {}): Entitlements {
-  return {
-    email: 'user@example.com',
-    planCode: 'free',
-    status: null,
-    limits: normalizeLimits({ meters: { aiJobs: 5, storageBytes: 1000, trackedTickers: 3, seats: 1 } }, 'free'),
-    upgradeTo: 'personal',
-    ...overrides
-  };
-}
-
-beforeAll(async () => {
-  mongod = await MongoMemoryServer.create();
-  await mongoose.connect(mongod.getUri());
-});
-
-afterAll(async () => {
-  await mongoose.disconnect();
-  await mongod.stop();
-});
-
-beforeEach(async () => {
-  process.env = { ...ORIGINAL_ENV };
-  await UsageMeter.deleteMany({});
-  // The unique index is what makes the concurrent upserts below collapse onto
-  // one document instead of racing into duplicates.
-  await UsageMeter.syncIndexes();
-  (logger.info as jest.Mock).mockClear();
-});
-
-afterAll(() => {
-  process.env = ORIGINAL_ENV;
-});
-
-describe('consumeQuota', () => {
-  it('records usage and allows a request that lands exactly on the limit', async () => {
-    await consumeQuota({ subjectId: 'user@example.com', meter: 'aiJobs', amount: 5, entitlements: entitlements() });
-
-    expect(await getUsage('user@example.com', 'aiJobs')).toBe(5);
-  });
-
-  it('rejects with a 402 carrying everything the upgrade dialog renders', async () => {
-    await setUsage('user@example.com', 'aiJobs', 5);
-
-    await expect(
-      consumeQuota({ subjectId: 'user@example.com', meter: 'aiJobs', amount: 1, entitlements: entitlements() })
-    ).rejects.toMatchObject({
-      statusCode: 402,
-      details: { code: 'QUOTA_EXCEEDED', meter: 'aiJobs', used: 5, limit: 5, planCode: 'free', upgradeTo: 'personal' }
-    });
-  });
-
-  it('rolls its own increment back when it rejects, so a refusal costs the user nothing', async () => {
-    await setUsage('user@example.com', 'aiJobs', 5);
-
-    await expect(
-      consumeQuota({ subjectId: 'user@example.com', meter: 'aiJobs', entitlements: entitlements() })
-    ).rejects.toMatchObject({ statusCode: 402 });
-
-    expect(await getUsage('user@example.com', 'aiJobs')).toBe(5);
-  });
-
-  it('admits exactly the limit under concurrency and rejects the rest', async () => {
-    const results = await Promise.allSettled(
-      Array.from({ length: 12 }, () =>
-        consumeQuota({ subjectId: 'user@example.com', meter: 'aiJobs', entitlements: entitlements() })
-      )
-    );
-
-    const admitted = results.filter(r => r.status === 'fulfilled');
-    expect(admitted).toHaveLength(5);
-    // The rejected requests all rolled back, so the counter reflects the
-    // admitted ones only — no permanent drift from the losers of the race.
-    expect(await getUsage('user@example.com', 'aiJobs')).toBe(5);
-  });
-
-  it('never blocks an unlimited meter', async () => {
-    const unlimited = entitlements({
-      planCode: 'family',
-      limits: normalizeLimits({ meters: { trackedTickers: UNLIMITED } }, 'family')
-    });
-
-    await consumeQuota({ subjectId: 'user@example.com', meter: 'trackedTickers', amount: 10_000, entitlements: unlimited });
-
-    expect(await getUsage('user@example.com', 'trackedTickers')).toBe(10_000);
-  });
-
-  it('counts monthly meters into the calendar month, so usage rolls over', async () => {
-    await consumeQuota({ subjectId: 'user@example.com', meter: 'aiJobs', amount: 5, entitlements: entitlements() });
-
-    // A document written under a previous month's bucket must not count.
-    const previousMonth = await UsageMeter.findOne({ meter: 'aiJobs' });
-    expect(previousMonth?.period).toBe(currentPeriod('aiJobs'));
-
-    await UsageMeter.updateOne({ meter: 'aiJobs' }, { $set: { period: '2001-01' } });
-    expect(await getUsage('user@example.com', 'aiJobs')).toBe(0);
-    await expect(
-      consumeQuota({ subjectId: 'user@example.com', meter: 'aiJobs', entitlements: entitlements() })
-    ).resolves.toBeUndefined();
-  });
-
-  it('bills the same subject regardless of email casing', async () => {
-    await consumeQuota({ subjectId: 'User@Example.com', meter: 'seats', entitlements: entitlements() });
-
-    expect(await getUsage('user@example.com', 'seats')).toBe(1);
-  });
-});
-
-describe('rejection logging', () => {
-  it('logs the block alongside throwing, so an operator sees what a user saw', async () => {
-    await setUsage('user@example.com', 'aiJobs', 5);
-
-    await expect(
-      consumeQuota({ subjectId: 'user@example.com', meter: 'aiJobs', entitlements: entitlements(), route: '/ai/dispatch' })
-    ).rejects.toMatchObject({ statusCode: 402 });
-
-    expect(logger.info).toHaveBeenCalledWith(
-      'entitlement.blocked',
-      expect.objectContaining({ meter: 'aiJobs', used: 5, limit: 5, route: '/ai/dispatch' })
-    );
-  });
-
-  it('flags a block that came from stale fallback limits rather than the real plan', async () => {
-    await setUsage('user@example.com', 'aiJobs', 5);
-
-    await expect(
-      consumeQuota({
-        subjectId: 'user@example.com',
-        meter: 'aiJobs',
-        entitlements: entitlements({ stale: true })
-      })
-    ).rejects.toMatchObject({ statusCode: 402 });
-
-    // A run of these means payment-service is down and paying users are being
-    // held to free limits — a different incident from a limit set too tight.
-    expect(logger.info).toHaveBeenCalledWith('entitlement.blocked', expect.objectContaining({ stale: true }));
-  });
-});
-
-describe('checkQuota', () => {
-  it('passes when the requested amount still fits and writes nothing', async () => {
-    await setUsage('user@example.com', 'storageBytes', 400);
-
-    await expect(
-      checkQuota({ subjectId: 'user@example.com', meter: 'storageBytes', amount: 600, entitlements: entitlements() })
-    ).resolves.toBeUndefined();
-    expect(await getUsage('user@example.com', 'storageBytes')).toBe(400);
-  });
-
-  it('rejects, and writes nothing, when the requested amount would overrun', async () => {
-    await setUsage('user@example.com', 'storageBytes', 400);
-
-    await expect(
-      checkQuota({ subjectId: 'user@example.com', meter: 'storageBytes', amount: 601, entitlements: entitlements() })
-    ).rejects.toMatchObject({ statusCode: 402 });
-
-    // Read-only by contract: the increment belongs to the point the resource
-    // actually comes into existence, not to the gate in front of it.
-    expect(await getUsage('user@example.com', 'storageBytes')).toBe(400);
-    expect(logger.info).toHaveBeenCalledWith(
-      'entitlement.blocked',
-      expect.objectContaining({ meter: 'storageBytes', used: 400, limit: 1000 })
-    );
-  });
-
-  it('skips the usage read entirely for an unlimited meter', async () => {
-    const unlimited = entitlements({ limits: normalizeLimits({ meters: { storageBytes: UNLIMITED } }, 'free') });
-
-    await expect(
-      checkQuota({ subjectId: 'user@example.com', meter: 'storageBytes', amount: 10 ** 12, entitlements: unlimited })
-    ).resolves.toBeUndefined();
-  });
-
-  it('rejects when the amount would overrun, reporting current usage', async () => {
-    await setUsage('user@example.com', 'storageBytes', 400);
-
-    await expect(
-      checkQuota({ subjectId: 'user@example.com', meter: 'storageBytes', amount: 601, entitlements: entitlements() })
-    ).rejects.toMatchObject({ statusCode: 402, details: { meter: 'storageBytes', used: 400, limit: 1000 } });
-  });
-});
-
-describe('releaseQuota', () => {
-  it('hands capacity back after a failure', async () => {
-    await consumeQuota({ subjectId: 'user@example.com', meter: 'aiJobs', amount: 3, entitlements: entitlements() });
-
-    await releaseQuota('user@example.com', 'aiJobs', 3);
-
-    expect(await getUsage('user@example.com', 'aiJobs')).toBe(0);
-  });
-
-  it('clamps at zero rather than going negative', async () => {
-    await setUsage('user@example.com', 'storageBytes', 100);
-
-    await releaseQuota('user@example.com', 'storageBytes', 500);
-
-    expect(await getUsage('user@example.com', 'storageBytes')).toBe(0);
-  });
-
-  it('does not lose concurrent releases', async () => {
-    await setUsage('user@example.com', 'storageBytes', 100);
-
-    await Promise.all(Array.from({ length: 10 }, () => releaseQuota('user@example.com', 'storageBytes', 10)));
-
-    expect(await getUsage('user@example.com', 'storageBytes')).toBe(0);
-  });
-
-  it('is a no-op when no counter exists', async () => {
-    await expect(releaseQuota('nobody@example.com', 'seats', 1)).resolves.toBeUndefined();
-    expect(await getUsage('nobody@example.com', 'seats')).toBe(0);
-  });
-});
-
-describe('recordUsage', () => {
-  it('increments a meter that does not exist yet', async () => {
-    await recordUsage('user@example.com', 'storageBytes', 4_096);
-
-    expect(await getUsage('user@example.com', 'storageBytes')).toBe(4_096);
-  });
-
-  it('records past the limit rather than refusing bytes already on disk', async () => {
-    // The gate ran at the signed-URL request; these bytes are in MinIO whatever
-    // the counter says. Rolling the increment back — what consumeQuota would do
-    // — would understate real storage and let the next upload through too.
-    await setUsage('user@example.com', 'storageBytes', 900);
-
-    await recordUsage('user@example.com', 'storageBytes', 500);
-
-    expect(await getUsage('user@example.com', 'storageBytes')).toBe(1_400);
-    // And the next request is the one that is refused.
-    await expect(
-      checkQuota({ subjectId: 'user@example.com', meter: 'storageBytes', amount: 1, entitlements: entitlements() })
-    ).rejects.toMatchObject({ statusCode: 402 });
-  });
-
-  it('does not lose concurrent increments', async () => {
-    await Promise.all(Array.from({ length: 10 }, () => recordUsage('user@example.com', 'storageBytes', 10)));
-
-    expect(await getUsage('user@example.com', 'storageBytes')).toBe(100);
-  });
-
-  it('ignores a non-positive amount instead of writing a no-op row', async () => {
-    await recordUsage('user@example.com', 'storageBytes', 0);
-    await recordUsage('user@example.com', 'storageBytes', -50);
-
-    expect(await UsageMeter.countDocuments({ subjectId: 'user@example.com' })).toBe(0);
-  });
-
-  it('never throws — the resource exists and the caller is on its success path', async () => {
-    const failing = jest
-      .spyOn(UsageMeter, 'updateOne')
-      .mockRejectedValueOnce(new Error('connection lost') as never);
-
-    await expect(recordUsage('user@example.com', 'storageBytes', 10)).resolves.toBeUndefined();
-    expect(logger.warn).toHaveBeenCalledWith('Failed to record usage', expect.objectContaining({ meter: 'storageBytes' }));
-
-    failing.mockRestore();
-  });
-});
-
-describe('getUsageSnapshot', () => {
-  it('reports every meter, defaulting the untouched ones to zero', async () => {
-    await setUsage('user@example.com', 'storageBytes', 42);
-    await setUsage('user@example.com', 'aiJobs', 7);
-    await setUsage('other@example.com', 'seats', 99);
-
-    expect(await getUsageSnapshot('user@example.com')).toEqual({
-      storageBytes: 42,
-      aiJobs: 7,
-      trackedTickers: 0,
-      seats: 0
-    });
-  });
-});
-
-describe('setUsage', () => {
-  it('overwrites for backfill and reconciliation, refusing negatives', async () => {
-    await setUsage('user@example.com', 'storageBytes', 5_000);
-    expect(await getUsage('user@example.com', 'storageBytes')).toBe(5_000);
-
-    await setUsage('user@example.com', 'storageBytes', -20);
-    expect(await getUsage('user@example.com', 'storageBytes')).toBe(0);
-  });
-});

package/src/entitlements/usage.ts

@@ -1,223 +0,0 @@
-import logger from '../logging/logger';
-import { PaymentRequiredError } from '../errors/HttpError';
-import { UsageMeter, currentPeriod } from './UsageMeter';
-import { MeterKey, METER_KEYS, UNLIMITED, fitsWithin } from './definitions';
-import { Entitlements } from './types';
-
-export interface QuotaRequest {
-  /** Who the usage is billed to — see `IUsageMeter.subjectId`. */
-  subjectId: string;
-  meter: MeterKey;
-  /** How much this request wants. Bytes for `storageBytes`, otherwise a count. */
-  amount?: number;
-  entitlements: Entitlements;
-  /** Attached to the rejection log so a 402 can be traced back to a route. */
-  route?: string;
-}
-
-/** Current count for one meter in its live period. */
-export async function getUsage(subjectId: string, meter: MeterKey, now?: Date): Promise<number> {
-  const doc = await UsageMeter.findOne({
-    subjectId: subjectId.toLowerCase(),
-    meter,
-    period: currentPeriod(meter, now)
-  }).lean();
-  return doc?.count ?? 0;
-}
-
-/** Every meter at once, for the account page and the pricing table's live numbers. */
-export async function getUsageSnapshot(subjectId: string, now?: Date): Promise<Record<MeterKey, number>> {
-  const periods = METER_KEYS.map(meter => ({ meter, period: currentPeriod(meter, now) }));
-  const docs = await UsageMeter.find({
-    subjectId: subjectId.toLowerCase(),
-    $or: periods.map(p => ({ meter: p.meter, period: p.period }))
-  }).lean();
-
-  const snapshot = Object.fromEntries(METER_KEYS.map(k => [k, 0])) as Record<MeterKey, number>;
-  for (const doc of docs) {
-    if ((METER_KEYS as readonly string[]).includes(doc.meter)) snapshot[doc.meter as MeterKey] = doc.count;
-  }
-  return snapshot;
-}
-
-function quotaError(req: QuotaRequest, used: number, limit: number): PaymentRequiredError {
-  return new PaymentRequiredError(`Limit reached for ${req.meter}`, {
-    code: 'QUOTA_EXCEEDED',
-    meter: req.meter,
-    used,
-    limit,
-    planCode: req.entitlements.planCode,
-    upgradeTo: req.entitlements.upgradeTo
-  });
-}
-
-/**
- * Every rejection is logged, not just thrown. The 402 reaches the user, but
- * only this line reaches the operator — and the two questions worth asking of a
- * paywall (which meter fires most, and how often it fires on a *stale* fallback
- * rather than on real limits) are answerable from nothing else.
- */
-function logBlocked(req: QuotaRequest, used: number, limit: number): void {
-  logger.info('entitlement.blocked', {
-    event: 'entitlement.blocked',
-    meter: req.meter,
-    subjectId: req.subjectId,
-    amount: req.amount ?? 1,
-    used,
-    limit,
-    planCode: req.entitlements.planCode,
-    route: req.route,
-    stale: req.entitlements.stale === true
-  });
-}
-
-/**
- * Read-only check for cumulative meters whose real increment happens later
- * (storage is counted when the upload lands, not when it is authorized).
- *
- * Racy by construction — two concurrent requests can both pass — which is
- * acceptable here precisely because the meters it guards are reconciled from
- * the underlying data. Use `consumeQuota` where the count is the only record.
- */
-export async function checkQuota(req: QuotaRequest): Promise<void> {
-  const limit = req.entitlements.limits.meters[req.meter] ?? UNLIMITED;
-  if (limit === UNLIMITED) return;
-
-  const used = await getUsage(req.subjectId, req.meter);
-  if (fitsWithin(limit, used, req.amount ?? 1)) return;
-
-  logBlocked(req, used, limit);
-  throw quotaError(req, used, limit);
-}
-
-/**
- * Atomically reserve capacity, throwing when the reservation would overrun.
- *
- * The increment and the check are one `$inc` + read, not a read-then-write:
- * two concurrent requests that both read "24 used" against a limit of 25 would
- * both proceed and overrun. Incrementing first and rejecting on the
- * *post-increment* value means the loser of that race is the one rejected.
- *
- * A rejected reservation rolls its own increment back before throwing — unlike
- * the provider-quota version this generalizes, where an over-limit count just
- * sits there until the day rolls over. A per-user cumulative meter never rolls
- * over, so a leaked increment is permanent and shows up months later as a user
- * who cannot upload despite being well under their limit.
- */
-export async function consumeQuota(req: QuotaRequest): Promise<void> {
-  const amount = req.amount ?? 1;
-  const limit = req.entitlements.limits.meters[req.meter] ?? UNLIMITED;
-  const period = currentPeriod(req.meter);
-  const subjectId = req.subjectId.toLowerCase();
-
-  const usage = await UsageMeter.findOneAndUpdate(
-    { subjectId, meter: req.meter, period },
-    { $inc: { count: amount } },
-    { upsert: true, returnDocument: 'after', setDefaultsOnInsert: true }
-  );
-
-  if (limit === UNLIMITED || usage.count <= limit) return;
-
-  const usedBefore = usage.count - amount;
-
-  logBlocked(req, usedBefore, limit);
-  await releaseQuota(subjectId, req.meter, amount);
-  throw quotaError(req, usedBefore, limit);
-}
-
-/**
- * Hand back capacity after a failure that never consumed it (the upload errored,
- * the AI service refused the job), and on deletes — a cumulative meter that only
- * counts up is a bug that surfaces as an angry support email six months in.
- *
- * Never drops below zero, and never throws: a failed release must not turn a
- * recoverable error into a 500 for the caller that was already unwinding.
- */
-export async function releaseQuota(
-  subjectId: string,
-  meter: MeterKey,
-  amount = 1,
-  now?: Date
-): Promise<void> {
-  try {
-    const filter = { subjectId: subjectId.toLowerCase(), meter, period: currentPeriod(meter, now) };
-
-    // Conditional `$inc` rather than read-then-write: a read-modify-write here
-    // loses concurrent releases, which on a cumulative meter is permanent drift.
-    const result = await UsageMeter.updateOne({ ...filter, count: { $gte: amount } }, { $inc: { count: -amount } });
-    if (result.matchedCount === 0) {
-      // Either no counter exists, or it holds less than we are handing back
-      // (a reconciliation reset it in between). Clamp at zero, never negative.
-      await UsageMeter.updateOne({ ...filter, count: { $lt: amount } }, { $set: { count: 0 } });
-    }
-  } catch (err) {
-    logger.warn('Failed to release usage quota', {
-      subjectId,
-      meter,
-      amount,
-      error: (err as Error)?.message
-    });
-  }
-}
-
-/**
- * Set a meter to a known value. For the backfill (existing storage has to be
- * seeded or every current user starts at zero and silently exceeds later) and
- * for periodic reconciliation against the source of truth.
- */
-export async function setUsage(
-  subjectId: string,
-  meter: MeterKey,
-  count: number,
-  now?: Date
-): Promise<void> {
-  await UsageMeter.updateOne(
-    { subjectId: subjectId.toLowerCase(), meter, period: currentPeriod(meter, now) },
-    { $set: { count: Math.max(0, Math.floor(count)) } },
-    { upsert: true, setDefaultsOnInsert: true }
-  );
-}
-
-/**
- * Record usage that has already happened, without a limit check.
- *
- * The storage gate runs on the *signed-URL request* — the only point where a
- * file's size is known before its bytes are written — so by the time the photo
- * record is created the object is already in MinIO. Neither of the existing
- * primitives fits that moment: `checkQuota` records nothing, and `consumeQuota`
- * would reject and roll back, leaving the meter understating bytes that are
- * genuinely stored while the user is refused a record for storage they have
- * already paid for.
- *
- * So this increments past the limit deliberately. A cumulative meter can only
- * be pushed over by a race or a stale entitlement, both bounded by one upload,
- * and the gate then refuses the *next* one — which is the correct behaviour:
- * the ceiling stops new writes, it does not un-store bytes.
- *
- * Never throws, for the same reason `releaseQuota` does not: the resource
- * exists, the caller is on its success path, and a failed counter update is
- * repaired by the nightly reconciliation this meter is derived for.
- */
-export async function recordUsage(
-  subjectId: string,
-  meter: MeterKey,
-  amount = 1,
-  now?: Date
-): Promise<void> {
-  if (amount <= 0) return;
-
-  try {
-    await UsageMeter.updateOne(
-      { subjectId: subjectId.toLowerCase(), meter, period: currentPeriod(meter, now) },
-      { $inc: { count: amount } },
-      { upsert: true, setDefaultsOnInsert: true }
-    );
-  } catch (err) {
-    logger.warn('Failed to record usage', {
-      subjectId,
-      meter,
-      amount,
-      error: (err as Error)?.message
-    });
-  }
-}

package/src/errors/HttpError.test.ts

@@ -1,76 +0,0 @@
-import { HttpError, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, TooManyRequestsError, PaymentRequiredError } from './HttpError';
-
-describe('HttpError', () => {
-  it('carries the given status code and message', () => {
-    const error = new HttpError(418, "I'm a teapot");
-    expect(error.statusCode).toBe(418);
-    expect(error.message).toBe("I'm a teapot");
-    expect(error).toBeInstanceOf(Error);
-  });
-
-  it('sets name to the concrete subclass name', () => {
-    expect(new HttpError(400, 'x').name).toBe('HttpError');
-  });
-
-  it('carries optional details for the error handler to serialize', () => {
-    expect(new HttpError(400, 'x').details).toBeUndefined();
-    expect(new HttpError(400, 'x', { field: 'title' }).details).toEqual({ field: 'title' });
-  });
-});
-
-describe('PaymentRequiredError', () => {
-  it('is a 402 — "you may, for money" — and never a 403', () => {
-    const error = new PaymentRequiredError('Storage limit reached', {
-      code: 'QUOTA_EXCEEDED',
-      meter: 'storageBytes',
-      used: 10,
-      limit: 10,
-      planCode: 'free',
-      upgradeTo: 'support'
-    });
-
-    expect(error.statusCode).toBe(402);
-    expect(error).toBeInstanceOf(HttpError);
-    expect(error.details).toEqual({
-      code: 'QUOTA_EXCEEDED',
-      meter: 'storageBytes',
-      used: 10,
-      limit: 10,
-      planCode: 'free',
-      upgradeTo: 'support'
-    });
-  });
-
-  it('copies the details, so a caller reusing its object cannot mutate the error', () => {
-    const details = { code: 'QUOTA_EXCEEDED', meter: 'seats' };
-    const error = new PaymentRequiredError('Seat limit reached', details);
-
-    details.meter = 'aiJobs';
-
-    expect(error.details?.meter).toBe('seats');
-  });
-});
-
-describe.each([
-  [BadRequestError, 400, 'Bad request'],
-  [UnauthorizedError, 401, 'Unauthorized'],
-  [ForbiddenError, 403, 'Access denied'],
-  [NotFoundError, 404, 'Not found'],
-  [ConflictError, 409, 'Conflict'],
-  [TooManyRequestsError, 429, 'Too many requests']
-] as const)('%p', (ErrorClass, expectedStatus, defaultMessage) => {
-  it(`defaults to status ${expectedStatus} and a sensible message`, () => {
-    const error = new ErrorClass();
-    expect(error.statusCode).toBe(expectedStatus);
-    expect(error.message).toBe(defaultMessage);
-    expect(error).toBeInstanceOf(HttpError);
-    expect(error).toBeInstanceOf(Error);
-    expect(error.name).toBe(ErrorClass.name);
-  });
-
-  it('accepts a custom message', () => {
-    const error = new ErrorClass('custom message');
-    expect(error.statusCode).toBe(expectedStatus);
-    expect(error.message).toBe('custom message');
-  });
-});