@takaro/modules 0.0.1 → 0.0.5

package/src/__tests__/gimme.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 { GameEvents } from '../dto/index.js';
 
 const group = 'gimme suite';
@@ -19,9 +18,9 @@ const tests = [
             items: ['apple', 'banana', 'orange'],
             commands: [],
           }),
-        }
+        },
       );
-      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',
@@ -29,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,
@@ -74,10 +73,10 @@ const tests = [
             items: [],
             commands: [],
           }),
-        }
+        },
       );
 
-      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',
@@ -85,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,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/gameEvents.js';
 
 const group = 'Help command';
@@ -13,9 +19,9 @@ const tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.utilsModule.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,
@@ -24,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(
-        'help: The text you are reading right now, displays information about commands.'
+      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.meta.msg).to.be.eq(
+        'ping: Replies with pong, useful for testing if the connection works.',
       );
-      expect(sortedEvents[2].data.msg).to.be.eq('ping: Replies with pong, useful for testing if the connection works.');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -39,13 +47,13 @@ const tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.utilsModule.id
+        this.setupData.utilsModule.id,
       );
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.teleportsModule.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,
@@ -53,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(
-        'help: The text you are reading right now, displays information about commands.'
+      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.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[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(
-        'setprivate: Sets a teleport to be private, only the teleport owner can teleport to it.'
+      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(
-        'setpublic: Sets a teleport to be public, allowing other players to teleport to it.'
+      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(
-        'teleportwaypoint: Placeholder command, this will not be used directly. The module will install aliases for this command corresponding to the waypoint '
+      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>({
@@ -84,10 +94,10 @@ const tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.utilsModule.id
+        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',
@@ -97,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>({
@@ -108,10 +120,10 @@ const tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.utilsModule.id
+        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',
@@ -119,8 +131,8 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq(
-        'Unknown command "foobar", use this command without arguments to see all available commands.'
+      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,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 { GameEvents } from '../dto/index.js';
 import { Client } from '@takaro/apiclient';
 
@@ -11,7 +10,7 @@ async function expectTicketAmountLengthToBe(
   client: Client,
   gameServerId: string,
   moduleId: string,
-  expectedAmount = 0
+  expectedAmount = 0,
 ) {
   const ticketVars = await client.variable.variableControllerSearch({
     filters: {
@@ -86,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, {
@@ -95,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>({
@@ -104,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;
@@ -121,8 +120,8 @@ const tests = [
       ).data.data.value;
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq(
-        `You have successfully bought ${ticketAmount} tickets for ${ticketPrice} ${currencyName}. Good luck!`
+      expect((await events)[0].data.meta.msg).to.be.eq(
+        `You have successfully bought ${ticketAmount} tickets for ${ticketPrice} ${currencyName}. Good luck!`,
       );
 
       let pog = (
@@ -132,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}`,
@@ -140,8 +139,8 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq(
-        `You have successfully bought ${ticketAmount} tickets for ${ticketPrice} ${currencyName}. Good luck!`
+      expect((await events)[0].data.meta.msg).to.be.eq(
+        `You have successfully bought ${ticketAmount} tickets for ${ticketPrice} ${currencyName}. Good luck!`,
       );
 
       pog = (
@@ -159,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}}`,
@@ -168,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',
@@ -178,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>({
@@ -192,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) => {
@@ -205,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,
@@ -216,7 +218,7 @@ const tests = [
       const mod = (
         await this.client.gameserver.gameServerControllerGetModuleInstallation(
           this.setupData.gameserver.id,
-          this.setupData.lotteryModule.id
+          this.setupData.lotteryModule.id,
         )
       ).data.data;
 
@@ -226,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');
@@ -246,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,
@@ -257,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>({
@@ -266,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, {
@@ -280,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,
@@ -291,9 +295,9 @@ 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(
-        `You have been refunded ${ticketCost} ${currencyName} because the lottery has been cancelled.`
+      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.`,
       );
 
       const pog = (
@@ -310,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',
@@ -320,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,5 +1,11 @@
-import { IntegrationTest, expect, integrationConfig } from '@takaro/test';
-import { 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';
@@ -18,13 +24,13 @@ async function cleanRoleSetup(this: IntegrationTest<IModuleTestsSetupData>) {
 
   await this.client.gameserver.gameServerControllerInstallModule(
     defaultSetup.gameserver.id,
-    defaultSetup.teleportsModule.id
+    defaultSetup.teleportsModule.id,
   );
 
   await Promise.all(
     playersRes.data.data.map(async (player) => {
       await this.client.player.playerControllerRemoveRole(player.id, defaultSetup.role.id);
-    })
+    }),
   );
 
   return defaultSetup;
@@ -48,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>({
@@ -76,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>({
@@ -106,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>({
@@ -129,13 +135,13 @@ const tests = [
           userConfig: JSON.stringify({
             timeout: 0,
           }),
-        }
+        },
       );
 
       await Promise.all(
         this.setupData.players.map(async (player) => {
           await this.client.player.playerControllerRemoveRole(player.id, this.setupData.role.id);
-        })
+        }),
       );
 
       const playerRoleRes = await this.client.role.roleControllerSearch({ filters: { name: ['Player'] } });
@@ -149,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',
@@ -157,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.');
     },
   }),
 ];