mika/pokerogue
1
0
Fork 0
mirror of https://github.com/pagefaultgames/pokerogue.git synced 2025-07-04 23:42:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

Enforced consistent use of expect.toHaveLength

Browse Source 
again, gives more info than "expected 1 to be 2"
This commit is contained in:
Bertie690 2025-04-30 15:56:38 -04:00 committed by Bertie690
parent 4796852bc3
commit 8d78963eec
49 changed files with 181 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/abilities/arena_trap.test.ts
View File

@ -50,7 +50,7 @@ describe("Abilities - Arena Trap", () => {
await game.classicMode.startBattle();
expect(game.scene.getEnemyField().length).toBe(2);
expect(game.scene.getEnemyField()).toHaveLength(2);
});
/**

2
test/abilities/illuminate.test.ts
View File

@ -49,6 +49,6 @@ describe("Abilities - Illuminate", () => {
await game.classicMode.startBattle();
expect(game.scene.getEnemyField().length).toBe(2);
expect(game.scene.getEnemyField()).toHaveLength(2);
});
});

4
test/abilities/imposter.test.ts
View File

@ -60,7 +60,7 @@ describe("Abilities - Imposter", () => {
const playerMoveset = player.getMoveset();
const enemyMoveset = player.getMoveset();
expect(playerMoveset.length).toBe(enemyMoveset.length);
expect(playerMoveset).toHaveLength(enemyMoveset.length);
for (let i = 0; i < playerMoveset.length && i < enemyMoveset.length; i++) {
expect(playerMoveset[i]?.moveId).toBe(enemyMoveset[i]?.moveId);
}
@ -68,7 +68,7 @@ describe("Abilities - Imposter", () => {
const playerTypes = player.getTypes();
const enemyTypes = enemy.getTypes();
expect(playerTypes.length).toBe(enemyTypes.length);
expect(playerTypes).toHaveLength(enemyTypes.length);
for (let i = 0; i < playerTypes.length && i < enemyTypes.length; i++) {
expect(playerTypes[i]).toBe(enemyTypes[i]);
}

6
test/abilities/moody.test.ts
View File

@ -45,7 +45,7 @@ describe("Abilities - Moody", () => {
);
expect(changedStats).toBeTruthy();
expect(changedStats.length).toBe(2);
expect(changedStats).toHaveLength(2);
expect(changedStats[0] !== changedStats[1]).toBeTruthy();
});
@ -64,7 +64,7 @@ describe("Abilities - Moody", () => {
const increasedStat = EFFECTIVE_STATS.filter(s => playerPokemon.getStatStage(s) === -4);
expect(increasedStat).toBeTruthy();
expect(increasedStat.length).toBe(1);
expect(increasedStat).toHaveLength(1);
});
it("should only decrease one stat stage by 1 stage if all stat stages are at 6", async () => {
@ -82,6 +82,6 @@ describe("Abilities - Moody", () => {
const decreasedStat = EFFECTIVE_STATS.filter(s => playerPokemon.getStatStage(s) === 5);
expect(decreasedStat).toBeTruthy();
expect(decreasedStat.length).toBe(1);
expect(decreasedStat).toHaveLength(1);
});
});

2
test/abilities/no_guard.test.ts
View File

@ -58,6 +58,6 @@ describe("Abilities - No Guard", () => {
await game.classicMode.startBattle();
expect(game.scene.getEnemyField().length).toBe(2);
expect(game.scene.getEnemyField()).toHaveLength(2);
});
});

8
test/abilities/perish_body.test.ts
View File

@ -74,14 +74,14 @@ describe("Abilities - Perish Song", () => {
await game.toNextTurn();
const cursola = game.scene.getPlayerPokemon();
expect(cursola?.summonData.tags.length).toBe(0);
expect(cursola?.summonData.tags).toHaveLength(0);
expect(magikarp?.summonData.tags[0].turnCount).toBe(2);
game.move.select(Moves.SPLASH);
await game.forceEnemyMove(Moves.AQUA_JET);
await game.toNextTurn();
expect(cursola?.summonData.tags.length).toBe(0);
expect(cursola?.summonData.tags).toHaveLength(0);
expect(magikarp?.summonData.tags[0].turnCount).toBe(1);
});
@ -99,14 +99,14 @@ describe("Abilities - Perish Song", () => {
const magikarp = game.scene.getEnemyPokemon();
expect(cursola?.summonData.tags[0].turnCount).toBe(3);
expect(magikarp?.summonData.tags.length).toBe(0);
expect(magikarp?.summonData.tags).toHaveLength(0);
game.move.select(Moves.SPLASH);
await game.forceEnemyMove(Moves.AQUA_JET);
await game.toNextTurn();
expect(cursola?.summonData.tags[0].turnCount).toBe(2);
expect(magikarp?.summonData.tags.length).toBe(1);
expect(magikarp?.summonData.tags).toHaveLength(1);
expect(magikarp?.summonData.tags[0].turnCount).toBe(3);
});
});

2
test/field/pokemon.test.ts
View File

@ -134,7 +134,7 @@ describe("Spec - Pokemon", () => {
const types = pokemon.getTypes();
expect(types[0]).toBe(PokemonType.PSYCHIC);
expect(types.length).toBe(1);
expect(types).toHaveLength(1);
});
it("Fusing mons with one and two types", async () => {

22
test/inputs/inputs.test.ts
View File

@ -33,56 +33,56 @@ describe("Inputs", () => {
it("Mobile - test touch holding for 1ms - 1 input", async () => {
await game.inputsHandler.pressTouch("dpadUp", 1);
expect(game.inputsHandler.log.length).toBe(1);
expect(game.inputsHandler.log).toHaveLength(1);
});
it("Mobile - test touch holding for 200ms - 1 input", async () => {
await game.inputsHandler.pressTouch("dpadUp", 200);
expect(game.inputsHandler.log.length).toBe(1);
expect(game.inputsHandler.log).toHaveLength(1);
});
it("Mobile - test touch holding for 300ms - 2 input", async () => {
await game.inputsHandler.pressTouch("dpadUp", 300);
expect(game.inputsHandler.log.length).toBe(2);
expect(game.inputsHandler.log).toHaveLength(2);
});
it("Mobile - test touch holding for 1000ms - 4 input", async () => {
await game.inputsHandler.pressTouch("dpadUp", 1050);
expect(game.inputsHandler.log.length).toBe(5);
expect(game.inputsHandler.log).toHaveLength(5);
});
it("keyboard - test input holding for 200ms - 1 input", async () => {
await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 200);
expect(game.inputsHandler.log.length).toBe(1);
expect(game.inputsHandler.log).toHaveLength(1);
});
it("keyboard - test input holding for 300ms - 2 input", async () => {
await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 300);
expect(game.inputsHandler.log.length).toBe(2);
expect(game.inputsHandler.log).toHaveLength(2);
});
it("keyboard - test input holding for 1000ms - 4 input", async () => {
await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 1050);
expect(game.inputsHandler.log.length).toBe(5);
expect(game.inputsHandler.log).toHaveLength(5);
});
it("gamepad - test input holding for 1ms - 1 input", async () => {
await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 1);
expect(game.inputsHandler.log.length).toBe(1);
expect(game.inputsHandler.log).toHaveLength(1);
});
it("gamepad - test input holding for 200ms - 1 input", async () => {
await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 200);
expect(game.inputsHandler.log.length).toBe(1);
expect(game.inputsHandler.log).toHaveLength(1);
});
it("gamepad - test input holding for 300ms - 2 input", async () => {
await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 300);
expect(game.inputsHandler.log.length).toBe(2);
expect(game.inputsHandler.log).toHaveLength(2);
});
it("gamepad - test input holding for 1000ms - 4 input", async () => {
await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 1050);
expect(game.inputsHandler.log.length).toBe(5);
expect(game.inputsHandler.log).toHaveLength(5);
});
});

4
test/items/double_battle_chance_booster.test.ts
View File

@ -31,7 +31,7 @@ describe("Items - Double Battle Chance Boosters", () => {
await game.classicMode.startBattle();
expect(game.scene.getEnemyField().length).toBe(2);
expect(game.scene.getEnemyField()).toHaveLength(2);
});
it("should guarantee double boss battle with 3 unique tiers", async () => {
@ -41,7 +41,7 @@ describe("Items - Double Battle Chance Boosters", () => {
const enemyField = game.scene.getEnemyField();
expect(enemyField.length).toBe(2);
expect(enemyField).toHaveLength(2);
expect(enemyField[0].isBoss()).toBe(true);
expect(enemyField[1].isBoss()).toBe(true);
});

2
test/moves/baddy_bad.test.ts
View File

@ -36,6 +36,6 @@ describe("Moves - Baddy Bad", () => {
game.move.select(Moves.BADDY_BAD);
await game.phaseInterceptor.to("BerryPhase");
expect(game.scene.arena.tags.length).toBe(0);
expect(game.scene.arena.tags).toHaveLength(0);
});
});

2
test/moves/destiny_bond.test.ts
View File

@ -249,6 +249,6 @@ describe("Moves - Destiny Bond", () => {
const revSeeds = game.scene
.getModifiers(PokemonInstantReviveModifier)
.filter(m => m.pokemonId === playerPokemon?.id);
expect(revSeeds.length).toBe(1);
expect(revSeeds).toHaveLength(1);
});
});

6
test/moves/dragon_tail.test.ts
View File

@ -156,7 +156,7 @@ describe("Moves - Dragon Tail", () => {
// Make sure the enemy has a fainted Pokemon in their party and not on the field
const faintedEnemy = game.scene.getEnemyParty().find(p => !p.isAllowedInBattle());
expect(faintedEnemy).toBeDefined();
expect(game.scene.getEnemyField().length).toBe(1);
expect(game.scene.getEnemyField()).toHaveLength(1);
});
it("should not cause a softlock when activating an opponent trainer's reviver seed", async () => {
@ -174,7 +174,7 @@ describe("Moves - Dragon Tail", () => {
const enemy = game.scene.getEnemyPokemon()!;
expect(enemy).toBeDefined();
expect(enemy.hp).toBe(Math.floor(enemy.getMaxHp() / 2));
expect(game.scene.getEnemyField().length).toBe(1);
expect(game.scene.getEnemyField()).toHaveLength(1);
});
it("should not cause a softlock when activating a player's reviver seed", async () => {
@ -192,7 +192,7 @@ describe("Moves - Dragon Tail", () => {
const dratini = game.scene.getPlayerPokemon()!;
expect(dratini).toBeDefined();
expect(dratini.hp).toBe(Math.floor(dratini.getMaxHp() / 2));
expect(game.scene.getPlayerField().length).toBe(1);
expect(game.scene.getPlayerField()).toHaveLength(1);
});
it("should force switches randomly", async () => {

12
test/moves/focus_punch.test.ts
View File

@ -51,12 +51,12 @@ describe("Moves - Focus Punch", () => {
await game.phaseInterceptor.to(MessagePhase);
expect(enemyPokemon.hp).toBe(enemyStartingHp);
expect(leadPokemon.getMoveHistory().length).toBe(0);
expect(leadPokemon.getMoveHistory()).toHaveLength(0);
await game.phaseInterceptor.to(BerryPhase, false);
expect(enemyPokemon.hp).toBeLessThan(enemyStartingHp);
expect(leadPokemon.getMoveHistory().length).toBe(1);
expect(leadPokemon.getMoveHistory()).toHaveLength(1);
expect(leadPokemon.turnData.totalDamageDealt).toBe(enemyStartingHp - enemyPokemon.hp);
});
@ -75,12 +75,12 @@ describe("Moves - Focus Punch", () => {
await game.phaseInterceptor.to(MessagePhase);
expect(enemyPokemon.hp).toBe(enemyStartingHp);
expect(leadPokemon.getMoveHistory().length).toBe(0);
expect(leadPokemon.getMoveHistory()).toHaveLength(0);
await game.phaseInterceptor.to(BerryPhase, false);
expect(enemyPokemon.hp).toBe(enemyStartingHp);
expect(leadPokemon.getMoveHistory().length).toBe(1);
expect(leadPokemon.getMoveHistory()).toHaveLength(1);
expect(leadPokemon.turnData.totalDamageDealt).toBe(0);
});
@ -96,11 +96,11 @@ describe("Moves - Focus Punch", () => {
await game.phaseInterceptor.to(MessagePhase); // Header message
expect(leadPokemon.getMoveHistory().length).toBe(0);
expect(leadPokemon.getMoveHistory()).toHaveLength(0);
await game.phaseInterceptor.to(BerryPhase, false);
expect(leadPokemon.getMoveHistory().length).toBe(1);
expect(leadPokemon.getMoveHistory()).toHaveLength(1);
expect(enemyPokemon.hp).toBe(enemyPokemon.getMaxHp());
});

16
test/moves/instruct.test.ts
View File

@ -118,7 +118,7 @@ describe("Moves - Instruct", () => {
await game.phaseInterceptor.to("BerryPhase");
instructSuccess(enemy, Moves.GIGATON_HAMMER);
expect(game.scene.getPlayerPokemon()!.turnData.attacksReceived.length).toBe(2);
expect(game.scene.getPlayerPokemon()!.turnData.attacksReceived).toHaveLength(2);
});
it("should add moves to move queue for copycat", async () => {
@ -135,7 +135,7 @@ describe("Moves - Instruct", () => {
instructSuccess(enemy1, Moves.WATER_GUN);
// amoonguss gets hit by water gun thrice; once by original attack, once by instructed use and once by copycat
expect(game.scene.getPlayerPokemon()!.turnData.attacksReceived.length).toBe(3);
expect(game.scene.getPlayerPokemon()!.turnData.attacksReceived).toHaveLength(3);
});
it("should respect enemy's status condition", async () => {
@ -175,7 +175,7 @@ describe("Moves - Instruct", () => {
const playerMoves = game.scene.getPlayerPokemon()!.getLastXMoves(-1)!;
expect(playerMoves[0].result).toBe(MoveResult.FAIL);
expect(enemyPokemon.getMoveHistory().length).toBe(1);
expect(enemyPokemon.getMoveHistory()).toHaveLength(1);
});
it("should redirect attacking moves if enemy faints", async () => {
@ -218,7 +218,7 @@ describe("Moves - Instruct", () => {
// fiery dance triggered dancer successfully for a total of 4 hits
// Enemy level is set to a high value so that it does not faint even after all 4 hits
instructSuccess(volcarona, Moves.FIERY_DANCE);
expect(game.scene.getEnemyField()[0].turnData.attacksReceived.length).toBe(4);
expect(game.scene.getEnemyField()[0].turnData.attacksReceived).toHaveLength(4);
});
it("should not repeat move when switching out", async () => {
@ -492,14 +492,14 @@ describe("Moves - Instruct", () => {
await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
await game.phaseInterceptor.to("BerryPhase");
expect(bulbasaur.turnData.attacksReceived.length).toBe(10);
expect(bulbasaur.turnData.attacksReceived).toHaveLength(10);
await game.toNextTurn();
game.move.select(Moves.INSTRUCT);
await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
await game.phaseInterceptor.to("BerryPhase");
expect(bulbasaur.turnData.attacksReceived.length).toBe(10);
expect(bulbasaur.turnData.attacksReceived).toHaveLength(10);
});
it("should cause multi-hit moves to hit the appropriate number of times in doubles", async () => {
@ -526,7 +526,7 @@ describe("Moves - Instruct", () => {
await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2]);
await game.phaseInterceptor.to("BerryPhase");
expect(ivysaur.turnData.attacksReceived.length).toBe(15);
expect(ivysaur.turnData.attacksReceived).toHaveLength(15);
await game.toNextTurn();
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
@ -536,6 +536,6 @@ describe("Moves - Instruct", () => {
await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER, BattlerIndex.PLAYER_2]);
await game.phaseInterceptor.to("BerryPhase");
expect(ivysaur.turnData.attacksReceived.length).toBe(15);
expect(ivysaur.turnData.attacksReceived).toHaveLength(15);
});
});

24
test/moves/roost.test.ts
View File

@ -58,7 +58,7 @@ describe("Moves - Roost", () => {
// Should only be normal type, and NOT flying type
let playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemonTypes[0]).toBe(PokemonType.NORMAL);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
expect(playerPokemon.isGrounded()).toBeTruthy();
await game.phaseInterceptor.to(TurnEndPhase);
@ -67,7 +67,7 @@ describe("Moves - Roost", () => {
playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemon.hp).toBeLessThan(playerPokemonStartingHP);
expect(playerPokemonTypes[0]).toBe(PokemonType.NORMAL);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
expect(playerPokemon.isGrounded()).toBeTruthy();
});
@ -106,7 +106,7 @@ describe("Moves - Roost", () => {
// Should only be pure fighting type and grounded
let playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemonTypes[0]).toBe(PokemonType.FIGHTING);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
expect(playerPokemon.isGrounded()).toBeTruthy();
await game.phaseInterceptor.to(TurnEndPhase);
@ -131,7 +131,7 @@ describe("Moves - Roost", () => {
// Should only be pure eletric type and grounded
let playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemonTypes[0]).toBe(PokemonType.ELECTRIC);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
expect(playerPokemon.isGrounded()).toBeFalsy();
await game.phaseInterceptor.to(TurnEndPhase);
@ -155,7 +155,7 @@ describe("Moves - Roost", () => {
// Should only be pure flying type after burn up
let playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemonTypes[0]).toBe(PokemonType.FLYING);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
await game.phaseInterceptor.to(TurnEndPhase);
game.move.select(Moves.ROOST);
@ -166,7 +166,7 @@ describe("Moves - Roost", () => {
playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemon.getTag(BattlerTagType.ROOSTED)).toBeDefined();
expect(playerPokemonTypes[0]).toBe(PokemonType.UNKNOWN);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
expect(playerPokemon.isGrounded()).toBeTruthy();
await game.phaseInterceptor.to(TurnEndPhase);
@ -175,7 +175,7 @@ describe("Moves - Roost", () => {
playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemon.hp).toBeLessThan(playerPokemonStartingHP);
expect(playerPokemonTypes[0]).toBe(PokemonType.FLYING);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
expect(playerPokemon.isGrounded()).toBeFalsy();
});
@ -191,7 +191,7 @@ describe("Moves - Roost", () => {
// Should only be pure flying type after burn up
let playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemonTypes[0]).toBe(PokemonType.FLYING);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
await game.phaseInterceptor.to(TurnEndPhase);
game.move.select(Moves.ROOST);
@ -202,7 +202,7 @@ describe("Moves - Roost", () => {
playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemon.getTag(BattlerTagType.ROOSTED)).toBeDefined();
expect(playerPokemonTypes[0]).toBe(PokemonType.UNKNOWN);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
expect(playerPokemon.isGrounded()).toBeTruthy();
await game.phaseInterceptor.to(TurnEndPhase);
@ -211,7 +211,7 @@ describe("Moves - Roost", () => {
playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemon.hp).toBeLessThan(playerPokemonStartingHP);
expect(playerPokemonTypes[0]).toBe(PokemonType.FLYING);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
expect(playerPokemon.isGrounded()).toBeFalsy();
});
@ -229,7 +229,7 @@ describe("Moves - Roost", () => {
let playerPokemonTypes = playerPokemon.getTypes();
expect(playerPokemonTypes[0]).toBe(PokemonType.FIRE);
expect(playerPokemonTypes.length).toBe(1);
expect(playerPokemonTypes).toHaveLength(1);
expect(playerPokemon.isGrounded()).toBeTruthy();
await game.phaseInterceptor.to(TurnEndPhase);
@ -239,7 +239,7 @@ describe("Moves - Roost", () => {
expect(playerPokemonTypes.filter(type => type === PokemonType.FLYING)).toHaveLength(1);
expect(playerPokemonTypes.filter(type => type === PokemonType.FIRE)).toHaveLength(1);
expect(playerPokemonTypes.filter(type => type === PokemonType.GHOST)).toHaveLength(1);
expect(playerPokemonTypes.length).toBe(3);
expect(playerPokemonTypes).toHaveLength(3);
expect(playerPokemon.isGrounded()).toBeFalsy();
});
});

2
test/moves/shed_tail.test.ts
View File

@ -56,7 +56,7 @@ describe("Moves - Shed Tail", () => {
await game.classicMode.startBattle([Species.MAGIKARP]);
const magikarp = game.scene.getPlayerPokemon()!;
expect(game.scene.getPlayerParty().length).toBe(1);
expect(game.scene.getPlayerParty()).toHaveLength(1);
game.move.select(Moves.SHED_TAIL);

6
test/moves/substitute.test.ts
View File

@ -309,7 +309,7 @@ describe("Moves - Substitute", () => {
await game.phaseInterceptor.to("BerryPhase", false);
expect(leadPokemon.getHeldItems().length).toBe(1);
expect(leadPokemon.getHeldItems()).toHaveLength(1);
});
it("should prevent the user's items from being removed", async () => {
@ -326,7 +326,7 @@ describe("Moves - Substitute", () => {
await game.phaseInterceptor.to("MoveEndPhase", false);
expect(enemyPokemon.getHeldItems().length).toBe(enemyNumItems);
expect(enemyPokemon.getHeldItems()).toHaveLength(enemyNumItems);
});
it("move effect should prevent the user's berries from being stolen and eaten", async () => {
@ -346,7 +346,7 @@ describe("Moves - Substitute", () => {
await game.phaseInterceptor.to("BerryPhase", false);
expect(leadPokemon.getHeldItems().length).toBe(1);
expect(leadPokemon.getHeldItems()).toHaveLength(1);
expect(enemyPokemon.hp).toBe(enemyPostAttackHp);
});

2
test/moves/toxic_spikes.test.ts
View File

@ -102,7 +102,7 @@ describe("Moves - Toxic Spikes", () => {
expect(muk.isFullHp()).toBe(true);
expect(muk.status?.effect).toBeUndefined();
expect(game.scene.arena.tags.length).toBe(0);
expect(game.scene.arena.tags).toHaveLength(0);
});
it("shouldn't create multiple layers per use in doubles", async () => {

6
test/mystery-encounter/encounters/a-trainers-test-encounter.test.ts
View File

@ -69,7 +69,7 @@ describe("A Trainer's Test - Mystery Encounter", () => {
expect(ATrainersTestEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(ATrainersTestEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(ATrainersTestEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(ATrainersTestEncounter.options.length).toBe(2);
expect(ATrainersTestEncounter.options).toHaveLength(2);
});
it("should initialize fully ", async () => {
@ -107,7 +107,7 @@ describe("A Trainer's Test - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(scene.currentBattle.trainer).toBeDefined();
expect(
[
@ -167,7 +167,7 @@ describe("A Trainer's Test - Mystery Encounter", () => {
await runMysteryEncounterToEnd(game, 2);
const partyHealPhases = phaseSpy.mock.calls.filter(p => p[0] instanceof PartyHealPhase).map(p => p[0]);
expect(partyHealPhases.length).toBe(1);
expect(partyHealPhases).toHaveLength(1);
});
it("Should reward the player with a Rare egg", async () => {

20
test/mystery-encounter/encounters/absolute-avarice-encounter.test.ts
View File

@ -66,7 +66,7 @@ describe("Absolute Avarice - Mystery Encounter", () => {
expect(AbsoluteAvariceEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(AbsoluteAvariceEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(AbsoluteAvariceEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(AbsoluteAvariceEncounter.options.length).toBe(3);
expect(AbsoluteAvariceEncounter.options).toHaveLength(3);
});
it("should not spawn outside of proper biomes", async () => {
@ -106,7 +106,7 @@ describe("Absolute Avarice - Mystery Encounter", () => {
await game.runToMysteryEncounter(MysteryEncounterType.ABSOLUTE_AVARICE, defaultParty);
expect(scene.currentBattle?.mysteryEncounter?.encounterType).toBe(MysteryEncounterType.ABSOLUTE_AVARICE);
expect(scene.modifiers?.length).toBe(0);
expect(scene.modifiers).toHaveLength(0);
});
describe("Option 1 - Fight the Greedent", () => {
@ -133,15 +133,15 @@ describe("Absolute Avarice - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(enemyField[0].species.speciesId).toBe(Species.GREEDENT);
const moveset = enemyField[0].moveset.map(m => m.moveId);
expect(moveset?.length).toBe(4);
expect(moveset).toEqual([Moves.THRASH, Moves.CRUNCH, Moves.BODY_PRESS, Moves.SLACK_OFF]);
expect(moveset).toHaveLength(4);
expect(moveset).toEqual([Moves.THRASH, Moves.BODY_PRESS, Moves.STUFF_CHEEKS, Moves.CRUNCH]);
const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
expect(movePhases.length).toBe(1);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STUFF_CHEEKS).length).toBe(1); // Stuff Cheeks used before battle
expect(movePhases).toHaveLength(1);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STUFF_CHEEKS)).toHaveLength(1); // Stuff Cheeks used before battle
});
it("should give reviver seed to each pokemon after battle", async () => {
@ -192,7 +192,7 @@ describe("Absolute Avarice - Mystery Encounter", () => {
await game.runToMysteryEncounter(MysteryEncounterType.ABSOLUTE_AVARICE, defaultParty);
expect(scene.currentBattle?.mysteryEncounter?.encounterType).toBe(MysteryEncounterType.ABSOLUTE_AVARICE);
expect(scene.modifiers?.length).toBe(0);
expect(scene.modifiers).toHaveLength(0);
await runMysteryEncounterToEnd(game, 2);
@ -212,7 +212,7 @@ describe("Absolute Avarice - Mystery Encounter", () => {
await game.runToMysteryEncounter(MysteryEncounterType.ABSOLUTE_AVARICE, defaultParty);
expect(scene.currentBattle?.mysteryEncounter?.encounterType).toBe(MysteryEncounterType.ABSOLUTE_AVARICE);
expect(scene.modifiers?.length).toBe(0);
expect(scene.modifiers).toHaveLength(0);
await runMysteryEncounterToEnd(game, 2);
@ -259,7 +259,7 @@ describe("Absolute Avarice - Mystery Encounter", () => {
const greedent = scene.getPlayerParty()[scene.getPlayerParty().length - 1];
expect(greedent.species.speciesId).toBe(Species.GREEDENT);
const moveset = greedent.moveset.map(m => m.moveId);
expect(moveset?.length).toBe(4);
expect(moveset).toHaveLength(4);
expect(moveset).toEqual([Moves.THRASH, Moves.BODY_PRESS, Moves.STUFF_CHEEKS, Moves.SLACK_OFF]);
});

4
test/mystery-encounter/encounters/an-offer-you-cant-refuse-encounter.test.ts
View File

@ -73,7 +73,7 @@ describe("An Offer You Can't Refuse - Mystery Encounter", () => {
`${namespace}:description`,
);
expect(AnOfferYouCantRefuseEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(AnOfferYouCantRefuseEncounter.options.length).toBe(3);
expect(AnOfferYouCantRefuseEncounter.options).toHaveLength(3);
});
it("should not spawn outside of HUMAN_TRANSITABLE_BIOMES", async () => {
@ -158,7 +158,7 @@ describe("An Offer You Can't Refuse - Mystery Encounter", () => {
await runMysteryEncounterToEnd(game, 1);
expect(scene.getPlayerParty().length).toBe(initialPartySize - 1);
expect(scene.getPlayerParty()).toHaveLength(initialPartySize - 1);
expect(scene.getPlayerParty().find(p => p.name === pokemonName)).toBeUndefined();
});

8
test/mystery-encounter/encounters/berries-abound-encounter.test.ts
View File

@ -69,7 +69,7 @@ describe("Berries Abound - Mystery Encounter", () => {
expect(BerriesAboundEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(BerriesAboundEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(BerriesAboundEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(BerriesAboundEncounter.options.length).toBe(3);
expect(BerriesAboundEncounter.options).toHaveLength(3);
});
it("should initialize fully", async () => {
@ -115,7 +115,7 @@ describe("Berries Abound - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
});
@ -189,7 +189,7 @@ describe("Berries Abound - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
// Should be enraged
@ -213,7 +213,7 @@ describe("Berries Abound - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
// Should be enraged

18
test/mystery-encounter/encounters/bug-type-superfan-encounter.test.ts
View File

@ -193,7 +193,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
expect(BugTypeSuperfanEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(BugTypeSuperfanEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(BugTypeSuperfanEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(BugTypeSuperfanEncounter.options.length).toBe(3);
expect(BugTypeSuperfanEncounter.options).toHaveLength(3);
});
it("should initialize fully", async () => {
@ -238,7 +238,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
const enemyParty = scene.getEnemyParty();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyParty.length).toBe(2);
expect(enemyParty).toHaveLength(2);
expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
expect(enemyParty[1].species.speciesId).toBe(Species.BUTTERFREE);
@ -251,7 +251,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
const enemyParty = scene.getEnemyParty();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyParty.length).toBe(3);
expect(enemyParty).toHaveLength(3);
expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
expect(enemyParty[1].species.speciesId).toBe(Species.BUTTERFREE);
@ -265,7 +265,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
const enemyParty = scene.getEnemyParty();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyParty.length).toBe(4);
expect(enemyParty).toHaveLength(4);
expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
expect(enemyParty[1].species.speciesId).toBe(Species.BUTTERFREE);
@ -280,7 +280,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
const enemyParty = scene.getEnemyParty();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyParty.length).toBe(5);
expect(enemyParty).toHaveLength(5);
expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
expect(enemyParty[1].species.speciesId).toBe(Species.BUTTERFREE);
@ -296,7 +296,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
const enemyParty = scene.getEnemyParty();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyParty.length).toBe(5);
expect(enemyParty).toHaveLength(5);
expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
expect(enemyParty[0].formIndex).toBe(1);
@ -314,7 +314,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
const enemyParty = scene.getEnemyParty();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyParty.length).toBe(5);
expect(enemyParty).toHaveLength(5);
expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
expect(enemyParty[0].formIndex).toBe(1);
@ -332,7 +332,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
const enemyParty = scene.getEnemyParty();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyParty.length).toBe(5);
expect(enemyParty).toHaveLength(5);
expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
expect(enemyParty[0].formIndex).toBe(1);
@ -350,7 +350,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
const enemyParty = scene.getEnemyParty();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyParty.length).toBe(5);
expect(enemyParty).toHaveLength(5);
expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
expect(enemyParty[0].formIndex).toBe(1);

20
test/mystery-encounter/encounters/clowning-around-encounter.test.ts
View File

@ -86,7 +86,7 @@ describe("Clowning Around - Mystery Encounter", () => {
expect(ClowningAroundEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(ClowningAroundEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(ClowningAroundEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(ClowningAroundEncounter.options.length).toBe(3);
expect(ClowningAroundEncounter.options).toHaveLength(3);
});
it("should not run below wave 80", async () => {
@ -124,7 +124,7 @@ describe("Clowning Around - Mystery Encounter", () => {
isBoss: true,
moveSet: [Moves.TRICK, Moves.HYPNOSIS, Moves.SHADOW_BALL, Moves.MIND_BLOWN],
});
expect(config.pokemonConfigs?.[1].customPokemonData?.types.length).toBe(2);
expect(config.pokemonConfigs?.[1].customPokemonData?.types).toHaveLength(2);
expect([
Abilities.STURDY,
Abilities.PICKUP,
@ -173,7 +173,7 @@ describe("Clowning Around - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(2);
expect(enemyField).toHaveLength(2);
expect(enemyField[0].species.speciesId).toBe(Species.MR_MIME);
expect(enemyField[0].moveset).toEqual([
new PokemonMove(Moves.TEETER_DANCE),
@ -191,9 +191,9 @@ describe("Clowning Around - Mystery Encounter", () => {
// Should have used moves pre-battle
const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
expect(movePhases.length).toBe(3);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.ROLE_PLAY).length).toBe(1);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.TAUNT).length).toBe(2);
expect(movePhases).toHaveLength(3);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.ROLE_PLAY)).toHaveLength(1);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.TAUNT)).toHaveLength(2);
});
it("should let the player gain the ability after battle completion", async () => {
@ -305,7 +305,7 @@ describe("Clowning Around - Mystery Encounter", () => {
expect(rogueCountAfter).toBe(7);
const secondItemsAfter = scene.getPlayerParty()[1].getHeldItems();
expect(secondItemsAfter.length).toBe(1);
expect(secondItemsAfter).toHaveLength(1);
expect(secondItemsAfter[0].type.id).toBe("SOUL_DEW");
expect(secondItemsAfter[0]?.stackCount).toBe(5);
});
@ -359,14 +359,14 @@ describe("Clowning Around - Mystery Encounter", () => {
const secondaryTypesAfter = scene.getPlayerParty()[1].getTypes();
const thirdTypesAfter = scene.getPlayerParty()[2].getTypes();
expect(leadTypesAfter.length).toBe(2);
expect(leadTypesAfter).toHaveLength(2);
expect(leadTypesAfter[0]).toBe(PokemonType.WATER);
expect([PokemonType.WATER, PokemonType.ICE].includes(leadTypesAfter[1])).toBeFalsy();
expect(secondaryTypesAfter.length).toBe(2);
expect(secondaryTypesAfter).toHaveLength(2);
expect(secondaryTypesAfter[0]).toBe(PokemonType.GHOST);
expect([PokemonType.GHOST, PokemonType.POISON].includes(secondaryTypesAfter[1])).toBeFalsy();
expect([PokemonType.GRASS, PokemonType.ELECTRIC].includes(secondaryTypesAfter[1])).toBeTruthy();
expect(thirdTypesAfter.length).toBe(2);
expect(thirdTypesAfter).toHaveLength(2);
expect(thirdTypesAfter[0]).toBe(PokemonType.PSYCHIC);
expect(secondaryTypesAfter[1]).not.toBe(PokemonType.PSYCHIC);
});

12
test/mystery-encounter/encounters/dancing-lessons-encounter.test.ts
View File

@ -69,7 +69,7 @@ describe("Dancing Lessons - Mystery Encounter", () => {
expect(DancingLessonsEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(DancingLessonsEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(DancingLessonsEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(DancingLessonsEncounter.options.length).toBe(3);
expect(DancingLessonsEncounter.options).toHaveLength(3);
});
it("should not spawn outside of proper biomes", async () => {
@ -107,15 +107,15 @@ describe("Dancing Lessons - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(enemyField[0].species.speciesId).toBe(Species.ORICORIO);
expect(enemyField[0].summonData.statStages).toEqual([1, 1, 1, 1, 0, 0, 0]);
const moveset = enemyField[0].moveset.map(m => m.moveId);
expect(moveset.some(m => m === Moves.REVELATION_DANCE)).toBeTruthy();
const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
expect(movePhases.length).toBe(1);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.REVELATION_DANCE).length).toBe(1); // Revelation Dance used before battle
expect(movePhases).toHaveLength(1);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.REVELATION_DANCE)).toHaveLength(1); // Revelation Dance used before battle
});
it("should have a Baton in the rewards after battle", async () => {
@ -163,8 +163,8 @@ describe("Dancing Lessons - Mystery Encounter", () => {
await runMysteryEncounterToEnd(game, 2, { pokemonNo: 1 });
const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof LearnMovePhase).map(p => p[0]);
expect(movePhases.length).toBe(1);
expect(movePhases.filter(p => (p as LearnMovePhase)["moveId"] === Moves.REVELATION_DANCE).length).toBe(1); // Revelation Dance taught to pokemon
expect(movePhases).toHaveLength(1);
expect(movePhases.filter(p => (p as LearnMovePhase)["moveId"] === Moves.REVELATION_DANCE)).toHaveLength(1); // Revelation Dance taught to pokemon
});
it("should leave encounter without battle", async () => {

2
test/mystery-encounter/encounters/delibirdy-encounter.test.ts
View File

@ -72,7 +72,7 @@ describe("Delibird-y - Mystery Encounter", () => {
expect(DelibirdyEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(DelibirdyEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(DelibirdyEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(DelibirdyEncounter.options.length).toBe(3);
expect(DelibirdyEncounter.options).toHaveLength(3);
});
it("should not spawn if player does not have enough money", async () => {

2
test/mystery-encounter/encounters/department-store-sale-encounter.test.ts
View File

@ -69,7 +69,7 @@ describe("Department Store Sale - Mystery Encounter", () => {
`${namespace}:description`,
);
expect(DepartmentStoreSaleEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(DepartmentStoreSaleEncounter.options.length).toBe(4);
expect(DepartmentStoreSaleEncounter.options).toHaveLength(4);
});
it("should not spawn outside of CIVILIZATION_ENCOUNTER_BIOMES", async () => {

2
test/mystery-encounter/encounters/field-trip-encounter.test.ts
View File

@ -67,7 +67,7 @@ describe("Field Trip - Mystery Encounter", () => {
expect(FieldTripEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(FieldTripEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(FieldTripEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(FieldTripEncounter.options.length).toBe(3);
expect(FieldTripEncounter.options).toHaveLength(3);
});
describe("Option 1 - Show off a physical move", () => {

8
test/mystery-encounter/encounters/fiery-fallout-encounter.test.ts
View File

@ -78,7 +78,7 @@ describe("Fiery Fallout - Mystery Encounter", () => {
expect(FieryFalloutEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(FieryFalloutEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(FieryFalloutEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(FieryFalloutEncounter.options.length).toBe(3);
expect(FieryFalloutEncounter.options).toHaveLength(3);
});
it("should not spawn outside of volcano biome", async () => {
@ -162,14 +162,14 @@ describe("Fiery Fallout - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(2);
expect(enemyField).toHaveLength(2);
expect(enemyField[0].species.speciesId).toBe(Species.VOLCARONA);
expect(enemyField[1].species.speciesId).toBe(Species.VOLCARONA);
expect(enemyField[0].gender).not.toEqual(enemyField[1].gender); // Should be opposite gender
const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
expect(movePhases.length).toBe(2);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.FIRE_SPIN).length).toBe(2); // Fire spin used twice before battle
expect(movePhases).toHaveLength(2);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.FIRE_SPIN)).toHaveLength(2); // Fire spin used twice before battle
});
it("should give attack type boosting item to lead pokemon", async () => {

4
test/mystery-encounter/encounters/fight-or-flight-encounter.test.ts
View File

@ -65,7 +65,7 @@ describe("Fight or Flight - Mystery Encounter", () => {
expect(FightOrFlightEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(FightOrFlightEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(FightOrFlightEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(FightOrFlightEncounter.options.length).toBe(3);
expect(FightOrFlightEncounter.options).toHaveLength(3);
});
it("should initialize fully", async () => {
@ -111,7 +111,7 @@ describe("Fight or Flight - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
});

2
test/mystery-encounter/encounters/fun-and-games-encounter.test.ts
View File

@ -74,7 +74,7 @@ describe("Fun And Games! - Mystery Encounter", () => {
expect(FunAndGamesEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(FunAndGamesEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(FunAndGamesEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(FunAndGamesEncounter.options.length).toBe(2);
expect(FunAndGamesEncounter.options).toHaveLength(2);
});
it("should not spawn outside of CIVILIZATIONN biomes", async () => {

4
test/mystery-encounter/encounters/global-trade-system-encounter.test.ts
View File

@ -66,7 +66,7 @@ describe("Global Trade System - Mystery Encounter", () => {
expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(GlobalTradeSystemEncounter.options.length).toBe(4);
expect(GlobalTradeSystemEncounter.options).toHaveLength(4);
});
it("should not loop infinitely when generating trade options for extreme BST non-legendaries", async () => {
@ -80,7 +80,7 @@ describe("Global Trade System - Mystery Encounter", () => {
expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(GlobalTradeSystemEncounter.options.length).toBe(4);
expect(GlobalTradeSystemEncounter.options).toHaveLength(4);
});
it("should not spawn outside of CIVILIZATION_ENCOUNTER_BIOMES", async () => {

2
test/mystery-encounter/encounters/lost-at-sea-encounter.test.ts
View File

@ -62,7 +62,7 @@ describe("Lost at Sea - Mystery Encounter", () => {
expect(LostAtSeaEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(LostAtSeaEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(LostAtSeaEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(LostAtSeaEncounter.options.length).toBe(3);
expect(LostAtSeaEncounter.options).toHaveLength(3);
});
it("should not spawn outside of sea biome", async () => {

6
test/mystery-encounter/encounters/mysterious-challengers-encounter.test.ts
View File

@ -72,7 +72,7 @@ describe("Mysterious Challengers - Mystery Encounter", () => {
`${namespace}:description`,
);
expect(MysteriousChallengersEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(MysteriousChallengersEncounter.options.length).toBe(3);
expect(MysteriousChallengersEncounter.options).toHaveLength(3);
});
it("should not spawn outside of HUMAN_TRANSITABLE_BIOMES", async () => {
@ -96,7 +96,7 @@ describe("Mysterious Challengers - Mystery Encounter", () => {
const onInitResult = onInit!();
expect(encounter.enemyPartyConfigs).toBeDefined();
expect(encounter.enemyPartyConfigs.length).toBe(3);
expect(encounter.enemyPartyConfigs).toHaveLength(3);
expect(encounter.enemyPartyConfigs).toEqual([
{
trainerConfig: expect.any(TrainerConfig),
@ -127,7 +127,7 @@ describe("Mysterious Challengers - Mystery Encounter", () => {
),
);
expect(encounter.spriteConfigs).toBeDefined();
expect(encounter.spriteConfigs.length).toBe(3);
expect(encounter.spriteConfigs).toHaveLength(3);
expect(onInitResult).toBe(true);
});

2
test/mystery-encounter/encounters/part-timer-encounter.test.ts
View File

@ -71,7 +71,7 @@ describe("Part-Timer - Mystery Encounter", () => {
expect(PartTimerEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(PartTimerEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(PartTimerEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(PartTimerEncounter.options.length).toBe(3);
expect(PartTimerEncounter.options).toHaveLength(3);
});
it("should not spawn outside of CIVILIZATION_ENCOUNTER_BIOMES", async () => {

2
test/mystery-encounter/encounters/safari-zone.test.ts
View File

@ -67,7 +67,7 @@ describe("Safari Zone - Mystery Encounter", () => {
expect(SafariZoneEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(SafariZoneEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(SafariZoneEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(SafariZoneEncounter.options.length).toBe(2);
expect(SafariZoneEncounter.options).toHaveLength(2);
});
it("should not spawn outside of the forest, swamp, or jungle biomes", async () => {

2
test/mystery-encounter/encounters/teleporting-hijinks-encounter.test.ts
View File

@ -69,7 +69,7 @@ describe("Teleporting Hijinks - Mystery Encounter", () => {
expect(TeleportingHijinksEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(TeleportingHijinksEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(TeleportingHijinksEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(TeleportingHijinksEncounter.options.length).toBe(3);
expect(TeleportingHijinksEncounter.options).toHaveLength(3);
});
it("should run in waves that are X1", async () => {

26
test/mystery-encounter/encounters/the-expert-breeder-encounter.test.ts
View File

@ -77,7 +77,7 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
`${namespace}:description`,
);
expect(TheExpertPokemonBreederEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(TheExpertPokemonBreederEncounter.options.length).toBe(3);
expect(TheExpertPokemonBreederEncounter.options).toHaveLength(3);
});
it("should not spawn outside of HUMAN_TRANSITABLE_BIOMES", async () => {
@ -103,11 +103,11 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
const onInitResult = onInit!();
expect(encounter.enemyPartyConfigs).toBeDefined();
expect(encounter.enemyPartyConfigs.length).toBe(1);
expect(encounter.enemyPartyConfigs).toHaveLength(1);
expect(encounter.enemyPartyConfigs[0].trainerType).toBe(TrainerType.EXPERT_POKEMON_BREEDER);
expect(encounter.enemyPartyConfigs[0].pokemonConfigs?.length).toBe(3);
expect(encounter.enemyPartyConfigs[0].pokemonConfigs).toHaveLength(3);
expect(encounter.spriteConfigs).toBeDefined();
expect(encounter.spriteConfigs.length).toBe(2);
expect(encounter.spriteConfigs).toHaveLength(2);
expect(onInitResult).toBe(true);
});
@ -159,7 +159,7 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(scene.currentBattle.trainer).toBeDefined();
expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
expect(scene.getPlayerParty().length).toBe(1);
expect(scene.getPlayerParty()).toHaveLength(1);
});
it("Should reward the player with friendship and eggs based on pokemon selected", async () => {
@ -182,8 +182,8 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
const rareEggs = scene.currentBattle.mysteryEncounter!.misc.pokemon1RareEggs;
expect(eggsAfter).toBeDefined();
expect(eggsBeforeLength + commonEggs + rareEggs).toBe(eggsAfter.length);
expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON).length).toBe(commonEggs);
expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE).length).toBe(rareEggs);
expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON)).toHaveLength(commonEggs);
expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE)).toHaveLength(rareEggs);
game.phaseInterceptor.superEndPhase();
await game.phaseInterceptor.to(PostMysteryEncounterPhase);
@ -244,7 +244,7 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(scene.currentBattle.trainer).toBeDefined();
expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
expect(scene.getPlayerParty().length).toBe(1);
expect(scene.getPlayerParty()).toHaveLength(1);
});
it("Should reward the player with friendship and eggs based on pokemon selected", async () => {
@ -267,8 +267,8 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
const rareEggs = scene.currentBattle.mysteryEncounter!.misc.pokemon2RareEggs;
expect(eggsAfter).toBeDefined();
expect(eggsBeforeLength + commonEggs + rareEggs).toBe(eggsAfter.length);
expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON).length).toBe(commonEggs);
expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE).length).toBe(rareEggs);
expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON)).toHaveLength(commonEggs);
expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE)).toHaveLength(rareEggs);
game.phaseInterceptor.superEndPhase();
await game.phaseInterceptor.to(PostMysteryEncounterPhase);
@ -326,7 +326,7 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(scene.currentBattle.trainer).toBeDefined();
expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
expect(scene.getPlayerParty().length).toBe(1);
expect(scene.getPlayerParty()).toHaveLength(1);
});
it("Should reward the player with friendship and eggs based on pokemon selected", async () => {
@ -349,8 +349,8 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
const rareEggs = scene.currentBattle.mysteryEncounter!.misc.pokemon3RareEggs;
expect(eggsAfter).toBeDefined();
expect(eggsBeforeLength + commonEggs + rareEggs).toBe(eggsAfter.length);
expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON).length).toBe(commonEggs);
expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE).length).toBe(rareEggs);
expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON)).toHaveLength(commonEggs);
expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE)).toHaveLength(rareEggs);
game.phaseInterceptor.superEndPhase();
await game.phaseInterceptor.to(PostMysteryEncounterPhase);

4
test/mystery-encounter/encounters/the-pokemon-salesman-encounter.test.ts
View File

@ -74,7 +74,7 @@ describe("The Pokemon Salesman - Mystery Encounter", () => {
expect(title).toBe(`${namespace}:title`);
expect(description).toMatch(new RegExp(`^${namespace}\\:description(_shiny)?$`));
expect(query).toBe(`${namespace}:query`);
expect(options.length).toBe(2);
expect(options).toHaveLength(2);
});
it("should not spawn outside of HUMAN_TRANSITABLE_BIOMES", async () => {
@ -150,7 +150,7 @@ describe("The Pokemon Salesman - Mystery Encounter", () => {
await runMysteryEncounterToEnd(game, 1);
expect(scene.getPlayerParty().length).toBe(initialPartySize + 1);
expect(scene.getPlayerParty()).toHaveLength(initialPartySize + 1);
const newlyPurchasedPokemon = scene.getPlayerParty()[scene.getPlayerParty().length - 1];
expect(newlyPurchasedPokemon.name).toBe(pokemonName);

12
test/mystery-encounter/encounters/the-strong-stuff-encounter.test.ts
View File

@ -77,7 +77,7 @@ describe("The Strong Stuff - Mystery Encounter", () => {
expect(TheStrongStuffEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(TheStrongStuffEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(TheStrongStuffEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(TheStrongStuffEncounter.options.length).toBe(2);
expect(TheStrongStuffEncounter.options).toHaveLength(2);
});
it("should not spawn outside of CAVE biome", async () => {
@ -193,11 +193,11 @@ describe("The Strong Stuff - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(enemyField[0].species.speciesId).toBe(Species.SHUCKLE);
expect(enemyField[0].summonData.statStages).toEqual([0, 1, 0, 1, 0, 0, 0]);
const shuckleItems = enemyField[0].getHeldItems();
expect(shuckleItems.length).toBe(5);
expect(shuckleItems).toHaveLength(5);
expect(shuckleItems.find(m => m instanceof BerryModifier && m.berryType === BerryType.SITRUS)?.stackCount).toBe(
1,
);
@ -220,9 +220,9 @@ describe("The Strong Stuff - Mystery Encounter", () => {
// Should have used moves pre-battle
const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
expect(movePhases.length).toBe(2);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.GASTRO_ACID).length).toBe(1);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STEALTH_ROCK).length).toBe(1);
expect(movePhases).toHaveLength(2);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.GASTRO_ACID)).toHaveLength(1);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STEALTH_ROCK)).toHaveLength(1);
});
it("should have Soul Dew in rewards", async () => {

18
test/mystery-encounter/encounters/the-winstrate-challenge-encounter.test.ts
View File

@ -79,7 +79,7 @@ describe("The Winstrate Challenge - Mystery Encounter", () => {
`${namespace}:description`,
);
expect(TheWinstrateChallengeEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(TheWinstrateChallengeEncounter.options.length).toBe(2);
expect(TheWinstrateChallengeEncounter.options).toHaveLength(2);
});
it("should not spawn outside of HUMAN_TRANSITABLE_BIOMES", async () => {
@ -103,7 +103,7 @@ describe("The Winstrate Challenge - Mystery Encounter", () => {
const onInitResult = onInit!();
expect(encounter.enemyPartyConfigs).toBeDefined();
expect(encounter.enemyPartyConfigs.length).toBe(5);
expect(encounter.enemyPartyConfigs).toHaveLength(5);
expect(encounter.enemyPartyConfigs).toEqual([
{
trainerType: TrainerType.VITO,
@ -236,7 +236,7 @@ describe("The Winstrate Challenge - Mystery Encounter", () => {
},
]);
expect(encounter.spriteConfigs).toBeDefined();
expect(encounter.spriteConfigs.length).toBe(5);
expect(encounter.spriteConfigs).toHaveLength(5);
expect(onInitResult).toBe(true);
});
@ -264,31 +264,31 @@ describe("The Winstrate Challenge - Mystery Encounter", () => {
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(scene.currentBattle.trainer).toBeDefined();
expect(scene.currentBattle.trainer!.config.trainerType).toBe(TrainerType.VICTOR);
expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs.length).toBe(4);
expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs).toHaveLength(4);
expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
await skipBattleToNextBattle(game);
expect(scene.currentBattle.trainer).toBeDefined();
expect(scene.currentBattle.trainer!.config.trainerType).toBe(TrainerType.VICTORIA);
expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs.length).toBe(3);
expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs).toHaveLength(3);
expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
await skipBattleToNextBattle(game);
expect(scene.currentBattle.trainer).toBeDefined();
expect(scene.currentBattle.trainer!.config.trainerType).toBe(TrainerType.VIVI);
expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs.length).toBe(2);
expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs).toHaveLength(2);
expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
await skipBattleToNextBattle(game);
expect(scene.currentBattle.trainer).toBeDefined();
expect(scene.currentBattle.trainer!.config.trainerType).toBe(TrainerType.VICKY);
expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs.length).toBe(1);
expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs).toHaveLength(1);
expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
await skipBattleToNextBattle(game);
expect(scene.currentBattle.trainer).toBeDefined();
expect(scene.currentBattle.trainer!.config.trainerType).toBe(TrainerType.VITO);
expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs.length).toBe(0);
expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs).toHaveLength(0);
expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
// Should have Macho Brace in the rewards
@ -330,7 +330,7 @@ describe("The Winstrate Challenge - Mystery Encounter", () => {
await runMysteryEncounterToEnd(game, 2);
const partyHealPhases = phaseSpy.mock.calls.filter(p => p[0] instanceof PartyHealPhase).map(p => p[0]);
expect(partyHealPhases.length).toBe(1);
expect(partyHealPhases).toHaveLength(1);
});
it("should have a Rarer Candy in the rewards", async () => {

10
test/mystery-encounter/encounters/trash-to-treasure-encounter.test.ts
View File

@ -75,7 +75,7 @@ describe("Trash to Treasure - Mystery Encounter", () => {
expect(TrashToTreasureEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(TrashToTreasureEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(TrashToTreasureEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(TrashToTreasureEncounter.options.length).toBe(2);
expect(TrashToTreasureEncounter.options).toHaveLength(2);
});
it("should initialize fully", async () => {
@ -221,7 +221,7 @@ describe("Trash to Treasure - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(enemyField[0].species.speciesId).toBe(Species.GARBODOR);
expect(enemyField[0].moveset).toEqual([
new PokemonMove(Moves.GUNK_SHOT),
@ -232,9 +232,9 @@ describe("Trash to Treasure - Mystery Encounter", () => {
// Should have used moves pre-battle
const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
expect(movePhases.length).toBe(2);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.TOXIC).length).toBe(1);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STOCKPILE).length).toBe(1);
expect(movePhases).toHaveLength(2);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.TOXIC)).toHaveLength(1);
expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STOCKPILE)).toHaveLength(1);
});
it("should have 2 Rogue, 1 Ultra, 1 Great in rewards", async () => {

10
test/mystery-encounter/encounters/uncommon-breed-encounter.test.ts
View File

@ -74,7 +74,7 @@ describe("Uncommon Breed - Mystery Encounter", () => {
expect(UncommonBreedEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(UncommonBreedEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(UncommonBreedEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(UncommonBreedEncounter.options.length).toBe(3);
expect(UncommonBreedEncounter.options).toHaveLength(3);
});
it("should initialize fully", async () => {
@ -122,7 +122,7 @@ describe("Uncommon Breed - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
const statStagePhases = unshiftPhaseSpy.mock.calls.filter(p => p[0] instanceof StatStageChangePhase)[0][0] as any;
@ -130,7 +130,7 @@ describe("Uncommon Breed - Mystery Encounter", () => {
// Should have used its egg move pre-battle
const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
expect(movePhases.length).toBe(1);
expect(movePhases).toHaveLength(1);
const eggMoves: Moves[] = speciesEggMoves[getPokemonSpecies(speciesToSpawn).getRootSpeciesId()];
const usedMove = (movePhases[0] as MovePhase).move.moveId;
expect(eggMoves.includes(usedMove)).toBe(true);
@ -149,7 +149,7 @@ describe("Uncommon Breed - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(enemyField).toHaveLength(1);
expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
const statStagePhases = unshiftPhaseSpy.mock.calls.filter(p => p[0] instanceof StatStageChangePhase)[0][0] as any;
@ -157,7 +157,7 @@ describe("Uncommon Breed - Mystery Encounter", () => {
// Should have used its egg move pre-battle
const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
expect(movePhases.length).toBe(1);
expect(movePhases).toHaveLength(1);
const eggMoves: Moves[] = speciesEggMoves[getPokemonSpecies(speciesToSpawn).getRootSpeciesId()];
const usedMove = (movePhases[0] as MovePhase).move.moveId;
expect(eggMoves.includes(usedMove)).toBe(true);

12
test/mystery-encounter/encounters/weird-dream-encounter.test.ts
View File

@ -74,7 +74,7 @@ describe("Weird Dream - Mystery Encounter", () => {
expect(WeirdDreamEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
expect(WeirdDreamEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
expect(WeirdDreamEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
expect(WeirdDreamEncounter.options.length).toBe(3);
expect(WeirdDreamEncounter.options).toHaveLength(3);
});
it("should initialize fully", async () => {
@ -126,14 +126,14 @@ describe("Weird Dream - Mystery Encounter", () => {
for (let i = 0; i < pokemonAfter.length; i++) {
const newPokemon = pokemonAfter[i];
expect(newPokemon.getSpeciesForm().speciesId).not.toBe(pokemonPrior[i].getSpeciesForm().speciesId);
expect(newPokemon.customPokemonData?.types.length).toBe(2);
expect(newPokemon.customPokemonData?.types).toHaveLength(2);
}
const plus90To110 = bstDiff.filter(bst => bst > 80);
const plus40To50 = bstDiff.filter(bst => bst < 80);
expect(plus90To110.length).toBe(2);
expect(plus40To50.length).toBe(1);
expect(plus90To110).toHaveLength(2);
expect(plus40To50).toHaveLength(1);
});
it("should have 1 Memory Mushroom, 5 Rogue Balls, and 3 Mints in rewards", async () => {
@ -187,8 +187,8 @@ describe("Weird Dream - Mystery Encounter", () => {
const enemyField = scene.getEnemyField();
expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
expect(enemyField.length).toBe(1);
expect(scene.getEnemyParty().length).toBe(scene.getPlayerParty().length);
expect(enemyField).toHaveLength(1);
expect(scene.getEnemyParty()).toHaveLength(scene.getPlayerParty().length);
});
it("should have 2 Rogue/2 Ultra/2 Great items in rewards", async () => {

4
test/phases/frenzy-move-reset.test.ts
View File

@ -59,14 +59,14 @@ describe("Frenzy Move Reset", () => {
await game.move.forceStatusActivation(false);
await game.toNextTurn();
expect(playerPokemon.summonData.moveQueue.length).toBe(2);
expect(playerPokemon.summonData.moveQueue).toHaveLength(2);
expect(playerPokemon.summonData.tags.some(tag => tag.tagType === BattlerTagType.FRENZY)).toBe(true);
await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
await game.move.forceStatusActivation(true);
await game.toNextTurn();
expect(playerPokemon.summonData.moveQueue.length).toBe(0);
expect(playerPokemon.summonData.moveQueue).toHaveLength(0);
expect(playerPokemon.summonData.tags.some(tag => tag.tagType === BattlerTagType.FRENZY)).toBe(false);
});
});

4
test/sprites/pokemonSprite.test.ts
View File

@ -189,7 +189,7 @@ describe("check if every variant's sprite are correctly set", () => {
if (errors.length) {
console.log("errors", errors);
}
expect(errors.length).toBe(0);
expect(errors).toHaveLength(0);
});
it("check exp back male variant files", () => {
@ -269,7 +269,7 @@ describe("check if every variant's sprite are correctly set", () => {
if (errors.length) {
console.log("errors for ", dirPath, errors);
}
expect(errors.length).toBe(0);
expect(errors).toHaveLength(0);
});
it("look over every file in variant exp female and check if present in masterlist", () => {

8
test/ui/pokedex.test.ts
View File

@ -443,7 +443,7 @@ describe("UI - Pokedex", () => {
let filteredPokemon = pokedexHandler.filteredPokemonData.map(pokemon => pokemon.species.speciesId);
// Red shiny
expect(filteredPokemon.length).toBe(1);
expect(filteredPokemon).toHaveLength(1);
expect(filteredPokemon[0], "tier 1 shiny").toBe(Species.CATERPIE);
// tier 2 shiny
@ -452,14 +452,14 @@ describe("UI - Pokedex", () => {
// @ts-expect-error - `filteredPokemonData` is private
filteredPokemon = pokedexHandler.filteredPokemonData.map(pokemon => pokemon.species.speciesId);
expect(filteredPokemon.length).toBe(1);
expect(filteredPokemon).toHaveLength(1);
expect(filteredPokemon[0], "tier 2 shiny").toBe(Species.RATTATA);
filter.toggleOptionState(2);
filter.toggleOptionState(1);
// @ts-expect-error - `filteredPokemonData` is private
filteredPokemon = pokedexHandler.filteredPokemonData.map(pokemon => pokemon.species.speciesId);
expect(filteredPokemon.length).toBe(1);
expect(filteredPokemon).toHaveLength(1);
expect(filteredPokemon[0], "tier 3 shiny").toBe(Species.EKANS);
// filter by no shiny
@ -468,7 +468,7 @@ describe("UI - Pokedex", () => {
// @ts-expect-error - `filteredPokemonData` is private
filteredPokemon = pokedexHandler.filteredPokemonData.map(pokemon => pokemon.species.speciesId);
expect(filteredPokemon.length).toBe(27);
expect(filteredPokemon).toHaveLength(27);
expect(filteredPokemon, "not shiny").not.toContain(Species.CATERPIE);
expect(filteredPokemon, "not shiny").not.toContain(Species.RATTATA);
expect(filteredPokemon, "not shiny").not.toContain(Species.EKANS);

2
test/ui/starter-select.test.ts
View File

@ -579,7 +579,7 @@ describe("UI - Starter select", () => {
});
});
expect(starterSelectUiHandler?.starterSpecies.length).toBe(1);
expect(starterSelectUiHandler?.starterSpecies).toHaveLength(1);
expect(starterSelectUiHandler?.starterSpecies[0].generation).toBe(1);
expect(starterSelectUiHandler?.starterSpecies[0].speciesId).toBe(32);
expect(starterSelectUiHandler?.cursorObj.x).toBe(53);

2
test/utils.test.ts
View File

@ -14,7 +14,7 @@ describe("utils", () => {
describe("randomString", () => {
it("should return a string of the specified length", () => {
const str = randomString(10);
expect(str.length).toBe(10);
expect(str).toHaveLength(10);
});
it("should work with seed", () => {