@forgehive/forge-cli 0.2.5 → 0.2.7

package/dist/test/tasks/create.test.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const createTask_1 = require("../../tasks/task/createTask");
 const memfs_1 = require("memfs");
 const path_1 = __importDefault(require("path"));
-const utils_1 = require("../utils");
+const testUtils_1 = require("../testUtils");
 // Verify the task file content
 const expectedContent = `// TASK: newTask
 // Run this task with:
@@ -58,32 +58,31 @@ describe('Create task', () => {
     });
     afterEach(() => {
         jest.clearAllMocks();
+        // Reset any boundary mocks
+        createTask_1.createTaskCommand.resetMocks();
     });
     it('should create a new task file with correct content and update forge.json', async () => {
-        // Create properly typed mocks for the boundaries
-        const persistTaskMock = (0, utils_1.createBoundaryMock)();
-        const persistConfMock = (0, utils_1.createBoundaryMock)();
-        const getCwdMock = (0, utils_1.createBoundaryMock)();
-        const persistTaskFn = persistTaskMock;
-        const persistConfFn = persistConfMock;
-        const getCwdFn = getCwdMock;
-        // Override the persistTask implementation to use our in-memory fs
-        persistTaskFn.mockImplementation(async (dir, fileName, content, cwd) => {
+        // Create mock functions with Jest
+        const persistTaskFn = jest.fn().mockImplementation(async (dir, fileName, content, cwd) => {
             const fullPath = path_1.default.join(cwd, dir, fileName);
             await fs.promises.writeFile(fullPath, content);
             return { path: fullPath };
         });
-        // Override the persistConf implementation to use our in-memory fs
-        persistConfFn.mockImplementation(async (conf, cwd) => {
+        // Mock persistConf to use our in-memory fs
+        const persistConfFn = jest.fn().mockImplementation(async (conf, cwd) => {
             const forgePath = path_1.default.join(cwd, 'forge.json');
             await fs.promises.writeFile(forgePath, JSON.stringify(conf, null, 2));
         });
-        // Override the getCwd implementation to return our root directory
-        getCwdFn.mockResolvedValue(rootDir);
-        // Override the boundaries
-        createTask_1.createTaskCommand.getBoundaries().persistTask = persistTaskMock;
-        createTask_1.createTaskCommand.getBoundaries().persistConf = persistConfMock;
-        createTask_1.createTaskCommand.getBoundaries().getCwd = getCwdMock;
+        // Mock getCwd to return our root directory
+        const getCwdFn = jest.fn().mockResolvedValue(rootDir);
+        // Create boundary mocks with proper type casting
+        const persistTaskMock = (0, testUtils_1.createMockBoundary)(persistTaskFn);
+        const persistConfMock = (0, testUtils_1.createMockBoundary)(persistConfFn);
+        const getCwdMock = (0, testUtils_1.createMockBoundary)(getCwdFn);
+        // Use the mockBoundary method to mock the boundaries
+        createTask_1.createTaskCommand.mockBoundary('persistTask', persistTaskMock);
+        createTask_1.createTaskCommand.mockBoundary('persistConf', persistConfMock);
+        createTask_1.createTaskCommand.mockBoundary('getCwd', getCwdMock);
         // Run the task
         const taskName = 'sample:new-task';
         await createTask_1.createTaskCommand.run({ descriptorName: taskName });

package/dist/test/tasks/init.test.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const init_1 = require("../../tasks/init");
 const memfs_1 = require("memfs");
 const path_1 = __importDefault(require("path"));
-const utils_1 = require("../utils");
+const testUtils_1 = require("../testUtils");
 describe('Init task', () => {
     let volume;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -20,23 +20,22 @@ describe('Init task', () => {
     });
     afterEach(() => {
         jest.clearAllMocks();
+        // Reset any boundary mocks after each test
+        init_1.init.resetMocks();
     });
     it('should create forge.json with correct content in the filesystem', async () => {
-        // Create properly typed mocks for the boundaries
-        const saveFileMock = (0, utils_1.createBoundaryMock)();
-        const getCwdMock = (0, utils_1.createBoundaryMock)();
-        const saveFileFn = saveFileMock;
-        const getCwdFn = getCwdMock;
-        // Override the saveFile implementation to use our in-memory fs
-        saveFileFn.mockImplementation(async (filePath, content) => {
+        // Create mocks directly using Jest
+        const saveFileFn = jest.fn().mockImplementation(async (filePath, content) => {
             const fullPath = path_1.default.join(rootDir, filePath);
             await fs.promises.writeFile(fullPath, content);
         });
-        // Override the getCwd implementation to return our root directory
-        getCwdFn.mockResolvedValue(rootDir);
-        // Override the boundaries
-        init_1.init.getBoundaries().saveFile = saveFileMock;
-        init_1.init.getBoundaries().getCwd = getCwdMock;
+        const getCwdFn = jest.fn().mockResolvedValue(rootDir);
+        // Create wrapped boundary mocks
+        const saveFileMock = (0, testUtils_1.createMockBoundary)(saveFileFn);
+        const getCwdMock = (0, testUtils_1.createMockBoundary)(getCwdFn);
+        // Mock the boundaries
+        init_1.init.mockBoundary('saveFile', saveFileMock);
+        init_1.init.mockBoundary('getCwd', getCwdMock);
         // Run the task
         await init_1.init.run({});
         // Read the created file
@@ -51,16 +50,15 @@ describe('Init task', () => {
         expect(config).toHaveProperty('runners');
     });
     it('should not create forge.json when dryRun is true', async () => {
-        // Create properly typed mocks for the boundaries
-        const saveFileMock = (0, utils_1.createBoundaryMock)();
-        const getCwdMock = (0, utils_1.createBoundaryMock)();
-        const saveFileFn = saveFileMock;
-        const getCwdFn = getCwdMock;
-        // Override the getCwd implementation to return our root directory
-        getCwdFn.mockResolvedValue(rootDir);
-        // Override the boundaries
-        init_1.init.getBoundaries().saveFile = saveFileMock;
-        init_1.init.getBoundaries().getCwd = getCwdMock;
+        // Create mocks directly using Jest
+        const saveFileFn = jest.fn();
+        const getCwdFn = jest.fn().mockResolvedValue(rootDir);
+        // Create wrapped boundary mocks
+        const saveFileMock = (0, testUtils_1.createMockBoundary)(saveFileFn);
+        const getCwdMock = (0, testUtils_1.createMockBoundary)(getCwdFn);
+        // Mock the boundaries
+        init_1.init.mockBoundary('saveFile', saveFileMock);
+        init_1.init.mockBoundary('getCwd', getCwdMock);
         // Run the task with dryRun flag
         const result = await init_1.init.run({ dryRun: true });
         // Verify saveFile was not called

package/dist/test/testUtils.d.ts

@@ -0,0 +1,8 @@
+import { type WrappedBoundaryFunction } from '@forgehive/task';
+/**
+ * Creates a mock boundary function that implements the WrappedBoundaryFunction interface
+ *
+ * @param mockFn Optional Jest mock function to use as the base function
+ * @returns A wrapped boundary function compatible with task.mockBoundary()
+ */
+export declare const createMockBoundary: (mockFn?: jest.Mock) => WrappedBoundaryFunction;

package/dist/test/testUtils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockBoundary = void 0;
+/**
+ * Creates a mock boundary function that implements the WrappedBoundaryFunction interface
+ *
+ * @param mockFn Optional Jest mock function to use as the base function
+ * @returns A wrapped boundary function compatible with task.mockBoundary()
+ */
+const createMockBoundary = (mockFn) => {
+    // Use provided mock or create a new one
+    const baseMockFn = mockFn || jest.fn().mockResolvedValue(undefined);
+    // Create a proper boundary function object that extends the mock function
+    const boundaryMock = Object.assign(baseMockFn, {
+        getTape: jest.fn().mockReturnValue([]),
+        setTape: jest.fn(),
+        getMode: jest.fn().mockReturnValue('proxy'),
+        setMode: jest.fn(),
+        startRun: jest.fn(),
+        stopRun: jest.fn(),
+        getRunData: jest.fn().mockReturnValue([])
+    });
+    return boundaryMock;
+};
+exports.createMockBoundary = createMockBoundary;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,10 +10,10 @@
   "publishConfig": {
     "access": "public",
     "dependencies": {
-      "@forgehive/record-tape": "^0.0.1",
-      "@forgehive/runner": "^0.1.4",
+      "@forgehive/record-tape": "^0.1.0",
+      "@forgehive/runner": "^0.1.7",
       "@forgehive/schema": "^0.1.4",
-      "@forgehive/task": "^0.1.5",
+      "@forgehive/task": "^0.1.7",
       "esbuild": "^0.25.0",
       "handlebars": "^4.7.8",
       "minimist": "^1.2.8"
@@ -25,10 +25,10 @@
     "esbuild": "^0.25.0",
     "handlebars": "^4.7.8",
     "minimist": "^1.2.8",
-    "@forgehive/task": "0.1.5",
     "@forgehive/schema": "0.1.4",
-    "@forgehive/record-tape": "0.0.2",
-    "@forgehive/runner": "0.1.5"
+    "@forgehive/record-tape": "0.1.0",
+    "@forgehive/runner": "0.1.7",
+    "@forgehive/task": "0.1.7"
   },
   "devDependencies": {
     "@types/jest": "^29.5.3",

package/src/test/tasks/create.test.ts

@@ -1,7 +1,7 @@
 import { createTaskCommand } from '../../tasks/task/createTask'
 import { createFsFromVolume, Volume } from 'memfs'
 import path from 'path'
-import { createBoundaryMock } from '../utils'
+import { createMockBoundary } from '../testUtils'
 import { ForgeConf } from '../../tasks/types'
 
 // Verify the task file content
@@ -59,37 +59,36 @@ describe('Create task', () => {
 
   afterEach(() => {
     jest.clearAllMocks()
+    // Reset any boundary mocks
+    createTaskCommand.resetMocks()
   })
 
   it('should create a new task file with correct content and update forge.json', async () => {
-    // Create properly typed mocks for the boundaries
-    const persistTaskMock = createBoundaryMock()
-    const persistConfMock = createBoundaryMock()
-    const getCwdMock = createBoundaryMock()
-    const persistTaskFn = persistTaskMock as unknown as jest.Mock
-    const persistConfFn = persistConfMock as unknown as jest.Mock
-    const getCwdFn = getCwdMock as unknown as jest.Mock
-
-    // Override the persistTask implementation to use our in-memory fs
-    persistTaskFn.mockImplementation(async (dir: string, fileName: string, content: string, cwd: string) => {
+    // Create mock functions with Jest
+    const persistTaskFn = jest.fn().mockImplementation(async (dir: string, fileName: string, content: string, cwd: string) => {
       const fullPath = path.join(cwd, dir, fileName)
       await (fs as { promises: { writeFile: (path: string, content: string) => Promise<void> } }).promises.writeFile(fullPath, content)
       return { path: fullPath }
     })
 
-    // Override the persistConf implementation to use our in-memory fs
-    persistConfFn.mockImplementation(async (conf: ForgeConf, cwd: string) => {
+    // Mock persistConf to use our in-memory fs
+    const persistConfFn = jest.fn().mockImplementation(async (conf: ForgeConf, cwd: string) => {
       const forgePath = path.join(cwd, 'forge.json')
       await (fs as { promises: { writeFile: (path: string, content: string) => Promise<void> } }).promises.writeFile(forgePath, JSON.stringify(conf, null, 2))
     })
 
-    // Override the getCwd implementation to return our root directory
-    getCwdFn.mockResolvedValue(rootDir)
+    // Mock getCwd to return our root directory
+    const getCwdFn = jest.fn().mockResolvedValue(rootDir)
 
-    // Override the boundaries
-    createTaskCommand.getBoundaries().persistTask = persistTaskMock
-    createTaskCommand.getBoundaries().persistConf = persistConfMock
-    createTaskCommand.getBoundaries().getCwd = getCwdMock
+    // Create boundary mocks with proper type casting
+    const persistTaskMock = createMockBoundary(persistTaskFn)
+    const persistConfMock = createMockBoundary(persistConfFn)
+    const getCwdMock = createMockBoundary(getCwdFn)
+
+    // Use the mockBoundary method to mock the boundaries
+    createTaskCommand.mockBoundary('persistTask', persistTaskMock)
+    createTaskCommand.mockBoundary('persistConf', persistConfMock)
+    createTaskCommand.mockBoundary('getCwd', getCwdMock)
 
     // Run the task
     const taskName = 'sample:new-task'

package/src/test/tasks/init.test.ts

@@ -1,7 +1,7 @@
 import { init } from '../../tasks/init'
 import { createFsFromVolume, Volume } from 'memfs'
 import path from 'path'
-import { createBoundaryMock } from '../utils'
+import { createMockBoundary } from '../testUtils'
 
 describe('Init task', () => {
   let volume: InstanceType<typeof Volume>
@@ -18,27 +18,26 @@ describe('Init task', () => {
 
   afterEach(() => {
     jest.clearAllMocks()
+    // Reset any boundary mocks after each test
+    init.resetMocks()
   })
 
   it('should create forge.json with correct content in the filesystem', async () => {
-    // Create properly typed mocks for the boundaries
-    const saveFileMock = createBoundaryMock()
-    const getCwdMock = createBoundaryMock()
-    const saveFileFn = saveFileMock as unknown as jest.Mock
-    const getCwdFn = getCwdMock as unknown as jest.Mock
-
-    // Override the saveFile implementation to use our in-memory fs
-    saveFileFn.mockImplementation(async (filePath: string, content: string) => {
+    // Create mocks directly using Jest
+    const saveFileFn = jest.fn().mockImplementation(async (filePath: string, content: string) => {
       const fullPath = path.join(rootDir, filePath)
       await (fs as { promises: { writeFile: (path: string, content: string) => Promise<void> } }).promises.writeFile(fullPath, content)
     })
 
-    // Override the getCwd implementation to return our root directory
-    getCwdFn.mockResolvedValue(rootDir)
+    const getCwdFn = jest.fn().mockResolvedValue(rootDir)
 
-    // Override the boundaries
-    init.getBoundaries().saveFile = saveFileMock
-    init.getBoundaries().getCwd = getCwdMock
+    // Create wrapped boundary mocks
+    const saveFileMock = createMockBoundary(saveFileFn)
+    const getCwdMock = createMockBoundary(getCwdFn)
+
+    // Mock the boundaries
+    init.mockBoundary('saveFile', saveFileMock)
+    init.mockBoundary('getCwd', getCwdMock)
 
     // Run the task
     await init.run({})
@@ -57,18 +56,17 @@ describe('Init task', () => {
   })
 
   it('should not create forge.json when dryRun is true', async () => {
-    // Create properly typed mocks for the boundaries
-    const saveFileMock = createBoundaryMock()
-    const getCwdMock = createBoundaryMock()
-    const saveFileFn = saveFileMock as unknown as jest.Mock
-    const getCwdFn = getCwdMock as unknown as jest.Mock
-
-    // Override the getCwd implementation to return our root directory
-    getCwdFn.mockResolvedValue(rootDir)
-
-    // Override the boundaries
-    init.getBoundaries().saveFile = saveFileMock
-    init.getBoundaries().getCwd = getCwdMock
+    // Create mocks directly using Jest
+    const saveFileFn = jest.fn()
+    const getCwdFn = jest.fn().mockResolvedValue(rootDir)
+
+    // Create wrapped boundary mocks
+    const saveFileMock = createMockBoundary(saveFileFn)
+    const getCwdMock = createMockBoundary(getCwdFn)
+
+    // Mock the boundaries
+    init.mockBoundary('saveFile', saveFileMock)
+    init.mockBoundary('getCwd', getCwdMock)
 
     // Run the task with dryRun flag
     const result = await init.run({ dryRun: true })

package/src/test/testUtils.ts

@@ -0,0 +1,28 @@
+import { type WrappedBoundaryFunction } from '@forgehive/task'
+
+/**
+ * Creates a mock boundary function that implements the WrappedBoundaryFunction interface
+ *
+ * @param mockFn Optional Jest mock function to use as the base function
+ * @returns A wrapped boundary function compatible with task.mockBoundary()
+ */
+export const createMockBoundary = (mockFn?: jest.Mock): WrappedBoundaryFunction => {
+  // Use provided mock or create a new one
+  const baseMockFn = mockFn || jest.fn().mockResolvedValue(undefined)
+
+  // Create a proper boundary function object that extends the mock function
+  const boundaryMock = Object.assign(
+    baseMockFn,
+    {
+      getTape: jest.fn().mockReturnValue([]),
+      setTape: jest.fn(),
+      getMode: jest.fn().mockReturnValue('proxy'),
+      setMode: jest.fn(),
+      startRun: jest.fn(),
+      stopRun: jest.fn(),
+      getRunData: jest.fn().mockReturnValue([])
+    }
+  ) as WrappedBoundaryFunction
+
+  return boundaryMock
+}

package/src/test/utils.ts

@@ -1,17 +0,0 @@
-import { type WrappedBoundaryFunction } from '@forgehive/task'
-
-export const createBoundaryMock = (): WrappedBoundaryFunction => {
-  const mockFn = jest.fn().mockResolvedValue(undefined)
-  const boundaryMock = mockFn as unknown as WrappedBoundaryFunction
-
-  // Add required methods to satisfy the interface
-  boundaryMock.getTape = jest.fn().mockReturnValue([])
-  boundaryMock.setTape = jest.fn()
-  boundaryMock.getMode = jest.fn().mockReturnValue('proxy')
-  boundaryMock.setMode = jest.fn()
-  boundaryMock.startRun = jest.fn()
-  boundaryMock.stopRun = jest.fn()
-  boundaryMock.getRunData = jest.fn().mockReturnValue([])
-
-  return boundaryMock
-}