@takaro/modules 0.2.0 → 0.3.0

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

@@ -1,140 +1,308 @@
-import {
-  IntegrationTest,
-  expect,
-  IModuleTestsSetupData,
-  modulesTestSetup,
-  chatMessageSorter,
-  EventsAwaiter,
-} from '@takaro/test';
-import { GameEvents } from '../dto/gameEvents.js';
+import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
+import { GameEvents } from '../dto/index.js';
 import { describe } from 'node:test';
 
-const group = 'Help command';
+const group = 'help command suite';
 
 const tests = [
   new IntegrationTest<IModuleTestsSetupData>({
     group,
     snapshot: false,
     setup: modulesTestSetup,
-    name: 'Help command responds with a list of installed commands',
+    name: 'Shows all available commands when no argument provided',
     test: async function () {
       await this.client.module.moduleInstallationsControllerInstallModule({
         gameServerId: this.setupData.gameserver.id,
         versionId: this.setupData.utilsModule.latestVersion.id,
       });
+
       const events = (await new EventsAwaiter().connect(this.client)).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);
+      const messages = await events;
+      expect(messages.length).to.be.greaterThan(0);
+      expect(messages[0].data.meta.msg).to.include('Available commands:');
+      // Should show help and ping commands from utils module
+      expect(messages.some((m) => m.data.meta.msg.includes('help:'))).to.be.true;
+      expect(messages.some((m) => m.data.meta.msg.includes('ping:'))).to.be.true;
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Shows specific command help when command name provided',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.utilsModule.latestVersion.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 
-      expect(sortedEvents[0].data.meta.msg).to.be.eq('Available commands:');
-      expect(sortedEvents[1].data.meta.msg).to.be.eq(
-        'help: The text you are reading right now, displays information about commands.',
-      );
-      expect(sortedEvents[2].data.meta.msg).to.be.eq(
-        'ping: Replies with pong, useful for testing if the connection works.',
-      );
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/help ping',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const messages = await events;
+      expect(messages.length).to.be.eq(1);
+      expect(messages[0].data.meta.msg).to.include('ping:');
+      expect(messages[0].data.meta.msg).to.include('pong');
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
     group,
     snapshot: false,
     setup: modulesTestSetup,
-    name: 'Help command responds with a list of installed commands, picking up commands from multiple modules',
+    name: 'Search returns commands with matching names',
     test: async function () {
       await this.client.module.moduleInstallationsControllerInstallModule({
         gameServerId: this.setupData.gameserver.id,
         versionId: this.setupData.utilsModule.latestVersion.id,
       });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/help search ping',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const messages = await events;
+      expect(messages.length).to.be.greaterThan(0);
+      expect(messages[0].data.meta.msg).to.include('Commands matching "ping":');
+      expect(messages.some((m) => m.data.meta.msg.includes('ping:'))).to.be.true;
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Search returns commands with matching help text',
+    test: async function () {
       await this.client.module.moduleInstallationsControllerInstallModule({
         gameServerId: this.setupData.gameserver.id,
-        versionId: this.setupData.teleportsModule.latestVersion.id,
+        versionId: this.setupData.utilsModule.latestVersion.id,
       });
-      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 13);
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
-        msg: '/help',
+        msg: '/help search pong',
         playerId: this.setupData.players[0].id,
       });
 
-      const sortedEvents = (await events).sort(chatMessageSorter);
+      const messages = await events;
+      expect(messages.length).to.be.greaterThan(0);
+      expect(messages[0].data.meta.msg).to.include('Commands matching "pong":');
+      expect(messages.some((m) => m.data.meta.msg.includes('ping:'))).to.be.true;
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Search is case-insensitive',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.utilsModule.latestVersion.id,
+      });
 
