@mdfriday/foundry/dist/internal/domain/fs/tests/vo-overlayfs-factory.test.js

The core engine of MDFriday. Convert Markdown and shortcodes into fully themed static sites – Hugo-style, powered by TypeScript.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const overlayfs_factory_1 = require("../vo/overlayfs-factory");
// Mock dependencies
jest.mock('../entity/overlayfs', () => ({
    newOverlayFs: jest.fn().mockImplementation((options) => ({
        name: jest.fn().mockReturnValue('MockOverlayFs'),
        options,
        fss: options.fss,
    })),
    createOverlayFs: jest.fn().mockImplementation((options) => ({
        name: jest.fn().mockReturnValue('MockOverlayFs'),
        options,
        fss: options.fss,
    })),
}));
jest.mock('../vo/overlayoptions', () => ({
    createDefaultOverlayOptions: jest.fn().mockImplementation((fss) => ({
        fss: fss || [],
        firstWritable: false,
        dirsMerger: jest.fn(),
        withDirsMerger: jest.fn().mockImplementation((merger) => ({
            fss: fss || [],
            firstWritable: false,
            dirsMerger: merger,
        })),
    })),
    createWritableOverlayOptions: jest.fn().mockImplementation((fss) => ({
        fss: fss || [],
        firstWritable: true,
        dirsMerger: jest.fn(),
    })),
}));
describe('OverlayFs Factory Value Object', () => {
    let mockFs1;
    let mockFs2;
    let mockFs3;
    let factory;
    beforeEach(() => {
        mockFs1 = {
            name: jest.fn().mockReturnValue('MockFs1'),
            create: jest.fn(),
            mkdir: jest.fn(),
            mkdirAll: jest.fn(),
            open: jest.fn(),
            openFile: jest.fn(),
            remove: jest.fn(),
            removeAll: jest.fn(),
            rename: jest.fn(),
            stat: jest.fn(),
            chmod: jest.fn(),
            chown: jest.fn(),
            chtimes: jest.fn(),
        };
        mockFs2 = {
            name: jest.fn().mockReturnValue('MockFs2'),
            create: jest.fn(),
            mkdir: jest.fn(),
            mkdirAll: jest.fn(),
            open: jest.fn(),
            openFile: jest.fn(),
            remove: jest.fn(),
            removeAll: jest.fn(),
            rename: jest.fn(),
            stat: jest.fn(),
            chmod: jest.fn(),
            chown: jest.fn(),
            chtimes: jest.fn(),
        };
        mockFs3 = {
            name: jest.fn().mockReturnValue('MockFs3'),
            create: jest.fn(),
            mkdir: jest.fn(),
            mkdirAll: jest.fn(),
            open: jest.fn(),
            openFile: jest.fn(),
            remove: jest.fn(),
            removeAll: jest.fn(),
            rename: jest.fn(),
            stat: jest.fn(),
            chmod: jest.fn(),
            chown: jest.fn(),
            chtimes: jest.fn(),
        };
        factory = new overlayfs_factory_1.Factory();
    });
    afterEach(() => {
        jest.clearAllMocks();
    });
    describe('Factory class', () => {
        describe('create', () => {
            it('should create overlay filesystem with default options', () => {
                const fss = [mockFs1, mockFs2];
                const result = factory.create(fss);
                expect(result).toBeDefined();
                expect(result.name()).toBe('MockOverlayFs');
                expect(result.fss).toEqual(fss);
            });
            it('should handle empty filesystem array', () => {
                const result = factory.create([]);
                expect(result).toBeDefined();
                expect(result.fss).toEqual([]);
            });
            it('should handle single filesystem', () => {
                const fss = [mockFs1];
                const result = factory.create(fss);
                expect(result).toBeDefined();
                expect(result.fss).toEqual(fss);
            });
            it('should call createDefaultOverlayOptions with filesystems', () => {
                const createDefaultOverlayOptions = require('../vo/overlayoptions').createDefaultOverlayOptions;
                const fss = [mockFs1, mockFs2];
                factory.create(fss);
                expect(createDefaultOverlayOptions).toHaveBeenCalledWith(fss);
            });
        });
        describe('createWithOptions', () => {
            it('should create overlay filesystem with custom options', () => {
                const customOptions = {
                    fss: [mockFs1, mockFs2],
                    firstWritable: true,
                    dirsMerger: jest.fn(),
                };
                const result = factory.createWithOptions(customOptions);
                expect(result).toBeDefined();
                expect(result.name()).toBe('MockOverlayFs');
            });
            it('should call createOverlayFs with provided options', () => {
                const createOverlayFs = require('../entity/overlayfs').createOverlayFs;
                const customOptions = {
                    fss: [mockFs1],
                    firstWritable: false,
                    dirsMerger: jest.fn(),
                };
                factory.createWithOptions(customOptions);
                expect(createOverlayFs).toHaveBeenCalledWith(customOptions);
            });
            it('should handle options with custom directory merger', () => {
                const customMerger = (lofi, bofi) => [...lofi, ...bofi];
                const customOptions = {
                    fss: [mockFs1],
                    firstWritable: true,
                    dirsMerger: customMerger,
                };
                const result = factory.createWithOptions(customOptions);
                expect(result).toBeDefined();
            });
        });
        describe('createReadOnly', () => {
            it('should create read-only overlay filesystem', () => {
                const fss = [mockFs1, mockFs2];
                const result = factory.createReadOnly(fss);
                expect(result).toBeDefined();
                expect(result.name()).toBe('MockOverlayFs');
                expect(result.fss).toEqual(fss);
            });
            it('should use default options for read-only filesystem', () => {
                const createDefaultOverlayOptions = require('../vo/overlayoptions').createDefaultOverlayOptions;
                const fss = [mockFs1];
                factory.createReadOnly(fss);
                expect(createDefaultOverlayOptions).toHaveBeenCalledWith(fss);
            });
            it('should handle multiple filesystems for read-only', () => {
                const fss = [mockFs1, mockFs2, mockFs3];
                const result = factory.createReadOnly(fss);
                expect(result).toBeDefined();
                expect(result.fss).toEqual(fss);
            });
        });
        describe('createWritable', () => {
            it('should create writable overlay filesystem', () => {
                const fss = [mockFs1, mockFs2];
                const result = factory.createWritable(fss);
                expect(result).toBeDefined();
                expect(result.name()).toBe('MockOverlayFs');
                expect(result.fss).toEqual(fss);
            });
            it('should use writable options', () => {
                const createWritableOverlayOptions = require('../vo/overlayoptions').createWritableOverlayOptions;
                const fss = [mockFs1, mockFs2];
                factory.createWritable(fss);
                expect(createWritableOverlayOptions).toHaveBeenCalledWith(fss);
            });
            it('should handle single writable filesystem', () => {
                const fss = [mockFs1];
                const result = factory.createWritable(fss);
                expect(result).toBeDefined();
                expect(result.fss).toEqual(fss);
            });
        });
        describe('createWithMerger', () => {
            it('should create overlay filesystem with custom merger', () => {
                const customMerger = (lofi, bofi) => [...bofi, ...lofi];
                const fss = [mockFs1, mockFs2];
                const result = factory.createWithMerger(fss, customMerger);
                expect(result).toBeDefined();
                expect(result.name()).toBe('MockOverlayFs');
            });
            it('should call withDirsMerger on default options', () => {
                const customMerger = jest.fn();
                const fss = [mockFs1];
                const mockOptions = {
                    fss,
                    firstWritable: false,
                    dirsMerger: jest.fn(),
                    withDirsMerger: jest.fn().mockReturnValue({
                        fss,
                        firstWritable: false,
                        dirsMerger: customMerger,
                    }),
                };
                const createDefaultOverlayOptions = require('../vo/overlayoptions').createDefaultOverlayOptions;
                createDefaultOverlayOptions.mockReturnValue(mockOptions);
                factory.createWithMerger(fss, customMerger);
                expect(mockOptions.withDirsMerger).toHaveBeenCalledWith(customMerger);
            });
            it('should handle empty merger function', () => {
                const emptyMerger = () => [];
                const fss = [mockFs1];
                const result = factory.createWithMerger(fss, emptyMerger);
                expect(result).toBeDefined();
            });
        });
    });
    describe('newOverlayFsFactory', () => {
        it('should create new factory instance', () => {
            const factory1 = (0, overlayfs_factory_1.newOverlayFsFactory)();
            const factory2 = (0, overlayfs_factory_1.newOverlayFsFactory)();
            expect(factory1).toBeInstanceOf(overlayfs_factory_1.Factory);
            expect(factory2).toBeInstanceOf(overlayfs_factory_1.Factory);
            expect(factory1).not.toBe(factory2);
        });
        it('should return factory with all methods', () => {
            const factory = (0, overlayfs_factory_1.newOverlayFsFactory)();
            expect(factory.create).toBeDefined();
            expect(factory.createWithOptions).toBeDefined();
            expect(factory.createReadOnly).toBeDefined();
            expect(factory.createWritable).toBeDefined();
            expect(factory.createWithMerger).toBeDefined();
        });
    });
    describe('createOverlayFileSystem', () => {
        it('should create overlay filesystem with default settings', () => {
            const fss = [mockFs1, mockFs2];
            const result = (0, overlayfs_factory_1.createOverlayFileSystem)(fss);
            expect(result).toBeDefined();
            expect(result.name()).toBe('MockOverlayFs');
        });
        it('should create overlay filesystem without options', () => {
            const fss = [mockFs1];
            const result = (0, overlayfs_factory_1.createOverlayFileSystem)(fss);
            expect(result).toBeDefined();
        });
        it('should create overlay filesystem with firstWritable option', () => {
            const fss = [mockFs1, mockFs2];
            const options = { firstWritable: true };
            const result = (0, overlayfs_factory_1.createOverlayFileSystem)(fss, options);
            expect(result).toBeDefined();
        });
        it('should create overlay filesystem with custom directory merger', () => {
            const customMerger = (lofi, bofi) => [...lofi, ...bofi];
            const fss = [mockFs1];
            const options = { dirsMerger: customMerger };
            const result = (0, overlayfs_factory_1.createOverlayFileSystem)(fss, options);
            expect(result).toBeDefined();
        });
        it('should create overlay filesystem with both options', () => {
            const customMerger = jest.fn();
            const fss = [mockFs1, mockFs2];
            const options = {
                firstWritable: true,
                dirsMerger: customMerger
            };
            const result = (0, overlayfs_factory_1.createOverlayFileSystem)(fss, options);
            expect(result).toBeDefined();
        });
        it('should handle empty options object', () => {
            const fss = [mockFs1];
            const result = (0, overlayfs_factory_1.createOverlayFileSystem)(fss, {});
            expect(result).toBeDefined();
        });
        it('should handle undefined firstWritable option', () => {
            const fss = [mockFs1];
            const options = {};
            const result = (0, overlayfs_factory_1.createOverlayFileSystem)(fss, options);
            expect(result).toBeDefined();
        });
    });
    describe('createReadOnlyOverlayFs', () => {
        it('should create read-only overlay filesystem', () => {
            const fss = [mockFs1, mockFs2];
            const result = (0, overlayfs_factory_1.createReadOnlyOverlayFs)(fss);
            expect(result).toBeDefined();
            expect(result.name()).toBe('MockOverlayFs');
        });
        it('should handle empty filesystem array', () => {
            const result = (0, overlayfs_factory_1.createReadOnlyOverlayFs)([]);
            expect(result).toBeDefined();
        });
        it('should handle single filesystem', () => {
            const fss = [mockFs1];
            const result = (0, overlayfs_factory_1.createReadOnlyOverlayFs)(fss);
            expect(result).toBeDefined();
        });
        it('should create new factory instance internally', () => {
            const fss = [mockFs1];
            const result = (0, overlayfs_factory_1.createReadOnlyOverlayFs)(fss);
            expect(result).toBeDefined();
        });
    });
    describe('createWritableOverlayFs', () => {
        it('should create writable overlay filesystem', () => {
            const fss = [mockFs1, mockFs2];
            const result = (0, overlayfs_factory_1.createWritableOverlayFs)(fss);
            expect(result).toBeDefined();
            expect(result.name()).toBe('MockOverlayFs');
        });
        it('should handle single writable filesystem', () => {
            const fss = [mockFs1];
            const result = (0, overlayfs_factory_1.createWritableOverlayFs)(fss);
            expect(result).toBeDefined();
        });
        it('should handle multiple filesystems for writable', () => {
            const fss = [mockFs1, mockFs2, mockFs3];
            const result = (0, overlayfs_factory_1.createWritableOverlayFs)(fss);
            expect(result).toBeDefined();
        });
        it('should create new factory instance internally', () => {
            const fss = [mockFs1];
            const result = (0, overlayfs_factory_1.createWritableOverlayFs)(fss);
            expect(result).toBeDefined();
        });
    });
    describe('integration tests', () => {
        it('should create different types of overlay filesystems', () => {
            const fss = [mockFs1, mockFs2];
            const readOnly = factory.createReadOnly(fss);
            const writable = factory.createWritable(fss);
            const withMerger = factory.createWithMerger(fss, jest.fn());
            expect(readOnly).toBeDefined();
            expect(writable).toBeDefined();
            expect(withMerger).toBeDefined();
        });
        it('should work with convenience functions', () => {
            const fss = [mockFs1, mockFs2];
            const readOnly = (0, overlayfs_factory_1.createReadOnlyOverlayFs)(fss);
            const writable = (0, overlayfs_factory_1.createWritableOverlayFs)(fss);
            const custom = (0, overlayfs_factory_1.createOverlayFileSystem)(fss, { firstWritable: true });
            expect(readOnly).toBeDefined();
            expect(writable).toBeDefined();
            expect(custom).toBeDefined();
        });
        it('should handle complex directory merger scenarios', () => {
            const complexMerger = (lofi, bofi) => {
                const result = [...lofi];
                for (const boFile of bofi) {
                    if (!lofi.some(loFile => loFile.name() === boFile.name())) {
                        result.push(boFile);
                    }
                }
                return result.sort((a, b) => a.name().localeCompare(b.name()));
            };
            const fss = [mockFs1, mockFs2, mockFs3];
            const result = factory.createWithMerger(fss, complexMerger);
            expect(result).toBeDefined();
        });
    });
    describe('error handling', () => {
        it('should handle null filesystem arrays', () => {
            expect(() => factory.create(null)).not.toThrow();
        });
        it('should handle undefined filesystem arrays', () => {
            expect(() => factory.create(undefined)).not.toThrow();
        });
        it('should handle null options in createWithOptions', () => {
            // NOTE: Current implementation throws error when options is null
            // This is a known limitation - null options are not properly handled
            expect(() => factory.createWithOptions(null)).toThrow();
        });
        it('should handle invalid merger functions', () => {
            const invalidMerger = null;
            expect(() => factory.createWithMerger([mockFs1], invalidMerger)).not.toThrow();
        });
        it('should handle createOverlayFileSystem with null filesystems', () => {
            expect(() => (0, overlayfs_factory_1.createOverlayFileSystem)(null)).not.toThrow();
        });
        it('should handle createOverlayFileSystem with invalid options', () => {
            const fss = [mockFs1];
            const invalidOptions = { firstWritable: 'invalid' };
            expect(() => (0, overlayfs_factory_1.createOverlayFileSystem)(fss, invalidOptions)).not.toThrow();
        });
    });
    describe('performance and memory', () => {
        it('should not create unnecessary objects', () => {
            const fss = [mockFs1];
            const result1 = factory.create(fss);
            const result2 = factory.create(fss);
            expect(result1).toBeDefined();
            expect(result2).toBeDefined();
            // Results should be different instances
            expect(result1).not.toBe(result2);
        });
        it('should handle large filesystem arrays', () => {
            const largeFss = Array(100).fill(null).map((_, i) => ({
                name: jest.fn().mockReturnValue(`MockFs${i}`),
                create: jest.fn(),
                mkdir: jest.fn(),
                mkdirAll: jest.fn(),
                open: jest.fn(),
                openFile: jest.fn(),
                remove: jest.fn(),
                removeAll: jest.fn(),
                rename: jest.fn(),
                stat: jest.fn(),
                chmod: jest.fn(),
                chown: jest.fn(),
                chtimes: jest.fn(),
            }));
            expect(() => factory.create(largeFss)).not.toThrow();
        });
        it('should handle multiple factory instances', () => {
            const factories = Array(10).fill(null).map(() => (0, overlayfs_factory_1.newOverlayFsFactory)());
            factories.forEach(factory => {
                const result = factory.create([mockFs1]);
                expect(result).toBeDefined();
            });
        });
    });
});
//# sourceMappingURL=vo-overlayfs-factory.test.js.map