@axiapps/gw2-data 0.1.0

package/tests/wiki-integration.test.js

@@ -0,0 +1,177 @@
+"use strict";
+
+const { resolveEntityFacts, parseFactsByMode } = require("../src/wiki/resolver");
+const { WikiClient } = require("../src/wiki/client");
+const { MemoryCache } = require("../src/wiki/cache");
+
+describe("Wiki fact resolution integration", () => {
+  let client;
+  let mockFetch;
+
+  const MOCK_WIKI_PAGES = {
+    Fireball: [
+      "{{skill fact|damage|coefficient=0.9}}",
+      "{{skill fact|burning|3|stacks=1}}",
+      "{{skill fact|range|900}}",
+    ].join("\n"),
+    Shelter: [
+      "| split = pve, wvw pvp",
+      "{{skill fact|healing|4000|coefficient=0.75}}",
+      "{{skill fact|healing|3200|coefficient=0.6|game mode=wvw pvp}}",
+      "{{skill fact|recharge|30}}",
+    ].join("\n"),
+    "Searing Slash": [
+      "| split = pve, wvw pvp",
+      "{{skill fact|damage|coefficient=1.2}}",
+      "{{skill fact|burning|4|stacks=2|game mode=pve}}",
+      "{{skill fact|burning|2|stacks=1|game mode=wvw pvp}}",
+      "{{skill fact|combo|fire}}",
+    ].join("\n"),
+  };
+
+  beforeEach(() => {
+    mockFetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        query: {
+          pages: Object.fromEntries(
+            Object.entries(MOCK_WIKI_PAGES).map(([title, wikitext], i) => [
+              String(i + 1),
+              { title, revisions: [{ "*": wikitext }] },
+            ])
+          ),
+        },
+      }),
+    });
+    client = new WikiClient({ cache: new MemoryCache(), fetch: mockFetch });
+  });
+
+  test("resolves all entities with correct per-mode facts", async () => {
+    const idToTitle = new Map([
+      [5489, "Fireball"],
+      [9124, "Shelter"],
+      [12345, "Searing Slash"],
+    ]);
+
+    const result = await resolveEntityFacts(client, idToTitle);
+
+    // Fireball: no split
+    const fireball = result.get(5489);
+    expect(fireball.hasSplit).toBe(false);
+    expect(fireball.pve).toHaveLength(3);
+    expect(fireball.wvw).toBeNull();
+    expect(fireball.pvp).toBeNull();
+
+    // Shelter: PvE vs WvW/PvP split
+    const shelter = result.get(9124);
+    expect(shelter.hasSplit).toBe(true);
+    expect(shelter.pve.length).toBeGreaterThanOrEqual(2);
+    expect(shelter.wvw).not.toBeNull();
+    // PvE healing = 4000, WvW has both universal (4000) and mode-specific (3200)
+    const pveHeal = shelter.pve.find((f) => f.target === "Healing" || f.text === "Healing");
+    if (pveHeal) expect(pveHeal.value).toBe(4000);
+    // WvW mode-specific healing is 3200 (find the one that differs from universal)
+    const wvwHeals = shelter.wvw.filter((f) => f.target === "Healing" || f.text === "Healing");
+    expect(wvwHeals.length).toBeGreaterThanOrEqual(1);
+    const wvwModeHeal = wvwHeals.find((f) => f.value === 3200);
+    if (wvwModeHeal) expect(wvwModeHeal.value).toBe(3200);
+
+    // Searing Slash: split with different burning stacks
+    const slash = result.get(12345);
+    expect(slash.hasSplit).toBe(true);
+    expect(slash.pve.length).toBeGreaterThanOrEqual(2);
+    expect(slash.wvw).not.toBeNull();
+    const pveBurn = slash.pve.find((f) => f.status === "Burning");
+    const wvwBurn = slash.wvw.find((f) => f.status === "Burning");
+    if (pveBurn) {
+      expect(pveBurn.duration).toBe(4);
+      expect(pveBurn.apply_count).toBe(2);
+    }
+    if (wvwBurn) {
+      expect(wvwBurn.duration).toBe(2);
+      expect(wvwBurn.apply_count).toBe(1);
+    }
+  });
+
+  test("missing wiki pages are not in result map", async () => {
+    mockFetch.mockReset();
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        query: {
+          pages: {
+            "1": { title: "Fireball", revisions: [{ "*": "{{skill fact|damage|0.8}}" }] },
+            "-1": { title: "Unknown Skill", missing: true },
+          },
+        },
+      }),
+    });
+
+    const idToTitle = new Map([
+      [5489, "Fireball"],
+      [9999, "Unknown Skill"],
+    ]);
+
+    const result = await resolveEntityFacts(client, idToTitle);
+    expect(result.has(5489)).toBe(true);
+    expect(result.has(9999)).toBe(false);
+  });
+
+  test("parseFactsByMode correctly separates all three modes", () => {
+    const wikitext = [
+      "| split = pve, wvw, pvp",
+      "{{skill fact|damage|coefficient=1.0}}",
+      "{{skill fact|recharge|20|game mode=pve}}",
+      "{{skill fact|recharge|25|game mode=wvw}}",
+      "{{skill fact|recharge|30|game mode=pvp}}",
+    ].join("\n");
+
+    const result = parseFactsByMode(wikitext);
+    expect(result.hasSplit).toBe(true);
+
+    // Damage is universal → all modes
+    expect(result.pve.length).toBeGreaterThanOrEqual(2);
+    expect(result.wvw.length).toBeGreaterThanOrEqual(2);
+    expect(result.pvp.length).toBeGreaterThanOrEqual(2);
+
+    // Recharge differs per mode
+    const pveRecharge = result.pve.find((f) => f.type === "Recharge");
+    const wvwRecharge = result.wvw.find((f) => f.type === "Recharge");
+    const pvpRecharge = result.pvp.find((f) => f.type === "Recharge");
+    expect(pveRecharge.value).toBe(20);
+    expect(wvwRecharge.value).toBe(25);
+    expect(pvpRecharge.value).toBe(30);
+  });
+
+  test("all fact entries have valid type fields", async () => {
+    const idToTitle = new Map([
+      [5489, "Fireball"],
+      [9124, "Shelter"],
+    ]);
+
+    const result = await resolveEntityFacts(client, idToTitle);
+
+    for (const [, entity] of result) {
+      for (const fact of entity.pve) {
+        expect(fact.type).toBeTruthy();
+        expect(typeof fact.type).toBe("string");
+      }
+      if (entity.wvw) {
+        for (const fact of entity.wvw) {
+          expect(fact.type).toBeTruthy();
+        }
+      }
+    }
+  });
+
+  test("buff facts have status and duration", async () => {
+    const idToTitle = new Map([[5489, "Fireball"]]);
+    const result = await resolveEntityFacts(client, idToTitle);
+    const fireball = result.get(5489);
+    const buffFacts = fireball.pve.filter((f) => f.type === "Buff");
+    for (const bf of buffFacts) {
+      expect(bf.status).toBeTruthy();
+      expect(typeof bf.duration).toBe("number");
+    }
+  });
+});