-      expect(sortedEvents[0].data.meta.msg).to.be.eq('Available commands:');
-      expect(sortedEvents[1].data.meta.msg).to.be.eq('deletetp: Deletes a location.');
-      expect(sortedEvents[2].data.meta.msg).to.be.eq('deletewaypoint: Deletes a waypoint.');
-      expect(sortedEvents[3].data.meta.msg).to.be.eq(
-        'help: The text you are reading right now, displays information about commands.',
-      );
-      expect(sortedEvents[4].data.meta.msg).to.be.eq('listwaypoints: Lists all waypoints.');
-      expect(sortedEvents[5].data.meta.msg).to.be.eq(
-        'ping: Replies with pong, useful for testing if the connection works.',
-      );
-      expect(sortedEvents[6].data.meta.msg).to.be.eq(
-        'setprivate: Sets a teleport to be private, only the teleport owner can teleport to it.',
-      );
-      expect(sortedEvents[7].data.meta.msg).to.be.eq(
-        'setpublic: Sets a teleport to be public, allowing other players to teleport to it.',
-      );
-      expect(sortedEvents[8].data.meta.msg).to.be.eq('settp: Sets a location to teleport to.');
-      expect(sortedEvents[9].data.meta.msg).to.be.eq('setwaypoint: Creates a new waypoint.');
-      expect(sortedEvents[10].data.meta.msg).to.be.eq('teleport: Teleports to one of your set locations.');
-      expect(sortedEvents[11].data.meta.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 names.',
-      );
-      expect(sortedEvents[12].data.meta.msg).to.be.eq('tplist: Lists all your set locations.');
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/help search PING',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const messages = await events;
+      expect(messages.length).to.be.greaterThan(0);
+      expect(messages[0].data.meta.msg).to.include('Commands matching "PING":');
+      expect(messages.some((m) => m.data.meta.msg.includes('ping:'))).to.be.true;
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
     group,
     snapshot: false,
     setup: modulesTestSetup,
-    name: 'Help command responds with detailed info about a specific command',
+    name: 'Search supports partial matches',
     test: async function () {
       await this.client.module.moduleInstallationsControllerInstallModule({
         gameServerId: this.setupData.gameserver.id,
         versionId: this.setupData.utilsModule.latestVersion.id,
       });
 
-      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
-        msg: '/help ping',
+        msg: '/help search hel',
         playerId: this.setupData.players[0].id,
       });
 
-      expect((await events).length).to.be.eq(1);
-      const sortedEvents = (await events).sort(chatMessageSorter);
+      const messages = await events;
+      expect(messages.length).to.be.greaterThan(0);
+      expect(messages[0].data.meta.msg).to.include('Commands matching "hel":');
+      expect(messages.some((m) => m.data.meta.msg.includes('help:'))).to.be.true;
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Search returns appropriate message when no matches found',
+    test: async function () {
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.utilsModule.latestVersion.id,
+      });
 
-      expect(sortedEvents[0].data.meta.msg).to.be.eq(
-        'ping: Replies with pong, useful for testing if the connection works.',
-      );
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/help search nonexistentcommand',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const messages = await events;
+      expect(messages.length).to.be.eq(1);
+      expect(messages[0].data.meta.msg).to.include('No commands found matching "nonexistentcommand"');
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Search works across multiple modules',
+    test: async function () {
+      // Install utils module
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.utilsModule.latestVersion.id,
+      });
+
+      // Install another module (gimme) to have more commands
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.gimmeModule.latestVersion.id,
+        userConfig: JSON.stringify({
+          items: [],
+          commands: ['say test'],
+        }),
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/help search command',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const messages = await events;
+      expect(messages.length).to.be.greaterThan(0);
+      expect(messages[0].data.meta.msg).to.include('Commands matching "command":');
+      // Should find help command which has "command" in its help text
+      expect(messages.some((m) => m.data.meta.msg.includes('help:'))).to.be.true;
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
     group,
     snapshot: false,
     setup: modulesTestSetup,
-    name: 'Help command responds with unknown command message if command does not exist',
+    name: 'Does not show commands from disabled modules',
     test: async function () {
+      // First install utils module normally so help command is available
       await this.client.module.moduleInstallationsControllerInstallModule({
         gameServerId: this.setupData.gameserver.id,
         versionId: this.setupData.utilsModule.latestVersion.id,
       });
 
-      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      // Install teleports module but disabled
+      const teleportsInstallation = await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+      });
+
+      // Get the current system config and disable the teleports module
+      const systemConfig = teleportsInstallation.data.data.systemConfig as any;
+      systemConfig.enabled = false;
+
+      // Uninstall and reinstall teleports module with disabled config
+      await this.client.module.moduleInstallationsControllerUninstallModule(
+        teleportsInstallation.data.data.moduleId,
+        this.setupData.gameserver.id,
+      );
+
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.teleportsModule.latestVersion.id,
+        systemConfig: JSON.stringify(systemConfig),
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 3);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
-        msg: '/help foobar',
+        msg: '/help',
         playerId: this.setupData.players[0].id,
       });
 
