Update tests to use mockCtx with hook for plugins

Refactored formula-plugin and validator-plugin tests to use a mockCtx object with a hook function instead of relying on the kernel's use method. This improves test accuracy for plugins that register hooks and ensures compatibility with different kernel configurations.

Author: hotlong

packages/foundation/core/test/formula-plugin.test.ts

@@ -12,13 +12,18 @@ import { ObjectKernel } from '@objectstack/runtime';
 describe('FormulaPlugin', () => {
     let plugin: FormulaPlugin;
     let mockKernel: any;
+    let mockCtx: any;
 
     beforeEach(() => {
         // Create a mock kernel with middleware and formula provider support
         mockKernel = {
             use: jest.fn(),
             registerFormulaProvider: jest.fn(),
         };
+        mockCtx = {
+            app: mockKernel,
+            hook: jest.fn(),
+        };
         plugin = new FormulaPlugin();
     });
 
@@ -55,16 +60,14 @@ describe('FormulaPlugin', () => {
 
     describe('Installation', () => {
         it('should install successfully with mock kernel', async () => {
-            const ctx = { app: mockKernel };
-            await plugin.init(ctx);
+            await plugin.init(mockCtx);
 
             // Verify that formula provider was registered
             expect(mockKernel.registerFormulaProvider).toHaveBeenCalled();
         });
 
         it('should register formula provider with evaluate function', async () => {
-            const ctx = { app: mockKernel };
-            await plugin.init(ctx);
+            await plugin.init(mockCtx);
 
             expect(mockKernel.registerFormulaProvider).toHaveBeenCalledWith(
                 expect.objectContaining({
@@ -77,22 +80,20 @@ describe('FormulaPlugin', () => {
 
         it('should register formula middleware when auto-evaluation is enabled', async () => {
             const pluginWithAuto = new FormulaPlugin({ autoEvaluateOnQuery: true });
-            const ctx = { app: mockKernel };
 
-            await pluginWithAuto.init(ctx);
+            await pluginWithAuto.init(mockCtx);
 
             // Check that middleware was registered
-            expect(mockKernel.use).toHaveBeenCalledWith('afterQuery', expect.any(Function));
+            expect(mockCtx.hook).toHaveBeenCalledWith('afterQuery', expect.any(Function));
         });
 
         it('should not register formula middleware when auto-evaluation is disabled', async () => {
             const pluginNoAuto = new FormulaPlugin({ autoEvaluateOnQuery: false });
-            const ctx = { app: mockKernel };
 
-            await pluginNoAuto.init(ctx);
+            await pluginNoAuto.init(mockCtx);
 
             // Should not have registered afterQuery hook
-            const afterQueryCalls = mockKernel.use.mock.calls.filter(
+            const afterQueryCalls = mockCtx.hook.mock.calls.filter(
                 (call: any[]) => call[0] === 'afterQuery'
             );
             expect(afterQueryCalls.length).toBe(0);
@@ -102,7 +103,7 @@ describe('FormulaPlugin', () => {
             const kernelNoProvider = {
                 use: jest.fn(),
             };
-            const ctx = { app: kernelNoProvider };
+            const ctx = { app: kernelNoProvider, hook: jest.fn() };
 
             // Should not throw error and should set formulaEngine property
             await expect(plugin.init(ctx)).resolves.not.toThrow();
@@ -113,7 +114,7 @@ describe('FormulaPlugin', () => {
             const kernelNoMiddleware = {
                 registerFormulaProvider: jest.fn(),
             };
-            const ctx = { app: kernelNoMiddleware };
+            const ctx = { app: kernelNoMiddleware, hook: undefined }; // Simulate no hook support
 
             // Should not throw error
             await expect(plugin.init(ctx)).resolves.not.toThrow();

packages/foundation/core/test/validator-plugin.test.ts

@@ -12,12 +12,17 @@ import { ObjectKernel } from '@objectstack/runtime';
 describe('ValidatorPlugin', () => {
     let plugin: ValidatorPlugin;
     let mockKernel: any;
+    let mockCtx: any;
 
     beforeEach(() => {
         // Create a mock kernel with middleware support
         mockKernel = {
             use: jest.fn(),
         };
+        mockCtx = {
+            app: mockKernel,
+            hook: jest.fn(),
+        };
         plugin = new ValidatorPlugin();
     });
 
@@ -54,62 +59,57 @@ describe('ValidatorPlugin', () => {
 
     describe('Installation', () => {
         it('should install successfully with mock kernel', async () => {
-            const ctx = { app: mockKernel };
-            await plugin.init(ctx);
+            await plugin.init(mockCtx);
 
             // Verify that middleware hooks were registered
-            expect(mockKernel.use).toHaveBeenCalled();
+            expect(mockCtx.hook).toHaveBeenCalled();
         });
 
         it('should register query validation when enabled', async () => {
             const pluginWithQuery = new ValidatorPlugin({ enableQueryValidation: true });
-            const ctx = { app: mockKernel };
 
-            await pluginWithQuery.init(ctx);
+            await pluginWithQuery.init(mockCtx);
 
             // Check that use was called (for query validation)
-            expect(mockKernel.use).toHaveBeenCalledWith('beforeQuery', expect.any(Function));
+            expect(mockCtx.hook).toHaveBeenCalledWith('beforeQuery', expect.any(Function));
         });
 
         it('should register mutation validation when enabled', async () => {
             const pluginWithMutation = new ValidatorPlugin({ enableMutationValidation: true });
-            const ctx = { app: mockKernel };
 
-            await pluginWithMutation.init(ctx);
+            await pluginWithMutation.init(mockCtx);
 
             // Check that use was called (for mutation validation)
-            expect(mockKernel.use).toHaveBeenCalledWith('beforeMutation', expect.any(Function));
+            expect(mockCtx.hook).toHaveBeenCalledWith('beforeMutation', expect.any(Function));
         });
 
         it('should not register query validation when disabled', async () => {
             const pluginNoQuery = new ValidatorPlugin({ enableQueryValidation: false });
-            const ctx = { app: mockKernel };
 
-            await pluginNoQuery.init(ctx);
+            await pluginNoQuery.init(mockCtx);
 
             // Should not have registered beforeQuery hook
-            const beforeQueryCalls = mockKernel.use.mock.calls.filter(
+            const beforeQueryCalls = mockCtx.hook.mock.calls.filter(
                 (call: any[]) => call[0] === 'beforeQuery'
             );
             expect(beforeQueryCalls.length).toBe(0);
         });
 
         it('should not register mutation validation when disabled', async () => {
             const pluginNoMutation = new ValidatorPlugin({ enableMutationValidation: false });
-            const ctx = { app: mockKernel };
 
-            await pluginNoMutation.init(ctx);
+            await pluginNoMutation.init(mockCtx);
 
             // Should not have registered beforeMutation hook
-            const beforeMutationCalls = mockKernel.use.mock.calls.filter(
+            const beforeMutationCalls = mockCtx.hook.mock.calls.filter(
                 (call: any[]) => call[0] === 'beforeMutation'
             );
             expect(beforeMutationCalls.length).toBe(0);
         });
 
         it('should handle kernel without middleware support', async () => {
             const kernelNoMiddleware = {};
-            const ctx = { app: kernelNoMiddleware };
+            const ctx = { app: kernelNoMiddleware, hook: undefined }; // Simulate no hook support
 
             // Should not throw error
             await expect(plugin.init(ctx)).resolves.not.toThrow();