package/tests/wiki-live-validation.test.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const { WikiClient } = require("../src/wiki/client");
+const { MemoryCache } = require("../src/wiki/cache");
+const { parseFactsByMode } = require("../src/wiki/resolver");
+
+const RUN_LIVE = process.env.GW2_LIVE_TESTS === "1";
+
+const REPRESENTATIVE_SKILLS = [
+  { title: "Fireball", expectedFactTypes: ["Damage"] },
+  { title: "Shelter", expectedModes: ["pve", "pvp", "wvw"] },
+  { title: "Signet of Inspiration", minFacts: 1 },
+  { title: "Shattering Blow", minFacts: 1 },
+  { title: "Moa Stance", minFacts: 1 },
+];
+
+(RUN_LIVE ? describe : describe.skip)("Live wiki fact validation", () => {
+  let client;
+
+  beforeAll(() => {
+    client = new WikiClient({ cache: new MemoryCache() });
+  });
+
+  for (const skill of REPRESENTATIVE_SKILLS) {
+    test(`${skill.title} — parses valid facts from live wiki`, async () => {
+      const wikitext = await client.getWikitext(skill.title);
+      expect(wikitext).not.toBeNull();
+
+      const result = parseFactsByMode(wikitext);
+      expect(result.pve.length).toBeGreaterThanOrEqual(skill.minFacts || 1);
+
+      // Every fact should have a type and text
+      for (const fact of result.pve) {
+        expect(fact.type).toBeTruthy();
+        expect(fact.text).toBeTruthy();
+      }
+
+      if (skill.expectedFactTypes) {
+        for (const expectedType of skill.expectedFactTypes) {
+          expect(result.pve.some((f) => f.type === expectedType)).toBe(true);
+        }
+      }
+
+      if (skill.expectedModes) {
+        for (const mode of skill.expectedModes) {
+          expect(result[mode].length).toBeGreaterThanOrEqual(1);
+        }
+      }
+    }, 15000);
+  }
+
+  test("batch fetch works with live wiki", async () => {
+    const titles = REPRESENTATIVE_SKILLS.map((s) => s.title);
+    const result = await client.getWikitextBatch(titles);
+    expect(result.size).toBe(titles.length);
+    for (const title of titles) {
+      expect(result.has(title)).toBe(true);
+      expect(result.get(title)).not.toBeNull();
+    }
+  }, 30000);
+});

