metis-desk/modules/companies/src/api/domain/mailbox.test.ts

import assert from "node:assert/strict";
import { test } from "node:test";

import { UniqueID } from "@repo/rdx-ddd";

import type { MailboxContext } from "../application/mailbox.repository";
import { mapMailboxInput, mapMailboxUseInput } from "../application/mailbox-input.mapper";
import { MailboxPersistenceMapper } from "../infrastructure/persistence/mailbox-persistence.mapper";

import { Mailbox } from "./mailbox.aggregate";
import { MailboxUse } from "./mailbox-use.aggregate";
import { MailboxUseValues } from "./value-objects/mailbox-use-values.vo";
import { MailboxValues } from "./value-objects/mailbox-values.vo";

const company = UniqueID.generateNewID();
const actor = UniqueID.generateNewID();
const person = UniqueID.generateNewID();
const now = "2026-10-05T10:00:00.000Z";
const fields = {
  address: "Ana@Example.test",
  kind: "corporate" as const,
  context: null,
  accountId: null,
  active: true,
  notes: null,
};
function values(data = fields) {
  const r = MailboxValues.create(data);
  assert.ok(r.isSuccess);
  return r.data;
}
function create() {
  const r = Mailbox.create(company, values(), actor, now);
  assert.ok(r.isSuccess);
  return r.data;
}
const box = create();
const ctx: MailboxContext = {
  mailboxes: [box],
  uses: [],
  people: [{ id: person, active: true }],
  items: [],
  actors: new Map(),
  today: "2026-10-05",
};
const period = {
  mailboxId: box.id.toPrimitive(),
  personId: person.toPrimitive(),
  startDate: "2026-10-01",
  endDate: null,
};
function useValues(
  data: { mailboxId: string; personId: string; startDate: string; endDate: string | null } = period
) {
  const r = MailboxUseValues.create(data);
  assert.ok(r.isSuccess);
  return r.data;
}
test("Buzón: identidad, dirección única, cuenta opcional, ámbito y cambios auditados", () => {
  assert.equal(box.id.toPrimitive()[14], "7");
  assert.equal(box.values.address.toPrimitive(), "ana@example.test");
  const noOp = box.update(values(), actor, now);
  assert.ok(noOp.isSuccess);
  assert.equal(noOp.data, box);
  const changed = box.update(values({ ...fields, active: false }), actor, now);
  assert.ok(changed.isSuccess);
  assert.equal(changed.data.history.length, 2);
  assert.equal(changed.data.history[0]?.values.active, true);
  assert.equal(mapMailboxInput(fields, ctx).isSuccess, false);
  assert.ok(mapMailboxInput(fields, ctx, box).isSuccess);
  assert.equal(
    mapMailboxInput({ ...fields, accountId: actor.toPrimitive() }, ctx).isSuccess,
    false
  );
  const external = MailboxValues.create({ ...fields, kind: "external" });
  assert.ok(external.isSuccess);
  assert.equal(box.update(external.data, actor, now).isSuccess, false);
});
test("Uso de buzón: fechas inclusiva/exclusiva, mismo día, solapes, varias personas e historial", () => {
  const value = useValues();
  assert.equal(value.current("2026-10-01"), true);
  assert.equal(value.current("2026-09-30"), false);
  const closed = useValues({ ...period, endDate: "2026-10-05" });
  assert.equal(closed.current("2026-10-05"), false);
  assert.equal(closed.overlaps(useValues({ ...period, startDate: "2026-10-05" })), false);
  assert.equal(closed.overlaps(useValues({ ...period, startDate: "2026-10-04" })), true);
  assert.equal(value.overlaps(useValues({ ...period, endDate: period.startDate })), false);
  assert.equal(MailboxUseValues.create({ ...period, endDate: "2026-09-30" }).isSuccess, false);
  const result = MailboxUse.create(company, value, actor, now);
  assert.ok(result.isSuccess);
  assert.equal(mapMailboxUseInput(period, { ...ctx, uses: [result.data] }).isSuccess, false);
  assert.ok(
    mapMailboxUseInput(
      { ...period, personId: actor.toPrimitive() },
      { ...ctx, people: [{ id: actor, active: true }], uses: [result.data] }
    ).isSuccess
  );
  const update = result.data.update(closed, actor, now);
  assert.ok(update.isSuccess);
  assert.ok(update.data.id.equals(result.data.id));
  assert.equal(update.data.history.length, 2);
  assert.equal(update.data.update(value, actor, now).isSuccess, false);
  assert.ok(
    mapMailboxUseInput(
      { ...period, endDate: "2026-10-05" },
      { ...ctx, people: [{ id: person, active: false }] },
      result.data
    ).isSuccess
  );
});
test("Buzones: mapper conserva identidad y revisiones, rechaza corrupción", () => {
  const mapper = new MailboxPersistenceMapper();
  const stored = mapper.toPersistence(box);
  const root = {
    ...stored,
    accountId: null,
    addressKey: `${company.toPrimitive()}:ana@example.test`,
  };
  const restored = mapper.toDomain(root, stored.revisions);
  assert.ok(restored.id.equals(box.id));
  assert.throws(() => mapper.toDomain({ ...root, addressKey: "invalid" }, stored.revisions));
  const use = MailboxUse.create(company, useValues(), actor, now);
  assert.ok(use.isSuccess);
  const rows = mapper.toPersistence(use.data);
  const useRoot = { ...rows, mailboxId: box.id.toPrimitive(), personId: person.toPrimitive() };
  assert.ok(mapper.toUseDomain(useRoot, rows.revisions).id.equals(use.data.id));
  assert.throws(() =>
    mapper.toUseDomain({ ...useRoot, personId: actor.toPrimitive() }, rows.revisions)
  );
});