@takaro/modules 0.0.1 → 0.0.5

package/src/__tests__/economyUtils.integration.test.ts

@@ -1,5 +1,11 @@
-import { IntegrationTest, expect } from '@takaro/test';
-import { IModuleTestsSetupData, modulesTestSetup, chatMessageSorter } from '@takaro/test';
+import {
+  IntegrationTest,
+  expect,
+  IModuleTestsSetupData,
+  modulesTestSetup,
+  chatMessageSorter,
+  EventsAwaiter,
+} from '@takaro/test';
 import { GameEvents } from '../dto/index.js';
 
 const group = 'Economy utils suite';
@@ -31,10 +37,10 @@ const tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.economyUtilsModule.id
+        this.setupData.economyUtilsModule.id,
       );
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/balance',
@@ -52,7 +58,7 @@ const tests = [
         playerOnGameServer[0].playerId,
         {
           currency: 1000,
-        }
+        },
       );
 
       // trigger balance command
@@ -62,8 +68,8 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(2);
-      expect((await events)[0].data.msg).to.be.eq('balance: 0 test coin');
-      expect((await events)[1].data.msg).to.be.eq('balance: 1000 test coin');
+      expect((await events)[0].data.meta.msg).to.be.eq('balance: 0 test coin');
+      expect((await events)[1].data.meta.msg).to.be.eq('balance: 1000 test coin');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -75,7 +81,7 @@ const tests = [
       // install module
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.economyUtilsModule.id
+        this.setupData.economyUtilsModule.id,
       );
 
       const giveCurrencies = this.setupData.players.map(async (player, index) => {
@@ -90,24 +96,24 @@ const tests = [
           playerOnGameServer[0].playerId,
           {
             currency: 1000 * index,
-          }
+          },
         );
       });
       await Promise.all(giveCurrencies);
 
       // title message (1) + balance of player messages (5)
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 6);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 6);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/topcurrency',
         playerId: this.setupData.players[0].id,
       });
 
-      const messages = (await events).map((e) => e.data.msg as string);
+      const messages = (await events).map((e) => e.data.meta.msg as string);
       expect((await events).length).to.be.eq(6);
       for (const message of messages) {
         expect(message).to.match(
-          /(Richest players\:|1\. .+ - 4000 test coin|2\. .+ - 3000 test coin|3\. .+ - 2000 test coin|4\. .+ - 1000 test coin|5\. .+ - 0 test coin)/
+          /(Richest players\:|1\. .+ - 4000 test coin|2\. .+ - 3000 test coin|3\. .+ - 2000 test coin|4\. .+ - 1000 test coin|5\. .+ - 0 test coin)/,
         );
       }
     },
@@ -120,7 +126,7 @@ const tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.economyUtilsModule.id
+        this.setupData.economyUtilsModule.id,
       );
 
       const transferAmount = 500;
@@ -133,36 +139,36 @@ const tests = [
         senderPog.playerId,
         {
           currency: transferAmount,
-        }
+        },
       );
 
       const receiver = this.setupData.players[1];
       const receiverPog = receiver.playerOnGameServers?.find(
-        (pog) => pog.gameServerId === this.setupData.gameserver.id
+        (pog) => pog.gameServerId === this.setupData.gameserver.id,
       );
       if (!receiverPog) throw new Error('Receiver playerOnGameServer does not exist');
       expect(receiverPog.currency).to.be.eq(0);
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: `/transfer ${receiver.name} ${transferAmount}`,
         playerId: sender.id,
       });
 
-      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.msg as string);
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
       expect((await events).length).to.be.eq(2);
 
       // check if balances are correct
       const updatedSender = await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
         senderPog.gameServerId,
-        senderPog.playerId
+        senderPog.playerId,
       );
       expect(updatedSender.data.data.currency).to.be.eq(0);
 
       const updatedReceiver = await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
         receiverPog.gameServerId,
-        receiverPog.playerId
+        receiverPog.playerId,
       );
       expect(updatedReceiver.data.data.currency).to.be.eq(transferAmount);
 
@@ -178,24 +184,24 @@ const tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.economyUtilsModule.id
+        this.setupData.economyUtilsModule.id,
       );
 
       const sender = this.setupData.players[0];
       const receiver = this.setupData.players[1];
       const transferAmount = 500;
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: `/transfer ${receiver.name} ${transferAmount}`,
         playerId: sender.id,
       });
 
