@takaro/modules 0.0.1 → 0.0.5

package/src/__tests__/onboarding.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 { EventPlayerConnected, GameEvents } from '../dto/gameEvents.js';
 import { HookEvents } from '../main.js';
 
@@ -15,9 +14,9 @@ const _tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.onboardingModule.id
+        this.setupData.onboardingModule.id,
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
       await this.client.hook.hookControllerTrigger({
         gameServerId: this.setupData.gameserver.id,
         playerId: this.setupData.players[0].id,
@@ -31,7 +30,7 @@ const _tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/Welcome .+ to the server!/);
+      expect((await events)[0].data.meta.msg).to.match(/Welcome .+ to the server!/);
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -47,9 +46,9 @@ const _tests = [
           userConfig: JSON.stringify({
             starterKitItems: ['cigar'],
           }),
-        }
+        },
       );
-      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.COMMAND_EXECUTED);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.COMMAND_EXECUTED);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/starterkit',
         playerId: this.setupData.players[0].id,
@@ -72,9 +71,9 @@ const _tests = [
           userConfig: JSON.stringify({
             starterKitItems: ['cigar'],
           }),
-        }
+        },
       );
-      const firstEvents = this.setupData.eventAwaiter.waitForEvents(HookEvents.COMMAND_EXECUTED);
+      const firstEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.COMMAND_EXECUTED);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/starterkit',
         playerId: this.setupData.players[0].id,
@@ -83,14 +82,14 @@ const _tests = [
       const resultLogs = (await firstEvents)[0].data.meta.result.logs;
       expect(resultLogs.some((log: any) => log.msg.match(/giveItem 200 OK/))).to.be.true;
 
-      const secondEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const secondEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/starterkit',
         playerId: this.setupData.players[0].id,
       });
 
       expect((await secondEvents).length).to.be.eq(1);
-      expect((await secondEvents)[0].data.msg).to.match(/ou already used starterkit on this server/);
+      expect((await secondEvents)[0].data.meta.msg).to.match(/ou already used starterkit on this server/);
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -101,16 +100,16 @@ const _tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.onboardingModule.id
+        this.setupData.onboardingModule.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: '/starterkit',
         playerId: this.setupData.players[0].id,
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.match(/No starter kit items configured/);
+      expect((await events)[0].data.meta.msg).to.match(/No starter kit items configured/);
     },
   }),
 ];

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

@@ -1,6 +1,5 @@
-import { IntegrationTest, expect } from '@takaro/test';
-import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
-import { GameEvents } from '../dto/index.js';
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { HookEvents } from '../dto/index.js';
 
 const group = 'Ping command';
 
@@ -13,10 +12,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);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/ping',
@@ -24,7 +23,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq('Pong!');
+      expect((await events)[0].data.meta.msg).to.be.eq('Pong!');
     },
   }),
 ];

package/src/__tests__/roleExpiry.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 = 'Role expiry';
@@ -13,15 +12,15 @@ const tests = [
     test: async function () {
       // First, ensure all players have no roles
       await Promise.all(
-        this.setupData.players.map((p) => this.client.player.playerControllerRemoveRole(p.id, this.setupData.role.id))
+        this.setupData.players.map((p) => this.client.player.playerControllerRemoveRole(p.id, this.setupData.role.id)),
       );
 
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id
+        this.setupData.teleportsModule.id,
       );
 
-      const eventsBeforeRole = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const eventsBeforeRole = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test',
@@ -29,7 +28,7 @@ const tests = [
       });
 
       expect((await eventsBeforeRole).length).to.be.eq(1);
-      expect((await eventsBeforeRole)[0].data.msg).to.match(/You do not have permission to use teleports/);
+      expect((await eventsBeforeRole)[0].data.meta.msg).to.match(/You do not have permission to use teleports/);
 
       // Assign the role with expiry 10 minutes from now
       await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, this.setupData.role.id, {
@@ -37,7 +36,7 @@ const tests = [
       });
 
       // Execute the command again. Now it should work, since the role is assigned
-      const eventsWithRole = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const eventsWithRole = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test2',
@@ -45,7 +44,7 @@ const tests = [
       });
 
       expect((await eventsWithRole).length).to.be.eq(1);
-      expect((await eventsWithRole)[0].data.msg).to.match(/Teleport test2 set/);
+      expect((await eventsWithRole)[0].data.meta.msg).to.match(/Teleport test2 set/);
 
       // Remove the role and reassign with expiry 1 ms from now
       await this.client.player.playerControllerRemoveRole(this.setupData.players[0].id, this.setupData.role.id);
@@ -54,7 +53,7 @@ const tests = [
       });
 
       // Execute the command again. Now it should not work, since the role is expired
-      const eventsAfterExpire = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const eventsAfterExpire = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test3',
@@ -62,7 +61,7 @@ const tests = [
       });
 
       expect((await eventsAfterExpire).length).to.be.eq(1);
