@takaro/modules 0.0.0-next.0da151e

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

@@ -0,0 +1,293 @@
+import { EventsAwaiter, expect, IntegrationTest, IShopSetup, shopSetup } from '@takaro/test';
+import { HookEvents } from '../../dto/index.js';
+import { Client, PlayerOutputDTO } from '@takaro/apiclient';
+import { describe } from 'node:test';
+
+const group = 'EconomyUtils:ZombieKillReward';
+
+async function triggerKills(client: Client, player: PlayerOutputDTO, gameServerId: string, count: number) {
+  const events = (await new EventsAwaiter().connect(client)).waitForEvents(HookEvents.ENTITY_KILLED, count);
+
+  if (!player.playerOnGameServers) throw new Error('Player has no pogs');
+  const pog = player.playerOnGameServers.find((pog) => pog.gameServerId === gameServerId);
+  if (!pog) throw new Error('Player not found on game server');
+
+  await Promise.all(
+    Array.from({ length: count }, () => {
+      return client.gameserver.gameServerControllerExecuteCommand(gameServerId, {
+        command: `triggerKill ${pog.gameId}`,
+      });
+    }),
+  );
+
+  await events;
+  return events;
+}
+
+const tests = [
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Simple happy path, killing one zombie gives one currency',
+    test: async function () {
+      const pogBefore = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+
+      (
+        await this.client.module.moduleInstallationsControllerInstallModule({
+          gameServerId: this.setupData.gameserver.id,
+          versionId: this.setupData.economyUtilsModule.latestVersion.id,
+        })
+      ).data.data;
+      const zombieKillCronjob = this.setupData.economyUtilsModule.latestVersion.cronJobs.find(
+        (cronjob) => cronjob.name === 'zombieKillReward',
+      );
+      if (!zombieKillCronjob) throw new Error('Cronjob not found');
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 1);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events;
+
+      const pogAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      expect(pogAfter.currency).to.equal(pogBefore.currency + 1);
+    },
+  }),
+  /**
+   * First kill 3 zombies, then trigger the cronjob
+   * Check if the player has 3 currency
+   * Then kill 4 zombies
+   * Check if the player has 7 currency
+   */
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Killing multiple zombies',
+    test: async function () {
+      const pogBefore = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+
+      (
+        await this.client.module.moduleInstallationsControllerInstallModule({
+          gameServerId: this.setupData.gameserver.id,
+          versionId: this.setupData.economyUtilsModule.latestVersion.id,
+        })
+      ).data.data;
+      const zombieKillCronjob = this.setupData.economyUtilsModule.latestVersion.cronJobs.find(
+        (cronjob) => cronjob.name === 'zombieKillReward',
+      );
+      if (!zombieKillCronjob) throw new Error('Cronjob not found');
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 3);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events;
+
+      let pogAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      expect(pogAfter.currency).to.equal(pogBefore.currency + 3);
+
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 4);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events2;
+
+      pogAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      expect(pogAfter.currency).to.equal(pogBefore.currency + 7);
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Different players killing zombies assigns the right amount to the right players',
+    test: async function () {
+      const pogBefore1 = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      const pogBefore2 = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[1].id,
+        )
+      ).data.data;
+
+      (
+        await this.client.module.moduleInstallationsControllerInstallModule({
+          gameServerId: this.setupData.gameserver.id,
+          versionId: this.setupData.economyUtilsModule.latestVersion.id,
+        })
+      ).data.data;
+      const zombieKillCronjob = this.setupData.economyUtilsModule.latestVersion.cronJobs.find(
+        (cronjob) => cronjob.name === 'zombieKillReward',
+      );
+      if (!zombieKillCronjob) throw new Error('Cronjob not found');
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 3);
+      await triggerKills(this.client, this.setupData.players[1], this.setupData.gameserver.id, 4);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events;
+
+      const pogAfter1 = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      const pogAfter2 = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[1].id,
+        )
+      ).data.data;
+      expect(pogAfter1.currency).to.equal(pogBefore1.currency + 3);
+      expect(pogAfter2.currency).to.equal(pogBefore2.currency + 4);
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can configure a custom amount of currency per kill',
+    test: async function () {
+      const pogBefore = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      (
+        await this.client.module.moduleInstallationsControllerInstallModule({
+          gameServerId: this.setupData.gameserver.id,
+          versionId: this.setupData.economyUtilsModule.latestVersion.id,
+          userConfig: JSON.stringify({ zombieKillReward: 5 }),
+        })
+      ).data.data;
+      const zombieKillCronjob = this.setupData.economyUtilsModule.latestVersion.cronJobs.find(
+        (cronjob) => cronjob.name === 'zombieKillReward',
+      );
+      if (!zombieKillCronjob) throw new Error('Cronjob not found');
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 1);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events;
+
+      const pogAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      expect(pogAfter.currency).to.equal(pogBefore.currency + 5);
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can override amount earned per role',
+    test: async function () {
+      const zombieKillEarnerPermission = await this.client.permissionCodesToInputs(['ZOMBIE_KILL_REWARD_OVERRIDE']);
+      await this.client.role.roleControllerUpdate(this.setupData.role.id, {
+        permissions: [
+          {
+            permissionId: zombieKillEarnerPermission[0].permissionId,
+            count: 3,
+          },
+        ],
+      });
+
+      const pogBefore = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      (
+        await this.client.module.moduleInstallationsControllerInstallModule({
+          gameServerId: this.setupData.gameserver.id,
+          versionId: this.setupData.economyUtilsModule.latestVersion.id,
+          userConfig: JSON.stringify({ zombieKillReward: 5 }),
+        })
+      ).data.data;
+
+      const zombieKillCronjob = this.setupData.economyUtilsModule.latestVersion.cronJobs.find(
+        (cronjob) => cronjob.name === 'zombieKillReward',
+      );
+      if (!zombieKillCronjob) throw new Error('Cronjob not found');
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 1);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events;
+
+      const pogAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      expect(pogAfter.currency).to.equal(pogBefore.currency + 3);
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

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

