@takaro/modules 0.0.1

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

@@ -0,0 +1,74 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+
+const group = 'Role expiry';
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Assigning an expiring role, removed when executing command',
+    test: async function () {
+      // First, ensure all players have no roles
+      await Promise.all(
+        this.setupData.players.map((p) => this.client.player.playerControllerRemoveRole(p.id, this.setupData.role.id))
+      );
+
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.teleportsModule.id
+      );
+
+      const eventsBeforeRole = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/settp test',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await eventsBeforeRole).length).to.be.eq(1);
+      expect((await eventsBeforeRole)[0].data.msg).to.match(/You do not have permission to use teleports/);
+
+      // Assign the role with expiry 10 minutes from now
+      await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, this.setupData.role.id, {
+        expiresAt: new Date(Date.now() + 10 * 60 * 1000).toISOString(),
+      });
+
+      // Execute the command again. Now it should work, since the role is assigned
+      const eventsWithRole = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/settp test2',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await eventsWithRole).length).to.be.eq(1);
+      expect((await eventsWithRole)[0].data.msg).to.match(/Teleport test2 set/);
+
+      // Remove the role and reassign with expiry 1 ms from now
+      await this.client.player.playerControllerRemoveRole(this.setupData.players[0].id, this.setupData.role.id);
+      await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, this.setupData.role.id, {
+        expiresAt: new Date(Date.now() + 1).toISOString(),
+      });
+
+      // Execute the command again. Now it should not work, since the role is expired
+      const eventsAfterExpire = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/settp test3',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await eventsAfterExpire).length).to.be.eq(1);
+      expect((await eventsAfterExpire)[0].data.msg).to.match(/You do not have permission to use teleports/);
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,104 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+import { sleep } from '@takaro/util';
+
+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.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.serverMessagesModule.id
+      );
+
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.serverMessagesModule.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.msg).to.be.eq(
+        // eslint-disable-next-line
+        "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.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.serverMessagesModule.id,
+        {
+          userConfig: JSON.stringify({
+            messages: ['This is a custom message'],
+          }),
+        }
+      );
+
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.serverMessagesModule.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.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.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.serverMessagesModule.id,
+        {
+          userConfig: JSON.stringify({
+            messages: ['Test message 1', 'Test message 2'],
+          }),
+        }
+      );
+
+      // We should see each of our test messages at least once
+
+      const numberOfEvents = 10;
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, numberOfEvents);
+
+      for (let i = 0; i < numberOfEvents; i++) {
+        await sleep(Math.floor(Math.random() * 10) + 1);
+        await this.client.cronjob.cronJobControllerTrigger({
+          cronjobId: this.setupData.serverMessagesModule.cronJobs[0].id,
+          gameServerId: this.setupData.gameserver.id,
+          moduleId: this.setupData.serverMessagesModule.id,
+        });
+      }
+
+      const messages = (await events).map((e) => e.data.msg);
+      expect(messages).to.include('Test message 1');
+      expect(messages).to.include('Test message 2');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,196 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+import { sleep } from '@takaro/util';
+
+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.gameserver.gameServerControllerInstallModule(
+    setupData.gameserver.id,
+    setupData.teleportsModule.id,
+    {
+      userConfig: JSON.stringify({
+        timeout: 0,
+      }),
+      systemConfig: JSON.stringify({
+        commands: {
+          teleport: {
+            delay: 0,
+            aliases: [],
+            cost: 10,
+          },
+        },
+      }),
+    }
+  );
+
+  const setEvents = setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+  await this.client.command.commandControllerTrigger(setupData.gameserver.id, {
+    msg: '/settp test',
+    playerId: setupData.players[0].id,
+  });
+
+  expect((await setEvents).length).to.be.eq(1);
+  expect((await setEvents)[0].data.msg).to.be.eq('Teleport test set.');
+
+  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 = this.setupData.eventAwaiter.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 = this.setupData.eventAwaiter.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 = this.setupData.eventAwaiter.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 = this.setupData.eventAwaiter.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 = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/tp test',
+        playerId: this.setupData.players[1].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.be.eq('You do not have enough currency to execute this command.');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,115 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { GameEvents } from '../../dto/index.js';
+
+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.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.teleportsModule.id
+      );
+
+      const setEvents = this.setupData.eventAwaiter.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.msg).to.match(/Teleport test\d set\./);
+      }
+
+      const events = this.setupData.eventAwaiter.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.msg).to.be.eq('You have 3 teleports available');
+      //  - test0: 61, -262, -52
+      expect((await events)[1].data.msg).to.match(/ - test0: [-\d]+, [-\d]+, [-\d]+/);
+      expect((await events)[2].data.msg).to.match(/ - test1: [-\d]+, [-\d]+, [-\d]+/);
+      expect((await events)[3].data.msg).to.match(/ - test2: [-\d]+, [-\d]+, [-\d]+/);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Public teleports show up in /tplist',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.teleportsModule.id,
+        {
+          userConfig: JSON.stringify({
+            allowPublicTeleports: true,
+          }),
+        }
+      );
+
+      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 setPublicEvent = this.setupData.eventAwaiter.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.msg).to.be.eq('Teleport test is now public.');
+
+      const setTpEvent2 = this.setupData.eventAwaiter.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.msg).to.be.eq('Teleport test2 set.');
+
+      const tpEvent = this.setupData.eventAwaiter.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.msg).to.be.eq('You have 1 teleport available');
+      expect((await tpEvent)[1].data.msg).to.match(/ - test: [-\d]+, [-\d]+, [-\d]+ \(public\)/);
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});