-      expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.meta.msg).to.be.eq(
-        'Unknown command "foobar", use this command without arguments to see all available commands.',
+      const messages = await events;
+      expect(messages.length).to.be.greaterThan(0);
+      expect(messages[0].data.meta.msg).to.include('Available commands:');
+      // Should show commands from utils module but NOT from disabled teleports module
+      expect(messages.some((m) => m.data.meta.msg.includes('help:'))).to.be.true;
+      expect(messages.some((m) => m.data.meta.msg.includes('ping:'))).to.be.true;
+      // Should NOT show teleports commands
+      expect(messages.some((m) => m.data.meta.msg.includes('settp:'))).to.be.false;
+      expect(messages.some((m) => m.data.meta.msg.includes('teleport:'))).to.be.false;
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Does not show individually disabled commands',
+    test: async function () {
+      // Install utils module
+      const moduleInstallation = await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.utilsModule.latestVersion.id,
+      });
+
+      // Disable only the ping command
+      const systemConfig = moduleInstallation.data.data.systemConfig as any;
+      systemConfig.commands.ping.enabled = false;
+
+      // Uninstall and reinstall with new config
+      await this.client.module.moduleInstallationsControllerUninstallModule(
+        moduleInstallation.data.data.moduleId,
+        this.setupData.gameserver.id,
       );
+
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.utilsModule.latestVersion.id,
+        systemConfig: JSON.stringify(systemConfig),
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 2);
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: '/help',
+        playerId: this.setupData.players[0].id,
+      });
+
+      const messages = await events;
+      expect(messages.length).to.be.greaterThan(0);
+      expect(messages[0].data.meta.msg).to.include('Available commands:');
+      // Should show help command but NOT ping command
+      expect(messages.some((m) => m.data.meta.msg.includes('help:'))).to.be.true;
+      expect(messages.some((m) => m.data.meta.msg.includes('ping:'))).to.be.false;
     },
   }),
 ];

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

@@ -171,7 +171,11 @@ const tests = [
         playerId: this.setupData.players[0].id,
       });
 
-      await waitForBuyEvents;
+      const buyEvents = await waitForBuyEvents;
+      expect(buyEvents.length).to.be.eq(1);
+      expect(buyEvents[0].data.meta.msg).to.be.eq(
+        `You have successfully bought ${wantAmount} tickets for ${wantAmount * ticketCost} Takaro coins. Good luck!`,
+      );
 
       const waitForViewEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
 

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

@@ -1,5 +1,5 @@
 import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
-import { GameEvents } from '../dto/index.js';
+import { IHookEventTypeEnum } from '@takaro/apiclient';
 import { describe } from 'node:test';
 import { randomUUID } from 'crypto';
 import { getMockServer } from '@takaro/mock-gameserver';
@@ -55,7 +55,10 @@ const tests = [
       });
       await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, this.setupData.role.id);
 
-      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(
+        IHookEventTypeEnum.ChatMessage,
+        1,
+      );
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test',
         playerId: this.setupData.players[0].id,
@@ -87,14 +90,19 @@ const tests = [
         gameServerId: newGameServer.id,
       });
 
-      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(
+        IHookEventTypeEnum.ChatMessage,
+        1,
+      );
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test',
         playerId: this.setupData.players[0].id,
       });
 
       expect((await setEvents).length).to.be.eq(1);
-      expect((await setEvents)[0].data.meta.msg).to.be.eq('You do not have permission to use teleports.');
+      expect((await setEvents)[0].data.meta.msg).to.be.eq(
+        "⚠️ You need the 'Teleports Use' permission to use this command. Please contact an admin if you need access.",
+      );
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -117,7 +125,10 @@ const tests = [
         gameServerId: this.setupData.gameserver.id,
       });
 
-      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const setEvents = (await new EventsAwaiter().connect(this.client)).waitForEvents(
+        IHookEventTypeEnum.ChatMessage,
+        1,
+      );
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test',
         playerId: this.setupData.players[0].id,
