@takaro/modules 0.0.4 → 0.0.6

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

@@ -1,4 +1,4 @@
-import { IntegrationTest, expect, 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';
@@ -35,7 +35,7 @@ const tests = [
           }),
         },
       );
-      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,
@@ -50,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>({
@@ -71,7 +70,7 @@ const tests = [
           }),
         },
       );
-      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,
@@ -110,7 +109,7 @@ const tests = [
           }),
         },
       );
-      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,
@@ -149,7 +148,7 @@ const tests = [
           }),
         },
       );
-      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,
@@ -165,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>({
@@ -186,7 +184,7 @@ const tests = [
           }),
         },
       );
-      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,
@@ -202,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>({
@@ -262,7 +221,7 @@ const tests = [
           }),
         },
       );
-      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,
@@ -278,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>({
@@ -308,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,
@@ -348,7 +306,7 @@ const tests = [
           }),
         },
       );
-      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,

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

@@ -1,4 +1,4 @@
-import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents } from '../dto/index.js';
 
 const group = 'gimme suite';
@@ -20,7 +20,7 @@ const tests = [
           }),
         },
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/gimme',
@@ -28,37 +28,37 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/You received (apple|banana|orange)/);
-    },
-  }),
-  new IntegrationTest<IModuleTestsSetupData>({
-    group,
-    snapshot: false,
-    setup: modulesTestSetup,
-    name: 'Can execute command',
-    test: async function () {
-      await this.client.gameserver.gameServerControllerInstallModule(
-        this.setupData.gameserver.id,
-        this.setupData.gimmeModule.id,
-        {
-          userConfig: JSON.stringify({
-            items: [],
-            commands: ['say hello from test'],
-          }),
-        },
-      );
-
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
-
-      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
-        msg: '/gimme',
-        playerId: this.setupData.players[0].id,
-      });
-
-      expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.eq('hello from test');
+      expect((await events)[0].data.meta.msg).to.match(/You received (apple|banana|orange)/);
     },
   }),
+  /*   new IntegrationTest<IModuleTestsSetupData>({
+      group,
+      snapshot: false,
+      setup: modulesTestSetup,
+      name: 'Can execute command',
+      test: async function () {
+        await this.client.gameserver.gameServerControllerInstallModule(
+          this.setupData.gameserver.id,
+          this.setupData.gimmeModule.id,
+          {
+            userConfig: JSON.stringify({
+              items: [],
+              commands: ['say hello from test'],
+            }),
+          },
+        );
+  
+        const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+  
+        await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+          msg: '/gimme',
+          playerId: this.setupData.players[0].id,
+        });
+  
+        expect((await events).length).to.be.eq(1);
+        expect((await events)[0].data.meta.msg).to.eq('hello from test');
+      },
+    }), */
   new IntegrationTest<IModuleTestsSetupData>({
     group,
     snapshot: false,
@@ -76,7 +76,7 @@ const tests = [
         },
       );
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/gimme',
@@ -84,7 +84,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/No items or commands configured/);
+      expect((await events)[0].data.meta.msg).to.match(/No items or commands configured/);
     },
   }),
 ];

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

@@ -1,4 +1,11 @@
-import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, chatMessageSorter } from '@takaro/test';
+import {
+  IntegrationTest,
+  expect,
+  IModuleTestsSetupData,
+  modulesTestSetup,
+  chatMessageSorter,
+  EventsAwaiter,
+} from '@takaro/test';
 import { GameEvents } from '../dto/gameEvents.js';
 
 const group = 'Help command';
@@ -14,7 +21,7 @@ const tests = [
         this.setupData.gameserver.id,
         this.setupData.utilsModule.id,
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 3);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 3);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/help',
         playerId: this.setupData.players[0].id,