-      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.msg as string);
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
       expect((await events).length).to.be.eq(1);
       expect(messages[0]).to.be.eq(
-        `Failed to transfer ${transferAmount} test coin to ${receiver.name}. Are you sure you have enough balance?`
+        `Failed to transfer ${transferAmount} test coin to ${receiver.name}. Are you sure you have enough balance?`,
       );
     },
   }),
@@ -212,7 +218,7 @@ const tests = [
           userConfig: JSON.stringify({
             pendingAmount: 100,
           }),
-        }
+        },
       );
 
       const transferAmount = 500;
@@ -228,73 +234,73 @@ const tests = [
         senderPog.playerId,
         {
           currency: transferAmount,
-        }
+        },
       );
 
       const receiver = this.setupData.players[1];
       const receiverPog = receiver.playerOnGameServers?.find(
-        (pog) => pog.gameServerId === this.setupData.gameserver.id
+        (pog) => pog.gameServerId === this.setupData.gameserver.id,
       );
       if (!receiverPog) throw new Error('Receiver playerOnGameServer does not exist');
       expect(receiverPog.currency).to.be.eq(0);
 
-      let events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      let events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: `/transfer ${receiver.name} ${transferAmount}`,
         playerId: sender.id,
       });
 
-      let messages = (await events).sort(chatMessageSorter).map((e) => e.data.msg as string);
+      let messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
 
       // check if balances have not changed yet
       expect(
         (
           await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
             senderPog.gameServerId,
-            senderPog.playerId
+            senderPog.playerId,
           )
-        ).data.data.currency
+        ).data.data.currency,
       ).to.be.eq(transferAmount);
       expect(
         (
           await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
             receiverPog.gameServerId,
-            receiverPog.playerId
+            receiverPog.playerId,
           )
-        ).data.data.currency
+        ).data.data.currency,
       ).to.be.eq(0);
       expect(messages.length).to.be.eq(1);
       expect(messages[0]).to.be.eq(
-        `You are about to send ${transferAmount} test coin to ${receiver.name}. (Please confirm by typing ${prefix}confirmtransfer)`
+        `You are about to send ${transferAmount} test coin to ${receiver.name}. (Please confirm by typing ${prefix}confirmtransfer)`,
       );
 
       // =================================================
       // transfer confirmed
       // =================================================
-      events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: `${prefix}confirmtransfer`,
         playerId: sender.id,
       });
 
-      messages = (await events).sort(chatMessageSorter).map((e) => e.data.msg as string);
+      messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
       expect((await events).length).to.be.eq(2);
       expect(
         (
           await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
             senderPog.gameServerId,
-            senderPog.playerId
+            senderPog.playerId,
           )
-        ).data.data.currency
+        ).data.data.currency,
       ).to.be.eq(0);
       expect(
         (
           await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
             receiverPog.gameServerId,
-            receiverPog.playerId
+            receiverPog.playerId,
           )
-        ).data.data.currency
+        ).data.data.currency,
       ).to.be.eq(transferAmount);
 
       expect(messages[0]).to.be.eq(`You received ${transferAmount} test coin from ${sender.name}`);
@@ -314,15 +320,15 @@ const tests = [
           userConfig: JSON.stringify({
             pendingAmount: 100,
           }),
-        }
+        },
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/confirmtransfer',
         playerId: this.setupData.players[0].id,
       });
 
-      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.msg as string);
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
       expect(messages[0]).to.be.eq('You have no pending transfer.');
     },
   }),
@@ -338,7 +344,7 @@ const tests = [
 
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.economyUtilsModule.id
+        this.setupData.economyUtilsModule.id,
       );
 
       // Change permissions of role to only have manageCurrency permission
@@ -352,25 +358,25 @@ const tests = [
       });
 
       const receiverPog = receiver.playerOnGameServers?.find(
-        (pog) => pog.gameServerId === this.setupData.gameserver.id
+        (pog) => pog.gameServerId === this.setupData.gameserver.id,
       );
       if (!receiverPog) throw new Error('Receiver playerOnGameServer does not exist');
       expect(receiverPog.currency).to.be.eq(0);
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: `/grantcurrency ${receiver.name} ${grantAmount}`,
         playerId: granter.id,
       });
 