@@ -148,6 +159,7 @@ const tests = [
       );
 
       const playerRoleRes = await this.client.role.roleControllerSearch({ filters: { name: ['Player'] } });
+
       const useTeleportsRole = await this.client.permissionCodesToInputs(['TELEPORTS_USE']);
       await this.client.role.roleControllerUpdate(playerRoleRes.data.data[0].id, {
         permissions: [
@@ -158,17 +170,22 @@ const tests = [
         ],
       });
 
-      const setTpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const setTpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(
+        IHookEventTypeEnum.ChatMessage,
+        1,
+      );
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/settp test',
         playerId: this.setupData.players[0].id,
       });
 
-      expect((await setTpEvent).length).to.be.eq(1);
-      expect((await setTpEvent)[0].data.meta.msg).to.be.eq('Teleport test set.');
+      const setTpEventResult = await setTpEvent;
+
+      expect(setTpEventResult.length).to.be.eq(1);
+      expect(setTpEventResult[0].data.meta.msg).to.be.eq('Teleport test set.');
 
-      const tpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const tpEvent = (await new EventsAwaiter().connect(this.client)).waitForEvents(IHookEventTypeEnum.ChatMessage, 1);
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/tp test',
@@ -182,14 +199,183 @@ const tests = [
         permissions: [],
       });
 
-      const tpEventNoPerm = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 1);
+      const tpEventNoPerm = (await new EventsAwaiter().connect(this.client)).waitForEvents(
+        IHookEventTypeEnum.ChatMessage,
+        1,
+      );
 
       await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
         msg: '/tp test',
         playerId: this.setupData.players[0].id,
       });
 