-      expect((await eventsAfterExpire)[0].data.msg).to.match(/You do not have permission to use teleports/);
+      expect((await eventsAfterExpire)[0].data.meta.msg).to.match(/You do not have permission to use teleports/);
     },
   }),
 ];

package/src/__tests__/serverMessages.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 { sleep } from '@takaro/util';
 
@@ -14,10 +13,10 @@ const tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.serverMessagesModule.id
+        this.setupData.serverMessagesModule.id,
       );
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.cronjob.cronJobControllerTrigger({
         cronjobId: this.setupData.serverMessagesModule.cronJobs[0].id,
@@ -26,9 +25,9 @@ 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(
         // eslint-disable-next-line
-        "This is an automated message, don't forget to read the server rules!"
+        "This is an automated message, don't forget to read the server rules!",
       );
     },
   }),
@@ -45,10 +44,10 @@ const tests = [
           userConfig: JSON.stringify({
             messages: ['This is a custom message'],
           }),
-        }
+        },
       );
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
       await this.client.cronjob.cronJobControllerTrigger({
         cronjobId: this.setupData.serverMessagesModule.cronJobs[0].id,
@@ -57,7 +56,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq('This is a custom message');
+      expect((await events)[0].data.meta.msg).to.be.eq('This is a custom message');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -73,13 +72,16 @@ const tests = [
           userConfig: JSON.stringify({
             messages: ['Test message 1', 'Test message 2'],
           }),
-        }
+        },
       );
 
       // We should see each of our test messages at least once
 
       const numberOfEvents = 10;
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, numberOfEvents);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(
+        GameEvents.CHAT_MESSAGE,
+        numberOfEvents,
+      );
 
       for (let i = 0; i < numberOfEvents; i++) {
         await sleep(Math.floor(Math.random() * 10) + 1);
@@ -90,7 +92,7 @@ const tests = [
         });
       }
 
-      const messages = (await events).map((e) => e.data.msg);
+      const messages = (await events).map((e) => e.data.meta.msg);
       expect(messages).to.include('Test message 1');
       expect(messages).to.include('Test message 2');
     },

package/src/__tests__/systemConfigCost.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 { sleep } from '@takaro/util';
 
@@ -28,17 +27,17 @@ const customSetup = async function (this: IntegrationTest<IModuleTestsSetupData>
           },
         },
       }),
-    }
+    },
   );
 
-  const setEvents = 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(setupData.gameserver.id, {
     msg: '/settp test',
     playerId: 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.');
 
   const giveCurrencies = setupData.players.map(async (player) => {
     const playerOnGameServer = (
@@ -52,7 +51,7 @@ const customSetup = async function (this: IntegrationTest<IModuleTestsSetupData>
       playerOnGameServer[0].playerId,
       {
         currency: 100,
-      }
+      },
     );
   });
   await Promise.all(giveCurrencies);
@@ -67,7 +66,7 @@ const tests = [
     setup: customSetup,
     name: 'Deducts money when cost is configured',
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents('command-executed', 1);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents('command-executed', 1);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/tp test',
         playerId: this.setupData.players[0].id,
@@ -92,7 +91,7 @@ const tests = [
     test: async function () {
       const amount = 10;
 
-      const setEvents = this.setupData.eventAwaiter.waitForEvents('command-executed', amount);
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents('command-executed', amount);
 
       await Promise.all(
         Array.from({ length: amount }).map(async (_, index) => {
@@ -101,12 +100,12 @@ const tests = [
             msg: `/settp test${index}`,
             playerId: this.setupData.players[0].id,
           });
-        })
+        }),
       );
 
       expect((await setEvents).length).to.be.eq(amount);
 
-      const events = this.setupData.eventAwaiter.waitForEvents('command-executed', amount);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents('command-executed', amount);
       await Promise.all(
         Array.from({ length: amount }).map(async (_, index) => {
           await sleep(1);
@@ -114,7 +113,7 @@ const tests = [
             msg: `/tp test${index}`,
             playerId: this.setupData.players[0].id,
           });
-        })
+        }),
       );
 
       expect((await events).length).to.be.eq(amount);
@@ -137,7 +136,7 @@ const tests = [
     setup: customSetup,
     name: 'Does not deduct currency when command unsuccessful',
     test: async function () {
-      const events = this.setupData.eventAwaiter.waitForEvents('command-executed', 1);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents('command-executed', 1);
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/tp doesntexist',
         playerId: this.setupData.players[0].id,
@@ -174,17 +173,17 @@ const tests = [
         playerOnGameServer[0].playerId,
         {
           currency: 5,
-        }
+        },
       );
 
-      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: '/tp test',
         playerId: this.setupData.players[1].id,
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.msg).to.be.eq('You do not have enough currency to execute this command.');
+      expect((await events)[0].data.meta.msg).to.be.eq('You do not have enough currency to execute this command.');
     },
   }),
 ];