@@ -23,11 +30,13 @@ const tests = [
       expect((await events).length).to.be.eq(3);
       const sortedEvents = (await events).sort(chatMessageSorter);
 
-      expect(sortedEvents[0].data.msg).to.be.eq('Available commands:');
-      expect(sortedEvents[1].data.msg).to.be.eq(
+      expect(sortedEvents[0].data.meta.msg).to.be.eq('Available commands:');
+      expect(sortedEvents[1].data.meta.msg).to.be.eq(
         'help: The text you are reading right now, displays information about commands.',
       );
-      expect(sortedEvents[2].data.msg).to.be.eq('ping: Replies with pong, useful for testing if the connection works.');
+      expect(sortedEvents[2].data.meta.msg).to.be.eq(
+        'ping: Replies with pong, useful for testing if the connection works.',
+      );
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -44,7 +53,7 @@ const tests = [
         this.setupData.gameserver.id,
         this.setupData.teleportsModule.id,
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 13);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 13);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/help',
         playerId: this.setupData.players[0].id,
@@ -52,27 +61,29 @@ const tests = [
 
       const sortedEvents = (await events).sort(chatMessageSorter);
 
-      expect(sortedEvents[0].data.msg).to.be.eq('Available commands:');
-      expect(sortedEvents[1].data.msg).to.be.eq('deletetp: Deletes a location.');
-      expect(sortedEvents[2].data.msg).to.be.eq('deletewaypoint: Deletes a waypoint.');
-      expect(sortedEvents[3].data.msg).to.be.eq(
+      expect(sortedEvents[0].data.meta.msg).to.be.eq('Available commands:');
+      expect(sortedEvents[1].data.meta.msg).to.be.eq('deletetp: Deletes a location.');
+      expect(sortedEvents[2].data.meta.msg).to.be.eq('deletewaypoint: Deletes a waypoint.');
+      expect(sortedEvents[3].data.meta.msg).to.be.eq(
         'help: The text you are reading right now, displays information about commands.',
       );
-      expect(sortedEvents[4].data.msg).to.be.eq('listwaypoints: Lists all waypoints.');
-      expect(sortedEvents[5].data.msg).to.be.eq('ping: Replies with pong, useful for testing if the connection works.');
-      expect(sortedEvents[6].data.msg).to.be.eq(
+      expect(sortedEvents[4].data.meta.msg).to.be.eq('listwaypoints: Lists all waypoints.');
+      expect(sortedEvents[5].data.meta.msg).to.be.eq(
+        'ping: Replies with pong, useful for testing if the connection works.',
+      );
+      expect(sortedEvents[6].data.meta.msg).to.be.eq(
         'setprivate: Sets a teleport to be private, only the teleport owner can teleport to it.',
       );
-      expect(sortedEvents[7].data.msg).to.be.eq(
+      expect(sortedEvents[7].data.meta.msg).to.be.eq(
         'setpublic: Sets a teleport to be public, allowing other players to teleport to it.',
       );
-      expect(sortedEvents[8].data.msg).to.be.eq('settp: Sets a location to teleport to.');
-      expect(sortedEvents[9].data.msg).to.be.eq('setwaypoint: Creates a new waypoint.');
-      expect(sortedEvents[10].data.msg).to.be.eq('teleport: Teleports to one of your set locations.');
-      expect(sortedEvents[11].data.msg).to.be.eq(
+      expect(sortedEvents[8].data.meta.msg).to.be.eq('settp: Sets a location to teleport to.');
+      expect(sortedEvents[9].data.meta.msg).to.be.eq('setwaypoint: Creates a new waypoint.');
+      expect(sortedEvents[10].data.meta.msg).to.be.eq('teleport: Teleports to one of your set locations.');
+      expect(sortedEvents[11].data.meta.msg).to.be.eq(
         'teleportwaypoint: Placeholder command, this will not be used directly. The module will install aliases for this command corresponding to the waypoint names.',
       );
-      expect(sortedEvents[12].data.msg).to.be.eq('tplist: Lists all your set locations.');
+      expect(sortedEvents[12].data.meta.msg).to.be.eq('tplist: Lists all your set locations.');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -86,7 +97,7 @@ const tests = [
         this.setupData.utilsModule.id,
       );
 
-      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: '/help ping',
@@ -96,7 +107,9 @@ const tests = [
       expect((await events).length).to.be.eq(1);
       const sortedEvents = (await events).sort(chatMessageSorter);
 
-      expect(sortedEvents[0].data.msg).to.be.eq('ping: Replies with pong, useful for testing if the connection works.');
+      expect(sortedEvents[0].data.meta.msg).to.be.eq(
+        'ping: Replies with pong, useful for testing if the connection works.',
+      );
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -110,7 +123,7 @@ const tests = [
         this.setupData.utilsModule.id,
       );
 
-      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: '/help foobar',
@@ -118,7 +131,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq(
+      expect((await events)[0].data.meta.msg).to.be.eq(
         'Unknown command "foobar", use this command without arguments to see all available commands.',
       );
     },

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

@@ -1,4 +1,4 @@
-import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents } from '../dto/index.js';
 import { Client } from '@takaro/apiclient';
 
@@ -85,7 +85,7 @@ const tests = [
     setup,
     name: 'Cannot buy 0 lottery tickets',
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
       const player = this.setupData.players[0];
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
@@ -94,7 +94,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq('You must buy at least 1 ticket.');
+      expect((await events)[0].data.meta.msg).to.be.eq('You must buy at least 1 ticket.');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -103,7 +103,7 @@ const tests = [
     setup,
     name: 'Can buy lottery ticket',
     test: async function () {
-      let events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      let events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       const ticketAmount = 1;
       const ticketPrice = ticketAmount * ticketCost;
@@ -120,7 +120,7 @@ const tests = [
       ).data.data.value;
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq(
+      expect((await events)[0].data.meta.msg).to.be.eq(
         `You have successfully bought ${ticketAmount} tickets for ${ticketPrice} ${currencyName}. Good luck!`,
       );
 
@@ -131,7 +131,7 @@ const tests = [
       expect(pog.currency).to.be.eq(playerStartBalance - ticketPrice);
       await expectTicketAmountLengthToBe(this.client, this.setupData.gameserver.id, this.setupData.lotteryModule.id, 1);
 
-      events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: `/buyTicket ${ticketAmount}`,
@@ -139,7 +139,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq(
+      expect((await events)[0].data.meta.msg).to.be.eq(
         `You have successfully bought ${ticketAmount} tickets for ${ticketPrice} ${currencyName}. Good luck!`,
       );
 
@@ -158,7 +158,7 @@ const tests = [
     test: async function () {
       const wantAmount = 10;
 
-      const waitForBuyEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const waitForBuyEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: `/buyTicket ${wantAmount}}`,
@@ -167,7 +167,7 @@ const tests = [
 
       await waitForBuyEvents;
 
-      const waitForViewEvent = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const waitForViewEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/viewTickets',
@@ -177,7 +177,7 @@ const tests = [
       const events = await waitForViewEvent;
 
       expect(events.length).to.be.eq(1);
-      expect(events[0].data.msg).to.be.eq(`You have bought ${wantAmount} tickets.`);
+      expect(events[0].data.meta.msg).to.be.eq(`You have bought ${wantAmount} tickets.`);
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -191,7 +191,10 @@ const tests = [
       ).data.data.value;
 
       const playerAmount = this.setupData.players.length;
-      const ticketEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, playerAmount);
+      const ticketEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(
+        GameEvents.CHAT_MESSAGE,
+        playerAmount,
+      );
 
       // let some players buy tickets
       const asyncTasks = this.setupData.players.map(async (player) => {
@@ -204,7 +207,7 @@ const tests = [
       await Promise.allSettled(asyncTasks);
       await ticketEvents;
 
-      const lotteryEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 4);
+      const lotteryEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 4);
 
       await this.client.cronjob.cronJobControllerTrigger({
         moduleId: this.setupData.lotteryModule.id,
@@ -225,9 +228,9 @@ const tests = [
       const events = await lotteryEvents;
 
       expect(events.length).to.be.eq(4);
-      expect(events[3].data.msg).to.contain(`${prize} ${currencyName}`);
+      expect(events[3].data.meta.msg).to.contain(`${prize} ${currencyName}`);
 
-      const winnerName = events[3].data.msg.split('!')[0];
+      const winnerName = events[3].data.meta.msg.split('!')[0];
       const winner = this.setupData.players.find((player) => player.name === winnerName);
       if (!winner) {
         throw new Error('winner name not found in the list of setup players');
@@ -245,7 +248,7 @@ const tests = [
     setup,
     name: 'If no players joined, the lottery is cancelled',
     test: async function () {
-      const waitForEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const waitForEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.cronjob.cronJobControllerTrigger({
         moduleId: this.setupData.lotteryModule.id,
@@ -256,7 +259,7 @@ const tests = [
       const events = await waitForEvents;
 
       expect(events.length).to.be.eq(1);
-      expect(events[0].data.msg).to.eq('No one has bought any tickets. The lottery has been cancelled.');
+      expect(events[0].data.meta.msg).to.eq('No one has bought any tickets. The lottery has been cancelled.');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -265,7 +268,9 @@ const tests = [
     setup,
     name: 'If one player joined, the lottery is cancelled and the player gets his money back',
     test: async function () {
-      const waitForTicketEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const waitForTicketEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(
+        GameEvents.CHAT_MESSAGE,
+      );
 
       const player = this.setupData.players[0];
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
@@ -279,7 +284,7 @@ const tests = [
         await this.client.settings.settingsControllerGetOne('currencyName', this.setupData.gameserver.id)
       ).data.data.value;
 
-      const waitForEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const waitForEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
 
       await this.client.cronjob.cronJobControllerTrigger({
         moduleId: this.setupData.lotteryModule.id,
@@ -290,8 +295,8 @@ const tests = [
       const events = await waitForEvents;
 
       expect(events.length).to.be.eq(2);
-      expect(events[0].data.msg).to.eq('Only one person has bought a ticket. The lottery has been cancelled.');
-      expect(events[1].data.msg).to.eq(
+      expect(events[0].data.meta.msg).to.eq('Only one person has bought a ticket. The lottery has been cancelled.');
+      expect(events[1].data.meta.msg).to.eq(
         `You have been refunded ${ticketCost} ${currencyName} because the lottery has been cancelled.`,
       );
 
@@ -309,7 +314,7 @@ const tests = [
     setup,
     name: 'Can view next lottery draw',
     test: async function () {
-      const waitForEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const waitForEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/nextDraw',
@@ -319,7 +324,7 @@ const tests = [
       const events = await waitForEvents;
 
       expect(events.length).to.be.eq(1);
-      expect(events[0].data.msg).to.contain('The next lottery draw is in');
+      expect(events[0].data.meta.msg).to.contain('The next lottery draw is in');
     },
   }),
 ];

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

@@ -1,4 +1,11 @@
-import { IntegrationTest, expect, integrationConfig, IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import {
+  IntegrationTest,
+  expect,
+  integrationConfig,
+  IModuleTestsSetupData,
+  modulesTestSetup,
+  EventsAwaiter,
+} from '@takaro/test';
 import { GameEvents } from '../dto/index.js';
 
 const group = 'Module permissions role assignments';
@@ -47,14 +54,14 @@ const tests = [
       });
       await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, this.setupData.role.id);
 
-      const setEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test',
         playerId: this.setupData.players[0].id,
       });
 
       expect((await setEvents).length).to.be.eq(1);
-      expect((await setEvents)[0].data.msg).to.be.eq('Teleport test set.');
+      expect((await setEvents)[0].data.meta.msg).to.be.eq('Teleport test set.');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -75,14 +82,14 @@ const tests = [
         gameServerId: newGameServer.data.data.id,
       });
 
-      const setEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test',
         playerId: this.setupData.players[0].id,
       });
 
       expect((await setEvents).length).to.be.eq(1);
-      expect((await setEvents)[0].data.msg).to.be.eq('You do not have permission to use teleports.');
+      expect((await setEvents)[0].data.meta.msg).to.be.eq('You do not have permission to use teleports.');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -105,14 +112,14 @@ const tests = [
         gameServerId: this.setupData.gameserver.id,
       });
 
-      const setEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test',
         playerId: this.setupData.players[0].id,
       });
 
       expect((await setEvents).length).to.be.eq(1);
-      expect((await setEvents)[0].data.msg).to.be.eq('Teleport test set.');
+      expect((await setEvents)[0].data.meta.msg).to.be.eq('Teleport test set.');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -148,7 +155,7 @@ const tests = [
         ],
       });
 
-      const setTpEvent = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const setTpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test',
@@ -156,30 +163,30 @@ const tests = [
       });
 
       expect((await setTpEvent).length).to.be.eq(1);
-      expect((await setTpEvent)[0].data.msg).to.be.eq('Teleport test set.');
+      expect((await setTpEvent)[0].data.meta.msg).to.be.eq('Teleport test set.');
 
-      const tpEvent = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const tpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/tp test',
         playerId: this.setupData.players[0].id,
       });
 
-      expect((await tpEvent)[0].data.msg).to.be.eq('Teleported to test.');
+      expect((await tpEvent)[0].data.meta.msg).to.be.eq('Teleported to test.');
 
       await this.client.role.roleControllerUpdate(playerRoleRes.data.data[0].id, {
         name: 'Player',
         permissions: [],
       });
 
-      const tpEventNoPerm = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const tpEventNoPerm = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/tp test',
         playerId: this.setupData.players[0].id,
       });
 
-      expect((await tpEventNoPerm)[0].data.msg).to.be.eq('You do not have permission to use teleports.');
+      expect((await tpEventNoPerm)[0].data.meta.msg).to.be.eq('You do not have permission to use teleports.');
     },
   }),
 ];