-      expect((await tpEventNoPerm)[0].data.meta.msg).to.be.eq('You do not have permission to use teleports.');
+      expect((await tpEventNoPerm)[0].data.meta.msg).to.include("You need the 'Teleports Use' permission");
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: async function () {
+      const defaultSetup = await modulesTestSetup.bind(this)();
+
+      // Remove all permissions from the default role
+      await this.client.role.roleControllerUpdate(defaultSetup.role.id, {
+        name: defaultSetup.role.name,
+        permissions: [],
+      });
+
+      return defaultSetup;
+    },
+    name: 'Command execution denied when player lacks requiredPermissions',
+    test: async function () {
+      // Install economyUtils module which has commands with requiredPermissions
+      const installRes = await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+      });
+
+      // Verify installation succeeded
+      expect(installRes.data.data).to.exist;
+
+      // Ensure we have at least 1 player
+      expect(this.setupData.players.length).to.be.at.least(1);
+      const executingPlayer = this.setupData.players[0];
+
+      // Remove any existing roles from the player to ensure they have no special permissions
+      await this.client.player.playerControllerRemoveRole(executingPlayer.id, this.setupData.role.id);
+
+      // Check player's roles after removal
+      const playerAfter = await this.client.player.playerControllerGetOne(executingPlayer.id);
+
+      // If player still has system roles, we need to handle the Player role specially
+      if (playerAfter.data.data.roleAssignments && playerAfter.data.data.roleAssignments.length > 0) {
+        // Find the Player role
+        const playerRole = playerAfter.data.data.roleAssignments.find((ra) => ra.role.name === 'Player');
+        if (!playerRole) throw new Error('Player role not found after removing roles');
+        // Update the Player role to have no permissions
+        await this.client.role.roleControllerUpdate(playerRole.role.id, {
+          name: 'Player',
+          permissions: [],
+        });
+      }
+
+      // Enable economy for this test
+      await this.client.settings.settingsControllerSet('economyEnabled', {
+        value: 'true',
+        gameServerId: this.setupData.gameserver.id,
+      });
+      await this.client.settings.settingsControllerSet('currencyName', {
+        gameServerId: this.setupData.gameserver.id,
+        value: 'test coin',
+      });
+
+      // Set up event listener - just listen for the chat message
+      const eventsAwaiter = await new EventsAwaiter().connect(this.client);
+      const chatEvents = eventsAwaiter.waitForEvents(IHookEventTypeEnum.ChatMessage, 1);
+
+      // Try to execute grantCurrency command without permission
+      const targetPlayer = this.setupData.players.length > 1 ? this.setupData.players[1] : executingPlayer;
+      const commandMsg = `/grantcurrency ${targetPlayer.name} 100`;
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: commandMsg,
+        playerId: executingPlayer.id,
+      });
+
+      // Check if we got a permission denied message
+      const chatEventResults = await chatEvents;
+      expect(chatEventResults).to.have.length(1);
+      expect(chatEventResults[0].data.meta.msg).to.match(/do not have permission|need.*permission/i);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'Command execution allowed when player has requiredPermissions',
+    test: async function () {
+      // Install economyUtils module
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+      });
+
+      // Create a role with ECONOMY_UTILS_MANAGE_CURRENCY permission
+      const permissions = await this.client.permissionCodesToInputs(['ECONOMY_UTILS_MANAGE_CURRENCY']);
+      const roleRes = await this.client.role.roleControllerCreate({
+        name: 'Currency Manager',
+        permissions,
+      });
+
+      // Assign the role to the player
+      await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, roleRes.data.data.id);
+
+      // Set up event listener for COMMAND_EXECUTED event
+      const eventsAwaiter = await new EventsAwaiter().connect(this.client);
+      const executedEvents = eventsAwaiter.waitForEvents(IHookEventTypeEnum.CommandExecuted, 1);
+
+      // Execute grantCurrency command with permission
+      const targetPlayer = this.setupData.players.length > 1 ? this.setupData.players[1] : this.setupData.players[0];
+
+      const commandMsg = `/grantcurrency ${targetPlayer.name} 100`;
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: commandMsg,
+        playerId: this.setupData.players[0].id,
+      });
+
+      // Verify COMMAND_EXECUTED event was logged (not COMMAND_EXECUTION_DENIED)
+      const executedEventResults = await executedEvents;
+      expect(executedEventResults).to.have.length(1);
+      expect(executedEventResults[0].data.eventName).to.equal('command-executed');
+      // Command might fail during execution, but the important thing is that it was allowed to execute
+      // expect(executedEventResults[0].data.command.name).to.equal('grantcurrency');
+      // expect(executedEventResults[0].data.player.id).to.equal(this.setupData.players[0].id);
+    },
+  }),
+  new IntegrationTest<IModuleTestsSetupData>({
+    group,
+    snapshot: false,
+    setup: modulesTestSetup,
+    name: 'ROOT permission bypasses command permission checks',
+    test: async function () {
+      // Install economyUtils module
+      await this.client.module.moduleInstallationsControllerInstallModule({
+        gameServerId: this.setupData.gameserver.id,
+        versionId: this.setupData.economyUtilsModule.latestVersion.id,
+      });
+
+      // Create a role with ROOT permission
+      const permissions = await this.client.permissionCodesToInputs(['ROOT']);
+      const roleRes = await this.client.role.roleControllerCreate({
+        name: 'Root Admin Test',
+        permissions,
+      });
+
+      // Remove existing roles and assign ROOT role
+      await this.client.player.playerControllerRemoveRole(this.setupData.players[0].id, this.setupData.role.id);
+      await this.client.player.playerControllerAssignRole(this.setupData.players[0].id, roleRes.data.data.id);
+
+      // Set up event listener for COMMAND_EXECUTED event
+      const eventsAwaiter = await new EventsAwaiter().connect(this.client);
+      const executedEvents = eventsAwaiter.waitForEvents(IHookEventTypeEnum.CommandExecuted, 1);
+
+      // Execute grantCurrency command with ROOT permission (should bypass permission check)
+      const targetPlayer = this.setupData.players.length > 1 ? this.setupData.players[1] : this.setupData.players[0];
+
+      const commandMsg = `/grantcurrency ${targetPlayer.name} 100`;
+
+      await this.client.command.commandControllerTrigger(this.setupData.gameserver.id, {
+        msg: commandMsg,
+        playerId: this.setupData.players[0].id,
+      });
+
+      // Verify command was executed successfully
+      const executedEventResults = await executedEvents;
+      expect(executedEventResults).to.have.length(1);
+      expect(executedEventResults[0].data.eventName).to.equal('command-executed');
+      // Command might fail during execution, but the important thing is that ROOT bypassed the permission check
+      // expect(executedEventResults[0].data.command.name).to.equal('grantcurrency');
     },
   }),
 ];