stock-manager/tests/unit/schemas/assignment.schema.test.ts

import { describe, expect, it } from "vitest"

import {
  buildCreateAssignmentSchema,
  buildReturnAssignmentSchema,
  buildUpdateAssignmentSchema,
} from "@/schemas/assignment.schema"

const schemaCopy = {
  personRequired: "La persona es obligatoria",
  itemIdRequired: "El artículo es obligatorio",
  quantityMinOne: "La cantidad debe ser al menos 1",
  assetIdRequired: "El activo es obligatorio cuando se especifica el artículo",
  idRequired: "El ID de asignación es obligatorio",
}

describe("assignment schema localization", () => {
  it("uses localized create validation messages for missing required fields", () => {
    const result = buildCreateAssignmentSchema(schemaCopy).safeParse({
      personId: "",
      quantity: 0,
    })

    expect(result.success).toBe(false)
    if (!result.success) {
      const errors = result.error.flatten().fieldErrors

      expect(errors.personId).toContain(schemaCopy.personRequired)
      expect(errors.quantity).toContain(schemaCopy.quantityMinOne)
    }
  })

  it("uses localized update validation messages for missing identifier and invalid item-asset combination", () => {
    const result = buildUpdateAssignmentSchema(schemaCopy).safeParse({
      id: "",
      itemId: "item-1",
      personId: "person-1",
      quantity: 1,
      assetId: "",
    })

    expect(result.success).toBe(false)
    if (!result.success) {
      const errors = result.error.flatten().fieldErrors

      expect(errors.id).toContain(schemaCopy.idRequired)
      expect(errors.assetId).toContain(schemaCopy.assetIdRequired)
    }
  })

  it("preserves valid create and update payloads without errors", () => {
    const createResult = buildCreateAssignmentSchema(schemaCopy).safeParse({
      personId: "person-1",
      itemId: "item-1",
      quantity: 2,
    })

    expect(createResult.success).toBe(true)
    if (createResult.success) {
      expect(createResult.data.personId).toBe("person-1")
      expect(createResult.data.quantity).toBe(2)
    }

    const updateResult = buildUpdateAssignmentSchema(schemaCopy).safeParse({
      id: "assignment-1",
      personId: "person-1",
      itemId: "item-1",
      assetId: "asset-1",
      quantity: 1,
    })

    expect(updateResult.success).toBe(true)
    if (updateResult.success) {
      expect(updateResult.data.id).toBe("assignment-1")
    }
  })

  it("keeps optional assignment fields optional in create", () => {
    const result = buildCreateAssignmentSchema(schemaCopy).safeParse({
      personId: "person-1",
      quantity: 1,
    })

    expect(result.success).toBe(true)
  })

  it("allows update without itemId when no assetId is required", () => {
    const result = buildUpdateAssignmentSchema(schemaCopy).safeParse({
      id: "assignment-1",
      personId: "person-1",
      quantity: 1,
    })

    expect(result.success).toBe(true)
    if (result.success) {
      expect(result.data.id).toBe("assignment-1")
    }
  })
})

describe("return assignment schema", () => {
  it("accepts a partial return payload with optional notes", () => {
    const result = buildReturnAssignmentSchema(schemaCopy).safeParse({
      id: "assignment-1",
      returns: [
        {
          assignmentLineId: "line-1",
          quantity: 2,
          notes: "Slightly damaged",
        },
      ],
    })

    expect(result.success).toBe(true)
    if (result.success) {
      expect(result.data.id).toBe("assignment-1")
      expect(result.data.returns).toHaveLength(1)
      expect(result.data.returns?.[0]).toMatchObject({
        assignmentLineId: "line-1",
        quantity: 2,
        notes: "Slightly damaged",
      })
    }
  })

  it("rejects a non-integer quantity", () => {
    const result = buildReturnAssignmentSchema(schemaCopy).safeParse({
      id: "assignment-1",
      returns: [
        {
          assignmentLineId: "line-1",
          quantity: 1.5,
        },
      ],
    })

    expect(result.success).toBe(false)
    if (!result.success) {
      expect(
        result.error.issues.some((issue) => issue.path.includes("quantity")),
      ).toBe(true)
    }
  })

  it("rejects a quantity less than or equal to zero", () => {
    const zeroResult = buildReturnAssignmentSchema(schemaCopy).safeParse({
      id: "assignment-1",
      returns: [{ assignmentLineId: "line-1", quantity: 0 }],
    })

    expect(zeroResult.success).toBe(false)
    if (!zeroResult.success) {
      expect(
        zeroResult.error.issues.some((issue) =>
          issue.path.includes("quantity"),
        ),
      ).toBe(true)
    }

    const negativeResult = buildReturnAssignmentSchema(schemaCopy).safeParse({
      id: "assignment-1",
      returns: [{ assignmentLineId: "line-1", quantity: -1 }],
    })

    expect(negativeResult.success).toBe(false)
    if (!negativeResult.success) {
      expect(
        negativeResult.error.issues.some((issue) =>
          issue.path.includes("quantity"),
        ),
      ).toBe(true)
    }
  })

  it("keeps the legacy full-return shape valid", () => {
    const result = buildReturnAssignmentSchema(schemaCopy).safeParse({
      id: "assignment-1",
    })

    expect(result.success).toBe(true)
    if (result.success) {
      expect(result.data.id).toBe("assignment-1")
      expect(result.data.returns).toBeUndefined()
    }
  })
})