hyb-oa/server/tests/unit/routes/invoicePool.travel-bind.test.js

const Fastify = require("fastify");

const { AppError } = require("../../../src/utils/AppError");
const invoicePoolRoutes = require("../../../src/routes/invoicePool");

function buildQueryRawHandler(state) {
  return vi.fn(async (strings) => {
    const sql = Array.isArray(strings) ? strings.join("?") : String(strings);
    if (sql.includes('FROM "invoice_pool"')) {
      return state.invoice ? [{
        id: state.invoice.id,
        status: state.invoice.status,
        linked_reimbursement_id: state.invoice.linked_reimbursement_id,
        travel_order_id: state.invoice.travel_order_id,
      }] : [];
    }
    if (sql.includes('FROM "travel_orders"')) {
      return state.travelOrder ? [{ id: state.travelOrder.id, status: state.travelOrder.status }] : [];
    }
    if (sql.includes('FROM "reimbursement_forms"')) {
      return state.reimbursement ? [state.reimbursement] : [];
    }
    return [];
  });
}

function buildPrisma({ invoice, travelOrder, reimbursement = null }) {
  const state = {
    invoice: { ...invoice },
    travelOrder: travelOrder ? { ...travelOrder } : null,
    reimbursement,
  };

  const prisma = {
    invoicePool: {
      findUnique: vi.fn().mockImplementation(async () => state.invoice),
      update: vi.fn().mockImplementation(async ({ data, select }) => {
        state.invoice = { ...state.invoice, ...data };
        if (!select) {
          return state.invoice;
        }
        return {
          ...state.invoice,
          verification_records: [],
        };
      }),
    },
    reimbursementItem: {
      findFirst: vi.fn().mockResolvedValue({ id: "item-1" }),
    },
    auditLog: {
      create: vi.fn().mockResolvedValue({ id: "audit-1" }),
    },
    $queryRaw: buildQueryRawHandler(state),
    $transaction: vi.fn().mockImplementation(async (callback) => callback(prisma)),
  };

  return { prisma, state };
}

async function buildApp({ prisma, permissionCodes = ["travel.payment.manage"] }) {
  const app = Fastify();

  app.decorate("prisma", prisma);
  app.decorate("config", {
    storageDir: "/tmp",
    appOrigin: "http://localhost:5173",
    maxUploadSizeBytes: 10 * 1024 * 1024,
    invoiceArchiveUnusedDays: 30,
  });
  app.decorate("authenticate", async (request) => {
    if (!request.headers.authorization) {
      throw new AppError({ code: "AUTH_001", message: "未登录", statusCode: 401 });
    }
    request.employee = { id: "actor-1", permissionCodes };
  });
  app.decorate("hasPermission", (employee, permissionCode) => (employee?.permissionCodes ?? []).includes("*") || (employee?.permissionCodes ?? []).includes(permissionCode));
  app.decorate("requirePermission", (permissionCode) => async (request) => {
    await app.authenticate(request);
    if (!app.hasPermission(request.employee, permissionCode)) {
      throw new AppError({ code: "PERM_001", message: "无权限", statusCode: 403 });
    }
  });

  app.setErrorHandler((error, request, reply) => {
    if (error instanceof AppError) {
      return reply.status(error.statusCode).send({
        requestId: request.id,
        error: {
          code: error.code,
          message: error.message,
          details: error.details ?? {},
        },
      });
    }
    return reply.status(500).send({
      requestId: request.id,
      error: { code: "SYS_001", message: "服务器内部错误", details: {} },
    });
  });

  await app.register(invoicePoolRoutes, { prefix: "/api" });
  return app;
}

describe("invoicePool travel-order bind routes", () => {
  it("binds invoice to confirmed travel order", async () => {
    const { prisma, state } = buildPrisma({
      invoice: {
        id: "11111111-1111-4111-8111-111111111111",
        status: "available",
        linked_reimbursement_id: null,
        linked_item_id: null,
        travel_order_id: null,
        total_amount: "500.00",
        verification_records: [],
      },
      travelOrder: { id: "22222222-2222-4222-8222-222222222222", status: "confirmed" },
    });
    const app = await buildApp({ prisma });

    const response = await app.inject({
      method: "POST",
      url: "/api/invoice-pool/11111111-1111-4111-8111-111111111111/bind",
      headers: { authorization: "Bearer test" },
      payload: { travelOrderId: "22222222-2222-4222-8222-222222222222" },
    });

    expect(response.statusCode).toBe(200);
    expect(response.json().data.linkedTravelOrderId).toBe("22222222-2222-4222-8222-222222222222");
    expect(state.invoice.travel_order_id).toBe("22222222-2222-4222-8222-222222222222");

    await app.close();
  });

  it("rejects binding when invoice is already linked elsewhere", async () => {
    const { prisma } = buildPrisma({
      invoice: {
        id: "11111111-1111-4111-8111-111111111111",
        status: "bound",
        linked_reimbursement_id: "reim-1",
        linked_item_id: null,
        travel_order_id: null,
        total_amount: "500.00",
        verification_records: [],
      },
      travelOrder: { id: "22222222-2222-4222-8222-222222222222", status: "confirmed" },
    });
    const app = await buildApp({ prisma });

    const response = await app.inject({
      method: "POST",
      url: "/api/invoice-pool/11111111-1111-4111-8111-111111111111/bind",
      headers: { authorization: "Bearer test" },
      payload: { travelOrderId: "22222222-2222-4222-8222-222222222222" },
    });

    expect(response.statusCode).toBe(409);
    expect(response.json().error.code).toBe("VALID_005");

    await app.close();
  });

  it("unbinds invoice from travel order with payment manage permission", async () => {
    const { prisma, state } = buildPrisma({
      invoice: {
        id: "11111111-1111-4111-8111-111111111111",
        status: "bound",
        linked_reimbursement_id: null,
        linked_item_id: null,
        travel_order_id: "22222222-2222-4222-8222-222222222222",
        total_amount: "500.00",
        verification_records: [],
      },
      travelOrder: { id: "22222222-2222-4222-8222-222222222222", status: "paid" },
    });
    const app = await buildApp({ prisma });

    const response = await app.inject({
      method: "POST",
      url: "/api/invoice-pool/11111111-1111-4111-8111-111111111111/unbind",
      headers: { authorization: "Bearer test" },
      payload: {},
    });

    expect(response.statusCode).toBe(200);
    expect(response.json().data.linkedTravelOrderId).toBe(null);
    expect(state.invoice.status).toBe("available");

    await app.close();
  });
});