package/tests/wiki-snapshots.test.js

@@ -0,0 +1,166 @@
+"use strict";
+const { parseFactsByMode } = require("../src/wiki/resolver");
+
+const SNAPSHOTS = [
+  {
+    name: "Fireball — simple damage + burning, no split",
+    wikitext: [
+      "{{skill fact|damage|coefficient=0.9|hits=1}}",
+      "{{skill fact|burning|3|stacks=1}}",
+      "{{skill fact|targets|5}}",
+      "{{skill fact|range|900}}",
+      "{{skill fact|combo|projectile}}",
+    ].join("\n"),
+    expected: {
+      hasSplit: false,
+      pveCount: 5,
+      pveTypes: ["Damage", "Buff", "Number", "Range", "ComboFinisher"],
+    },
+  },
+  {
+    name: "Shelter — healing + block with WvW split",
+    wikitext: [
+      "{{skill fact|healing|4000|coefficient=0.75|game mode=pve}}",
+      "{{skill fact|healing|3200|coefficient=0.75|game mode=wvw pvp}}",
+      "| split = pve, wvw pvp",
+    ].join("\n"),
+    expected: {
+      hasSplit: true,
+      pveCount: 1,
+      wvwCount: 1,
+      pvpCount: 1,
+      pveHealingValue: 4000,
+      wvwHealingValue: 3200,
+    },
+  },
+  {
+    name: "Signet of Inspiration — boon application",
+    wikitext: [
+      "{{skill fact|quickness|2|stacks=1}}",
+      "{{skill fact|fury|5|stacks=1}}",
+      "{{skill fact|might|8|stacks=3}}",
+      "{{skill fact|recharge|30}}",
+    ].join("\n"),
+    expected: {
+      hasSplit: false,
+      pveCount: 4,
+      pveTypes: ["Buff", "Buff", "Buff", "Recharge"],
+    },
+  },
+  {
+    name: "All three mode variants — pve/wvw/pvp burning durations",
+    wikitext: [
+      "{{skill fact|damage|coefficient=1.0|hits=1}}",
+      "{{skill fact|burning|4|stacks=1|game mode=pve}}",
+      "{{skill fact|burning|2|stacks=1|game mode=wvw}}",
+      "{{skill fact|burning|1|stacks=1|game mode=pvp}}",
+      "| split = pve, wvw, pvp",
+    ].join("\n"),
+    expected: {
+      hasSplit: true,
+      pveCount: 2,
+      wvwCount: 2,
+      pvpCount: 2,
+      pveBurningDuration: 4,
+      wvwBurningDuration: 2,
+      pvpBurningDuration: 1,
+    },
+  },
+  {
+    name: "Combo field skill — Damage, ComboField (fire), Radius",
+    wikitext: [
+      "{{skill fact|damage|coefficient=0.5|hits=1}}",
+      "{{skill fact|combo|fire}}",
+      "{{skill fact|radius|240}}",
+    ].join("\n"),
+    expected: {
+      hasSplit: false,
+      pveCount: 3,
+      pveTypes: ["Damage", "ComboField", "Radius"],
+    },
+  },
+  {
+    name: "Attribute conversion — BuffConversion + Time",
+    wikitext: [
+      "{{skill fact|gain|source=Power|target=Condition Damage|percent=10}}",
+      "{{skill fact|duration|8}}",
+    ].join("\n"),
+    expected: {
+      hasSplit: false,
+      pveCount: 2,
+      pveTypes: ["BuffConversion", "Time"],
+    },
+  },
+  {
+    name: "Defiance break + conditions removed",
+    wikitext: [
+      "{{skill fact|defiance break|200}}",
+      "{{skill fact|conditions removed|3}}",
+      "{{skill fact|range|900}}",
+    ].join("\n"),
+    expected: {
+      hasSplit: false,
+      pveCount: 3,
+      pveTypes: ["Number", "Number", "Range"],
+    },
+  },
+];
+
+describe("Wiki fact parsing snapshots", () => {
+  for (const snapshot of SNAPSHOTS) {
+    test(snapshot.name, () => {
+      const result = parseFactsByMode(snapshot.wikitext);
+      const { expected } = snapshot;
+
+      if ("hasSplit" in expected) {
+        expect(result.hasSplit).toBe(expected.hasSplit);
+      }
+
+      if ("pveCount" in expected) {
+        expect(result.pve).toHaveLength(expected.pveCount);
+      }
+
+      if ("wvwCount" in expected) {
+        expect(result.wvw).toHaveLength(expected.wvwCount);
+      }
+
+      if ("pvpCount" in expected) {
+        expect(result.pvp).toHaveLength(expected.pvpCount);
+      }
+
+      if ("pveTypes" in expected) {
+        expect(result.pve.map((f) => f.type)).toEqual(expected.pveTypes);
+      }
+
+      if ("pveHealingValue" in expected) {
+        const healingFact = result.pve.find((f) => f.target === "Healing");
+        expect(healingFact).toBeDefined();
+        expect(healingFact.value).toBe(expected.pveHealingValue);
+      }
+
+      if ("wvwHealingValue" in expected) {
+        const healingFact = result.wvw.find((f) => f.target === "Healing");
+        expect(healingFact).toBeDefined();
+        expect(healingFact.value).toBe(expected.wvwHealingValue);
+      }
+
+      if ("pveBurningDuration" in expected) {
+        const burningFact = result.pve.find((f) => f.status === "Burning");
+        expect(burningFact).toBeDefined();
+        expect(burningFact.duration).toBe(expected.pveBurningDuration);
+      }
+
+      if ("wvwBurningDuration" in expected) {
+        const burningFact = result.wvw.find((f) => f.status === "Burning");
+        expect(burningFact).toBeDefined();
+        expect(burningFact.duration).toBe(expected.wvwBurningDuration);
+      }
+
+      if ("pvpBurningDuration" in expected) {
+        const burningFact = result.pvp.find((f) => f.status === "Burning");
+        expect(burningFact).toBeDefined();
+        expect(burningFact.duration).toBe(expected.pvpBurningDuration);
+      }
+    });
+  }
+});