osrs-tools 2.3.0 → 2.3.3

package/dist/out-tsc/test/unit/quest/QuestTool.test.js

@@ -0,0 +1,193 @@
+import { OsrsAccount } from "../../../source/runescape/model/account/OsrsAccount";
+import { QuestTool } from "../../../source/runescape/model/quest/QuestTool";
+import { LevelRequirement, QuestRequirement } from "../../../source/runescape/model/Requirement";
+import { account } from "../../resources/A_Squeezer_Main_Data";
+import { simpleQuest } from "./mockQuests";
+// Helper: create an account with a given skill level
+function makeAccountWithSkill(skill, level) {
+    return OsrsAccount.fromJson({
+        combatLevel: 3,
+        name: "Test",
+        questPoints: 0,
+        skills: { [skill]: { level } },
+    });
+}
+describe("QuestTool", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should set and get OsrsAccount", () => {
+        const acc = OsrsAccount.fromJson(account);
+        const tool = new QuestTool();
+        expect(tool.getOsrsAccount()).toBeUndefined();
+        tool.setOsrsAccount(acc);
+        expect(tool.getOsrsAccount()).toBe(acc);
+    });
+    it("should get max skill boost for known and unknown skills", () => {
+        expect(QuestTool.getMaxSkillBoost("Attack")).toBeGreaterThan(0);
+        expect(QuestTool.getMaxSkillBoost("Herblore")).toBeGreaterThan(0);
+        expect(QuestTool.getMaxSkillBoost("UnknownSkill")).toBe(0);
+    });
+    describe("Quest Cache", () => {
+        let mockGetQuestByName;
+        beforeEach(() => {
+            QuestTool["questCache"].clear();
+            // Setup mock for getQuestByName that returns our test quest
+            mockGetQuestByName = jest.spyOn(QuestTool, "getQuestByName");
+        });
+        afterEach(() => {
+            mockGetQuestByName.mockRestore();
+        });
+        it("should handle non-existent quests", () => {
+            mockGetQuestByName.mockImplementation(() => undefined);
+            const result = QuestTool.getQuestByName("NonexistentQuest");
+            expect(result).toBeUndefined();
+            // Second lookup should still check since we don't cache undefined results
+            const result2 = QuestTool.getQuestByName("NonexistentQuest");
+            expect(result2).toBeUndefined();
+            expect(mockGetQuestByName).toHaveBeenCalledTimes(2);
+        });
+        it("should clear cache between tests", () => {
+            const mockQuest = { ...simpleQuest, name: "Test Quest" };
+            mockGetQuestByName.mockImplementation(() => mockQuest);
+            // First test - should call implementation
+            const result1 = QuestTool.getQuestByName("Test Quest");
+            expect(result1).toBe(mockQuest);
+            expect(mockGetQuestByName).toHaveBeenCalledTimes(1);
+            // Clear cache manually (simulating beforeEach)
+            QuestTool["questCache"].clear();
+            // Should call implementation again after cache clear
+            const result2 = QuestTool.getQuestByName("Test Quest");
+            expect(result2).toBe(mockQuest);
+            expect(mockGetQuestByName).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe("Quest Requirements", () => {
+        let tool;
+        beforeEach(() => {
+            tool = new QuestTool();
+        });
+        it("should handle multiple skill requirements", () => {
+            const quest = {
+                ...simpleQuest,
+                requirements: [new LevelRequirement("attack", 60, false), new LevelRequirement("defence", 60, false), new LevelRequirement("strength", 60, false)],
+            };
+            // Test with insufficient levels
+            tool.setOsrsAccount(makeAccountWithSkill("attack", 59));
+            expect(tool.canCompleteQuest(quest)).toBe(false);
+            // Test with all requirements met
+            tool.setOsrsAccount(OsrsAccount.fromJson({
+                combatLevel: 3,
+                name: "Test",
+                questPoints: 0,
+                skills: {
+                    attack: { level: 60, rank: 0, xp: 0 },
+                    defence: { level: 60, rank: 0, xp: 0 },
+                    strength: { level: 60, rank: 0, xp: 0 },
+                },
+            }));
+            expect(tool.canCompleteQuest(quest)).toBe(true);
+        });
+        it("should handle boostable and non-boostable requirements", () => {
+            const quest = {
+                ...simpleQuest,
+                requirements: [
+                    new LevelRequirement("attack", 60, false), // Non-boostable
+                    new LevelRequirement("herblore", 90, true), // Boostable
+                ],
+            };
+            // Test with insufficient non-boostable level
+            tool.setOsrsAccount(makeAccountWithSkill("attack", 59));
+            expect(tool.canCompleteQuest(quest)).toBe(false);
+            // Test with boostable but insufficient herblore
+            tool.setOsrsAccount(OsrsAccount.fromJson({
+                combatLevel: 3,
+                name: "Test",
+                questPoints: 0,
+                skills: {
+                    attack: { level: 60, rank: 0, xp: 0 },
+                    herblore: { level: 84, rank: 0, xp: 0 }, // Max boost +5, not enough
+                },
+            }));
+            expect(tool.canCompleteQuest(quest)).toBe(false);
+            // Test with both requirements met (one through boost)
+            tool.setOsrsAccount(OsrsAccount.fromJson({
+                combatLevel: 3,
+                name: "Test",
+                questPoints: 0,
+                skills: {
+                    attack: { level: 60 },
+                    herblore: { level: 86 }, // Can boost to 91
+                },
+            }));
+            expect(tool.canCompleteQuest(quest)).toBe(true);
+        });
+        it("should handle quest chains", () => {
+            // Create a chain: Quest3 requires Quest2 requires Quest1
+            const quest1 = { ...simpleQuest, name: "Quest1" };
+            const quest2 = {
+                ...simpleQuest,
+                name: "Quest2",
+                requirements: [new QuestRequirement("Quest1")],
+            };
+            const quest3 = {
+                ...simpleQuest,
+                name: "Quest3",
+                requirements: [new QuestRequirement("Quest2")],
+            };
+            // Mock getQuestByName
+            jest.spyOn(QuestTool, "getQuestByName").mockImplementation((name) => {
+                switch (name) {
+                    case "Quest1":
+                        return quest1;
+                    case "Quest2":
+                        return quest2;
+                    case "Quest3":
+                        return quest3;
+                    default:
+                        return undefined;
+                }
+            });
+            tool.setOsrsAccount(makeAccountWithSkill("attack", 1));
+            expect(tool.canCompleteQuest(quest3)).toBe(true);
+        });
+        it("should handle circular quest dependencies", () => {
+            // Create circular dependency: QuestA requires QuestB requires QuestA
+            const questA = {
+                ...simpleQuest,
+                name: "QuestA",
+                requirements: [new QuestRequirement("QuestB")],
+            };
+            const questB = {
+                ...simpleQuest,
+                name: "QuestB",
+                requirements: [new QuestRequirement("QuestA")],
+            };
+            // Mock getQuestByName
+            jest.spyOn(QuestTool, "getQuestByName").mockImplementation((name) => {
+                switch (name) {
+                    case "QuestA":
+                        return questA;
+                    case "QuestB":
+                        return questB;
+                    default:
+                        return undefined;
+                }
+            });
+            tool.setOsrsAccount(makeAccountWithSkill("attack", 1));
+            expect(tool.canCompleteQuest(questA)).toBe(true); // Should not get stuck in infinite loop
+        });
+        it("should handle missing quests", () => {
+            const quest = {
+                ...simpleQuest,
+                requirements: [new QuestRequirement("NonexistentQuest")],
+            };
+            tool.setOsrsAccount(makeAccountWithSkill("attack", 1));
+            expect(tool.canCompleteQuest(quest)).toBe(false);
+        });
+        it("should handle undefined quest", () => {
+            tool.setOsrsAccount(makeAccountWithSkill("attack", 1));
+            expect(tool.canCompleteQuest(undefined)).toBe(false);
+        });
+    });
+});

package/dist/out-tsc/test/unit/quest/mockQuests.js

@@ -0,0 +1,75 @@
+import { QuestStatus } from '../../../source/runescape/model/quest/Quest';
+import { QuestDifficulty, QuestLength } from '../../../source/runescape/model/quest/enums';
+import { LevelRequirement, QuestRequirement } from '../../../source/runescape/model/Requirement';
+export const simpleQuest = {
+    age: 'Fifth',
+    description: 'A quest with no requirements.',
+    difficulty: QuestDifficulty.Novice,
+    id: 1,
+    length: QuestLength.Short,
+    members: false,
+    miniquest: false,
+    name: 'Simple Quest',
+    questPoints: 1,
+    recommendations: [],
+    recommendedPrayers: [],
+    recommendedSkills: {},
+    requirements: [],
+    rewards: { questPoints: 1 },
+    shortName: 'SimpleQuest',
+    startLocation: '',
+    status: QuestStatus.NotStarted,
+    steps: [],
+    url: '',
+};
+export const skillQuest = {
+    ...simpleQuest,
+    id: 2,
+    name: 'Skill Quest',
+    requirements: [new LevelRequirement('attack', 50, false)],
+};
+export const boostableSkillQuest = {
+    ...simpleQuest,
+    id: 3,
+    name: 'Boostable Skill Quest',
+    requirements: [new LevelRequirement('herblore', 90, true)],
+};
+export const questReqQuest = {
+    ...simpleQuest,
+    id: 4,
+    name: 'Quest Req Quest',
+    requirements: [new QuestRequirement('Simple Quest')],
+};
+export const recursiveQuest = {
+    ...simpleQuest,
+    id: 5,
+    name: 'Recursive Quest',
+    requirements: [new QuestRequirement('Quest Req Quest')],
+};
+export const multiRequirementQuest = {
+    ...simpleQuest,
+    difficulty: QuestDifficulty.Master,
+    id: 6,
+    name: 'Multi Requirement Quest',
+    requirements: [
+        new LevelRequirement('attack', 70, false),
+        new LevelRequirement('defence', 70, false),
+        new LevelRequirement('strength', 70, false),
+        new LevelRequirement('ranged', 70, true),
+        new QuestRequirement('Simple Quest'),
+        new QuestRequirement('Skill Quest'),
+    ],
+    series: 'Combat',
+};
+export const circularQuest1 = {
+    ...simpleQuest,
+    id: 7,
+    name: 'Circular Quest 1',
+    requirements: [new QuestRequirement('Circular Quest 2')],
+};
+export const circularQuest2 = {
+    ...simpleQuest,
+    id: 8,
+    name: 'Circular Quest 2',
+    requirements: [new QuestRequirement('Circular Quest 1')],
+};

package/dist/out-tsc/test/unit/quest/types.test.js

@@ -0,0 +1,98 @@
+import { QuestDifficulty, QuestLength } from "../../../source/runescape/model/quest/enums";
+import { createItemRequirement, createLevelRequirement, createQuestPointRequirement, createQuestRequirement, RequirementType } from "../../../source/runescape/model/quest/Requirements";
+import { QuestStatus } from "../../../source/runescape/model/quest/Quest";
+describe("Quest Types and Requirements", () => {
+    describe("Requirements", () => {
+        it("should create level requirements correctly", () => {
+            const req = createLevelRequirement("Mining", 55, true);
+            expect(req).toEqual({
+                boostable: true,
+                description: "55 Mining",
+                level: 55,
+                skillName: "Mining",
+                type: RequirementType.Level,
+            });
+        });
+        it("should create quest requirements correctly", () => {
+            const req = createQuestRequirement("Dragon Slayer");
+            expect(req).toEqual({
+                description: "Completion of Dragon Slayer",
+                questName: "Dragon Slayer",
+                type: RequirementType.Quest,
+            });
+        });
+        it("should create quest point requirements correctly", () => {
+            const req = createQuestPointRequirement(32);
+            expect(req).toEqual({
+                description: "32 Quest Points",
+                points: 32,
+                type: RequirementType.QuestPoint,
+            });
+        });
+        it("should create item requirements correctly", () => {
+            const req = createItemRequirement("Dragon bones", 3, true);
+            expect(req).toEqual({
+                consumed: true,
+                description: "3x Dragon bones (consumed)",
+                itemName: "Dragon bones",
+                quantity: 3,
+                type: RequirementType.Item,
+            });
+        });
+        it("should handle optional item requirement parameters", () => {
+            const req = createItemRequirement("Tinderbox");
+            expect(req).toEqual({
+                consumed: false,
+                description: "1x Tinderbox",
+                itemName: "Tinderbox",
+                quantity: 1,
+                type: RequirementType.Item,
+            });
+        });
+    });
+    describe("Quest Interface", () => {
+        it("should validate a complete quest object", () => {
+            const quest = {
+                age: "Fifth Age",
+                description: "Help the cook make a cake.",
+                difficulty: QuestDifficulty.Novice,
+                id: 1,
+                length: QuestLength.Short,
+                members: false,
+                miniquest: false,
+                name: "Cook's Assistant",
+                questPoints: 1,
+                recommendations: [],
+                recommendedPrayers: [],
+                recommendedSkills: {},
+                requirements: [],
+                rewards: {
+                    areas: [],
+                    experience: [{ amount: 300, skill: "Cooking" }],
+                    items: [],
+                    lamps: [],
+                    pets: [],
+                    points: [],
+                    questPoints: 1,
+                    unlocks: [{ description: "Access to the kitchen" }],
+                },
+                series: null,
+                shortName: "cooksAssistant",
+                startLocation: "Lumbridge Castle Kitchen",
+                status: QuestStatus.NotStarted,
+                steps: [
+                    "Talk to the cook in Lumbridge Castle kitchen.",
+                    "Get an egg from the farm north of Lumbridge.",
+                    "Get a bucket of milk from a dairy cow.",
+                    "Get a pot of flour from the mill north of Lumbridge.",
+                    "Return all ingredients to the cook.",
+                ],
+                url: "https://oldschool.runescape.wiki/w/Cook%27s_Assistant",
+            };
+            // Just checking that it compiles - TypeScript would catch type errors
+            expect(quest.name).toBe("Cook's Assistant");
+            expect(quest.difficulty).toBe(QuestDifficulty.Novice);
+            expect(quest.rewards.experience?.[0].amount).toBe(300);
+        });
+    });
+});

package/dist/out-tsc/test/unit/requirements/Requirement.test.js

@@ -0,0 +1,52 @@
+// Test file for all requirement types
+import { CombatLevelRequirement, ItemRequirement, LocationRequirement, QuestPointRequirement, QuestRequirement, RequirementType, SlayerLevelRequirement, SlayerUnlockRequirement, } from '../../../source/runescape/model/Requirement';
+describe('Requirement', () => {
+    it('should create a QuestRequirement', () => {
+        const req = new QuestRequirement('Dragon Slayer II');
+        expect(req.questName).toBe('Dragon Slayer II');
+        expect(req.type).toBe(RequirementType.Quest);
+        expect(req.completionDescription).toBe('Completion of Dragon Slayer II');
+        expect(req.description).toBe('Completed quest: Dragon Slayer II');
+    });
+    it('should create an ItemRequirement', () => {
+        const req = new ItemRequirement('Dragon bones', 5, { noted: true });
+        expect(req.itemName).toBe('Dragon bones');
+        expect(req.quantity).toBe(5);
+        expect(req.noted).toBe(true);
+        expect(req.type).toBe(RequirementType.Item);
+        expect(req.description).toBe('5x Dragon bones (noted)');
+    });
+    it('should create a SlayerUnlockRequirement', () => {
+        const req = new SlayerUnlockRequirement('Slug Salter');
+        expect(req.name).toBe('Slug Salter');
+        expect(req.type).toBe(RequirementType.SlayerUnlock);
+        expect(req.description).toBe('Slayer unlock: Slug Salter');
+    });
+    // CombatLevelRequirement
+    it('should create a CombatLevelRequirement', () => {
+        const req = new CombatLevelRequirement(75);
+        expect(req.level).toBe(75);
+        expect(req.type).toBe(RequirementType.CombatLevel);
+        expect(req.description).toBe('Combat level 75');
+    });
+    // slayer level requirement
+    it('should create a SlayerLevelRequirement', () => {
+        const req = new SlayerLevelRequirement(90);
+        expect(req.level).toBe(90);
+        expect(req.type).toBe(RequirementType.SlayerLevel);
+        expect(req.description).toBe('Slayer level 90');
+    });
+    // slayer level requirement
+    it('should create a QuestPointRequirement ', () => {
+        const req = new QuestPointRequirement(135);
+        expect(req.amount).toBe(135);
+        expect(req.type).toBe(RequirementType.QuestPoint);
+        expect(req.description).toBe('Quest Points Needed: 135');
+    });
+    // LocationRequirement
+    it('should create a LocationRequirement ', () => {
+        const req = new LocationRequirement('Yanille');
+        expect(req.type).toBe(RequirementType.Location);
+        expect(req.description).toBe('Access to location: Yanille');
+    });
+});

package/dist/out-tsc/test/unit/slayer/SlayerMaster.test.js

@@ -0,0 +1,43 @@
+import { SlayerMaster } from "../../../source/runescape/model/slayer/SlayerMaster";
+import { Task } from "../../../source/runescape/model/slayer/Task";
+describe("SlayerMaster", () => {
+    const mockTasks = [new Task("Banshee", 0, 15, [], null, null, [], 5), new Task("Cave Crawler", 0, 15, [], null, null, [], 3), new Task("Crawling Hand", 0, 15, [], null, null, [], 2)];
+    const taskPoints = { 1: 2, 10: 10, 50: 50 };
+    const eliteDiaryTaskPoints = { 1: 3, 10: 15, 50: 75 };
+    const master = new SlayerMaster("Test Master", mockTasks, "Testville", 50, "https://wiki.test/Test_Master", taskPoints, eliteDiaryTaskPoints);
+    it("should construct with correct properties", () => {
+        expect(master.getName()).toBe("Test Master");
+        expect(master.getLocation()).toBe("Testville");
+        expect(master.getMinimumCombatLevel()).toBe(50);
+        expect(master.getWikiUrl()).toBe("https://wiki.test/Test_Master");
+        expect(master.getTasks()).toEqual(mockTasks);
+        expect(master.getTotalWeight()).toBe(10);
+        expect(master.taskPoints).toEqual(taskPoints);
+        expect(master.eliteDiaryTaskPoints).toEqual(eliteDiaryTaskPoints);
+    });
+    it("should calculate total weight correctly", () => {
+        expect(master.calculateTotalWeight()).toBe(10);
+    });
+    it("should get points for task interval", () => {
+        expect(master.getPointsForTaskInterval(1)).toBe(2);
+        expect(master.getPointsForTaskInterval(10)).toBe(10);
+        expect(master.getPointsForTaskInterval(50)).toBe(50);
+        expect(master.getPointsForTaskInterval(99)).toBe(0);
+    });
+    it("should return a random task (weighted)", () => {
+        // Run multiple times to check randomness and always return a valid task
+        for (let i = 0; i < 10; i++) {
+            const task = master.getRandomTask();
+            expect(task).not.toBeNull();
+            expect(mockTasks).toContain(task);
+        }
+    });
+    it("should return null for random task if no tasks", () => {
+        const emptyMaster = new SlayerMaster("Empty", [], "Nowhere", 1, "", {});
+        expect(emptyMaster.getRandomTask()).toBeNull();
+    });
+    it("toString should return a string", () => {
+        expect(typeof master.toString()).toBe("string");
+        expect(master.toString()).toContain("Test Master");
+    });
+});

package/dist/out-tsc/test/unit/slayer/master/Chaeldar.test.js

@@ -0,0 +1,20 @@
+import { Chaeldar } from '../../../../source/runescape/model/slayer/Masters';
+describe('Chaeldar', () => {
+    it('should be defined', () => {
+        expect(Chaeldar).toBeDefined();
+    });
+    it('should have a list of tasks', () => {
+        const tasks = Chaeldar.tasks;
+        expect(Array.isArray(tasks)).toBe(true);
+        expect(tasks.length).toBeGreaterThan(0);
+    });
+    it('should have the correct name', () => {
+        expect(Chaeldar.name).toBe('Chaeldar');
+    });
+    it('should have the correct location', () => {
+        expect(Chaeldar.location).toBe('Zanaris');
+    });
+    it('should have the correct wiki URL', () => {
+        expect(Chaeldar.wikiUrl).toBe('https://oldschool.runescape.wiki/w/Chaeldar');
+    });
+});

package/dist/out-tsc/test/unit/slayer/master/Duradel.test.js

@@ -0,0 +1,22 @@
+// Test for the Tureal data from the JSON file
+import { Duradel } from '../../../../source/runescape/model/slayer/Masters';
+describe('Duradel', () => {
+    it('should be defined', () => {
+        expect(Duradel).toBeDefined();
+    });
+    it('should have a list of tasks', () => {
+        const tasks = Duradel.tasks;
+        expect(Array.isArray(tasks)).toBe(true);
+        expect(tasks.length).toBeGreaterThan(0);
+    });
+    it('should have the correct name', () => {
+        expect(Duradel.name).toBe('Duradel');
+    });
+    it('should have the correct location', () => {
+        expect(Duradel.location).toBe('Shilo Village');
+    });
+    it('should have the correct wiki URL', () => {
+        expect(Duradel.wikiUrl).toBe('https://oldschool.runescape.wiki/w/Duradel');
+    });
+});
+// We recommend installing an extension to run jest tests.

package/dist/out-tsc/test/unit/slayer/master/Konar.test.js

@@ -0,0 +1,20 @@
+import { KonarQuoMaten } from '../../../../source/runescape/model/slayer/Masters';
+describe('Konar Quo Maten', () => {
+    it('should be defined', () => {
+        expect(KonarQuoMaten).toBeDefined();
+    });
+    it('should have a list of tasks', () => {
+        const tasks = KonarQuoMaten.tasks;
+        expect(Array.isArray(tasks)).toBe(true);
+        expect(tasks.length).toBeGreaterThan(0);
+    });
+    it('should have the correct name', () => {
+        expect(KonarQuoMaten.name).toBe('Konar Quo Maten');
+    });
+    it('should have the correct location', () => {
+        expect(KonarQuoMaten.location).toBe('Mount Karuulm');
+    });
+    it('should have the correct wiki URL', () => {
+        expect(KonarQuoMaten.wikiUrl).toBe('https://oldschool.runescape.wiki/w/Konar_Quo_Maten');
+    });
+});

package/dist/out-tsc/test/unit/slayer/master/Krystillia.test.js

@@ -0,0 +1,20 @@
+import { Krystilia } from '../../../../source/runescape/model/slayer/Masters';
+describe('Krystilia', () => {
+    it('should be defined', () => {
+        expect(Krystilia).toBeDefined();
+    });
+    it('should have a list of tasks', () => {
+        const tasks = Krystilia.tasks;
+        expect(Array.isArray(tasks)).toBe(true);
+        expect(tasks.length).toBeGreaterThan(0);
+    });
+    it('should have the correct name', () => {
+        expect(Krystilia.name).toBe('Krystilia');
+    });
+    it('should have the correct location', () => {
+        expect(Krystilia.location).toBe('Edgeville');
+    });
+    it('should have the correct wiki URL', () => {
+        expect(Krystilia.wikiUrl).toBe('https://oldschool.runescape.wiki/w/Krystilia');
+    });
+});

package/dist/out-tsc/test/unit/slayer/master/Mazchna.test.js

@@ -0,0 +1,20 @@
+import { Mazchna } from '../../../../source/runescape/model/slayer/Masters';
+describe('Mazchna', () => {
+    it('should be defined', () => {
+        expect(Mazchna).toBeDefined();
+    });
+    it('should have a list of tasks', () => {
+        const tasks = Mazchna.tasks;
+        expect(Array.isArray(tasks)).toBe(true);
+        expect(tasks.length).toBeGreaterThan(0);
+    });
+    it('should have the correct name', () => {
+        expect(Mazchna.name).toBe('Mazchna');
+    });
+    it('should have the correct location', () => {
+        expect(Mazchna.location).toBe('Canifis');
+    });
+    it('should have the correct wiki URL', () => {
+        expect(Mazchna.wikiUrl).toBe('https://oldschool.runescape.wiki/w/Mazchna');
+    });
+});

package/dist/out-tsc/test/unit/slayer/master/Nieve.test.js

@@ -0,0 +1,20 @@
+import { Nieve } from '../../../../source/runescape/model/slayer/Masters';
+describe('Nieve', () => {
+    it('should be defined', () => {
+        expect(Nieve).toBeDefined();
+    });
+    it('should have a list of tasks', () => {
+        const tasks = Nieve.tasks;
+        expect(Array.isArray(tasks)).toBe(true);
+        expect(tasks.length).toBeGreaterThan(0);
+    });
+    it('should have the correct name', () => {
+        expect(Nieve.name).toBe('Nieve');
+    });
+    it('should have the correct location', () => {
+        expect(Nieve.location).toBe("Nieve's Cave");
+    });
+    it('should have the correct wiki URL', () => {
+        expect(Nieve.wikiUrl).toBe('https://oldschool.runescape.wiki/w/Nieve');
+    });
+});

package/dist/out-tsc/test/unit/slayer/master/Spria.test.js

@@ -0,0 +1,21 @@
+// Test for the Spria data from the JSON file
+import { Spria } from '../../../../source/runescape/model/slayer/Masters';
+describe('Spria', () => {
+    it('should be defined', () => {
+        expect(Spria).toBeDefined();
+    });
+    it('should have a list of tasks', () => {
+        const tasks = Spria.tasks;
+        expect(Array.isArray(tasks)).toBe(true);
+        expect(tasks.length).toBeGreaterThan(0);
+    });
+    it('should have the correct name', () => {
+        expect(Spria.name).toBe('Spria');
+    });
+    it('should have the correct location', () => {
+        expect(Spria.location).toBe('Draynor Village');
+    });
+    it('should have the correct wiki URL', () => {
+        expect(Spria.wikiUrl).toBe('https://oldschool.runescape.wiki/w/Spria');
+    });
+});

package/dist/out-tsc/test/unit/slayer/master/Tureal.test.js

@@ -0,0 +1,21 @@
+// Test for the Tureal data from the JSON file
+import { Turael } from '../../../../source/runescape/model/slayer/Masters';
+describe('Turael', () => {
+    it('should be defined', () => {
+        expect(Turael).toBeDefined();
+    });
+    it('should have a list of tasks', () => {
+        const tasks = Turael.tasks;
+        expect(Array.isArray(tasks)).toBe(true);
+        expect(tasks.length).toBeGreaterThan(0);
+    });
+    it('should have the correct name', () => {
+        expect(Turael.name).toBe('Turael');
+    });
+    it('should have the correct location', () => {
+        expect(Turael.location).toBe('Burthope');
+    });
+    it('should have the correct wiki URL', () => {
+        expect(Turael.wikiUrl).toBe('https://oldschool.runescape.wiki/w/Turael');
+    });
+});

package/dist/out-tsc/test/unit/slayer/master/Vannaka.test.js

@@ -0,0 +1,20 @@
+import { Vannaka } from '../../../../source/runescape/model/slayer/Masters';
+describe('Vannaka', () => {
+    it('should be defined', () => {
+        expect(Vannaka).toBeDefined();
+    });
+    it('should have a list of tasks', () => {
+        const tasks = Vannaka.tasks;
+        expect(Array.isArray(tasks)).toBe(true);
+        expect(tasks.length).toBeGreaterThan(0);
+    });
+    it('should have the correct name', () => {
+        expect(Vannaka.name).toBe('Vannaka');
+    });
+    it('should have the correct location', () => {
+        expect(Vannaka.location).toBe('Edgeville Dungeon');
+    });
+    it('should have the correct wiki URL', () => {
+        expect(Vannaka.wikiUrl).toBe('https://oldschool.runescape.wiki/w/Vannaka');
+    });
+});