@takaro/modules 0.0.0-next.09a7ca1

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

@@ -0,0 +1,291 @@
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { GameEvents } from '../dto/gameEvents.js';
+import { CommandArgumentCreateDTO } from '@takaro/apiclient';
+import { describe } from 'node:test';
+
+const group = 'Command args';
+
+const createSetup = (commandArgs: CommandArgumentCreateDTO[]) => {
+  return async function (this: IntegrationTest<IModuleTestsSetupData>) {
+    const setupRes = await modulesTestSetup.bind(this)();
+    const moduleRes = await this.client.module.moduleControllerCreate({
+      name: 'test',
+    });
+
+    await this.client.command.commandControllerCreate({
+      name: 'test',
+      trigger: 'test',
+      versionId: moduleRes.data.data.latestVersion.id,
+      arguments: commandArgs,
+      function: `import { getTakaro, getData } from '@takaro/helpers';
+
+      async function main() {
+        const data = await getData();
+        const takaro = await getTakaro(data);
+        const { arguments: args } = data;
+        await data.player.pm(JSON.stringify(args));
+      }
+      
+      await main();`,
+    });
+
+    await this.client.module.moduleInstallationsControllerInstallModule({
+      gameServerId: setupRes.gameserver.id,
+      versionId: moduleRes.data.data.latestVersion.id,
+    });
+
+    return setupRes;
+  };
+};
+
+const playerArgSetup = async function (this: IntegrationTest<IModuleTestsSetupData>) {
+  const setupRes = await modulesTestSetup.bind(this)();
+  const moduleRes = await this.client.module.moduleControllerCreate({
+    name: 'test',
+  });
+
+  await this.client.command.commandControllerCreate({
+    name: 'test',
+    trigger: 'test',
+    versionId: moduleRes.data.data.latestVersion.id,
+    arguments: [{ name: 'name', type: 'player', position: 0 }],
+    function: `import { getTakaro, getData } from '@takaro/helpers';
+
+    async function main() {
+      const data = await getData();
+      const takaro = await getTakaro(data);
+      const { arguments: args } = data;
+      await data.player.pm(args.name.gameId);
+      await data.player.pm(args.name.positionX.toString());
+    }
+    
+    await main();`,
+  });
+
+  await this.client.module.moduleInstallationsControllerInstallModule({
+    gameServerId: setupRes.gameserver.id,
+    versionId: moduleRes.data.data.latestVersion.id,
+  });
+
+  return setupRes;
+};
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Sends a clear error when passing invalid arguments (passing string to number args)',
+    group,
+    snapshot: false,
+    setup: createSetup([
+      {
+        name: 'test',
+        type: 'number',
+        position: 0,
+      },
+    ]),
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/test "test"',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.be.eq(
+        'The value for "test" should be a number. Please correct it and try again.',
+      );
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Respects default values',
+    group,
+    snapshot: false,
+    setup: createSetup([
+      { name: 'name', type: 'string', position: 0 },
+      { name: 'public', type: 'boolean', position: 1, defaultValue: 'false' },
+      { name: 'number', type: 'number', position: 2, defaultValue: '42' },
+    ]),
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/test "test"',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.be.eq('{"name":"test","public":false,"number":42}');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Handles spaces properly',
+    group,
+    snapshot: false,
+    setup: createSetup([
+      { name: 'name', type: 'string', position: 0 },
+      { name: 'public', type: 'boolean', position: 1 },
+    ]),
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/test "test test" true',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.be.eq('{"name":"test test","public":true}');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Can do a basic player arg',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+        filters: {
+          playerId: [this.setupData.players[0].id],
+          gameServerId: [this.setupData.gameserver.id],
+        },
+      });
+      const pog = pogRes.data.data[0];
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/test ${this.setupData.players[0].name}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(2);
+      expect((await events)[0].data.meta.msg).to.be.eq(pog.gameId);
+      expect((await events)[1].data.meta.msg).to.be.eq(pog.positionX?.toString());
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Can do a player arg with partial name',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+        filters: {
+          playerId: [this.setupData.players[0].id],
+          gameServerId: [this.setupData.gameserver.id],
+        },
+      });
+      const pog = pogRes.data.data[0];
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/test ${this.setupData.players[0].name.substring(0, 3)}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(2);
+      expect((await events)[0].data.meta.msg).to.be.eq(pog.gameId);
+      expect((await events)[1].data.meta.msg).to.be.eq(pog.positionX?.toString());
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Can do a player arg with case switched',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+        filters: {
+          playerId: [this.setupData.players[0].id],
+          gameServerId: [this.setupData.gameserver.id],
+        },
+      });
+      const pog = pogRes.data.data[0];
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/test ${this.setupData.players[0].name.toUpperCase()}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(2);
+      expect((await events)[0].data.meta.msg).to.be.eq(pog.gameId);
+      expect((await events)[1].data.meta.msg).to.be.eq(pog.positionX?.toString());
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Can do a player arg with steam ID',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      const pogRes = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+        filters: {
+          playerId: [this.setupData.players[0].id],
+          gameServerId: [this.setupData.gameserver.id],
+        },
+      });
+      const pog = pogRes.data.data[0];
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/test ${this.setupData.players[0].steamId}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(2);
+      expect((await events)[0].data.meta.msg).to.be.eq(pog.gameId);
+      expect((await events)[1].data.meta.msg).to.be.eq(pog.positionX?.toString());
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Shows an error when multiple players are found',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      // Find a letter contained in one of the players' names
+      const letterToSearch = ['e', 'a'].find((letter) => {
+        return this.setupData.players.some((player) => {
+          return player.name.includes(letter);
+        });
+      });
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/test ${letterToSearch}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.match(/Multiple players found/);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    name: 'Shows an error when no players are found',
+    group,
+    snapshot: false,
+    setup: playerArgSetup,
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/test itsimpossiblethatwewilleverfindaplayerwiththisnameright',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.match(/No player found with the name or ID/);
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,176 @@
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { GameEvents } from '../dto/gameEvents.js';
+import { randomUUID } from 'crypto';
+import { getMockServer } from '@takaro/mock-gameserver';
+import { GameServerOutputDTO } from '@takaro/apiclient';
+import { describe } from 'node:test';
+
+const group = 'Cross-server player commands';
+
+interface CrossServerSetupData extends IModuleTestsSetupData {
+  server2: GameServerOutputDTO;
+  sharedSteamId: string;
+  sharedPlayerOnServer2: any;
+}
+
+const crossServerPlayerSetup = async function (
+  this: IntegrationTest<CrossServerSetupData>,
+): Promise<CrossServerSetupData> {
+  const setupRes = await modulesTestSetup.bind(this as unknown as IntegrationTest<IModuleTestsSetupData>)();
+  if (!this.domainRegistrationToken) throw new Error('Domain registration token is not set. Invalid setup?');
+  // Create a second server
+  const server2IdentityToken = randomUUID();
+  await getMockServer({
+    mockserver: {
+      registrationToken: this.domainRegistrationToken,
+      identityToken: server2IdentityToken,
+    },
+  });
+
+  // Wait for the second server to be registered
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  // Find the second server
+  const gameServersRes = await this.client.gameserver.gameServerControllerSearch({
+    filters: { identityToken: [server2IdentityToken] },
+  });
+  const server2 = gameServersRes.data.data[0];
+
+  // Create a module with a command that uses player argument
+  const moduleRes = await this.client.module.moduleControllerCreate({
+    name: 'cross-server-test',
+  });
+
+  await this.client.command.commandControllerCreate({
+    name: 'playerinfo',
+    trigger: 'playerinfo',
+    versionId: moduleRes.data.data.latestVersion.id,
+    arguments: [{ name: 'targetPlayer', type: 'player', position: 0 }],
+    function: `import { getTakaro, getData } from '@takaro/helpers';
+
+    async function main() {
+      const data = await getData();
+      const takaro = await getTakaro(data);
+      const { arguments: args } = data;
+      
+      // Get the target player info
+      // targetPlayer is a PlayerOnGameserver object from the command argument resolution
+      const targetPlayer = args.targetPlayer;
+      
+      // Search for all PlayerOnGameserver records for this player
+      const pogsSearch = await takaro.playerOnGameserver.playerOnGameServerControllerSearch({
+        filters: {
+          playerId: [targetPlayer.playerId]
+        }
+      });
+      
+      const serverCount = pogsSearch.data.data.length;
+      const serverNames = [];
+      
+      // Get server names for each POG
+      for (const pog of pogsSearch.data.data) {
+        const serverRes = await takaro.gameserver.gameServerControllerGetOne(pog.gameServerId);
+        if (serverRes.data.data) {
+          serverNames.push(serverRes.data.data.name);
+        }
+      }
+      
+      await data.player.pm(\`Player \${targetPlayer.name} (Steam ID: \${targetPlayer.steamId}) exists on \${serverCount} server(s): \${serverNames.join(', ')}\`);
+    }
+    
+    await main();`,
+  });
+
+  // Install module on both servers
+  await this.client.module.moduleInstallationsControllerInstallModule({
+    gameServerId: setupRes.gameserver.id,
+    versionId: moduleRes.data.data.latestVersion.id,
+  });
+
+  await this.client.module.moduleInstallationsControllerInstallModule({
+    gameServerId: server2.id,
+    versionId: moduleRes.data.data.latestVersion.id,
+  });
+
+  // Define a shared Steam ID
+  const sharedSteamId = '76561198000000001';
+
+  // Create a player with the same Steam ID on both servers
+  await this.client.gameserver.gameServerControllerExecuteCommand(setupRes.gameserver.id, {
+    command: `createPlayer player1 {"name": "SharedPlayer", "steamId": "${sharedSteamId}", "online": true}`,
+  });
+
+  await this.client.gameserver.gameServerControllerExecuteCommand(server2.id, {
+    command: `createPlayer player2 {"name": "SharedPlayer", "steamId": "${sharedSteamId}", "online": true}`,
+  });
+
+  // Wait for players to be created and synced
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  // Get the PlayerOnGameserver for SharedPlayer on server2 to use as command executor
+  const server2Players = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+    filters: {
+      gameServerId: [server2.id],
+      gameId: ['player2'],
+    },
+  });
+
+  const sharedPlayerOnServer2 = server2Players.data.data[0];
+
+  return {
+    ...setupRes,
+    server2,
+    sharedSteamId,
+    sharedPlayerOnServer2,
+  };
+};
+
+const tests = [
+  new IntegrationTest<CrossServerSetupData>({
+    name: 'Can target a player that exists on multiple servers using Steam ID',
+    group,
+    snapshot: false,
+    setup: crossServerPlayerSetup,
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      // Trigger command on server1 targeting the shared player by Steam ID
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/playerinfo ${this.setupData.sharedSteamId}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      const chatEvents = await events;
+      expect(chatEvents.length).to.be.eq(1);
+      expect(chatEvents[0].data.meta.msg).to.include('exists on 2 server(s)');
+      expect(chatEvents[0].data.meta.msg).to.include(this.setupData.gameserver.name);
+      expect(chatEvents[0].data.meta.msg).to.include(this.setupData.server2.name);
+    },
+  }),
+
+  new IntegrationTest<CrossServerSetupData>({
+    name: 'Can target a player by name when they exist on multiple servers',
+    group,
+    snapshot: false,
+    setup: crossServerPlayerSetup,
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      // Trigger command on server2 targeting the shared player by name
+      await this.client.command.commandControllerTrigger(this.setupData.server2.id, {
+        msg: '/playerinfo SharedPlayer',
+        playerId: this.setupData.sharedPlayerOnServer2.playerId,
+      });
+
+      const chatEvents = await events;
+      expect(chatEvents.length).to.be.eq(1);
+      expect(chatEvents[0].data.meta.msg).to.include('exists on 2 server(s)');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,215 @@
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+import { describe } from 'node:test';
+
+const group = 'DefaultSystemConfig Aliases';
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    name: 'Custom module with defaultSystemConfig aliases should work after installation',
+    setup: modulesTestSetup,
+    test: async function () {
+      // Create a module WITHOUT defaultSystemConfig first
+      const mod = (
+        await this.client.module.moduleControllerCreate({
+          name: 'Test Module With Default Aliases',
+          latestVersion: {
+            description: 'Testing defaultSystemConfig aliases',
+          },
+        })
+      ).data.data;
+
+      // Create a command in the module FIRST
+      await this.client.command.commandControllerCreate({
+        name: 'pingcommand',
+        description: 'Test ping command',
+        trigger: 'ping',
+        versionId: mod.latestVersion.id,
+        function: `import { data, takaro } from '@takaro/helpers';
+          async function main() {
+            await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
+              message: 'command executed via alias',
+            });
+          }
+          await main();`,
+      });
+
+      // THEN update module with defaultSystemConfig (now command exists, schema is valid)
+      await this.client.module.moduleControllerUpdate(mod.id, {
+        latestVersion: {
+          defaultSystemConfig: JSON.stringify({
+            commands: {
+              pingcommand: {
+                aliases: ['pong', 'pp'],
+              },
+            },
+          }),
+        },
+      });
+
+      // Install the module WITHOUT providing explicit systemConfig
+      // This should use the defaultSystemConfig with aliases
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: mod.latestVersion.id,
+      });
+
+      // Try to trigger the command using the alias from defaultSystemConfig
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/pong', // Using the alias from defaultSystemConfig
+        playerId: this.setupData.players[0].id,
+      });
+
+      // Verify the command executed
+      const receivedEvents = await events;
+      expect(receivedEvents.length).to.be.eq(1);
+      expect(receivedEvents[0].data.meta.msg).to.be.eq('command executed via alias');
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    name: 'Custom module aliases work when explicitly provided during installation',
+    setup: modulesTestSetup,
+    test: async function () {
+      // Create a module WITHOUT defaultSystemConfig first
+      const mod = (
+        await this.client.module.moduleControllerCreate({
+          name: 'Test Module Explicit Aliases',
+          latestVersion: {
+            description: 'Testing explicit aliases',
+          },
+        })
+      ).data.data;
+
+      // Create command FIRST
+      await this.client.command.commandControllerCreate({
+        name: 'echocommand',
+        description: 'Test echo command',
+        trigger: 'echo',
+        versionId: mod.latestVersion.id,
+        function: `import { data, takaro } from '@takaro/helpers';
+          async function main() {
+            await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
+              message: 'command executed',
+            });
+          }
+          await main();`,
+      });
+
+      // THEN update module with defaultSystemConfig
+      await this.client.module.moduleControllerUpdate(mod.id, {
+        latestVersion: {
+          defaultSystemConfig: JSON.stringify({
+            commands: {
+              echocommand: {
+                aliases: ['defaultalias'],
+              },
+            },
+          }),
+        },
+      });
+
+      // Install the module WITH explicit systemConfig (overriding defaults)
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: mod.latestVersion.id,
+        systemConfig: JSON.stringify({
+          commands: {
+            echocommand: {
+              aliases: ['explicitalias', 'ea'],
+            },
+          },
+        }),
+      });
+
+      // Verify explicit alias works
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/explicitalias',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const receivedEvents = await events;
+      expect(receivedEvents.length).to.be.eq(1);
+      expect(receivedEvents[0].data.meta.msg).to.be.eq('command executed');
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    name: 'Multiple aliases from defaultSystemConfig should all work',
+    setup: modulesTestSetup,
+    test: async function () {
+      // Create module WITHOUT defaultSystemConfig first
+      const mod = (
+        await this.client.module.moduleControllerCreate({
+          name: 'Test Module Multiple Aliases',
+          latestVersion: {
+            description: 'Testing multiple aliases',
+          },
+        })
+      ).data.data;
+
+      // Create command FIRST
+      await this.client.command.commandControllerCreate({
+        name: 'testcmd',
+        description: 'Test command',
+        trigger: 'test',
+        versionId: mod.latestVersion.id,
+        function: `import { data, takaro } from '@takaro/helpers';
+          async function main() {
+            await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
+              message: 'success',
+            });
+          }
+          await main();`,
+      });
+
+      // THEN update module with defaultSystemConfig
+      await this.client.module.moduleControllerUpdate(mod.id, {
+        latestVersion: {
+          defaultSystemConfig: JSON.stringify({
+            commands: {
+              testcmd: {
+                aliases: ['alias1', 'alias2', 'alias3'],
+              },
+            },
+          }),
+        },
+      });
+
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: mod.latestVersion.id,
+      });
+
+      // Test each alias
+      for (const alias of ['alias1', 'alias2', 'alias3']) {
+        const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+        await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+          msg: `/${alias}`,
+          playerId: this.setupData.players[0].id,
+        });
+
+        const receivedEvents = await events;
+        expect(receivedEvents.length).to.be.eq(1);
+        expect(receivedEvents[0].data.meta.msg).to.be.eq('success');
+      }
+    },
+  }),
+];
+
+describe(group, () => {
+  tests.forEach((test) => {
+    test.run();
+  });
+});