@takaro/modules 0.0.1

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

@@ -0,0 +1,380 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { HookEvents } from '../dto/index.js';
+import { TakaroEventPlayerNewIpDetected } from '@takaro/modules';
+import { faker } from '@faker-js/faker';
+
+const group = 'Geo Block';
+
+const customSetup = async function (this: IntegrationTest<IModuleTestsSetupData>): Promise<IModuleTestsSetupData> {
+  const setupData = await modulesTestSetup.bind(this)();
+
+  await Promise.all(
+    setupData.players.map(async (player) => {
+      await this.client.player.playerControllerRemoveRole(player.id, setupData.role.id);
+    })
+  );
+
+  return setupData;
+};
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'DENY MODE: Blocked country detected -> player gets kicked based on configuration',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.geoBlockModule.id,
+        {
+          userConfig: JSON.stringify({
+            mode: 'deny',
+            countries: ['RU'],
+            ban: false,
+          }),
+        }
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.PLAYER_DISCONNECTED);
+      await this.client.hook.hookControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        playerId: this.setupData.players[0].id,
+        eventType: HookEvents.PLAYER_NEW_IP_DETECTED,
+        eventMeta: new TakaroEventPlayerNewIpDetected({
+          city: 'nowhere',
+          country: 'RU',
+          latitude: '0',
+          longitude: '0',
+          ip: faker.internet.ip(),
+        }),
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.match(/Kicked Your IP address is banned/);
+      expect((await events)[0].data.player.name).to.be.eq(this.setupData.players[0].name);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'DENY MODE: Non-blocked country detected -> no action taken',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.geoBlockModule.id,
+        {
+          userConfig: JSON.stringify({
+            mode: 'deny',
+            countries: ['RU'],
+            ban: false,
+          }),
+        }
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.HOOK_EXECUTED);
+
+      await this.client.hook.hookControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        playerId: this.setupData.players[0].id,
+        eventType: HookEvents.PLAYER_NEW_IP_DETECTED,
+        eventMeta: new TakaroEventPlayerNewIpDetected({
+          city: 'nowhere',
+          country: 'BE',
+          latitude: '0',
+          longitude: '0',
+          ip: faker.internet.ip(),
+        }),
+      });
+
+      expect((await events).length).to.be.eq(1);
+      const containsAllowedCountryMessage = (await events)[0].data.meta.result.logs.some((log: any) => {
+        return log.msg.includes('Allowed country detected, no action');
+      });
+      expect(containsAllowedCountryMessage).to.be.eq(true, 'Decision message not found');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'ALLOW MODE: Allowed country detected -> no action taken',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.geoBlockModule.id,
+        {
+          userConfig: JSON.stringify({
+            mode: 'allow',
+            countries: ['RU'],
+            ban: false,
+          }),
+        }
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.HOOK_EXECUTED);
+
+      await this.client.hook.hookControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        playerId: this.setupData.players[0].id,
+        eventType: HookEvents.PLAYER_NEW_IP_DETECTED,
+        eventMeta: new TakaroEventPlayerNewIpDetected({
+          city: 'nowhere',
+          country: 'RU',
+          latitude: '0',
+          longitude: '0',
+          ip: faker.internet.ip(),
+        }),
+      });
+
+      expect((await events).length).to.be.eq(1);
+      const containsAllowedCountryMessage = (await events)[0].data.meta.result.logs.some((log: any) => {
+        return log.msg.includes('Allowed country detected, no action');
+      });
+      expect(containsAllowedCountryMessage).to.be.eq(true, 'Decision message not found');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'ALLOW MODE: Non-Allowed country detected -> player gets kicked/banned based on configuration',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.geoBlockModule.id,
+        {
+          userConfig: JSON.stringify({
+            mode: 'allow',
+            countries: ['RU'],
+            ban: false,
+          }),
+        }
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.PLAYER_DISCONNECTED);
+
+      await this.client.hook.hookControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        playerId: this.setupData.players[0].id,
+        eventType: HookEvents.PLAYER_NEW_IP_DETECTED,
+        eventMeta: new TakaroEventPlayerNewIpDetected({
+          city: 'nowhere',
+          country: 'BE',
+          latitude: '0',
+          longitude: '0',
+          ip: faker.internet.ip(),
+        }),
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.match(/Kicked Your IP address is banned/);
+      expect((await events)[0].data.player.name).to.be.eq(this.setupData.players[0].name);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'BAN CONFIGURATION: Ban enabled -> player gets banned instead of kicked',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.geoBlockModule.id,
+        {
+          userConfig: JSON.stringify({
+            mode: 'allow',
+            countries: ['RU'],
+            ban: true,
+          }),
+        }
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.PLAYER_DISCONNECTED);
+
+      await this.client.hook.hookControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        playerId: this.setupData.players[0].id,
+        eventType: HookEvents.PLAYER_NEW_IP_DETECTED,
+        eventMeta: new TakaroEventPlayerNewIpDetected({
+          city: 'nowhere',
+          country: 'BE',
+          latitude: '0',
+          longitude: '0',
+          ip: faker.internet.ip(),
+        }),
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.match(/Banned Your IP address is banned/);
+      expect((await events)[0].data.player.name).to.be.eq(this.setupData.players[0].name);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'MESSAGE CONFIGURATION: Custom message displayed to player on kick/ban',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.geoBlockModule.id,
+        {
+          userConfig: JSON.stringify({
+            mode: 'allow',
+            countries: ['RU'],
+            ban: true,
+            message: 'Custom message',
+          }),
+        }
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.PLAYER_DISCONNECTED);
+
+      await this.client.hook.hookControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        playerId: this.setupData.players[0].id,
+        eventType: HookEvents.PLAYER_NEW_IP_DETECTED,
+        eventMeta: new TakaroEventPlayerNewIpDetected({
+          city: 'nowhere',
+          country: 'BE',
+          latitude: '0',
+          longitude: '0',
+          ip: faker.internet.ip(),
+        }),
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.match(/Banned Custom message/);
+      expect((await events)[0].data.player.name).to.be.eq(this.setupData.players[0].name);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'MULTIPLE COUNTRIES: Handling multiple countries in the whitelist or blacklist',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.geoBlockModule.id,
+        {
+          userConfig: JSON.stringify({
+            mode: 'deny',
+            countries: ['RU', 'BE'],
+            ban: true,
+            message: 'Custom message',
+          }),
+        }
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.PLAYER_DISCONNECTED);
+
+      await this.client.hook.hookControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        playerId: this.setupData.players[0].id,
+        eventType: HookEvents.PLAYER_NEW_IP_DETECTED,
+        eventMeta: new TakaroEventPlayerNewIpDetected({
+          city: 'nowhere',
+          country: 'BE',
+          latitude: '0',
+          longitude: '0',
+          ip: faker.internet.ip(),
+        }),
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.match(/Banned Custom message/);
+      expect((await events)[0].data.player.name).to.be.eq(this.setupData.players[0].name);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'IMMUNITY PERMISSION: Player with GEOBLOCK_IMMUNITY permission is neither kicked nor banned',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.geoBlockModule.id,
+        {
+          userConfig: JSON.stringify({
+            mode: 'deny',
+            countries: ['RU'],
+            ban: true,
+            message: 'Custom message',
+          }),
+        }
+      );
+      const permissions = await this.client.permissionCodesToInputs(['GEOBLOCK_IMMUNITY']);
+      const roleRes = await this.client.role.roleControllerCreate({
+        name: 'Immune to geoblock',
+        permissions,
+      });
+
+      await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, roleRes.data.data.id);
+
+      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.HOOK_EXECUTED);
+
+      await this.client.hook.hookControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        playerId: this.setupData.players[0].id,
+        eventType: HookEvents.PLAYER_NEW_IP_DETECTED,
+        eventMeta: new TakaroEventPlayerNewIpDetected({
+          city: 'nowhere',
+          country: 'RU',
+          latitude: '0',
+          longitude: '0',
+          ip: faker.internet.ip(),
+        }),
+      });
+
+      expect((await events).length).to.be.eq(1);
+      const containsAllowedCountryMessage = (await events)[0].data.meta.result.logs.some((log: any) => {
+        return log.msg.includes('Player has immunity, no action');
+      });
+      expect(containsAllowedCountryMessage).to.be.eq(true, 'Decision message not found');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'NO COUNTRIES CONFIGURED: No action taken if countries array is empty',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.geoBlockModule.id,
+        {
+          userConfig: JSON.stringify({
+            mode: 'deny',
+            countries: [],
+            ban: true,
+            message: 'Custom message',
+          }),
+        }
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(HookEvents.HOOK_EXECUTED);
+
+      await this.client.hook.hookControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        playerId: this.setupData.players[0].id,
+        eventType: HookEvents.PLAYER_NEW_IP_DETECTED,
+        eventMeta: new TakaroEventPlayerNewIpDetected({
+          city: 'nowhere',
+          country: 'BE',
+          latitude: '0',
+          longitude: '0',
+          ip: faker.internet.ip(),
+        }),
+      });
+
+      expect((await events).length).to.be.eq(1);
+      const containsAllowedCountryMessage = (await events)[0].data.meta.result.logs.some((log: any) => {
+        return log.msg.includes('Allowed country detected, no action');
+      });
+      expect(containsAllowedCountryMessage).to.be.eq(true, 'Decision message not found');
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,97 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+
+const group = 'gimme suite';
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Can give an item to a player',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.gimmeModule.id,
+        {
+          userConfig: JSON.stringify({
+            items: ['apple', 'banana', 'orange'],
+            commands: [],
+          }),
+        }
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/gimme',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.match(/You received (apple|banana|orange)/);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Can execute command',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.gimmeModule.id,
+        {
+          userConfig: JSON.stringify({
+            items: [],
+            commands: ['say hello from test'],
+          }),
+        }
+      );
+
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/gimme',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.eq('hello from test');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'When no items or commands configured, displays an error',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.gimmeModule.id,
+        {
+          userConfig: JSON.stringify({
+            items: [],
+            commands: [],
+          }),
+        }
+      );
+
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/gimme',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.match(/No items or commands configured/);
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,133 @@
+import { IntegrationTest, expect } from '@takaro/test';
+import { IModuleTestsSetupData, modulesTestSetup, chatMessageSorter } from '@takaro/test';
+import { GameEvents } from '../dto/gameEvents.js';
+
+const group = 'Help command';
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Help command responds with a list of installed commands',
+    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, 3);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/help',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(3);
+      const sortedEvents = (await events).sort(chatMessageSorter);
+
+      expect(sortedEvents[0].data.msg).to.be.eq('Available commands:');
+      expect(sortedEvents[1].data.msg).to.be.eq(
+        'help: The text you are reading right now, displays information about commands.'
+      );
+      expect(sortedEvents[2].data.msg).to.be.eq('ping: Replies with pong, useful for testing if the connection works.');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Help command responds with a list of installed commands, picking up commands from multiple modules',
+    test: async function () {
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.utilsModule.id
+      );
+      await this.client.gameserver.gameServerControllerInstallModule(
+        this.setupData.gameserver.id,
+        this.setupData.teleportsModule.id
+      );
+      const events = this.setupData.eventAwaiter.waitForEvents(GameEvents.CHAT_MESSAGE, 13);
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/help',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const sortedEvents = (await events).sort(chatMessageSorter);
+
+      expect(sortedEvents[0].data.msg).to.be.eq('Available commands:');
+      expect(sortedEvents[1].data.msg).to.be.eq('deletetp: Deletes a location.');
+      expect(sortedEvents[2].data.msg).to.be.eq('deletewaypoint: Deletes a waypoint.');
+      expect(sortedEvents[3].data.msg).to.be.eq(
+        'help: The text you are reading right now, displays information about commands.'
+      );
+      expect(sortedEvents[4].data.msg).to.be.eq('listwaypoints: Lists all waypoints.');
+      expect(sortedEvents[5].data.msg).to.be.eq('ping: Replies with pong, useful for testing if the connection works.');
+      expect(sortedEvents[6].data.msg).to.be.eq(
+        'setprivate: Sets a teleport to be private, only the teleport owner can teleport to it.'
+      );
+      expect(sortedEvents[7].data.msg).to.be.eq(
+        'setpublic: Sets a teleport to be public, allowing other players to teleport to it.'
+      );
+      expect(sortedEvents[8].data.msg).to.be.eq('settp: Sets a location to teleport to.');
+      expect(sortedEvents[9].data.msg).to.be.eq('setwaypoint: Creates a new waypoint.');
+      expect(sortedEvents[10].data.msg).to.be.eq('teleport: Teleports to one of your set locations.');
+      expect(sortedEvents[11].data.msg).to.be.eq(
+        'teleportwaypoint: Placeholder command, this will not be used directly. The module will install aliases for this command corresponding to the waypoint '
+      );
+      expect(sortedEvents[12].data.msg).to.be.eq('tplist: Lists all your set locations.');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Help command responds with detailed info about a specific command',
+    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, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/help ping',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      const sortedEvents = (await events).sort(chatMessageSorter);
+
+      expect(sortedEvents[0].data.msg).to.be.eq('ping: Replies with pong, useful for testing if the connection works.');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Help command responds with unknown command message if command does not exist',
+    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, 1);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/help foobar',
+        playerId: this.setupData.players[0].id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.msg).to.be.eq(
+        'Unknown command "foobar", use this command without arguments to see all available commands.'
+      );
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});