@takaro/modules 0.0.1

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

@@ -0,0 +1,332 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+import { Client } from '@takaro/apiclient';
+
+const group = 'lottery suite';
+const ticketCost = 50;
+const playerStartBalance = 1000;
+
+async function expectTicketAmountLengthToBe(
+  client: Client,
+  gameServerId: string,
+  moduleId: string,
+  expectedAmount = 0
+) {
+  const ticketVars = await client.variable.variableControllerSearch({
+    filters: {
+      gameServerId: [gameServerId],
+      moduleId: [moduleId],
+      key: ['lottery_tickets_bought'],
+    },
+  });
+
+  const amount = ticketVars.data.data.reduce((acc, variable) => {
+    return acc + parseInt(JSON.parse(variable.value).amount, 10);
+  }, 0);
+
+  expect(expectedAmount).to.be.eq(amount);
+}
+
+const setup = async function (this: IntegrationTest<IModuleTestsSetupData>): Promise<IModuleTestsSetupData> {
+  const data = await modulesTestSetup.call(this);
+
+  await this.client.settings.settingsControllerSet('economyEnabled', {
+    value: 'true',
+    gameServerId: data.gameserver.id,
+  });
+
+  await this.client.gameserver.gameServerControllerInstallModule(data.gameserver.id, data.economyUtilsModule.id);
+
+  const pogs = await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+    filters: {
+      gameServerId: [data.gameserver.id],
+    },
+  });
+
+  const tasks = pogs.data.data.map((pog) => {
+    return this.client.playerOnGameserver.playerOnGameServerControllerAddCurrency(pog.gameServerId, pog.playerId, {
+      currency: playerStartBalance,
+    });
+  });
+
+  await Promise.allSettled(tasks);
+
+  await this.client.gameserver.gameServerControllerInstallModule(data.gameserver.id, data.lotteryModule.id, {
+    systemConfig: JSON.stringify({
+      commands: {
+        buyTicket: {
+          cost: ticketCost,
+        },
+      },
+    }),
+  });
+
+  const useLotteryRole = await this.client.permissionCodesToInputs(['LOTTERY_BUY']);
+  const viewLotteryRole = await this.client.permissionCodesToInputs(['LOTTERY_VIEW_TICKETS']);
+
+  await this.client.role.roleControllerUpdate(data.role.id, {
+    permissions: [
+      {
+        permissionId: useLotteryRole[0].permissionId,
+      },
+      {
+        permissionId: viewLotteryRole[0].permissionId,
+      },
+    ],
+  });
+
+  return data;
+};
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup,
+    name: 'Cannot buy 0 lottery tickets',
+    test: async function () {
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      const player = this.setupData.players[0];
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/buyTicket 0',
+        playerId: player.id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.be.eq('You must buy at least 1 ticket.');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup,
+    name: 'Can buy lottery ticket',
+    test: async function () {
+      let events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      const ticketAmount = 1;
+      const ticketPrice = ticketAmount * ticketCost;
+
+      const player = this.setupData.players[0];
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/buyTicket ${ticketAmount}`,
+        playerId: player.id,
+      });
+
+      const currencyName = (
+        await this.client.settings.settingsControllerGetOne('currencyName', this.setupData.gameserver.id)
+      ).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!`
+      );
+
+      let pog = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(this.setupData.gameserver.id, player.id)
+      ).data.data;
+
+      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);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/buyTicket ${ticketAmount}`,
+        playerId: player.id,
+      });
+
+      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!`
+      );
+
+      pog = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(this.setupData.gameserver.id, player.id)
+      ).data.data;
+      expect(pog.currency).to.be.eq(playerStartBalance - 2 * ticketPrice);
+      await expectTicketAmountLengthToBe(this.client, this.setupData.gameserver.id, this.setupData.lotteryModule.id, 2);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup,
+    name: 'Can view lottery tickets',
+    test: async function () {
+      const wantAmount = 10;
+
+      const waitForBuyEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/buyTicket ${wantAmount}}`,
+        playerId: this.setupData.players[0].id,
+      });
+
+      await waitForBuyEvents;
+
+      const waitForViewEvent = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/viewTickets',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const events = await waitForViewEvent;
+
+      expect(events.length).to.be.eq(1);
+      expect(events[0].data.msg).to.be.eq(`You have bought ${wantAmount} tickets.`);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup,
+    name: 'Can give the lottery winner the prize money',
+    test: async function () {
+      const currencyName = (
+        await this.client.settings.settingsControllerGetOne('currencyName', this.setupData.gameserver.id)
+      ).data.data.value;
+
+      const playerAmount = this.setupData.players.length;
+      const ticketEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, playerAmount);
+
+      // let some players buy tickets
+      const asyncTasks = this.setupData.players.map(async (player) => {
+        return await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+          msg: '/buyTicket 1',
+          playerId: player.id,
+        });
+      });
+
+      await Promise.allSettled(asyncTasks);
+      await ticketEvents;
+
+      const lotteryEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 4);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        moduleId: this.setupData.lotteryModule.id,
+        cronjobId: this.setupData.lotteryModule.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+      });
+
+      const mod = (
+        await this.client.gameserver.gameServerControllerGetModuleInstallation(
+          this.setupData.gameserver.id,
+          this.setupData.lotteryModule.id
+        )
+      ).data.data;
+
+      const userConfig: Record<string, any> = mod.userConfig;
+      const prize = ticketCost * playerAmount * (1 - userConfig.profitMargin);
+
+      const events = await lotteryEvents;
+
+      expect(events.length).to.be.eq(4);
+      expect(events[3].data.msg).to.contain(`${prize} ${currencyName}`);
+
+      const winnerName = events[3].data.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');
+      }
+
+      const winnerPog = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(this.setupData.gameserver.id, winner.id)
+      ).data.data;
+      expect(winnerPog.currency).to.be.eq(playerStartBalance + (prize - ticketCost));
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup,
+    name: 'If no players joined, the lottery is cancelled',
+    test: async function () {
+      const waitForEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        moduleId: this.setupData.lotteryModule.id,
+        cronjobId: this.setupData.lotteryModule.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+      });
+
+      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.');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    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 player = this.setupData.players[0];
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/buyTicket 1',
+        playerId: player.id,
+      });
+
+      await waitForTicketEvents;
+
+      const currencyName = (
+        await this.client.settings.settingsControllerGetOne('currencyName', this.setupData.gameserver.id)
+      ).data.data.value;
+
+      const waitForEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        moduleId: this.setupData.lotteryModule.id,
+        cronjobId: this.setupData.lotteryModule.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+      });
+
+      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.`
+      );
+
+      const pog = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(this.setupData.gameserver.id, player.id)
+      ).data.data;
+      expect(pog.currency).to.be.eq(playerStartBalance);
+
+      await expectTicketAmountLengthToBe(this.client, this.setupData.gameserver.id, this.setupData.lotteryModule.id);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup,
+    name: 'Can view next lottery draw',
+    test: async function () {
+      const waitForEvents = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/nextDraw',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const events = await waitForEvents;
+
+      expect(events.length).to.be.eq(1);
+      expect(events[0].data.msg).to.contain('The next lottery draw is in');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,192 @@
+import { IntegrationTest, expect, integrationConfig } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+
+const group = 'Module permissions role assignments';
+
+async function cleanRoleSetup(this: IntegrationTest<IModuleTestsSetupData>) {
+  const defaultSetup = await modulesTestSetup.bind(this)();
+
+  const playersRes = await this.client.player.playerControllerSearch();
+
+  const permissions = await this.client.permissionCodesToInputs(['TELEPORTS_USE']);
+
+  await this.client.role.roleControllerUpdate(defaultSetup.role.id, {
+    name: defaultSetup.role.name,
+    permissions,
+  });
+
+  await this.client.gameserver.gameServerControllerInstallModule(
+    defaultSetup.gameserver.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;
+}
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: cleanRoleSetup,
+    name: 'Player has global role -> works',
+    test: async function () {
+      const useTeleportsRole = await this.client.permissionCodesToInputs(['TELEPORTS_USE']);
+      await this.client.role.roleControllerUpdate(this.setupData.role.id, {
+        permissions: [
+          {
+            permissionId: useTeleportsRole[0].permissionId,
+            count: 3,
+          },
+        ],
+      });
+      await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, this.setupData.role.id);
+
+      const setEvents = this.setupData.eventAwaiter.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.');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: cleanRoleSetup,
+    name: 'Player has role on other gameserver -> command denied',
+    test: async function () {
+      const newGameServer = await this.client.gameserver.gameServerControllerCreate({
+        name: 'newServer',
+        connectionInfo: JSON.stringify({
+          host: integrationConfig.get('mockGameserver.host'),
+        }),
+        type: 'MOCK',
+      });
+
+      await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, this.setupData.role.id, {
+        gameServerId: newGameServer.data.data.id,
+      });
+
+      const setEvents = this.setupData.eventAwaiter.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.');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: cleanRoleSetup,
+    name: 'Player has role on correct gameserver -> works',
+    test: async function () {
+      const useTeleportsRole = await this.client.permissionCodesToInputs(['TELEPORTS_USE']);
+      await this.client.role.roleControllerUpdate(this.setupData.role.id, {
+        permissions: [
+          {
+            permissionId: useTeleportsRole[0].permissionId,
+            count: 3,
+          },
+        ],
+      });
+
+      await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, this.setupData.role.id, {
+        gameServerId: this.setupData.gameserver.id,
+      });
+
+      const setEvents = this.setupData.eventAwaiter.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.');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Uses system roles',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.teleportsModule.id,
+        {
+          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'] } });
+      const useTeleportsRole = await this.client.permissionCodesToInputs(['TELEPORTS_USE']);
+      await this.client.role.roleControllerUpdate(playerRoleRes.data.data[0].id, {
+        permissions: [
+          {
+            permissionId: useTeleportsRole[0].permissionId,
+            count: 3,
+          },
+        ],
+      });
+
+      const setTpEvent = this.setupData.eventAwaiter.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.msg).to.be.eq('Teleport test set.');
+
+      const tpEvent = this.setupData.eventAwaiter.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.');
+
+      await this.client.role.roleControllerUpdate(playerRoleRes.data.data[0].id, {
+        name: 'Player',
+        permissions: [],
+      });
+
+      const tpEventNoPerm = this.setupData.eventAwaiter.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.');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,123 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { EventPlayerConnected, GameEvents } from '../dto/gameEvents.js';
+import { HookEvents } from '../main.js';
+
+const group = 'Onboarding';
+const groupStarterkit = 'Onboarding - Starterkit';
+
+const _tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'PlayerConnected hook sends a message when a player connects to the server',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.onboardingModule.id
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+      await this.client.hook.hookControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        playerId: this.setupData.players[0].id,
+        eventType: GameEvents.PLAYER_CONNECTED,
+        eventMeta: new EventPlayerConnected({
+          player: {
+            gameId: '1',
+          },
+          msg: 'Player connected',
+        }),
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.match(/Welcome .+ to the server!/);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group: groupStarterkit,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Starterkit command gives the player items',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.onboardingModule.id,
+        {
+          userConfig: JSON.stringify({
+            starterKitItems: ['cigar'],
+          }),
+        }
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.COMMAND_EXECUTED);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/starterkit',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const resultLogs = (await events)[0].data.meta.result.logs;
+      expect(resultLogs.some((log: any) => log.msg.match(/giveItem 200 OK/))).to.be.true;
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group: groupStarterkit,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Starterkit command can only be used once',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.onboardingModule.id,
+        {
+          userConfig: JSON.stringify({
+            starterKitItems: ['cigar'],
+          }),
+        }
+      );
+      const firstEvents = this.setupData.eventAwaiter.waitForEvents(HookEvents.COMMAND_EXECUTED);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/starterkit',
+        playerId: this.setupData.players[0].id,
+      });
+
+      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);
+      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/);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group: groupStarterkit,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Starterkit with nothing configured, shows an error message',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.onboardingModule.id
+      );
+      const events = this.setupData.eventAwaiter.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/);
+    },
+  }),
+];
+
+// Temp disabled...
+/* describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+}); */

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

@@ -0,0 +1,36 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+
+const group = 'Ping command';
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Ping command replies with pong',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.utilsModule.id
+      );
+
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/ping',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.be.eq('Pong!');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});