BlueGit

timfa questward

Files

questward / server / tests / origins.test.js

origins.test.js

origins.test.js 4.4 KiB Download Raw
1import test from "node:test";
2import assert from "node:assert/strict";
3import { ItemOriginKind, formatOriginBreakdown, mergeOriginLists, splitOrigins } from "../../shared/items/origin.js";
4import { emptySlots, insertStack, takeFromSlot, insertStackGrowable, singleItemFromStack } from "../../shared/items/inventory.js";
5import { stackRulesFor } from "../../shared/items/stackRules.js";
6import { ItemId, itemDefinition } from "../../shared/definitions/items.js";
7
8const crafterA = { kind: ItemOriginKind.crafted, displayName: "Ada" };
9const crafterB = { kind: ItemOriginKind.crafted, displayName: "Bob" };
10
11test("mixed-origin stacks merge and show a breakdown label", () =>
12{
13 const slots = emptySlots();
14 const def = itemDefinition(ItemId.apple);
15 const first = insertStack(slots, {
16 itemId: ItemId.apple,
17 quantity: 5,
18 origins: [{ origin: crafterA, quantity: 5 }]
19 }, def);
20 const second = insertStack(first.slots, {
21 itemId: ItemId.apple,
22 quantity: 3,
23 origins: [{ origin: crafterB, quantity: 3 }]
24 }, def);
25 assert.equal(second.ok, true);
26 assert.equal(second.slots[0].quantity, 8);
27 assert.equal(formatOriginBreakdown(second.slots[0]), "5 made by Ada, 3 made by Bob");
28});
29
30test("splitting a stack distributes origins FIFO", () =>
31{
32 const slots = emptySlots();
33 const def = itemDefinition(ItemId.apple);
34 const inserted = insertStack(slots, {
35 itemId: ItemId.apple,
36 quantity: 8,
37 origins: [
38 { origin: crafterA, quantity: 5 },
39 { origin: crafterB, quantity: 3 }
40 ]
41 }, def);
42 const taken = takeFromSlot(inserted.slots, 0, 6);
43 assert.equal(taken.taken.quantity, 6);
44 assert.deepEqual(taken.taken.origins, [
45 { origin: crafterA, quantity: 5 },
46 { origin: crafterB, quantity: 1 }
47 ]);
48 assert.deepEqual(taken.slots[0].origins, [
49 { origin: crafterB, quantity: 2 }
50 ]);
51});
52
53test("equipment stacks only in inventory, but can stack in the vault", () =>
54{
55 const shirt = itemDefinition(ItemId.clothShirt);
56 const invRules = stackRulesFor(shirt, { inVault: false });
57 const vaultRules = stackRulesFor(shirt, { inVault: true });
58 assert.equal(invRules.maxStackSize, 1);
59 assert.equal(invRules.stackable, false);
60 assert.equal(vaultRules.stackable, true);
61 assert.equal(vaultRules.maxStackSize, Number.POSITIVE_INFINITY);
62
63 const inv = insertStack(emptySlots(), { itemId: ItemId.clothShirt, quantity: 1 }, shirt);
64 const invSecond = insertStack(inv.slots, { itemId: ItemId.clothShirt, quantity: 1 }, shirt);
65 assert.equal(invSecond.slots.filter(Boolean).length, 2);
66
67 const vault = insertStackGrowable([], { itemId: ItemId.clothShirt, quantity: 1 }, shirt);
68 const vaultSecond = insertStackGrowable(vault.slots, { itemId: ItemId.clothShirt, quantity: 1 }, shirt);
69 assert.equal(vaultSecond.slots.length, 1);
70 assert.equal(vaultSecond.slots[0].quantity, 2);
71});
72
73test("unique items never stack, even in the vault", () =>
74{
75 const letter = itemDefinition(ItemId.letter);
76 const vaultRules = stackRulesFor(letter, { inVault: true });
77 assert.equal(vaultRules.uniqueInstance, true);
78 assert.equal(vaultRules.stackable, false);
79
80 const first = insertStackGrowable([], {
81 itemId: ItemId.letter,
82 quantity: 1,
83 instance: { kind: "letter", letterId: "a", body: "Hi" }
84 }, letter);
85 const second = insertStackGrowable(first.slots, {
86 itemId: ItemId.letter,
87 quantity: 1,
88 instance: { kind: "letter", letterId: "b", body: "Bye" }
89 }, letter);
90 assert.equal(second.slots.length, 2);
91});
92
93test("mergeOriginLists combines matching crafters", () =>
94{
95 const merged = mergeOriginLists(
96 [{ origin: crafterA, quantity: 2 }],
97 [{ origin: crafterA, quantity: 3 }, { origin: crafterB, quantity: 1 }]
98 );
99 assert.deepEqual(merged, [
100 { origin: crafterA, quantity: 5 },
101 { origin: crafterB, quantity: 1 }
102 ]);
103 const split = splitOrigins(merged, 6);
104 assert.deepEqual(split.taken, [
105 { origin: crafterA, quantity: 5 },
106 { origin: crafterB, quantity: 1 }
107 ]);
108});
109
110test("unequip-style insert merges stackable items within max stack size", () =>
111{
112 const def = itemDefinition(ItemId.apple);
113 const origin = { kind: ItemOriginKind.crafted, displayName: "Ada" };
114 let slots = emptySlots();
115 slots[0] = { itemId: ItemId.apple, quantity: 5, origins: [{ origin, quantity: 5 }] };
116 const worn = singleItemFromStack({
117 itemId: ItemId.apple,
118 quantity: 1,
119 origins: [{ origin, quantity: 1 }]
120 });
121 const inserted = insertStack(slots, worn, def);
122 assert.equal(inserted.ok, true);
123 assert.equal(inserted.slots[0].quantity, 6);
124 assert.equal(inserted.slots.filter(Boolean).length, 1);
125});