481 lines
15 KiB
TypeScript
481 lines
15 KiB
TypeScript
import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest"
|
|
import type { PrismaClient } from "@/generated/prisma/client"
|
|
import {
|
|
createTestItem,
|
|
createTestPerson,
|
|
createTestUser,
|
|
} from "../helpers/factories"
|
|
import {
|
|
resetIntegrationTestDatabase,
|
|
startIntegrationTestDatabase,
|
|
stopIntegrationTestDatabase,
|
|
} from "../helpers/test-db"
|
|
|
|
let prisma: PrismaClient
|
|
let createAssetUseCase: typeof import("@/use-cases/asset.use-cases").createAssetUseCase
|
|
let updateAssetUseCase: typeof import("@/use-cases/asset.use-cases").updateAssetUseCase
|
|
let AssetService: typeof import("@/services/asset.service").AssetService
|
|
|
|
beforeAll(async () => {
|
|
await startIntegrationTestDatabase()
|
|
|
|
const prismaModule = await import("@/lib/prisma")
|
|
const assetUseCases = await import("@/use-cases/asset.use-cases")
|
|
const assetService = await import("@/services/asset.service")
|
|
|
|
prisma = prismaModule.prisma
|
|
createAssetUseCase = assetUseCases.createAssetUseCase
|
|
updateAssetUseCase = assetUseCases.updateAssetUseCase
|
|
AssetService = assetService.AssetService
|
|
})
|
|
|
|
beforeEach(async () => {
|
|
await resetIntegrationTestDatabase(prisma)
|
|
})
|
|
|
|
afterAll(async () => {
|
|
await prisma?.$disconnect()
|
|
await stopIntegrationTestDatabase()
|
|
})
|
|
|
|
describe("asset use-cases", () => {
|
|
it("creates an available asset, increments item stock, and records an IN movement", async () => {
|
|
const actor = await createTestUser(prisma)
|
|
const item = await createTestItem(prisma, { stock: 0 })
|
|
|
|
const result = await createAssetUseCase({
|
|
actorId: actor.id,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-AVAILABLE-001",
|
|
deliveryNote: "DN-001",
|
|
status: "AVAILABLE",
|
|
notes: "Ready to assign",
|
|
})
|
|
|
|
expect(result.success).toBe(true)
|
|
if (!result.success) throw new Error("Expected asset creation success")
|
|
|
|
const [asset, updatedItem, movements] = await Promise.all([
|
|
prisma.asset.findUniqueOrThrow({ where: { id: result.assetId } }),
|
|
prisma.item.findUniqueOrThrow({ where: { id: item.id } }),
|
|
prisma.inventoryMovement.findMany({
|
|
include: { stockLines: true, assetLines: true },
|
|
orderBy: [{ createdAt: "asc" }, { id: "asc" }],
|
|
}),
|
|
])
|
|
|
|
expect(asset).toMatchObject({
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-AVAILABLE-001",
|
|
deliveryNote: "DN-001",
|
|
status: "AVAILABLE",
|
|
notes: "Ready to assign",
|
|
})
|
|
expect(updatedItem.stock).toBe(1)
|
|
expect(movements).toHaveLength(1)
|
|
expect(movements[0]).toMatchObject({
|
|
type: "RECEIPT",
|
|
performedById: actor.id,
|
|
})
|
|
expect(movements[0].stockLines[0]).toMatchObject({
|
|
itemId: item.id,
|
|
stockDelta: 1,
|
|
previousStock: 0,
|
|
newStock: 1,
|
|
})
|
|
expect(movements[0].assetLines[0]).toMatchObject({
|
|
assetId: result.assetId,
|
|
})
|
|
})
|
|
|
|
it("persists operational asset fields during create and update flows", async () => {
|
|
const actor = await createTestUser(prisma)
|
|
const item = await createTestItem(prisma, { stock: 0 })
|
|
|
|
const created = await createAssetUseCase({
|
|
actorId: actor.id,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-OPS-001",
|
|
status: "AVAILABLE",
|
|
assetTag: "IT-000777",
|
|
manufacturer: "Lenovo",
|
|
model: "ThinkPad X1",
|
|
purchaseDate: new Date("2026-01-15T00:00:00.000Z"),
|
|
purchasePrice: 1249.99,
|
|
warrantyEndsAt: new Date("2028-01-15T00:00:00.000Z"),
|
|
})
|
|
|
|
expect(created.success).toBe(true)
|
|
if (!created.success) throw new Error("Expected asset creation success")
|
|
|
|
const createdAsset = await prisma.asset.findUniqueOrThrow({
|
|
where: { id: created.assetId },
|
|
})
|
|
|
|
expect(createdAsset).toMatchObject({
|
|
assetTag: "IT-000777",
|
|
manufacturer: "Lenovo",
|
|
model: "ThinkPad X1",
|
|
})
|
|
expect(createdAsset.purchaseDate?.toISOString()).toBe(
|
|
"2026-01-15T00:00:00.000Z",
|
|
)
|
|
expect(createdAsset.purchasePrice?.toString()).toBe("1249.99")
|
|
expect(createdAsset.warrantyEndsAt?.toISOString()).toBe(
|
|
"2028-01-15T00:00:00.000Z",
|
|
)
|
|
|
|
const updated = await updateAssetUseCase({
|
|
actorId: actor.id,
|
|
id: created.assetId,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-OPS-001",
|
|
status: "BROKEN",
|
|
assetTag: "IT-000778",
|
|
manufacturer: "Dell",
|
|
model: "Latitude 7420",
|
|
purchaseDate: new Date("2026-02-01T00:00:00.000Z"),
|
|
purchasePrice: 1499.5,
|
|
warrantyEndsAt: new Date("2027-02-01T00:00:00.000Z"),
|
|
})
|
|
|
|
expect(updated.success).toBe(true)
|
|
|
|
const updatedAsset = await prisma.asset.findUniqueOrThrow({
|
|
where: { id: created.assetId },
|
|
})
|
|
|
|
expect(updatedAsset).toMatchObject({
|
|
assetTag: "IT-000778",
|
|
manufacturer: "Dell",
|
|
model: "Latitude 7420",
|
|
status: "BROKEN",
|
|
})
|
|
expect(updatedAsset.purchaseDate?.toISOString()).toBe(
|
|
"2026-02-01T00:00:00.000Z",
|
|
)
|
|
expect(updatedAsset.purchasePrice?.toString()).toBe("1499.5")
|
|
expect(updatedAsset.warrantyEndsAt?.toISOString()).toBe(
|
|
"2027-02-01T00:00:00.000Z",
|
|
)
|
|
})
|
|
|
|
it("soft deletes assets and excludes them from active queries", async () => {
|
|
const actor = await createTestUser(prisma)
|
|
const item = await createTestItem(prisma, { stock: 0 })
|
|
|
|
const created = await createAssetUseCase({
|
|
actorId: actor.id,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-SOFT-DELETE-001",
|
|
status: "AVAILABLE",
|
|
})
|
|
|
|
expect(created.success).toBe(true)
|
|
if (!created.success) throw new Error("Expected asset creation success")
|
|
|
|
await AssetService.delete(created.assetId)
|
|
|
|
const deletedAsset = await prisma.asset.findUniqueOrThrow({
|
|
where: { id: created.assetId },
|
|
})
|
|
expect(deletedAsset.deletedAt).toBeInstanceOf(Date)
|
|
expect(await AssetService.findById(created.assetId)).toBeNull()
|
|
expect(await AssetService.findAllAssetsCount()).toBe(0)
|
|
expect(await AssetService.findAll()).toHaveLength(0)
|
|
})
|
|
|
|
it("creates an assigned asset with assignment and ASSIGNMENT movement", async () => {
|
|
const actor = await createTestUser(prisma)
|
|
const person = await createTestPerson(prisma)
|
|
const item = await createTestItem(prisma, { stock: 0 })
|
|
|
|
const result = await createAssetUseCase({
|
|
actorId: actor.id,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-ASSIGNED-001",
|
|
status: "ASSIGNED",
|
|
personId: person.id,
|
|
})
|
|
|
|
expect(result.success).toBe(true)
|
|
if (!result.success) throw new Error("Expected asset creation success")
|
|
|
|
const [asset, updatedItem, assignment, movements] = await Promise.all([
|
|
prisma.asset.findUniqueOrThrow({ where: { id: result.assetId } }),
|
|
prisma.item.findUniqueOrThrow({ where: { id: item.id } }),
|
|
prisma.assignment.findFirstOrThrow({
|
|
where: {
|
|
status: "OPEN",
|
|
assetLines: { some: { assetId: result.assetId, returnedAt: null } },
|
|
},
|
|
include: { assetLines: true },
|
|
}),
|
|
prisma.inventoryMovement.findMany({
|
|
include: { stockLines: true, assetLines: true },
|
|
orderBy: [{ createdAt: "asc" }, { id: "asc" }],
|
|
}),
|
|
])
|
|
|
|
expect(asset).toMatchObject({
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-ASSIGNED-001",
|
|
status: "ASSIGNED",
|
|
})
|
|
expect(updatedItem.stock).toBe(0)
|
|
expect(assignment).toMatchObject({
|
|
personId: person.id,
|
|
createdById: actor.id,
|
|
closedAt: null,
|
|
})
|
|
expect(assignment.assetLines[0]).toMatchObject({ assetId: result.assetId })
|
|
expect(movements).toHaveLength(1)
|
|
expect(movements[0]).toMatchObject({
|
|
type: "ASSIGNMENT",
|
|
assignmentId: assignment.id,
|
|
performedById: actor.id,
|
|
})
|
|
expect(movements[0].stockLines).toEqual([])
|
|
expect(movements[0].assetLines).toHaveLength(1)
|
|
expect(movements[0].assetLines[0]).toMatchObject({
|
|
assetId: result.assetId,
|
|
})
|
|
})
|
|
|
|
it("rejects creating an assigned asset without a person", async () => {
|
|
const actor = await createTestUser(prisma)
|
|
const item = await createTestItem(prisma, { stock: 0 })
|
|
|
|
const result = await createAssetUseCase({
|
|
actorId: actor.id,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-ASSIGNED-NO-PERSON-001",
|
|
status: "ASSIGNED",
|
|
})
|
|
|
|
expect(result).toEqual({
|
|
success: false,
|
|
errors: { personId: ["Person is required"] },
|
|
})
|
|
await expect(prisma.asset.count()).resolves.toBe(0)
|
|
})
|
|
|
|
it("moves an available asset to assigned and back to available", async () => {
|
|
const actor = await createTestUser(prisma)
|
|
const person = await createTestPerson(prisma)
|
|
const item = await createTestItem(prisma, { stock: 0 })
|
|
|
|
const created = await createAssetUseCase({
|
|
actorId: actor.id,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-LIFECYCLE-001",
|
|
status: "AVAILABLE",
|
|
})
|
|
|
|
expect(created.success).toBe(true)
|
|
if (!created.success) throw new Error("Expected asset creation success")
|
|
|
|
await expect(
|
|
updateAssetUseCase({
|
|
actorId: actor.id,
|
|
id: created.assetId,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-LIFECYCLE-001",
|
|
status: "ASSIGNED",
|
|
personId: person.id,
|
|
}),
|
|
).resolves.toEqual({ success: true })
|
|
|
|
const [assignedAsset, assignedItem, activeAssignment] = await Promise.all([
|
|
prisma.asset.findUniqueOrThrow({ where: { id: created.assetId } }),
|
|
prisma.item.findUniqueOrThrow({ where: { id: item.id } }),
|
|
prisma.assignment.findFirstOrThrow({
|
|
where: {
|
|
status: "OPEN",
|
|
assetLines: { some: { assetId: created.assetId, returnedAt: null } },
|
|
},
|
|
include: { assetLines: true },
|
|
}),
|
|
])
|
|
|
|
expect(assignedAsset.status).toBe("ASSIGNED")
|
|
expect(assignedItem.stock).toBe(0)
|
|
expect(activeAssignment).toMatchObject({
|
|
personId: person.id,
|
|
})
|
|
expect(activeAssignment.assetLines[0]).toMatchObject({
|
|
assetId: created.assetId,
|
|
})
|
|
|
|
await expect(
|
|
updateAssetUseCase({
|
|
actorId: actor.id,
|
|
id: created.assetId,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-LIFECYCLE-001",
|
|
status: "AVAILABLE",
|
|
}),
|
|
).resolves.toEqual({ success: true })
|
|
|
|
const [availableAsset, availableItem, returnedAssignment, movements] =
|
|
await Promise.all([
|
|
prisma.asset.findUniqueOrThrow({ where: { id: created.assetId } }),
|
|
prisma.item.findUniqueOrThrow({ where: { id: item.id } }),
|
|
prisma.assignment.findUniqueOrThrow({
|
|
where: { id: activeAssignment.id },
|
|
}),
|
|
prisma.inventoryMovement.findMany({
|
|
include: { stockLines: true, assetLines: true },
|
|
orderBy: [{ createdAt: "asc" }, { id: "asc" }],
|
|
}),
|
|
])
|
|
|
|
expect(availableAsset.status).toBe("AVAILABLE")
|
|
expect(availableItem.stock).toBe(1)
|
|
expect(returnedAssignment.closedAt).toBeInstanceOf(Date)
|
|
expect(returnedAssignment).toMatchObject({
|
|
personId: person.id,
|
|
status: "RETURNED",
|
|
})
|
|
expect(movements).toHaveLength(3)
|
|
expect(movements.map((movement) => movement.type)).toEqual([
|
|
"RECEIPT",
|
|
"ASSIGNMENT",
|
|
"RETURN",
|
|
])
|
|
expect(movements[0].stockLines[0]).toMatchObject({
|
|
itemId: item.id,
|
|
stockDelta: 1,
|
|
previousStock: 0,
|
|
newStock: 1,
|
|
})
|
|
expect(movements[1]).toMatchObject({
|
|
assignmentId: activeAssignment.id,
|
|
performedById: actor.id,
|
|
})
|
|
expect(movements[1].stockLines[0]).toMatchObject({
|
|
itemId: item.id,
|
|
stockDelta: -1,
|
|
previousStock: 1,
|
|
newStock: 0,
|
|
})
|
|
expect(movements[1].assetLines[0]).toMatchObject({
|
|
assetId: created.assetId,
|
|
})
|
|
expect(movements[2]).toMatchObject({
|
|
assignmentId: activeAssignment.id,
|
|
performedById: actor.id,
|
|
})
|
|
expect(movements[2].stockLines[0]).toMatchObject({
|
|
itemId: item.id,
|
|
stockDelta: 1,
|
|
previousStock: 0,
|
|
newStock: 1,
|
|
})
|
|
expect(movements[2].assetLines[0]).toMatchObject({
|
|
assetId: created.assetId,
|
|
})
|
|
})
|
|
|
|
it("rejects updating an asset to assigned without a person", async () => {
|
|
const actor = await createTestUser(prisma)
|
|
const item = await createTestItem(prisma, { stock: 0 })
|
|
|
|
const created = await createAssetUseCase({
|
|
actorId: actor.id,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-UPDATE-ASSIGNED-NO-PERSON-001",
|
|
status: "AVAILABLE",
|
|
})
|
|
|
|
expect(created.success).toBe(true)
|
|
if (!created.success) throw new Error("Expected asset creation success")
|
|
|
|
const result = await updateAssetUseCase({
|
|
actorId: actor.id,
|
|
id: created.assetId,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-UPDATE-ASSIGNED-NO-PERSON-001",
|
|
status: "ASSIGNED",
|
|
})
|
|
|
|
expect(result).toEqual({
|
|
success: false,
|
|
errors: { personId: ["Person is required"] },
|
|
})
|
|
|
|
const asset = await prisma.asset.findUniqueOrThrow({
|
|
where: { id: created.assetId },
|
|
})
|
|
expect(asset.status).toBe("AVAILABLE")
|
|
})
|
|
|
|
it("returns an active assignment without restoring stock when an assigned asset moves to a terminal status", async () => {
|
|
const actor = await createTestUser(prisma)
|
|
const person = await createTestPerson(prisma)
|
|
const item = await createTestItem(prisma, { stock: 0 })
|
|
|
|
const created = await createAssetUseCase({
|
|
actorId: actor.id,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-BROKEN-001",
|
|
status: "ASSIGNED",
|
|
personId: person.id,
|
|
})
|
|
|
|
expect(created.success).toBe(true)
|
|
if (!created.success) throw new Error("Expected asset creation success")
|
|
|
|
const activeAssignment = await prisma.assignment.findFirstOrThrow({
|
|
where: {
|
|
status: "OPEN",
|
|
assetLines: { some: { assetId: created.assetId, returnedAt: null } },
|
|
},
|
|
})
|
|
|
|
await expect(
|
|
updateAssetUseCase({
|
|
actorId: actor.id,
|
|
id: created.assetId,
|
|
itemId: item.id,
|
|
serialNumber: "ASSET-BROKEN-001",
|
|
status: "BROKEN",
|
|
}),
|
|
).resolves.toEqual({ success: true })
|
|
|
|
const [asset, itemAfterUpdate, returnedAssignment, movements] =
|
|
await Promise.all([
|
|
prisma.asset.findUniqueOrThrow({ where: { id: created.assetId } }),
|
|
prisma.item.findUniqueOrThrow({ where: { id: item.id } }),
|
|
prisma.assignment.findUniqueOrThrow({
|
|
where: { id: activeAssignment.id },
|
|
}),
|
|
prisma.inventoryMovement.findMany({
|
|
include: { stockLines: true, assetLines: true },
|
|
orderBy: [{ createdAt: "asc" }, { id: "asc" }],
|
|
}),
|
|
])
|
|
|
|
expect(asset.status).toBe("BROKEN")
|
|
expect(itemAfterUpdate.stock).toBe(0)
|
|
expect(returnedAssignment.closedAt).toBeInstanceOf(Date)
|
|
expect(movements).toHaveLength(2)
|
|
expect(movements.map((movement) => movement.type)).toEqual([
|
|
"ASSIGNMENT",
|
|
"RETURN",
|
|
])
|
|
expect(movements[1]).toMatchObject({
|
|
type: "RETURN",
|
|
assignmentId: activeAssignment.id,
|
|
performedById: actor.id,
|
|
})
|
|
expect(movements[1].stockLines[0]).toMatchObject({
|
|
itemId: item.id,
|
|
stockDelta: 1,
|
|
})
|
|
expect(movements[1].assetLines[0]).toMatchObject({
|
|
assetId: created.assetId,
|
|
})
|
|
})
|
|
})
|