extwee 2.3.2 → 2.3.4

package/test/Config/isFile.test.js

@@ -1,11 +1,14 @@
-import { isFile } from '../../src/CLI/isFile.js';
-import { statSync } from 'node:fs';
+import {jest} from '@jest/globals';
 
-// Mock the statSync function from 'fs'.
-jest.mock('node:fs', () => ({
-    statSync: jest.fn(),
+// Mock the fs module before importing anything that uses it
+const mockStatSync = jest.fn();
+jest.unstable_mockModule('node:fs', () => ({
+    statSync: mockStatSync
 }));
 
+// Now import the modules that depend on the mocked module
+const { isFile } = await import('../../src/CLI/isFile.js');
+
 describe('isFile', () => {
     afterEach(() => {
         jest.clearAllMocks();
@@ -13,36 +16,36 @@ describe('isFile', () => {
 
     it('should return true if the path is a valid file', () => {
         // Mock statSync to return an object with isFile() returning true.
-        statSync.mockReturnValue({
+        mockStatSync.mockReturnValue({
             isFile: jest.fn(() => true),
         });
 
         const result = isFile('/path/to/file');
         expect(result).toBe(true);
-        expect(statSync).toHaveBeenCalledWith('/path/to/file');
+        expect(mockStatSync).toHaveBeenCalledWith('/path/to/file');
     });
 
     it('should return false if the path is not a valid file', () => {
         // Mock statSync to return an object with isFile() returning false.
-        statSync.mockReturnValue({
+        mockStatSync.mockReturnValue({
             isFile: jest.fn(() => false),
         });
 
         const result = isFile('/path/to/directory');
         expect(result).toBe(false);
-        expect(statSync).toHaveBeenCalledWith('/path/to/directory');
+        expect(mockStatSync).toHaveBeenCalledWith('/path/to/directory');
     });
 
     it('should return false and log an error if statSync throws an error', () => {
         // Mock statSync to throw an error.
         const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-        statSync.mockImplementation(() => {
+        mockStatSync.mockImplementation(() => {
             throw new Error('File not found');
         });
 
         const result = isFile('/invalid/path');
         expect(result).toBe(false);
-        expect(statSync).toHaveBeenCalledWith('/invalid/path');
+        expect(mockStatSync).toHaveBeenCalledWith('/invalid/path');
         expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Error: Error: File not found'));
 
         consoleErrorSpy.mockRestore();

package/test/Config/loadStoryFormat.test.js

@@ -1,13 +1,29 @@
-import { loadStoryFormat } from "../../src/CLI/ProcessConfig/loadStoryFormat.js";
-import { isDirectory } from "../../src/CLI/isDirectory.js";
-import { isFile } from "../../src/CLI/isFile.js";
-import { readDirectories } from "../../src/CLI/ProcessConfig/readDirectories.js";
-import { readFileSync } from "node:fs";
+import {jest} from '@jest/globals';
 
-jest.mock("../../src/CLI/isDirectory.js");
-jest.mock("../../src/CLI/isFile.js");
-jest.mock("../../src/CLI/ProcessConfig/readDirectories.js");
-jest.mock("node:fs");
+// Mock all dependencies before importing anything that uses them
+const mockIsDirectory = jest.fn();
+const mockIsFile = jest.fn();
+const mockReadDirectories = jest.fn();
+const mockReadFileSync = jest.fn();
+
+jest.unstable_mockModule("../../src/CLI/isDirectory.js", () => ({
+    isDirectory: mockIsDirectory
+}));
+
+jest.unstable_mockModule("../../src/CLI/isFile.js", () => ({
+    isFile: mockIsFile
+}));
+
+jest.unstable_mockModule("../../src/CLI/ProcessConfig/readDirectories.js", () => ({
+    readDirectories: mockReadDirectories
+}));
+
+jest.unstable_mockModule("node:fs", () => ({
+    readFileSync: mockReadFileSync
+}));
+
+// Now import the modules that depend on the mocked modules
+const { loadStoryFormat } = await import("../../src/CLI/ProcessConfig/loadStoryFormat.js");
 
 describe("loadStoryFormat", () => {
     afterEach(() => {
@@ -15,7 +31,7 @@ describe("loadStoryFormat", () => {
     });
 
     it("should throw an error if the story-formats directory does not exist", () => {
-        isDirectory.mockReturnValueOnce(false);
+        mockIsDirectory.mockReturnValueOnce(false);
 
         expect(() => loadStoryFormat("Harlowe", "3.2.0")).toThrow(
             "Error: story-formats directory does not exist. Consider running 'npx sfa-get' to download the latest story formats."
@@ -23,7 +39,7 @@ describe("loadStoryFormat", () => {
     });
 
     it("should throw an error if the named story format directory does not exist", () => {
-        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(false);
+        mockIsDirectory.mockReturnValueOnce(true).mockReturnValueOnce(false);
 
         expect(() => loadStoryFormat("Harlowe", "3.2.0")).toThrow(
             "Error: story format Harlowe does not exist in the story-formats directory."
@@ -31,7 +47,7 @@ describe("loadStoryFormat", () => {
     });
 
     it("should throw an error if the version directory does not exist", () => {
-        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true).mockReturnValueOnce(false);
+        mockIsDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true).mockReturnValueOnce(false);
 
         expect(() => loadStoryFormat("Harlowe", "3.2.0")).toThrow(
             "Error: story format Harlowe version 3.2.0 does not exist in the story-formats directory."
@@ -39,8 +55,8 @@ describe("loadStoryFormat", () => {
     });
 
     it("should throw an error if the format.js file does not exist in the version directory", () => {
-        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true).mockReturnValueOnce(true);
-        isFile.mockReturnValueOnce(false);
+        mockIsDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true).mockReturnValueOnce(true);
+        mockIsFile.mockReturnValueOnce(false);
 
         expect(() => loadStoryFormat("Harlowe", "3.2.0")).toThrow(
             "Error: story format Harlowe version 3.2.0 does not have a format.js file."
@@ -48,29 +64,29 @@ describe("loadStoryFormat", () => {
     });
 
     it("should return the contents of the format.js file if all checks pass", () => {
-        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true).mockReturnValueOnce(true);
-        isFile.mockReturnValueOnce(true);
-        readFileSync.mockReturnValueOnce("format.js content");
+        mockIsDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true).mockReturnValueOnce(true);
+        mockIsFile.mockReturnValueOnce(true);
+        mockReadFileSync.mockReturnValueOnce("format.js content");
 
         const result = loadStoryFormat("Harlowe", "3.2.0");
         expect(result).toBe("format.js content");
     });
 
     it("should handle 'latest' version and return the contents of the format.js file", () => {
-        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
-        isFile.mockReturnValueOnce(false).mockReturnValueOnce(true);
-        readDirectories.mockReturnValueOnce(["3.2.0", "3.1.0"]);
-        readFileSync.mockReturnValueOnce("latest format.js content");
+        mockIsDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
+        mockIsFile.mockReturnValueOnce(false).mockReturnValueOnce(true);
+        mockReadDirectories.mockReturnValueOnce(["3.2.0", "3.1.0"]);
+        mockReadFileSync.mockReturnValueOnce("latest format.js content");
 
         const result = loadStoryFormat("Harlowe", "latest");
         expect(result).toBe("latest format.js content");
-        expect(readDirectories).toHaveBeenCalledWith("story-formats/Harlowe");
+        expect(mockReadDirectories).toHaveBeenCalledWith("story-formats/Harlowe");
     });
 
     it("should throw an error if 'latest' version has no format.js file", () => {
-        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
-        isFile.mockReturnValueOnce(false).mockReturnValueOnce(false);
-        readDirectories.mockReturnValueOnce(["3.2.0", "3.1.0"]);
+        mockIsDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
+        mockIsFile.mockReturnValueOnce(false).mockReturnValueOnce(false);
+        mockReadDirectories.mockReturnValueOnce(["3.2.0", "3.1.0"]);
 
         expect(() => loadStoryFormat("Harlowe", "latest")).toThrow(
             "Error: story format Harlowe version latest does not have a format.js file."
@@ -78,20 +94,20 @@ describe("loadStoryFormat", () => {
     });
 
     it("should read format.js file from the story format directory if it exists", () => {
-        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
-        isFile.mockReturnValueOnce(true);
-        readDirectories.mockReturnValueOnce([]);
-        readFileSync.mockReturnValueOnce("latest format.js content");
+        mockIsDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
+        mockIsFile.mockReturnValueOnce(true);
+        mockReadDirectories.mockReturnValueOnce([]);
+        mockReadFileSync.mockReturnValueOnce("latest format.js content");
 
         const result = loadStoryFormat("Harlowe", "latest");
         expect(result).toBe("latest format.js content");
-        expect(readFileSync).toHaveBeenCalledWith("story-formats/Harlowe/format.js", "utf-8");
+        expect(mockReadFileSync).toHaveBeenCalledWith("story-formats/Harlowe/format.js", "utf-8");
     });
 
     it("should throw an error if the story format version is not 'latest' and version directories do not exist", () => {
-        isDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
-        isFile.mockReturnValueOnce(false);
-        readDirectories.mockReturnValueOnce([]);
+        mockIsDirectory.mockReturnValueOnce(true).mockReturnValueOnce(true);
+        mockIsFile.mockReturnValueOnce(false);
+        mockReadDirectories.mockReturnValueOnce([]);
 
         expect(() => loadStoryFormat("Harlowe", "latest")).toThrow(
             `Error: story format Harlowe does not have any version directories.`

package/test/Config/readDirectories.test.js

@@ -1,9 +1,19 @@
-import { readDirectories } from '../../src/CLI/ProcessConfig/readDirectories.js';
-import { readdirSync } from 'node:fs';
-import { isDirectory } from '../../src/CLI/isDirectory.js';
+import {jest} from '@jest/globals';
 
-jest.mock('node:fs');
-jest.mock('../../src/CLI/isDirectory.js');
+// Mock the fs module and isDirectory before importing anything that uses them
+const mockReaddirSync = jest.fn();
+const mockIsDirectory = jest.fn();
+
+jest.unstable_mockModule('node:fs', () => ({
+    readdirSync: mockReaddirSync
+}));
+
+jest.unstable_mockModule('../../src/CLI/isDirectory.js', () => ({
+    isDirectory: mockIsDirectory
+}));
+
+// Now import the modules that depend on the mocked modules
+const { readDirectories } = await import('../../src/CLI/ProcessConfig/readDirectories.js');
 
 describe('readDirectories', () => {
     afterEach(() => {
@@ -12,7 +22,7 @@ describe('readDirectories', () => {
 
     it('should return an empty array and log an error if the directory does not exist', () => {
         const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-        isDirectory.mockReturnValue(false);
+        mockIsDirectory.mockReturnValue(false);
 
         const result = readDirectories('/nonexistent');
 
@@ -23,8 +33,8 @@ describe('readDirectories', () => {
 
     it('should return an empty array and log an error if readdirSync throws an error', () => {
         const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-        isDirectory.mockReturnValue(true);
-        readdirSync.mockImplementation(() => {
+        mockIsDirectory.mockReturnValue(true);
+        mockReaddirSync.mockImplementation(() => {
             throw new Error('Permission denied');
         });
 
@@ -36,8 +46,8 @@ describe('readDirectories', () => {
     });
 
     it('should return an empty array if the directory is empty', () => {
-        isDirectory.mockReturnValue(true);
-        readdirSync.mockReturnValue([]);
+        mockIsDirectory.mockReturnValue(true);
+        mockReaddirSync.mockReturnValue([]);
 
         const result = readDirectories('/empty');
 
@@ -45,10 +55,10 @@ describe('readDirectories', () => {
     });
 
     it('should return an array of directories', () => {
-        isDirectory.mockReturnValue(true);
-        readdirSync.mockReturnValue(['dir1', 'file1', 'dir2']);
+        mockIsDirectory.mockReturnValue(true);
+        mockReaddirSync.mockReturnValue(['dir1', 'file1', 'dir2']);
 
-        isDirectory.mockImplementation((path) => {
+        mockIsDirectory.mockImplementation((path) => {
             return path === '/test/dir1' || path === '/test/dir2';
         });
 
@@ -58,8 +68,8 @@ describe('readDirectories', () => {
     });
     
     it('should return an empty array if the result is not an array', () => {
-        isDirectory.mockReturnValue(true);
-        readdirSync.mockReturnValue('not an array');
+        mockIsDirectory.mockReturnValue(true);
+        mockReaddirSync.mockReturnValue('not an array');
 
         const result = readDirectories('/test');
 

package/test/Objects/Story.test.js

@@ -1,3 +1,4 @@
+import {jest} from '@jest/globals';
 import { Story, creatorName, creatorVersion } from '../../src/Story.js';
 import Passage from '../../src/Passage.js';
 import { parse as parseTwee } from '../../src/Twee/parse.js';

package/test/StoryFormat/StoryFormat.Parse.test.js

@@ -1,3 +1,4 @@
+import {jest} from '@jest/globals';
 import { parse as parseStoryFormat } from '../../src/StoryFormat/parse.js';
 
 describe('StoryFormat', () => {