-      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.msg as string);
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
       expect(
         (
           await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
             receiverPog.gameServerId,
-            receiverPog.playerId
+            receiverPog.playerId,
           )
-        ).data.data.currency
+        ).data.data.currency,
       ).to.be.eq(grantAmount);
       expect(messages[0]).to.be.eq(`Granted ${grantAmount} test coin by ${granter.name}`);
       expect(messages[1]).to.be.eq(`You successfully granted ${grantAmount} test coin to ${receiver.name}`);
@@ -388,7 +394,7 @@ const tests = [
 
       // make sure receiver has enough currency
       const receiverPog = receiver.playerOnGameServers?.find(
-        (pog) => pog.gameServerId === this.setupData.gameserver.id
+        (pog) => pog.gameServerId === this.setupData.gameserver.id,
       );
       if (!receiverPog) throw new Error('Receiver playerOnGameServer does not exist');
       await this.client.playerOnGameserver.playerOnGameServerControllerSetCurrency(
@@ -396,12 +402,12 @@ const tests = [
         receiverPog.playerId,
         {
           currency: revokeAmount,
-        }
+        },
       );
 
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.economyUtilsModule.id
+        this.setupData.economyUtilsModule.id,
       );
 
       // Change permissions of role to only have manageCurrency permission
@@ -416,23 +422,23 @@ const tests = [
 
       // currency before revoke
       expect(
-        receiver.playerOnGameServers?.find((pog) => pog.gameServerId === this.setupData.gameserver.id)?.currency
+        receiver.playerOnGameServers?.find((pog) => pog.gameServerId === this.setupData.gameserver.id)?.currency,
       ).to.be.eq(0);
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: `/revokecurrency ${receiver.name} ${revokeAmount}`,
         playerId: revoker.id,
       });
 
-      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.msg as string);
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
       expect(
         (
           await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
             receiverPog.gameServerId,
-            receiverPog.playerId
+            receiverPog.playerId,
           )
-        ).data.data.currency
+        ).data.data.currency,
       ).to.be.eq(0);
       expect(messages[0]).to.be.eq(`${revokeAmount} test coin were revoked by ${revoker.name}`);
       expect(messages[1]).to.be.eq(`You successfully revoked ${revokeAmount} test coin of ${receiver.name}'s balance`);
@@ -455,15 +461,15 @@ const tests = [
 
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.economyUtilsModule.id
+        this.setupData.economyUtilsModule.id,
       );
 
       // currency before revoke
       expect(
-        receiver.playerOnGameServers?.find((pog) => pog.gameServerId === this.setupData.gameserver.id)?.currency
+        receiver.playerOnGameServers?.find((pog) => pog.gameServerId === this.setupData.gameserver.id)?.currency,
       ).to.be.eq(0);
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: `/grantcurrency ${receiver.name} ${amount}`,
         playerId: sender.id,
@@ -474,7 +480,7 @@ const tests = [
         playerId: sender.id,
       });
 
-      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.msg as string);
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
       expect(messages[0]).to.be.eq('You do not have permission to use grant currency command.');
       expect(messages[1]).to.be.eq('You do not have permission to use revoke currency command.');
     },

package/src/__tests__/geoblock.integration.test.ts

@@ -1,5 +1,4 @@
-import { IntegrationTest, expect } from '@takaro/test';
-import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { HookEvents } from '../dto/index.js';
 import { TakaroEventPlayerNewIpDetected } from '@takaro/modules';
 import { faker } from '@faker-js/faker';
@@ -12,7 +11,7 @@ const customSetup = async function (this: IntegrationTest<IModuleTestsSetupData>
   await Promise.all(
     setupData.players.map(async (player) => {
       await this.client.player.playerControllerRemoveRole(player.id, setupData.role.id);
-    })
+    }),
   );
 
   return setupData;
@@ -34,9 +33,9 @@ const tests = [
             countries: ['RU'],
             ban: false,
           }),
-        }
+        },
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.PLAYER_DISCONNECTED);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.PLAYER_DISCONNECTED);
       await this.client.hook.hookControllerTrigger({
         gameServerId: this.setupData.gameserver.id,
         playerId: this.setupData.players[0].id,
@@ -51,8 +50,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/Kicked Your IP address is banned/);
-      expect((await events)[0].data.player.name).to.be.eq(this.setupData.players[0].name);
+      expect((await events)[0].data.playerId).to.be.eq(this.setupData.players[0].id);
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -70,9 +68,9 @@ const tests = [
             countries: ['RU'],
             ban: false,
           }),
