@takaro/modules 0.0.0-next.0da151e

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

@@ -0,0 +1,116 @@
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+import { describe } from 'node:test';
+
+const group = 'Server messages';
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Default install sends the default message',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.serverMessagesModule.latestVersion.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.serverMessagesModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.serverMessagesModule.id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.be.eq(
+        "This is an automated message, don't forget to read the server rules!",
+      );
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Can override default message via userConfig',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.serverMessagesModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          messages: ['This is a custom message'],
+        }),
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.serverMessagesModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.serverMessagesModule.id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.be.eq('This is a custom message');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Can override default message via userConfig with multiple messages',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.serverMessagesModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          messages: ['Test message 1', 'Test message 2'],
+        }),
+      });
+
+      // We should see each of our test messages at least once
+
+      const firstEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.serverMessagesModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.serverMessagesModule.id,
+      });
+
+      expect((await firstEvents).length).to.be.eq(1);
+      expect((await firstEvents)[0].data.meta.msg).to.be.eq('Test message 1');
+
+      const secondEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.serverMessagesModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.serverMessagesModule.id,
+      });
+
+      expect((await secondEvents).length).to.be.eq(1);
+      expect((await secondEvents)[0].data.meta.msg).to.be.eq('Test message 2');
+
+      // After this, it should loop back to the first message
+      const thirdEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.serverMessagesModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.serverMessagesModule.id,
+      });
+
+      expect((await thirdEvents).length).to.be.eq(1);
+      expect((await thirdEvents)[0].data.meta.msg).to.be.eq('Test message 1');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,84 @@
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { HookEvents } from '../dto/index.js';
+import { describe } from 'node:test';
+
+const group = 'System config - cooldown';
+
+const customSetup = async function (this: IntegrationTest<IModuleTestsSetupData>): Promise<IModuleTestsSetupData> {
+  const setupData = await modulesTestSetup.bind(this)();
+
+  await this.client.module.moduleInstallationsControllerInstallModule({
+    gameServerId: setupData.gameserver.id,
+    versionId: setupData.utilsModule.latestVersion.id,
+    systemConfig: JSON.stringify({
+      commands: {
+        ping: {
+          cooldown: 60,
+        },
+      },
+    }),
+  });
+  return setupData;
+};
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Returns error when player tries to execute command that is on cooldown',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.COMMAND_EXECUTED, 1);
+      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);
+
+      const events2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/ping',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events2).length).to.be.eq(1);
+      expect((await events2)[0].data.meta.msg).to.match(
+        /This command can only be executed once every 60 seconds\. You can execute it again at /,
+      );
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    attempts: 5,
+    setup: customSetup,
+    name: 'Handles cooldown when using commands in rapid succession',
+    test: async function () {
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CHAT_MESSAGE, 2);
+      await Promise.all([
+        this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+          msg: '/ping',
+          playerId: this.setupData.players[0].id,
+        }),
+        this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+          msg: '/ping',
+          playerId: this.setupData.players[0].id,
+        }),
+      ]);
+
+      const sorted = (await events).sort((a, b) => a.data.meta.msg - b.data.meta.msg);
+      expect(sorted.length).to.be.eq(2);
+      expect(sorted[0].data.meta.msg).to.be.eq(
+        'You can only execute one command at a time. Please wait for the previous command to finish.',
+      );
+      expect(sorted[1].data.meta.msg).to.be.eq('Pong!');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,194 @@
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+import { sleep } from '@takaro/util';
+import { describe } from 'node:test';
+
+const group = 'System config - cost';
+
+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.module.moduleInstallationsControllerInstallModule({
+    gameServerId: setupData.gameserver.id,
+    versionId: setupData.teleportsModule.latestVersion.id,
+    userConfig: JSON.stringify({
+      timeout: 0,
+    }),
+    systemConfig: JSON.stringify({
+      commands: {
+        teleport: {
+          delay: 0,
+          aliases: [],
+          cost: 10,
+        },
+      },
+    }),
+  });
+
+  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.meta.msg).to.be.eq('Teleport test set.');
+
+  const giveCurrencies = setupData.players.map(async (player) => {
+    const playerOnGameServer = (
+      await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+        filters: { playerId: [player.id], gameServerId: [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: 100,
+      },
+    );
+  });
+  await Promise.all(giveCurrencies);
+
+  return setupData;
+};
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Deducts money when cost is configured',
+    test: async function () {
+      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,
+      });
+
+      expect((await events).length).to.be.eq(1);
+
+      const playerOnGameServerAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+          filters: { playerId: [this.setupData.players[0].id], gameServerId: [this.setupData.gameserver.id] },
+        })
+      ).data.data;
+
+      expect(playerOnGameServerAfter[0].currency).to.be.eq(90);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Handles concurrent commands properly',
+    test: async function () {
+      const amount = 10;
+
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents('command-executed', amount);
+
+      await Promise.all(
+        Array.from({ length: amount }).map(async (_, index) => {
+          await sleep(10);
+          await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+            msg: `/settp test${index}`,
+            playerId: this.setupData.players[0].id,
+          });
+        }),
+      );
+
+      expect((await setEvents).length).to.be.eq(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);
+          await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+            msg: `/tp test${index}`,
+            playerId: this.setupData.players[0].id,
+          });
+        }),
+      );
+
+      expect((await events).length).to.be.eq(amount);
+      for (const event of await events) {
+        expect(event.data.meta.result.success).to.be.eq(true);
+      }
+
+      const playerOnGameServerAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+          filters: { playerId: [this.setupData.players[0].id], gameServerId: [this.setupData.gameserver.id] },
+        })
+      ).data.data;
+
+      expect(playerOnGameServerAfter[0].currency).to.be.eq(0);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Does not deduct currency when command unsuccessful',
+    test: async function () {
+      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,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.result.success).to.be.eq(false);
+
+      const playerOnGameServerAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+          filters: { playerId: [this.setupData.players[0].id], gameServerId: [this.setupData.gameserver.id] },
+        })
+      ).data.data;
+
+      expect(playerOnGameServerAfter[0].currency).to.be.eq(100);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'Rejects command if player does not have enough currency',
+    test: async function () {
+      // set players' currency to 5
+      const playerOnGameServer = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerSearch({
+          filters: { playerId: [this.setupData.players[1].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: 5,
+        },
+      );
+
+      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.meta.msg).to.be.eq('You do not have enough currency to execute this command.');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

package/src/__tests__/teleports/listtp.integration.test.ts

@@ -0,0 +1,189 @@
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { GameEvents } from '../../dto/index.js';
+import { describe } from 'node:test';
+
+const group = 'Teleports suite';
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Can list teleports with /tplist',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+      });
+
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 3);
+
+      await Promise.all(
+        Array.from({ length: 3 }).map(async (_, i) => {
+          return this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+            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.meta.msg).to.match(/Teleport test\d set\./);
+      }
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 4);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/tplist',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(4);
+      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>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Public teleports show up in /tplist',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          allowPublicTeleports: true,
+        }),
+      });
+
+      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 setPublicEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/setpublic test',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await setPublicEvent).length).to.be.eq(1);
+      expect((await setPublicEvent)[0].data.meta.msg).to.be.eq('Teleport test is now public.');
+
+      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[0].id,
+      });
+
+      expect((await setTpEvent2).length).to.be.eq(1);
+      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.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.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,
+    name: "bug repro /tplist: Player A and B have teleports set but B cannot see A's teleports",
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.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 = (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(/test2: \([-\d]+,[-\d]+,[-\d]+\)/);
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});