package/src/__tests__/teleports/listtp.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 = 'Teleports suite';
@@ -13,10 +12,10 @@ const tests = [
     test: async function () {
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
-        this.setupData.teleportsModule.id
+        this.setupData.teleportsModule.id,
       );
 
-      const setEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 3);
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 3);
 
       await Promise.all(
         Array.from({ length: 3 }).map(async (_, i) => {
@@ -24,16 +23,16 @@ const tests = [
             msg: `/settp test${i}`,
             playerId: this.setupData.players[0].id,
           });
-        })
+        }),
       );
 
       expect((await setEvents).length).to.be.eq(3);
 
       for (const event of await setEvents) {
-        expect(event.data.msg).to.match(/Teleport test\d set\./);
+        expect(event.data.meta.msg).to.match(/Teleport test\d set\./);
       }
 
-      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 4);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 4);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/tplist',
@@ -41,11 +40,10 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(4);
-      expect((await events)[0].data.msg).to.be.eq('You have 3 teleports available');
-      //  - test0: 61, -262, -52
-      expect((await events)[1].data.msg).to.match(/ - test0: [-\d]+, [-\d]+, [-\d]+/);
-      expect((await events)[2].data.msg).to.match(/ - test1: [-\d]+, [-\d]+, [-\d]+/);
-      expect((await events)[3].data.msg).to.match(/ - test2: [-\d]+, [-\d]+, [-\d]+/);
+      expect((await events)[0].data.meta.msg).to.be.eq('You have 3 teleports available');
+      expect((await events)[1].data.meta.msg).to.match(/test0: \([-\d]+,[-\d]+,[-\d]+\)/);
+      expect((await events)[2].data.meta.msg).to.match(/test1: \([-\d]+,[-\d]+,[-\d]+\)/);
+      expect((await events)[3].data.meta.msg).to.match(/test2: \([-\d]+,[-\d]+,[-\d]+\)/);
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -61,10 +59,10 @@ const tests = [
           userConfig: JSON.stringify({
             allowPublicTeleports: true,
           }),
-        }
+        },
       );
 
-      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',
@@ -72,9 +70,9 @@ 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 setPublicEvent = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const setPublicEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/setpublic test',
@@ -82,9 +80,9 @@ const tests = [
       });
 
       expect((await setPublicEvent).length).to.be.eq(1);
-      expect((await setPublicEvent)[0].data.msg).to.be.eq('Teleport test is now public.');
+      expect((await setPublicEvent)[0].data.meta.msg).to.be.eq('Teleport test is now public.');
 
-      const setTpEvent2 = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const setTpEvent2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test2',
@@ -92,9 +90,87 @@ const tests = [
       });
 
       expect((await setTpEvent2).length).to.be.eq(1);
-      expect((await setTpEvent2)[0].data.msg).to.be.eq('Teleport test2 set.');
+      expect((await setTpEvent2)[0].data.meta.msg).to.be.eq('Teleport test2 set.');
+
+      const tpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/tplist',
+        playerId: this.setupData.players[1].id,
+      });
+
+      expect((await tpEvent).length).to.be.eq(2);
+      expect((await tpEvent)[0].data.meta.msg).to.be.eq('You have 1 teleport available');
+      expect((await tpEvent)[1].data.meta.msg).to.match(/test: \([-\d]+,[-\d]+,[-\d]+\) \(public\)/);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Teleports set by player A cannot be seen by player B with /tplist',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.teleportsModule.id,
+      );
+
+      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',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await setTpEvent).length).to.be.eq(1);
+      expect((await setTpEvent)[0].data.meta.msg).to.be.eq('Teleport test set.');
+
+      const tpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/tplist',
+        playerId: this.setupData.players[1].id,
+      });
+
+      expect((await tpEvent).length).to.be.eq(1);
+      expect((await tpEvent)[0].data.meta.msg).to.be.eq(
+        'You have no teleports available, use /settp <name> to set one.',
+      );
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    // eslint-disable-next-line quotes
+    name: "bug repro /tplist: Player A and B have teleports set but B cannot see A's teleports",
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.teleportsModule.id,
+      );
+
+      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',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await setTpEvent).length).to.be.eq(1);
+      expect((await setTpEvent)[0].data.meta.msg).to.be.eq('Teleport test set.');
+
+      const setTpEvent2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/settp test2',
+        playerId: this.setupData.players[1].id,
+      });
+
+      expect((await setTpEvent2).length).to.be.eq(1);
+      expect((await setTpEvent2)[0].data.meta.msg).to.be.eq('Teleport test2 set.');
 
-      const tpEvent = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      const tpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/tplist',
@@ -102,8 +178,8 @@ const tests = [
       });
 
       expect((await tpEvent).length).to.be.eq(2);
-      expect((await tpEvent)[0].data.msg).to.be.eq('You have 1 teleport available');
-      expect((await tpEvent)[1].data.msg).to.match(/ - test: [-\d]+, [-\d]+, [-\d]+ \(public\)/);
+      expect((await tpEvent)[0].data.meta.msg).to.be.eq('You have 1 teleport available');
+      expect((await tpEvent)[1].data.meta.msg).to.match(/test2: \([-\d]+,[-\d]+,[-\d]+\)/);
     },
   }),
 ];