-        }
+        },
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.HOOK_EXECUTED);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.HOOK_EXECUTED);
 
       await this.client.hook.hookControllerTrigger({
         gameServerId: this.setupData.gameserver.id,
@@ -109,9 +107,9 @@ const tests = [
             countries: ['RU'],
             ban: false,
           }),
-        }
+        },
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.HOOK_EXECUTED);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.HOOK_EXECUTED);
 
       await this.client.hook.hookControllerTrigger({
         gameServerId: this.setupData.gameserver.id,
@@ -148,9 +146,9 @@ const tests = [
             countries: ['RU'],
             ban: false,
           }),
-        }
+        },
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.PLAYER_DISCONNECTED);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.PLAYER_DISCONNECTED);
 
       await this.client.hook.hookControllerTrigger({
         gameServerId: this.setupData.gameserver.id,
@@ -166,8 +164,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/Kicked Your IP address is banned/);
-      expect((await events)[0].data.player.name).to.be.eq(this.setupData.players[0].name);
+      expect((await events)[0].data.playerId).to.be.eq(this.setupData.players[0].id);
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -185,9 +182,9 @@ const tests = [
             countries: ['RU'],
             ban: true,
           }),
-        }
+        },
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.PLAYER_DISCONNECTED);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.PLAYER_DISCONNECTED);
 
       await this.client.hook.hookControllerTrigger({
         gameServerId: this.setupData.gameserver.id,
@@ -203,46 +200,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/Banned Your IP address is banned/);
-      expect((await events)[0].data.player.name).to.be.eq(this.setupData.players[0].name);
-    },
-  }),
-  new IntegrationTest<IModuleTestsSetupData>({
-    group,
-    snapshot: false,
-    setup: customSetup,
-    name: 'MESSAGE CONFIGURATION: Custom message displayed to player on kick/ban',
-    test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.geoBlockModule.id,
-        {
-          userConfig: JSON.stringify({
-            mode: 'allow',
-            countries: ['RU'],
-            ban: true,
-            message: 'Custom message',
-          }),
-        }
-      );
-      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.PLAYER_DISCONNECTED);
-
-      await this.client.hook.hookControllerTrigger({
-        gameServerId: this.setupData.gameserver.id,
-        playerId: this.setupData.players[0].id,
-        eventType: HookEvents.PLAYER_NEW_IP_DETECTED,
-        eventMeta: new TakaroEventPlayerNewIpDetected({
-          city: 'nowhere',
-          country: 'BE',
-          latitude: '0',
-          longitude: '0',
-          ip: faker.internet.ip(),
-        }),
-      });
-
-      expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/Banned Custom message/);
-      expect((await events)[0].data.player.name).to.be.eq(this.setupData.players[0].name);
+      expect((await events)[0].data.playerId).to.be.eq(this.setupData.players[0].id);
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -261,9 +219,9 @@ const tests = [
             ban: true,
             message: 'Custom message',
           }),
-        }
+        },
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.PLAYER_DISCONNECTED);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.PLAYER_DISCONNECTED);
 
       await this.client.hook.hookControllerTrigger({
         gameServerId: this.setupData.gameserver.id,
@@ -279,8 +237,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/Banned Custom message/);
-      expect((await events)[0].data.player.name).to.be.eq(this.setupData.players[0].name);
+      expect((await events)[0].data.playerId).to.be.eq(this.setupData.players[0].id);
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -299,7 +256,7 @@ const tests = [
             ban: true,
             message: 'Custom message',
           }),
-        }
+        },
       );
       const permissions = await this.client.permissionCodesToInputs(['GEOBLOCK_IMMUNITY']);
       const roleRes = await this.client.role.roleControllerCreate({
@@ -309,7 +266,7 @@ const tests = [
 
       await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, roleRes.data.data.id);
 
-      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.HOOK_EXECUTED);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.HOOK_EXECUTED);
 
       await this.client.hook.hookControllerTrigger({
         gameServerId: this.setupData.gameserver.id,
@@ -347,9 +304,9 @@ const tests = [
             ban: true,
             message: 'Custom message',
           }),
-        }
+        },
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.HOOK_EXECUTED);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.HOOK_EXECUTED);
 
       await this.client.hook.hookControllerTrigger({
         gameServerId: this.setupData.gameserver.id,