@takaro/modules 0.0.30 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takaro/modules",
-  "version": "0.0.30",
+  "version": "0.1.0",
   "description": "Built-in modules for Takaro",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",

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

@@ -11,7 +11,7 @@ const tests = [
     setup: shopSetup,
     name: 'Can claim an order happy path',
     test: async function () {
-      await this.setupData.userClient.shopOrder.shopOrderControllerCreate({
+      await this.setupData.client1.shopOrder.shopOrderControllerCreate({
         listingId: this.setupData.listing100.id,
         amount: 1,
       });
@@ -47,7 +47,7 @@ const tests = [
     setup: shopSetup,
     name: 'Handles double-claiming an order',
     test: async function () {
-      await this.setupData.userClient.shopOrder.shopOrderControllerCreate({
+      await this.setupData.client1.shopOrder.shopOrderControllerCreate({
         listingId: this.setupData.listing100.id,
         amount: 1,
       });
@@ -76,11 +76,11 @@ const tests = [
     setup: shopSetup,
     name: 'Only claims the first order by default',
     test: async function () {
-      await this.setupData.userClient.shopOrder.shopOrderControllerCreate({
+      await this.setupData.client1.shopOrder.shopOrderControllerCreate({
         listingId: this.setupData.listing100.id,
         amount: 1,
       });
-      await this.setupData.userClient.shopOrder.shopOrderControllerCreate({
+      await this.setupData.client1.shopOrder.shopOrderControllerCreate({
         listingId: this.setupData.listing33.id,
         amount: 1,
       });
@@ -111,11 +111,11 @@ const tests = [
     setup: shopSetup,
     name: 'Can claim all orders in one go',
     test: async function () {
-      await this.setupData.userClient.shopOrder.shopOrderControllerCreate({
+      await this.setupData.client1.shopOrder.shopOrderControllerCreate({
         listingId: this.setupData.listing100.id,
         amount: 1,
       });
-      await this.setupData.userClient.shopOrder.shopOrderControllerCreate({
+      await this.setupData.client1.shopOrder.shopOrderControllerCreate({
         listingId: this.setupData.listing33.id,
         amount: 1,
       });

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

@@ -114,7 +114,7 @@ const tests = [
       expect((await events).length).to.be.eq(6);
       for (const message of messages) {
         expect(message).to.match(
-          /(Richest players\:|1\. .+ - 4000 test coin|2\. .+ - 3000 test coin|3\. .+ - 2000 test coin|4\. .+ - 1000 test coin|5\. .+ - 0 test coin)/,
+          /(Richest players\:|1\. .+ - 9000 test coin|2\. .+ - 8000 test coin|3\. .+ - 7000 test coin|4\. .+ - 6000 test coin|5\. .+ - 5000 test coin)/,
         );
       }
     },

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

@@ -0,0 +1,618 @@
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
+import { describe } from 'node:test';
+
+const group = 'High Ping Kicker';
+
+const tests = [
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should warn players with high ping using default configuration',
+    test: async function () {
+      // Install module with default configuration (pingThreshold: 200, warningsBeforeKick: 3)
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+      });
+
+      // Set player ping to be above threshold
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 250}',
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      // Trigger the cron job
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for event processing
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.match(/Your ping \(250\) is too high\. Warning 1\/3/);
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should kick player after reaching warning threshold',
+    test: async function () {
+      // Install module with default configuration
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+      });
+
+      // Set player ping to be above threshold
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 300}',
+      });
+
+      // First warning
+      const events1 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+      expect((await events1).length).to.be.eq(1);
+      expect((await events1)[0].data.meta.msg).to.match(/Your ping \(300\) is too high\. Warning 1\/3/);
+
+      // Second warning
+      const events2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+      expect((await events2).length).to.be.eq(1);
+      expect((await events2)[0].data.meta.msg).to.match(/Your ping \(300\) is too high\. Warning 2\/3/);
+
+      // Third warning should trigger kick
+      const kickEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.PLAYER_DISCONNECTED);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      expect((await kickEvent).length).to.be.eq(1);
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should respect custom configuration values',
+    test: async function () {
+      // Install module with custom configuration (lower threshold and fewer warnings)
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          pingThreshold: 100,
+          warningsBeforeKick: 2,
+        }),
+      });
+
+      // Set player ping to be above custom threshold
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 150}',
+      });
+
+      // First warning
+      const events1 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+      expect((await events1).length).to.be.eq(1);
+      expect((await events1)[0].data.meta.msg).to.match(/Your ping \(150\) is too high\. Warning 1\/2/);
+
+      // Second warning should trigger kick
+      const kickEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.PLAYER_DISCONNECTED);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      expect((await kickEvent).length).to.be.eq(1);
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should not warn players with ping below threshold',
+    test: async function () {
+      // Install module with default configuration
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+      });
+
+      // Set player ping to be below threshold
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 50}',
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      // Trigger the cron job
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      // Should timeout without receiving any events
+      try {
+        await events;
+        expect.fail('Should not have received any warning messages');
+      } catch (error: any) {
+        // Expected timeout
+        expect(error.message).to.include('timed out');
+      }
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should handle multiple players with different ping values correctly',
+    test: async function () {
+      // Install module with default configuration
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+      });
+
+      // Set different ping values for different players
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 250}',
+      });
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 1 {"ping": 50}',
+      });
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 2 {"ping": 300}',
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      // Trigger the cron job
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      // Should receive warnings for players 0 and 2, but not player 1
+      const receivedEvents = await events;
+      expect(receivedEvents.length).to.be.eq(2);
+
+      const messages = receivedEvents.map((e) => e.data.meta.msg);
+      expect(messages).to.satisfy((msgs: string[]) => msgs.some((msg) => msg.includes('Your ping (250) is too high')));
+      expect(messages).to.satisfy((msgs: string[]) => msgs.some((msg) => msg.includes('Your ping (300) is too high')));
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should reset warnings after player is kicked',
+    test: async function () {
+      // Install module with configuration for quick kick (1 warning before kick)
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          pingThreshold: 200,
+          warningsBeforeKick: 1,
+        }),
+      });
+
+      // Set player ping to be above threshold
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 250}',
+      });
+
+      // First trigger should kick the player
+      const kickEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.PLAYER_DISCONNECTED);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+      expect((await kickEvent).length).to.be.eq(1);
+
+      // Reconnect the player by setting online status
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"online": true}',
+      });
+
+      // Keep high ping
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 250}',
+      });
+
+      // Next trigger should kick again (warnings were reset)
+      const kickEvent2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.PLAYER_DISCONNECTED);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+      expect((await kickEvent2).length).to.be.eq(1);
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should handle edge case of zero warnings before kick',
+    test: async function () {
+      // Install module with configuration for immediate kick (0 warnings)
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          pingThreshold: 200,
+          warningsBeforeKick: 0,
+        }),
+      });
+
+      // Set player ping to be above threshold
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 250}',
+      });
+
+      // Should immediately kick without warning
+      const kickEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.PLAYER_DISCONNECTED);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      expect((await kickEvent).length).to.be.eq(1);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should handle ping exactly at threshold (boundary condition)',
+    test: async function () {
+      // Install module with default configuration
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+      });
+
+      // Set player ping exactly at threshold (should not trigger warning)
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 200}',
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      // Trigger the cron job
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      // Should timeout without receiving any events (ping = threshold should not warn)
+      try {
+        await events;
+        expect.fail('Should not have received any warning messages for ping exactly at threshold');
+      } catch (error: any) {
+        // Expected timeout
+        expect(error.message).to.include('timed out');
+      }
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should warn for ping just above threshold (boundary condition)',
+    test: async function () {
+      // Install module with default configuration
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+      });
+
+      // Set player ping just above threshold
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 201}',
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      // Trigger the cron job
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.match(/Your ping \(201\) is too high\. Warning 1\/3/);
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should handle very high ping values correctly',
+    test: async function () {
+      // Install module with default configuration
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+      });
+
+      // Set extremely high ping
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 9999}',
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      // Trigger the cron job
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.match(/Your ping \(9999\) is too high\. Warning 1\/3/);
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should handle offline players correctly',
+    test: async function () {
+      // Install module with default configuration
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+      });
+
+      // Set player offline but with high ping
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 300, "online": false}',
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      // Trigger the cron job
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      // Should timeout as offline players shouldn't be checked
+      try {
+        await events;
+        expect.fail('Should not have received any warning messages for offline players');
+      } catch (error: any) {
+        // Expected timeout
+        expect(error.message).to.include('timed out');
+      }
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should handle ping fluctuation correctly',
+    test: async function () {
+      // Install module with default configuration
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+      });
+
+      // Set high ping
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 300}',
+      });
+
+      // First warning
+      const events1 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+      expect((await events1).length).to.be.eq(1);
+
+      // Lower ping temporarily
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 50}',
+      });
+
+      // Should not warn or kick
+      const events2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      try {
+        await events2;
+        expect.fail('Should not have received warning for good ping');
+      } catch (error: any) {
+        expect(error.message).to.include('timed out');
+      }
+
+      // Raise ping again
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 350}',
+      });
+
+      // Should continue from previous warning count
+      const events3 = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+      expect((await events3).length).to.be.eq(1);
+      expect((await events3)[0].data.meta.msg).to.match(/Warning 2\/3/);
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should handle extreme configuration values',
+    test: async function () {
+      // Install module with extreme configuration (very low threshold, high warning count)
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          pingThreshold: 1,
+          warningsBeforeKick: 10,
+        }),
+      });
+
+      // Set moderate ping that would be above extremely low threshold
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"ping": 50}',
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      // Trigger the cron job
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      expect((await events).length).to.be.eq(1);
+      expect((await events)[0].data.meta.msg).to.match(/Your ping \(50\) is too high\. Warning 1\/10/);
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should handle concurrent ping changes during warning period',
+    test: async function () {
+      // Install module with custom configuration
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          pingThreshold: 200,
+          warningsBeforeKick: 2,
+        }),
+      });
+
+      // Set high ping for multiple players simultaneously
+      await Promise.all([
+        this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+          command: 'setPlayerData 0 {"ping": 250}',
+        }),
+        this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+          command: 'setPlayerData 1 {"ping": 260}',
+        }),
+        this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+          command: 'setPlayerData 2 {"ping": 270}',
+        }),
+      ]);
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 3);
+
+      // Trigger the cron job
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      const receivedEvents = await events;
+      expect(receivedEvents.length).to.be.eq(3);
+
+      // All should get warning 1
+      receivedEvents.forEach((event) => {
+        expect(event.data.meta.msg).to.match(/Warning 1\/2/);
+      });
+    },
+  }),
+
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Should handle player with missing ping data gracefully',
+    test: async function () {
+      // Install module with default configuration
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.highPingKickerModule.latestVersion.id,
+      });
+
+      // Don't set any ping data for player 0, but ensure they're online
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'setPlayerData 0 {"online": true}',
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+
+      // Trigger the cron job
+      await this.client.cronjob.cronJobControllerTrigger({
+        cronjobId: this.setupData.highPingKickerModule.latestVersion.cronJobs[0].id,
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.highPingKickerModule.id,
+      });
+
+      // Should timeout as undefined/null ping should not trigger warnings
+      try {
+        await events;
+        expect.fail('Should not have received warning for undefined ping');
+      } catch (error: any) {
+        expect(error.message).to.include('timed out');
+      }
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});