pokemon-inventory/apps/api/tests/application/sale-service.test.js

import assert from 'node:assert/strict';
import test from 'node:test';

import { createSaleService } from '../../src/modules/sales/services/sale-service.js';

function validInput(overrides = {}) {
  return {
    sellerId: 'seller-1',
    inventoryItemId: 'inventory-1',
    saleDate: '2026-09-09',
    soldPriceMinor: 2499,
    costBasisMinor: 1200,
    ...overrides,
  };
}

test('creates a sale through the repository with validated money values', async () => {
  let received;
  const service = createSaleService({
    saleRepository: {
      async createForInventoryItem(input) {
        received = input;
        return {
          status: 'CREATED',
          sale: {
            id: 'sale-1',
            soldPriceMinor: 2499,
            platformFeesMinor: 100,
            paymentProcessingFeesMinor: 0,
            shippingCostMinor: 0,
            taxesMinor: 0,
            otherFeesMinor: 0,
          },
          saleItem: { costBasisMinor: 1200 },
        };
      },
    },
  });

  assert.deepEqual(await service.create(validInput()), {
    status: 'CREATED',
    sale: {
      id: 'sale-1',
      soldPriceMinor: 2499,
      platformFeesMinor: 100,
      paymentProcessingFeesMinor: 0,
      shippingCostMinor: 0,
      taxesMinor: 0,
      otherFeesMinor: 0,
    },
    saleItem: { costBasisMinor: 1200 },
    netProceedsMinor: 2399,
    profitMinor: 1199,
  });
  assert.equal(received.sale.sellerId, 'seller-1');
  assert.equal(received.sale.soldPriceMinor, 2499);
  assert.equal(received.costBasisMinor, 1200);
});

test('lists seller sales with derived net proceeds and profit', async () => {
  const service = createSaleService({
    saleRepository: {
      async listBySellerId(sellerId) {
        assert.equal(sellerId, 'seller-1');
        return [{
          sale: { soldPriceMinor: 3000, shippingCostMinor: 200 },
          saleItem: { costBasisMinor: 1500 },
          inventoryItem: { id: 'inventory-1', status: 'SOLD' },
        }];
      },
    },
  });

  const [sale] = await service.list({ sellerId: 'seller-1' });
  assert.equal(sale.netProceedsMinor, 2800);
  assert.equal(sale.profitMinor, 1300);
});

test('voids an owned sale with a required reason', async () => {
  let received;
  const service = createSaleService({
    saleRepository: {
      async voidForSeller(input) {
        received = input;
        return {
          status: 'VOIDED',
          sale: { id: 'sale-1', soldPriceMinor: 3000 },
          saleItem: { costBasisMinor: 1500 },
          inventoryItem: { id: 'inventory-1', status: 'ACTIVE' },
        };
      },
    },
  });

  const result = await service.void({
    saleId: 'sale-1',
    sellerId: 'seller-1',
    actorUserId: 'user-1',
    reason: ' Duplicate sale ',
  });

  assert.equal(received.reason, 'Duplicate sale');
  assert.equal(result.inventoryItem.status, 'ACTIVE');
  await assert.rejects(
    () => service.void({ saleId: 'sale-1', sellerId: 'seller-1', actorUserId: 'user-1', reason: 'x' }),
    (error) => error.code === 'SALE_VOID_REASON_REQUIRED' && error.statusCode === 400,
  );
});

test('creates one sale containing multiple inventory items', async () => {
  let received;
  const service = createSaleService({
    saleRepository: {
      async createForInventoryItems(input) {
        received = input;
        return {
          status: 'CREATED',
          sale: { id: 'sale-2', soldPriceMinor: 3000 },
          saleItems: input.items,
          saleItem: input.items[0],
          inventoryItems: input.items.map(({ inventoryItemId }) => ({ id: inventoryItemId, status: 'SOLD' })),
          inventoryItem: { id: input.items[0].inventoryItemId, status: 'SOLD' },
        };
      },
    },
  });

  const result = await service.create({
    sellerId: 'seller-1',
    saleDate: '2026-09-09',
    items: [
      { inventoryItemId: 'inventory-1', soldPriceMinor: 1200, costBasisMinor: 500 },
      { inventoryItemId: 'inventory-2', soldPriceMinor: 1800, costBasisMinor: 700 },
    ],
  });

  assert.equal(received.sale.soldPriceMinor, 3000);
  assert.equal(received.items.length, 2);
  assert.equal(result.profitMinor, 1800);
});

test('maps missing and already-sold inventory to application errors', async () => {
  for (const result of [
    { status: 'NOT_FOUND', code: 'INVENTORY_NOT_FOUND', statusCode: 404 },
    { status: 'NOT_ACTIVE', code: 'INVENTORY_NOT_AVAILABLE_FOR_SALE', statusCode: 409 },
  ]) {
    const service = createSaleService({
      saleRepository: { async createForInventoryItem() { return result; } },
    });

    await assert.rejects(
      () => service.create(validInput()),
      (error) => error.code === result.code && error.statusCode === result.statusCode,
    );
  }
});