@takaro/modules 0.0.0-next.0da151e

package/src/__tests__/economy/economyUtils.integration.test.ts

@@ -0,0 +1,495 @@
+import {
+  IntegrationTest,
+  expect,
+  IModuleTestsSetupData,
+  modulesTestSetup,
+  chatMessageSorter,
+  EventsAwaiter,
+} from '@takaro/test';
+import { GameEvents } from '../../dto/index.js';
+import { describe } from 'node:test';
+
+const group = 'EconomyUtils';
+
+const customSetup = async function (this: IntegrationTest<IModuleTestsSetupData>): Promise<IModuleTestsSetupData> {
+  const setupData = await modulesTestSetup.bind(this)();
+
+  await this.client.settings.settingsControllerSet('economyEnabled', {
+    value: 'true',
+    gameServerId: setupData.gameserver.id,
+  });
+
+  await this.client.settings.settingsControllerSet('economyEnabled', {
+    value: 'true',
+  });
+  await this.client.settings.settingsControllerSet('currencyName', {
+    gameServerId: setupData.gameserver.id,
+    value: 'test coin',
+  });
+  return setupData;
+};
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Can get balance',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/balance',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const playerOnGameServer = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+          filters: { playerId: [this.setupData.players[0].id], gameServerId: [this.setupData.gameserver.id] },
+        })
+      ).data.data;
+      if (playerOnGameServer.length === 0) throw new Error('player not found');
+      await this.client.playerOnGameserver.playerOnGameServerControllerSetCurrency(
+        playerOnGameServer[0].gameServerId,
+        playerOnGameServer[0].playerId,
+        {
+          currency: 1000,
+        },
+      );
+
+      // trigger balance command
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/balance',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(2);
+      expect((await events)[0].data.meta.msg).to.be.eq('balance: 0 test coin');
+      expect((await events)[1].data.meta.msg).to.be.eq('balance: 1000 test coin');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Can show list of top (max 10) players with highest balance',
+    test: async function () {
+      // install module
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+      });
+
+      const giveCurrencies = this.setupData.players.map(async (player, index) => {
+        const playerOnGameServer = (
+          await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+            filters: { playerId: [player.id], gameServerId: [this.setupData.gameserver.id] },
+          })
+        ).data.data;
+        if (playerOnGameServer.length === 0) throw new Error('player not found');
+        return this.client.playerOnGameserver.playerOnGameServerControllerSetCurrency(
+          playerOnGameServer[0].gameServerId,
+          playerOnGameServer[0].playerId,
+          {
+            currency: 1000 * index + 1,
+          },
+        );
+      });
+      await Promise.all(giveCurrencies);
+
+      // title message (1) + balance of player messages (5)
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 6);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/topcurrency',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const messages = (await events).map((e) => e.data.meta.msg as string);
+      expect((await events).length).to.be.eq(6);
+      for (const message of messages) {
+        expect(message).to.match(
+          /(Richest players\:|1\. .+ - 9001 test coin|2\. .+ - 8001 test coin|3\. .+ - 7001 test coin|4\. .+ - 6001 test coin|5\. .+ - 5001 test coin)/,
+        );
+      }
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Can transfer money to another player',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+      });
+
+      const transferAmount = 500;
+
+      const sender = this.setupData.players[0];
+      const senderPog = sender.playerOnGameServers?.find((pog) => pog.gameServerId === this.setupData.gameserver.id);
+      if (!senderPog) throw new Error('Sender playerOnGameServer does not exist');
+      await this.client.playerOnGameserver.playerOnGameServerControllerSetCurrency(
+        senderPog.gameServerId,
+        senderPog.playerId,
+        {
+          currency: transferAmount,
+        },
+      );
+
+      const receiver = this.setupData.players[1];
+      const receiverPog = receiver.playerOnGameServers?.find(
+        (pog) => pog.gameServerId === this.setupData.gameserver.id,
+      );
+      if (!receiverPog) throw new Error('Receiver playerOnGameServer does not exist');
+      expect(receiverPog.currency).to.be.eq(0);
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/transfer ${receiver.name} ${transferAmount}`,
+        playerId: sender.id,
+      });
+
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
+      expect((await events).length).to.be.eq(2);
+
+      // check if balances are correct
+      const updatedSender = await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+        senderPog.gameServerId,
+        senderPog.playerId,
+      );
+      expect(updatedSender.data.data.currency).to.be.eq(0);
+
+      const updatedReceiver = await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+        receiverPog.gameServerId,
+        receiverPog.playerId,
+      );
+      expect(updatedReceiver.data.data.currency).to.be.eq(transferAmount);
+
+      expect(messages[0]).to.be.eq(`You received ${transferAmount} test coin from ${sender.name}`);
+      expect(messages[1]).to.be.eq(`You successfully transferred ${transferAmount} test coin to ${receiver.name}`);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Should return friendly user error when not enough currency',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+      });
+
+      const sender = this.setupData.players[0];
+      const receiver = this.setupData.players[1];
+      const transferAmount = 500;
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/transfer ${receiver.name} ${transferAmount}`,
+        playerId: sender.id,
+      });
+
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
+      expect((await events).length).to.be.eq(1);
+      expect(messages[0]).to.be.eq(
+        `Failed to transfer ${transferAmount} test coin to ${receiver.name}. Are you sure you have enough balance?`,
+      );
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Should require confirmation when transfer amount is above pendingAmount',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          pendingAmount: 100,
+        }),
+      });
+
+      const transferAmount = 500;
+      const prefix = (
+        await this.client.settings.settingsControllerGetOne('commandPrefix', this.setupData.gameserver.id)
+      ).data.data.value;
+
+      const sender = this.setupData.players[0];
+      const senderPog = sender.playerOnGameServers?.find((pog) => pog.gameServerId === this.setupData.gameserver.id);
+      if (!senderPog) throw new Error('Sender playerOnGameServer does not exist');
+      await this.client.playerOnGameserver.playerOnGameServerControllerSetCurrency(
+        senderPog.gameServerId,
+        senderPog.playerId,
+        {
+          currency: transferAmount,
+        },
+      );
+
+      const receiver = this.setupData.players[1];
+      const receiverPog = receiver.playerOnGameServers?.find(
+        (pog) => pog.gameServerId === this.setupData.gameserver.id,
+      );
+      if (!receiverPog) throw new Error('Receiver playerOnGameServer does not exist');
+      expect(receiverPog.currency).to.be.eq(0);
+
+      let events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/transfer ${receiver.name} ${transferAmount}`,
+        playerId: sender.id,
+      });
+
+      let messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
+
+      // check if balances have not changed yet
+      expect(
+        (
+          await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+            senderPog.gameServerId,
+            senderPog.playerId,
+          )
+        ).data.data.currency,
+      ).to.be.eq(transferAmount);
+      expect(
+        (
+          await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+            receiverPog.gameServerId,
+            receiverPog.playerId,
+          )
+        ).data.data.currency,
+      ).to.be.eq(0);
+      expect(messages.length).to.be.eq(1);
+      expect(messages[0]).to.be.eq(
+        `You are about to send ${transferAmount} test coin to ${receiver.name}. (Please confirm by typing ${prefix}confirmtransfer)`,
+      );
+
+      // =================================================
+      // transfer confirmed
+      // =================================================
+      events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `${prefix}confirmtransfer`,
+        playerId: sender.id,
+      });
+
+      messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
+      expect((await events).length).to.be.eq(2);
+      expect(
+        (
+          await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+            senderPog.gameServerId,
+            senderPog.playerId,
+          )
+        ).data.data.currency,
+      ).to.be.eq(0);
+      expect(
+        (
+          await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+            receiverPog.gameServerId,
+            receiverPog.playerId,
+          )
+        ).data.data.currency,
+      ).to.be.eq(transferAmount);
+
+      expect(messages[0]).to.be.eq(`You received ${transferAmount} test coin from ${sender.name}`);
+      expect(messages[1]).to.be.eq(`You successfully transferred ${transferAmount} test coin to ${receiver.name}`);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Should return no pending transfers when there are none',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          pendingAmount: 100,
+        }),
+      });
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/confirmtransfer',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
+      expect(messages[0]).to.be.eq('You have no pending transfer.');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Can grant currency to a player',
+    test: async function () {
+      const granter = this.setupData.players[0];
+      const receiver = this.setupData.players[1];
+      const grantAmount = 500;
+
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+      });
+
+      // Change permissions of role to only have manageCurrency permission
+      const manageCurrencyPermission = await this.client.permissionCodesToInputs(['ECONOMY_UTILS_MANAGE_CURRENCY']);
+      await this.client.role.roleControllerUpdate(this.setupData.role.id, {
+        permissions: [
+          {
+            permissionId: manageCurrencyPermission[0].permissionId,
+          },
+        ],
+      });
+
+      const receiverPog = receiver.playerOnGameServers?.find(
+        (pog) => pog.gameServerId === this.setupData.gameserver.id,
+      );
+      if (!receiverPog) throw new Error('Receiver playerOnGameServer does not exist');
+      expect(receiverPog.currency).to.be.eq(0);
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/grantcurrency ${receiver.name} ${grantAmount}`,
+        playerId: granter.id,
+      });
+
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
+      expect(
+        (
+          await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+            receiverPog.gameServerId,
+            receiverPog.playerId,
+          )
+        ).data.data.currency,
+      ).to.be.eq(grantAmount);
+      expect(messages[0]).to.be.eq(`Granted ${grantAmount} test coin by ${granter.name}`);
+      expect(messages[1]).to.be.eq(`You successfully granted ${grantAmount} test coin to ${receiver.name}`);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Can revoke currency from a player',
+    test: async function () {
+      const revoker = this.setupData.players[0];
+      const receiver = this.setupData.players[1];
+      const revokeAmount = 500;
+
+      // make sure receiver has enough currency
+      const receiverPog = receiver.playerOnGameServers?.find(
+        (pog) => pog.gameServerId === this.setupData.gameserver.id,
+      );
+      if (!receiverPog) throw new Error('Receiver playerOnGameServer does not exist');
+      await this.client.playerOnGameserver.playerOnGameServerControllerSetCurrency(
+        receiverPog.gameServerId,
+        receiverPog.playerId,
+        {
+          currency: revokeAmount,
+        },
+      );
+
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+      });
+
+      // Change permissions of role to only have manageCurrency permission
+      const manageCurrencyPermission = await this.client.permissionCodesToInputs(['ECONOMY_UTILS_MANAGE_CURRENCY']);
+      await this.client.role.roleControllerUpdate(this.setupData.role.id, {
+        permissions: [
+          {
+            permissionId: manageCurrencyPermission[0].permissionId,
+          },
+        ],
+      });
+
+      // currency before revoke
+      expect(
+        receiver.playerOnGameServers?.find((pog) => pog.gameServerId === this.setupData.gameserver.id)?.currency,
+      ).to.be.eq(0);
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/revokecurrency ${receiver.name} ${revokeAmount}`,
+        playerId: revoker.id,
+      });
+
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
+      expect(
+        (
+          await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+            receiverPog.gameServerId,
+            receiverPog.playerId,
+          )
+        ).data.data.currency,
+      ).to.be.eq(0);
+      expect(messages[0]).to.be.eq(`${revokeAmount} test coin were revoked by ${revoker.name}`);
+      expect(messages[1]).to.be.eq(`You successfully revoked ${revokeAmount} test coin of ${receiver.name}'s balance`);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Cannot use commands that require manageCurrency permission without it',
+    test: async function () {
+      const sender = this.setupData.players[0];
+      const receiver = this.setupData.players[1];
+      const amount = 500;
+
+      // by default all users get root permission => remove all permissions
+      await this.client.role.roleControllerUpdate(this.setupData.role.id, {
+        permissions: [],
+      });
+
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+      });
+
+      // currency before revoke
+      expect(
+        receiver.playerOnGameServers?.find((pog) => pog.gameServerId === this.setupData.gameserver.id)?.currency,
+      ).to.be.eq(0);
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/grantcurrency ${receiver.name} ${amount}`,
+        playerId: sender.id,
+      });
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: `/revokecurrency ${receiver.name} ${amount}`,
+        playerId: sender.id,
+      });
+
+      const messages = (await events).sort(chatMessageSorter).map((e) => e.data.meta.msg as string);
+      expect(messages[0]).to.be.eq(
+        "⚠️ You need the 'Economy Utils Manage Currency' permission to use this command. Please contact an admin if you need access.",
+      );
+      expect(messages[1]).to.be.eq(
+        "⚠️ You need the 'Economy Utils Manage Currency' permission to use this command. Please contact an admin if you need access.",
+      );
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

package/src/__tests__/economy/shop.integration.test.ts

@@ -0,0 +1,177 @@
+import { EventsAwaiter, expect, IntegrationTest, IShopSetup, shopSetup } from '@takaro/test';
+import { HookEvents } from '../../dto/index.js';
+import { describe } from 'node:test';
+
+const group = 'EconomyUtils:Shop:Browse';
+
+const tests = [
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Calling /shop without arguments displays help information',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 5);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(5);
+      expect((await events)[0].data.meta.msg).to.eq(
+        'This command allows you to browse the shop and view available items.',
+      );
+      expect((await events)[1].data.meta.msg).to.eq('Usage: /shop [page] [item] [action]');
+      expect((await events)[2].data.meta.msg).to.eq('/shop 2 - View the second page of shop items');
+      expect((await events)[3].data.meta.msg).to.eq('/shop 1 3 - View details about the third item on the first page');
+      expect((await events)[4].data.meta.msg).to.eq('/shop 1 3 buy - Purchase the third item on the first page');
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'First page shows the first 5 items',
+    test: async function () {
+      await this.setupData.createListings(this.client, { gameServerId: this.setupData.gameserver.id, amount: 5 });
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 5);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 1',
+        playerId: this.setupData.players[0].id,
+      });
+
+      console.log(JSON.stringify((await events)[0].data.meta.msg, null, 2));
+      expect(await events).to.have.length(5);
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can view the second page of shop items',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.utilsModule.latestVersion.id,
+      });
+      await this.setupData.createListings(this.client, { gameServerId: this.setupData.gameserver.id, amount: 5 });
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 3);
+      const commandExecutedEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(
+        HookEvents.COMMAND_EXECUTED,
+        1,
+      );
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 2',
+        playerId: this.setupData.players[0].id,
+      });
+
+      await commandExecutedEvent;
+
+      // We trigger the ping command to make sure we can see the FULL output of the previous command
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/ping',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(3);
+      expect((await events)[(await events).length - 1].data.meta.msg).to.eq('Pong!');
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'When no items are available, shows a message',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 5',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(1);
+      expect((await events)[0].data.meta.msg).to.equal('No items found.');
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can show details about an item',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 2);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 1 1',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(2);
+      expect((await events)[0].data.meta.msg).to.equal('Listing Test item - 100 test coin');
+      expect((await events)[1].data.meta.msg).to.equal('- 1x Stone.  Description: Stone can get you stoned');
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Shows an error when requesting details for an invalid item',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 1 5',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(1);
+      expect((await events)[0].data.meta.msg).to.equal(
+        'Item not found. Please select an item from the list, valid options are 1-2.',
+      );
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can buy an item',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 2);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 1 1 buy',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect(await events).to.have.length(2);
+      expect((await events)[0].data.meta.msg).to.equal('You have purchased Test item for 100 test coin.');
+      expect((await events)[1].data.meta.msg).to.equal('You have received items from a shop order.');
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can buy an item when not linked to a user',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 2);
+      const unlinkedPlayer = this.setupData.players[1];
+      await this.client.playerOnGameserver.playerOnGameServerControllerAddCurrency(
+        this.setupData.gameserver.id,
+        unlinkedPlayer.id,
+        { currency: 250 },
+      );
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/shop 1 1 buy',
+        playerId: unlinkedPlayer.id,
+      });
+
+      expect(await events).to.have.length(2);
+      expect((await events)[0].data.meta.msg).to.equal('You have purchased Test item for 100 test coin.');
+      expect((await events)[1].data.meta.msg).to.equal('You have received items from a shop order.');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});