@@ -0,0 +1,322 @@
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { HookEvents } from '../dto/index.js';
+import { TakaroEventPlayerNewIpDetected } from '@takaro/modules';
+import { faker } from '@faker-js/faker';
+import { describe } from 'node:test';
+
+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.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.geoBlockModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          mode: 'deny',
+          countries: ['RU'],
+          ban: false,
+        }),
+      });
+      const events = (await new EventsAwaiter().connect(this.client)).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.playerId).to.be.eq(this.setupData.players[0].id);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: customSetup,
+    name: 'DENY MODE: Non-blocked country detected -> no action taken',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.geoBlockModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          mode: 'deny',
+          countries: ['RU'],
+          ban: false,
+        }),
+      });
+      const events = (await new EventsAwaiter().connect(this.client)).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.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.geoBlockModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          mode: 'allow',
+          countries: ['RU'],
+          ban: false,
+        }),
+      });
+      const events = (await new EventsAwaiter().connect(this.client)).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.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.geoBlockModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          mode: 'allow',
+          countries: ['RU'],
+          ban: false,
+        }),
+      });
+      const events = (await new EventsAwaiter().connect(this.client)).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.playerId).to.be.eq(this.setupData.players[0].id);
+    },
+  }),
+  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.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.geoBlockModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          mode: 'allow',
+          countries: ['RU'],
+          ban: true,
+        }),
+      });
+      const events = (await new EventsAwaiter().connect(this.client)).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.playerId).to.be.eq(this.setupData.players[0].id);
+    },
+  }),
+  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.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.geoBlockModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          mode: 'deny',
+          countries: ['RU', 'BE'],
+          ban: true,
+          message: 'Custom message',
+        }),
+      });
+      const events = (await new EventsAwaiter().connect(this.client)).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.playerId).to.be.eq(this.setupData.players[0].id);
+    },
+  }),
+  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.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.geoBlockModule.latestVersion.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 = (await new EventsAwaiter().connect(this.client)).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.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.geoBlockModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          mode: 'deny',
+          countries: [],
+          ban: true,
+          message: 'Custom message',
+        }),
+      });
+      const events = (await new EventsAwaiter().connect(this.client)).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();
+  });
+});