@axiapps/gw2-data 0.1.1 → 0.1.2

package/tests/resolver.test.js

@@ -1,721 +0,0 @@
-"use strict";
-
-const {
-  groupFactsByMode,
-  parseFactsByMode,
-  resolveEntityFacts,
-  isDisambiguation,
-  extractInfoboxId,
-} = require("../src/wiki/resolver");
-const { WikiClient } = require("../src/wiki/client");
-const { MemoryCache } = require("../src/wiki/cache");
-
-describe("groupFactsByMode", () => {
-  test("universal facts go to all three arrays", () => {
-    const facts = [
-      { type: "Damage", text: "Damage", dmg_multiplier: 0.8, hit_count: 1, _modes: ["pve", "wvw", "pvp"] },
-    ];
-    const result = groupFactsByMode(facts);
-
-    expect(result.pve).toHaveLength(1);
-    expect(result.wvw).toHaveLength(1);
-    expect(result.pvp).toHaveLength(1);
-    expect(result.pve[0]).toEqual({ type: "Damage", text: "Damage", dmg_multiplier: 0.8, hit_count: 1 });
-    expect(result.wvw[0]).toEqual({ type: "Damage", text: "Damage", dmg_multiplier: 0.8, hit_count: 1 });
-    expect(result.pvp[0]).toEqual({ type: "Damage", text: "Damage", dmg_multiplier: 0.8, hit_count: 1 });
-  });
-
-  test("pve-only fact goes only to pve", () => {
-    const facts = [
-      { type: "Recharge", text: "Recharge", value: 10, _modes: ["pve"] },
-    ];
-    const result = groupFactsByMode(facts);
-
-    expect(result.pve).toHaveLength(1);
-    expect(result.wvw).toHaveLength(0);
-    expect(result.pvp).toHaveLength(0);
-  });
-
-  test("wvw+pvp fact goes to both but not pve", () => {
-    const facts = [
-      { type: "Recharge", text: "Recharge", value: 15, _modes: ["wvw", "pvp"] },
-    ];
-    const result = groupFactsByMode(facts);
-
-    expect(result.pve).toHaveLength(0);
-    expect(result.wvw).toHaveLength(1);
-    expect(result.pvp).toHaveLength(1);
-  });
-
-  test("mixed universal and mode-specific facts", () => {
-    const facts = [
-      { type: "Damage", text: "Damage", dmg_multiplier: 0.8, hit_count: 1, _modes: ["pve", "wvw", "pvp"] },
-      { type: "Recharge", text: "Recharge", value: 10, _modes: ["pve"] },
-      { type: "Recharge", text: "Recharge", value: 15, _modes: ["wvw", "pvp"] },
-    ];
-    const result = groupFactsByMode(facts);
-
-    expect(result.pve).toHaveLength(2); // damage + pve recharge
-    expect(result.wvw).toHaveLength(2); // damage + wvw/pvp recharge
-    expect(result.pvp).toHaveLength(2); // damage + wvw/pvp recharge
-  });
-
-  test("_modes is stripped from output facts", () => {
-    const facts = [
-      { type: "Damage", text: "Damage", dmg_multiplier: 1.0, hit_count: 1, _modes: ["pve", "wvw", "pvp"] },
-    ];
-    const result = groupFactsByMode(facts);
-
-    expect(result.pve[0]._modes).toBeUndefined();
-    expect(result.wvw[0]._modes).toBeUndefined();
-    expect(result.pvp[0]._modes).toBeUndefined();
-  });
-});
-
-describe("parseFactsByMode", () => {
-  test("simple skill with no split returns pve facts, null-able wvw/pvp", () => {
-    const wikitext = "{{skill fact|damage|0.8}}\n{{skill fact|recharge|10}}";
-    const result = parseFactsByMode(wikitext);
-
-    expect(result.pve.length).toBeGreaterThan(0);
-    expect(result.hasSplit).toBe(false);
-    // wvw/pvp get facts too (universal), but hasSplit is false
-    // so the caller (resolveEntityFacts) would set them to null
-  });
-
-  test("skill with pve/wvw split separates correctly", () => {
-    const wikitext = [
-      "| split = pve, wvw, pvp",
-      "{{skill fact|damage|0.8}}",
-      "{{skill fact|recharge|10|game mode = pve}}",
-      "{{skill fact|recharge|15|game mode = wvw pvp}}",
-    ].join("\n");
-    const result = parseFactsByMode(wikitext);
-
-    expect(result.hasSplit).toBe(true);
-    // PvE should have damage + pve recharge
-    const pveRecharge = result.pve.find((f) => f.type === "Recharge");
-    expect(pveRecharge.value).toBe(10);
-    // WvW should have damage + wvw/pvp recharge
-    const wvwRecharge = result.wvw.find((f) => f.type === "Recharge");
-    expect(wvwRecharge.value).toBe(15);
-  });
-
-  test("skill with only universal facts but split marker still returns hasSplit", () => {
-    const wikitext = [
-      "| split = pve, wvw pvp",
-      "{{skill fact|damage|0.8}}",
-      "| recharge pvp = 25",
-    ].join("\n");
-    const result = parseFactsByMode(wikitext);
-
-    // splitGrouping.wvwHasSplit is true (wvw grouped with pvp => wvwHasSplit true)
-    expect(result.hasSplit).toBe(true);
-    // wvw/pvp should have the universal damage fact
-    expect(result.wvw.length).toBeGreaterThan(0);
-    expect(result.pvp.length).toBeGreaterThan(0);
-  });
-});
-
-describe("resolveEntityFacts", () => {
-  let client;
-  let mockFetch;
-
-  beforeEach(() => {
-    mockFetch = jest.fn();
-    client = new WikiClient({ cache: new MemoryCache(), fetch: mockFetch });
-  });
-
-  test("resolves facts for multiple entities", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": {
-              title: "Fireball",
-              revisions: [{ "*": "{{skill fact|damage|0.8}}" }],
-            },
-            "2": {
-              title: "Heal",
-              revisions: [{ "*": "{{skill fact|healing|372|coefficient=0.25}}" }],
-            },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([
-      [5489, "Fireball"],
-      [5503, "Heal"],
-    ]);
-
-    const result = await resolveEntityFacts(client, idToTitle);
-
-    expect(result.size).toBe(2);
-    expect(result.get(5489).pve.length).toBeGreaterThan(0);
-    expect(result.get(5489).pve[0].type).toBe("Damage");
-    expect(result.get(5503).pve.length).toBeGreaterThan(0);
-    expect(result.get(5503).pve[0].type).toBe("AttributeAdjust");
-    // No split, so wvw/pvp should be null
-    expect(result.get(5489).wvw).toBeNull();
-    expect(result.get(5489).pvp).toBeNull();
-  });
-
-  test("skips missing wiki pages", async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": {
-              title: "Fireball",
-              revisions: [{ "*": "{{skill fact|damage|0.8}}" }],
-            },
-            "-1": {
-              title: "Nonexistent Skill",
-              missing: true,
-            },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([
-      [5489, "Fireball"],
-      [9999, "Nonexistent Skill"],
-    ]);
-
-    const result = await resolveEntityFacts(client, idToTitle);
-
-    expect(result.size).toBe(1);
-    expect(result.has(5489)).toBe(true);
-    expect(result.has(9999)).toBe(false);
-  });
-
-  test("returns empty map for empty input", async () => {
-    const idToTitle = new Map();
-    const result = await resolveEntityFacts(client, idToTitle);
-
-    expect(result.size).toBe(0);
-    expect(mockFetch).not.toHaveBeenCalled();
-  });
-
-  test("retries disambiguation pages with profession-specific suffix", async () => {
-    const disambigWikitext = "'''Charge''' may refer to:\n{{disambig}}\n* [[Charge (warrior skill)]]\n* [[Charge (ranger skill)]]";
-    const realWikitext = "{{skill fact|damage|0.8}}\n| recharge = 10";
-
-    // First fetch: returns the disambig page
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "100": { title: "Charge", revisions: [{ "*": disambigWikitext }] },
-          },
-        },
-      }),
-    });
-    // Second fetch: retry with "Charge (warrior skill)"
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "200": { title: "Charge (warrior skill)", revisions: [{ "*": realWikitext }] },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([[14401, "Charge"]]);
-    const result = await resolveEntityFacts(client, idToTitle, { profession: "Warrior" });
-
-    expect(result.size).toBe(1);
-    expect(result.has(14401)).toBe(true);
-    expect(result.get(14401).pve[0].type).toBe("Damage");
-    expect(result.get(14401).recharge.pve).toBe(10);
-    // Should have made 2 fetch calls: original batch + retry batch
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-  });
-
-  test("skips disambiguation pages when no profession provided", async () => {
-    const disambigWikitext = "'''Charge''' may refer to:\n{{disambig}}";
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "100": { title: "Charge", revisions: [{ "*": disambigWikitext }] },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([[14401, "Charge"]]);
-    const result = await resolveEntityFacts(client, idToTitle);
-
-    expect(result.size).toBe(0);
-    expect(mockFetch).toHaveBeenCalledTimes(1);
-  });
-
-  test("retries with prefix search when page has wrong infobox type", async () => {
-    const locationWikitext = "{{Location infobox\n| name = Ring of Fire\n| id = 20\n}}";
-    const skillWikitext = "{{Skill infobox\n| id = 5765\n}}\n{{skill fact|damage|1.0}}";
-
-    // Initial batch fetch returns location page
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": { title: "Ring of Fire", revisions: [{ "*": locationWikitext }] },
-          },
-        },
-      }),
-    });
-
-    // Prefix search for "Ring of Fire (" returns candidates
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          prefixsearch: [
-            { title: "Ring of Fire (elementalist skill)" },
-            { title: "Ring of Fire (location)" },
-          ],
-        },
-      }),
-    });
-
-    // Batch fetch of skill candidate (location filtered out by regex)
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "2": { title: "Ring of Fire (elementalist skill)", revisions: [{ "*": skillWikitext }] },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([[5765, "Ring of Fire"]]);
-    const result = await resolveEntityFacts(client, idToTitle, { profession: "Elementalist" });
-
-    expect(result.size).toBe(1);
-    expect(result.has(5765)).toBe(true);
-    expect(result.get(5765).pve[0].type).toBe("Damage");
-  });
-
-  test("prefix search finds generic (skill) suffix", async () => {
-    const weaponWikitext = "{{Weapon infobox\n| type = Sword\n| id = 29181\n}}";
-    const skillWikitext = "{{Skill infobox\n| id = 63281\n}}\n{{skill fact|damage|0.5}}";
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": { title: "Zap", revisions: [{ "*": weaponWikitext }] },
-          },
-        },
-      }),
-    });
-
-    // Prefix search returns only the generic (skill) page
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          prefixsearch: [{ title: "Zap (skill)" }],
-        },
-      }),
-    });
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "3": { title: "Zap (skill)", revisions: [{ "*": skillWikitext }] },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([[63281, "Zap"]]);
-    const result = await resolveEntityFacts(client, idToTitle, { profession: "Elementalist" });
-
-    expect(result.size).toBe(1);
-    expect(result.has(63281)).toBe(true);
-    expect(result.get(63281).pve[0].type).toBe("Damage");
-  });
-
-  test("accepts page directly when it has correct infobox type", async () => {
-    const skillWikitext = "{{Skill infobox\n| id = 5489\n}}\n{{skill fact|damage|0.8}}";
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": { title: "Fireball", revisions: [{ "*": skillWikitext }] },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([[5489, "Fireball"]]);
-    const result = await resolveEntityFacts(client, idToTitle, { profession: "Elementalist" });
-
-    expect(result.size).toBe(1);
-    expect(result.has(5489)).toBe(true);
-    expect(mockFetch).toHaveBeenCalledTimes(1);
-  });
-
-  test("falls back to API facts when prefix search finds no skill/trait candidates", async () => {
-    const locationWikitext = "{{Location infobox\n| name = Some Place\n| id = 99\n}}";
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": { title: "Some Place", revisions: [{ "*": locationWikitext }] },
-          },
-        },
-      }),
-    });
-
-    // Prefix search returns no skill/trait candidates
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          prefixsearch: [{ title: "Some Place (location)" }],
-        },
-      }),
-    });
-
-    // Batch fetch of the candidate page (location infobox, not skill/trait)
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "2": { title: "Some Place (location)", revisions: [{ "*": "{{Location infobox\n| name = Some Place\n| id = 99\n}}" }] },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([[12345, "Some Place"]]);
-    const result = await resolveEntityFacts(client, idToTitle, { profession: "Warrior" });
-
-    expect(result.size).toBe(0);
-  });
-
-  test("prefix search finds (trait skill) suffix", async () => {
-    const locationWikitext = "{{Location infobox\n| name = Pulmonary Impact\n| id = 99\n}}";
-    const traitSkillWikitext = "{{Skill infobox\n| id = 62710\n}}\n{{skill fact|damage|1.2}}";
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": { title: "Pulmonary Impact", revisions: [{ "*": locationWikitext }] },
-          },
-        },
-      }),
-    });
-
-    // Prefix search finds the (trait skill) page
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          prefixsearch: [{ title: "Pulmonary Impact (trait skill)" }],
-        },
-      }),
-    });
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "5": { title: "Pulmonary Impact (trait skill)", revisions: [{ "*": traitSkillWikitext }] },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([[62710, "Pulmonary Impact"]]);
-    const result = await resolveEntityFacts(client, idToTitle, { profession: "Harbinger" });
-
-    expect(result.size).toBe(1);
-    expect(result.has(62710)).toBe(true);
-    expect(result.get(62710).pve[0].type).toBe("Damage");
-  });
-
-  test("prefix search works without profession option", async () => {
-    const locationWikitext = "{{Location infobox\n| name = Some Skill\n| id = 99\n}}";
-    const skillWikitext = "{{Skill infobox\n| id = 1234\n}}\n{{skill fact|damage|0.5}}";
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": { title: "Some Skill", revisions: [{ "*": locationWikitext }] },
-          },
-        },
-      }),
-    });
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          prefixsearch: [{ title: "Some Skill (skill)" }],
-        },
-      }),
-    });
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "2": { title: "Some Skill (skill)", revisions: [{ "*": skillWikitext }] },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([[1234, "Some Skill"]]);
-    const result = await resolveEntityFacts(client, idToTitle); // no profession
-
-    expect(result.size).toBe(1);
-    expect(result.has(1234)).toBe(true);
-  });
-
-  test("resolves different facts for entities with disambiguated titles", async () => {
-    const weaponSkillWikitext = "{{Skill infobox\n| id = 12525\n}}\n{{skill fact|damage|1.5}}\n| recharge = 4";
-    const petSkillWikitext = "{{Skill infobox\n| id = 41406\n}}\n{{skill fact|damage|0.8}}\n| recharge = 10";
-
-    // Both titles fetched in a single batch
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": { title: "Maul (ranger greatsword skill)", revisions: [{ "*": weaponSkillWikitext }] },
-            "2": { title: "Maul (porcine)", revisions: [{ "*": petSkillWikitext }] },
-          },
-        },
-      }),
-    });
-
-    // Two different IDs, each with their own disambiguated title
-    const idToTitle = new Map([
-      [12525, "Maul (ranger greatsword skill)"],
-      [41406, "Maul (porcine)"],
-    ]);
-
-    const result = await resolveEntityFacts(client, idToTitle, { profession: "Ranger" });
-
-    expect(result.size).toBe(2);
-    // Weapon skill gets its own facts
-    expect(result.get(12525).pve[0].type).toBe("Damage");
-    expect(result.get(12525).recharge.pve).toBe(4);
-    // Pet skill gets different facts
-    expect(result.get(41406).pve[0].type).toBe("Damage");
-    expect(result.get(41406).recharge.pve).toBe(10);
-    // Only one batch fetch needed (both titles in the same request)
-    expect(mockFetch).toHaveBeenCalledTimes(1);
-  });
-
-  test("uses infobox ID matching to refine facts for colliding names", async () => {
-    // Wiki page "Maul" is about the ranger greatsword skill (id 12525).
-    // A pet skill (id 41406) shares the name "Maul" — it initially gets the same
-    // facts, but the resolver's prefix search finds a better-matched page and
-    // overwrites with the correct facts.
-    const mainPageWikitext = "{{Skill infobox\n| id = 12525\n}}\n{{skill fact|damage|1.5}}\n| recharge = 4";
-    const petPageWikitext = "{{Skill infobox\n| id = 41406\n}}\n{{skill fact|damage|0.8}}\n| recharge = 10";
-
-    // Initial batch: both IDs request "Maul"
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": { title: "Maul", revisions: [{ "*": mainPageWikitext }] },
-          },
-        },
-      }),
-    });
-
-    // Prefix search for "Maul (" returns candidates
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          prefixsearch: [
-            { title: "Maul (porcine)" },
-            { title: "Maul (ranger greatsword skill)" },
-          ],
-        },
-      }),
-    });
-
-    // Batch fetch of prefix search candidates
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "2": { title: "Maul (porcine)", revisions: [{ "*": petPageWikitext }] },
-            "3": { title: "Maul (ranger greatsword skill)", revisions: [{ "*": mainPageWikitext }] },
-          },
-        },
-      }),
-    });
-
-    // Both IDs share the same bare title "Maul"
-    const idToTitle = new Map([
-      [12525, "Maul"],
-      [41406, "Maul"],
-    ]);
-
-    const result = await resolveEntityFacts(client, idToTitle, { profession: "Ranger" });
-
-    expect(result.size).toBe(2);
-    // Weapon skill matched by infobox ID on the main page
-    expect(result.get(12525).recharge.pve).toBe(4);
-    // Pet skill: initially got main page facts, then overwritten by prefix search match
-    expect(result.get(41406).recharge.pve).toBe(10);
-  });
-
-  test("shares facts across variant IDs when page lists matching infobox ID", async () => {
-    // "True Nature" has multiple API IDs (one per legend) but one wiki page.
-    // The wiki lists only one ID in its infobox. All IDs should get the facts,
-    // and unmatched IDs get queued for prefix search (which finds nothing, so
-    // they keep the initially-shared facts).
-    const wikitext = "{{Skill infobox\n| id = 29393\n}}\n{{skill fact|damage|0.5}}\n| recharge = 1";
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "1": { title: "True Nature", revisions: [{ "*": wikitext }] },
-          },
-        },
-      }),
-    });
-
-    // Prefix search for unmatched IDs — finds nothing useful
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({ query: { prefixsearch: [] } }),
-    });
-
-    const idToTitle = new Map([
-      [29393, "True Nature"],
-      [51675, "True Nature"],
-      [51714, "True Nature"],
-    ]);
-
-    const result = await resolveEntityFacts(client, idToTitle);
-
-    // All 3 IDs should have facts (shared from the one wiki page)
-    expect(result.size).toBe(3);
-    expect(result.get(29393).recharge.pve).toBe(1);
-    expect(result.get(51675).recharge.pve).toBe(1);
-    expect(result.get(51714).recharge.pve).toBe(1);
-  });
-
-  test("skips pages with no fact templates (keeps API facts)", async () => {
-    // A wiki page exists but has no {{skill fact|...}} or {{trait fact|...}} templates
-    const noFactsWikitext = "'''Piercing Shards''' is a trait for Elementalist that makes ice shards pierce.";
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        query: {
-          pages: {
-            "42": { title: "Piercing Shards", revisions: [{ slots: { main: { "*": noFactsWikitext } } }] },
-          },
-        },
-      }),
-    });
-
-    const idToTitle = new Map([[1234, "Piercing Shards"]]);
-    const result = await resolveEntityFacts(client, idToTitle);
-
-    // Should NOT have an entry — empty facts would wipe valid API facts
-    expect(result.size).toBe(0);
-    expect(result.has(1234)).toBe(false);
-  });
-});
-
-describe("isDisambiguation", () => {
-  test("detects {{disambig}} template", () => {
-    expect(isDisambiguation("Some text\n{{disambig}}\n* [[Link]]")).toBe(true);
-  });
-
-  test("detects {{disambiguation}} template", () => {
-    expect(isDisambiguation("{{disambiguation}}\n* [[Link]]")).toBe(true);
-  });
-
-  test("detects {{disambig|...}} with parameters", () => {
-    expect(isDisambiguation("{{disambig|skill}}\n* [[Link]]")).toBe(true);
-  });
-
-  test("returns false for normal skill pages", () => {
-    expect(isDisambiguation("{{skill fact|damage|0.8}}\n| recharge = 10")).toBe(false);
-  });
-
-  test("returns false for pages mentioning disambig in prose", () => {
-    expect(isDisambiguation("This page is not a disambiguation page")).toBe(false);
-  });
-});
-
-describe("extractInfoboxId", () => {
-  test("extracts single ID from skill infobox", () => {
-    const wikitext = "{{Skill infobox\n| id = 5489\n| description = Launch a ball of fire.\n}}";
-    expect(extractInfoboxId(wikitext)).toEqual([5489]);
-  });
-
-  test("extracts multi-ID from skill infobox", () => {
-    const wikitext = "{{Skill infobox\n| id = 5805,6020\n| description = Equip a kit.\n}}";
-    expect(extractInfoboxId(wikitext)).toEqual([5805, 6020]);
-  });
-
-  test("extracts ID from trait infobox", () => {
-    const wikitext = "{{Trait infobox\n| line = Spite\n| id = 903\n}}";
-    expect(extractInfoboxId(wikitext)).toEqual([903]);
-  });
-
-  test("returns empty array for location infobox", () => {
-    const wikitext = "{{Location infobox\n| name = Ring of Fire\n| id = 20\n}}";
-    expect(extractInfoboxId(wikitext)).toEqual([]);
-  });
-
-  test("returns empty array for weapon infobox", () => {
-    const wikitext = "{{Weapon infobox\n| type = Sword\n| id = 29181\n}}";
-    expect(extractInfoboxId(wikitext)).toEqual([]);
-  });
-
-  test("returns empty array for page with no infobox", () => {
-    const wikitext = "'''Some Page''' is about something.";
-    expect(extractInfoboxId(wikitext)).toEqual([]);
-  });
-
-  test("handles whitespace variations", () => {
-    const wikitext = "{{Skill infobox\n|id=5489\n}}";
-    expect(extractInfoboxId(wikitext)).toEqual([5489]);
-  });
-});