308 lines
10 KiB
TypeScript
308 lines
10 KiB
TypeScript
import { afterAll, beforeAll, describe, expect, it } from "vitest";
|
||
import { tr } from "@/i18n/tr";
|
||
import { AuditLogModel } from "@/models/audit-log";
|
||
import { StockMovementModel } from "@/models/stock-movement";
|
||
import { todayIstanbul } from "@/shared/dates";
|
||
import { addDays } from "@/shared/recurrence";
|
||
import {
|
||
productTypeFormSchema,
|
||
stockCategoryFormSchema,
|
||
stockCountFormSchema,
|
||
stockMovementFormSchema,
|
||
type ProductTypeFormInput,
|
||
} from "@/shared/schemas/stock";
|
||
import { setupSeededDb, teardownDb } from "@/test/seeded-db";
|
||
import {
|
||
addStockMovement,
|
||
countStock,
|
||
createProductType,
|
||
createStockCategory,
|
||
deleteStockMovement,
|
||
getProductType,
|
||
getStock,
|
||
getStockOptions,
|
||
listStockCategories,
|
||
quickConsume,
|
||
setProductTypeArchived,
|
||
setStockCategoryArchived,
|
||
updateStockCategory,
|
||
} from "./service";
|
||
|
||
let ids: Awaited<ReturnType<typeof setupSeededDb>>;
|
||
let cakir = "";
|
||
let ayse = "";
|
||
let zeynep = "";
|
||
let fatma = "";
|
||
const today = todayIstanbul();
|
||
|
||
beforeAll(async () => {
|
||
ids = await setupSeededDb();
|
||
cakir = ids.household("Çakır Ailesi");
|
||
ayse = ids.user("ayse");
|
||
zeynep = ids.user("zeynep");
|
||
fatma = ids.user("fatma");
|
||
});
|
||
afterAll(teardownDb);
|
||
|
||
async function categoryId(path: string) {
|
||
const o = (await getStockOptions(ayse, cakir))!;
|
||
return o.categories.find((c) => c.path === path)!.id;
|
||
}
|
||
|
||
function product(input: Partial<ProductTypeFormInput> & { categoryId: string }) {
|
||
return productTypeFormSchema.parse({
|
||
name: "Test Ürün",
|
||
unit: "kg",
|
||
targetQuantity: "4",
|
||
thresholdPct: "20",
|
||
step: "0,5",
|
||
...input,
|
||
});
|
||
}
|
||
|
||
describe("seed ve görünüm", () => {
|
||
it("varsayılan ağaç, gider eşlemesi devralınır; azalanlar ve SKT", async () => {
|
||
const s = (await getStock(ayse, cakir))!;
|
||
expect(s.items).toHaveLength(19);
|
||
const bakliyat = s.categories.find((c) => c.path === "Mutfak › Bakliyat")!;
|
||
expect(bakliyat.depth).toBe(1);
|
||
expect(bakliyat.expense).toEqual(
|
||
expect.objectContaining({ path: "Market › Gıda", inherited: true }),
|
||
);
|
||
expect(s.categories.find((c) => c.path === "Mutfak")!.expense?.inherited).toBe(false);
|
||
// Bir süredir alınmayanlar eşiğin altında.
|
||
const low = s.suggestions.map((i) => i.name);
|
||
expect(low).toEqual(expect.arrayContaining(["Kırmızı Mercimek", "Tablet Deterjan"]));
|
||
for (const i of s.suggestions) {
|
||
expect(i.level.low).toBe(true);
|
||
expect(i.suggestedQuantity).toBe(i.targetQuantity - Math.max(0, i.current));
|
||
}
|
||
// Hiçbir stok eksiye düşmez; süt partilerinin SKT'si yakın.
|
||
expect(s.items.every((i) => i.current >= 0)).toBe(true);
|
||
expect(s.expiring.some((e) => e.item.name === "Süt")).toBe(true);
|
||
// Kategori sırası: Mutfak ürünleri temizlikten önce.
|
||
expect(s.items.findIndex((i) => i.name === "Domates")).toBeLessThan(
|
||
s.items.findIndex((i) => i.name === "Toz Deterjan"),
|
||
);
|
||
|
||
const annemler = (await getStock(fatma, ids.household("Annemler")))!;
|
||
expect(annemler.items).toHaveLength(0);
|
||
expect(annemler.categories.length).toBe(12);
|
||
});
|
||
|
||
it("izolasyon: üye olmayan göremez, izleyici yazamaz", async () => {
|
||
expect(await getStock(fatma, cakir)).toBeNull();
|
||
const s = (await getStock(zeynep, cakir))!;
|
||
expect(s.canWrite).toBe(false);
|
||
const any = s.items[0]!;
|
||
expect((await quickConsume(zeynep, cakir, any.id)).ok).toBe(false);
|
||
expect(await getProductType(fatma, cakir, any.id)).toBeNull();
|
||
});
|
||
});
|
||
|
||
describe("ürün tipi ve hareketler", () => {
|
||
it("başlangıç miktarı, tüketim sınırı, 1 azalt, fire, SKT FIFO, sayım, silme", async () => {
|
||
const cat = await categoryId("Mutfak › Bakliyat");
|
||
const created = await createProductType(
|
||
ayse,
|
||
cakir,
|
||
product({ categoryId: cat, name: "Bulgur", initialQuantity: "1,5" }),
|
||
);
|
||
expect(created.ok).toBe(true);
|
||
const id = created.ok ? created.data.id : "";
|
||
let p = (await getProductType(ayse, cakir, id))!;
|
||
expect(p.current).toBe(1_500);
|
||
expect(p.movements[0]).toMatchObject({ kind: "count_adjust", initial: true, delta: 1_500 });
|
||
// 1,5 < %20 × 4 = 0,8? hayır → azalmadı.
|
||
expect(p.level.low).toBe(false);
|
||
|
||
const dup = await createProductType(ayse, cakir, product({ categoryId: cat, name: "bulgur" }));
|
||
expect(dup.ok).toBe(false);
|
||
|
||
const tooMuch = await addStockMovement(
|
||
ayse,
|
||
cakir,
|
||
id,
|
||
stockMovementFormSchema.parse({ kind: "consume", date: today, quantity: "2" }),
|
||
);
|
||
expect(tooMuch).toMatchObject({ ok: false, fieldErrors: { quantity: expect.any(String) } });
|
||
|
||
const q = await quickConsume(ayse, cakir, id);
|
||
expect(q).toEqual({ ok: true, data: { remaining: 1_000 } });
|
||
|
||
// Alım (SKT'li) sonra fire: fire en eski partiden (başlangıç) düşer.
|
||
await addStockMovement(
|
||
ayse,
|
||
cakir,
|
||
id,
|
||
stockMovementFormSchema.parse({
|
||
kind: "purchase",
|
||
date: today,
|
||
quantity: "1",
|
||
expiryDate: addDays(today, 3),
|
||
}),
|
||
);
|
||
expect(
|
||
stockMovementFormSchema.safeParse({ kind: "waste", date: today, quantity: "1" }).success,
|
||
).toBe(false);
|
||
await addStockMovement(
|
||
ayse,
|
||
cakir,
|
||
id,
|
||
stockMovementFormSchema.parse({
|
||
kind: "waste",
|
||
date: today,
|
||
quantity: "0,8",
|
||
wasteReason: "spoiled",
|
||
}),
|
||
);
|
||
p = (await getProductType(ayse, cakir, id))!;
|
||
expect(p.current).toBe(1_200);
|
||
expect(p.lots).toEqual([
|
||
expect.objectContaining({ remaining: 200, expiryDate: null }),
|
||
expect.objectContaining({ remaining: 1_000, expiryDate: addDays(today, 3), status: "soon" }),
|
||
]);
|
||
expect(p.expiring).toHaveLength(1);
|
||
|
||
// Sayım: 0,5 sayıldı → −0,7 düzeltme; aynı miktar tekrar → fark yok.
|
||
const c = await countStock(
|
||
ayse,
|
||
cakir,
|
||
id,
|
||
stockCountFormSchema.parse({ date: today, actualQuantity: "0,5" }),
|
||
);
|
||
expect(c).toEqual({ ok: true, data: { diff: -700 } });
|
||
const same = await countStock(
|
||
ayse,
|
||
cakir,
|
||
id,
|
||
stockCountFormSchema.parse({ date: today, actualQuantity: "0,5" }),
|
||
);
|
||
expect(same).toEqual({ ok: true, data: { diff: 0 } });
|
||
p = (await getProductType(ayse, cakir, id))!;
|
||
expect(p.current).toBe(500);
|
||
expect(p.level.low).toBe(true);
|
||
expect(p.suggestedQuantity).toBe(3_500);
|
||
|
||
// Hareket silme: yeniden hesap + denetim kaydı.
|
||
const adj = p.movements[0]!;
|
||
expect(adj.kind).toBe("count_adjust");
|
||
expect((await deleteStockMovement(ayse, cakir, adj.id)).ok).toBe(true);
|
||
expect((await getProductType(ayse, cakir, id))!.current).toBe(1_200);
|
||
expect(
|
||
await AuditLogModel.exists({ action: "stock.movement.delete", targetId: adj.id }),
|
||
).toBeTruthy();
|
||
expect(await StockMovementModel.exists({ _id: adj.id, deletedAt: null })).toBeNull();
|
||
|
||
// Arşivli üründe hareket yok; arşivden çıkınca devam.
|
||
expect((await setProductTypeArchived(ayse, cakir, id, true)).ok).toBe(true);
|
||
expect((await quickConsume(ayse, cakir, id)).ok).toBe(false);
|
||
expect((await getStock(ayse, cakir))!.items.some((i) => i.id === id)).toBe(false);
|
||
expect((await setProductTypeArchived(ayse, cakir, id, false)).ok).toBe(true);
|
||
});
|
||
|
||
it("boş stokta 1 azalt reddedilir; özel birim", async () => {
|
||
const cat = await categoryId("Genel Temizlik › Çamaşır");
|
||
const r = await createProductType(
|
||
ayse,
|
||
cakir,
|
||
product({ categoryId: cat, name: "Leke Çıkarıcı", unit: "yıkama", step: "1" }),
|
||
);
|
||
const id = r.ok ? r.data.id : "";
|
||
expect(await quickConsume(ayse, cakir, id)).toEqual({
|
||
ok: false,
|
||
error: tr.stock.validation.emptyStock,
|
||
});
|
||
expect((await getProductType(ayse, cakir, id))!.unit).toBe("yıkama");
|
||
});
|
||
});
|
||
|
||
describe("stok kategorileri", () => {
|
||
it("oluştur, gider eşle, taşıma kuralları, arşiv koşulu", async () => {
|
||
const opts = (await getStockOptions(ayse, cakir))!;
|
||
const market = opts.expenseCategories.find((c) => c.path === "Market")!;
|
||
const parent = await createStockCategory(
|
||
ayse,
|
||
cakir,
|
||
stockCategoryFormSchema.parse({
|
||
name: "Bebek",
|
||
parentId: "",
|
||
expenseCategoryId: market.id,
|
||
countEveryDays: "30",
|
||
}),
|
||
);
|
||
const parentId = parent.ok ? parent.data.id : "";
|
||
const child = await createStockCategory(
|
||
ayse,
|
||
cakir,
|
||
stockCategoryFormSchema.parse({
|
||
name: "Bez",
|
||
parentId,
|
||
expenseCategoryId: "",
|
||
countEveryDays: "",
|
||
}),
|
||
);
|
||
const childId = child.ok ? child.data.id : "";
|
||
let list = (await listStockCategories(ayse, cakir))!.categories;
|
||
const bez = list.find((c) => c.id === childId)!;
|
||
expect(bez).toMatchObject({
|
||
path: "Bebek › Bez",
|
||
effectiveCountDays: 30,
|
||
expense: expect.objectContaining({ path: "Market", inherited: true }),
|
||
});
|
||
|
||
// Kendi altına taşınamaz; aynı adlı kardeş olamaz.
|
||
const loop = await updateStockCategory(
|
||
ayse,
|
||
cakir,
|
||
parentId,
|
||
stockCategoryFormSchema.parse({
|
||
name: "Bebek",
|
||
parentId: childId,
|
||
expenseCategoryId: "",
|
||
countEveryDays: "",
|
||
}),
|
||
);
|
||
expect(loop.ok).toBe(false);
|
||
const dup = await createStockCategory(
|
||
ayse,
|
||
cakir,
|
||
stockCategoryFormSchema.parse({
|
||
name: "mutfak",
|
||
parentId: "",
|
||
expenseCategoryId: "",
|
||
countEveryDays: "",
|
||
}),
|
||
);
|
||
expect(dup.ok).toBe(false);
|
||
|
||
// Gelir kategorisi eşlenemez.
|
||
const income = await createStockCategory(ayse, cakir, {
|
||
name: "Yanlış",
|
||
parentId: null,
|
||
expenseCategoryId: "0".repeat(24),
|
||
countEveryDays: null,
|
||
});
|
||
expect(income.ok).toBe(false);
|
||
|
||
// Ürün varken arşivlenemez; ürün yokken alt ağaçla arşivlenir.
|
||
const r = await createProductType(
|
||
ayse,
|
||
cakir,
|
||
product({ categoryId: childId, name: "Islak Mendil" }),
|
||
);
|
||
expect((await setStockCategoryArchived(ayse, cakir, parentId, true)).ok).toBe(false);
|
||
await setProductTypeArchived(ayse, cakir, r.ok ? r.data.id : "", true);
|
||
expect((await setStockCategoryArchived(ayse, cakir, parentId, true)).ok).toBe(true);
|
||
list = (await listStockCategories(ayse, cakir))!.categories;
|
||
expect(list.find((c) => c.id === childId)!.archived).toBe(true);
|
||
expect((await getStockOptions(ayse, cakir))!.categories.some((c) => c.id === childId)).toBe(
|
||
false,
|
||
);
|
||
// Arşivli kategoriye ürün eklenemez.
|
||
expect(
|
||
(await createProductType(ayse, cakir, product({ categoryId: childId, name: "Pudra" }))).ok,
|
||
).toBe(false);
|
||
});
|
||
});
|