@fgv/ts-web-extras 5.1.0-0 → 5.1.0-10

package/dist/test/unit/fileSystemAccessTreeAccessors.test.js

@@ -20,6 +20,7 @@
  * SOFTWARE.
  */
 import '@fgv/ts-utils-jest';
+import { fail } from '@fgv/ts-utils';
 import { FileSystemAccessTreeAccessors } from '../../packlets/file-tree';
 import { FileApiTreeAccessors } from '../../packlets/file-tree';
 import { FileTree } from '@fgv/ts-json-base';
@@ -331,186 +332,290 @@ describe('FileSystemAccessTreeAccessors', () => {
                 })).orThrow();
                 accessors.saveFileContents('/test.txt', 'modified').orThrow();
                 // Verify file is marked dirty but not synced
-                expect(accessors.isDirty()).toBe(true);
                 expect(accessors.getDirtyPaths()).toContain('/test.txt');
                 // In-memory content should be modified
                 expect(accessors.getFileContents('/test.txt')).toSucceedWith('modified');
             });
-        });
-    });
-    describe('fileIsMutable', () => {
-        test('returns persistent detail when write permission granted', async () => {
-            const dirHandle = createMockDirectoryHandle('/', {
-                'test.txt': { content: 'test', type: 'text/plain' }
-            });
-            const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
-            const result = accessors.fileIsMutable('/test.txt');
-            expect(result).toSucceedWithDetail(true, 'persistent');
-        });
-        test('returns transient detail when write permission not granted', async () => {
-            const dirHandle = createMockDirectoryHandle('/', { 'test.txt': { content: 'test', type: 'text/plain' } }, { hasWritePermission: false });
-            const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
-                mutable: true,
-                requireWritePermission: false
-            })).orThrow();
-            const result = accessors.fileIsMutable('/test.txt');
-            expect(result).toSucceedWithDetail(true, 'transient');
-        });
-        test('returns not-mutable when mutability disabled', async () => {
-            const dirHandle = createMockDirectoryHandle('/', {
-                'test.txt': { content: 'test', type: 'text/plain' }
+            test('logs when save auto-sync returns a failure Result', async () => {
+                const logger = {
+                    detail: jest.fn(),
+                    info: jest.fn(),
+                    warn: jest.fn(),
+                    error: jest.fn()
+                };
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'test.txt': { content: 'original', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
+                    mutable: true,
+                    autoSync: true,
+                    logger
+                })).orThrow();
+                accessors._syncFile = async () => fail('simulated save sync failure');
+                accessors.saveFileContents('/test.txt', 'modified').orThrow();
+                await new Promise((resolve) => setTimeout(resolve, 0));
+                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('simulated save sync failure'));
+            });
+            test('logs when delete auto-sync throws unexpectedly', async () => {
+                const logger = {
+                    detail: jest.fn(),
+                    info: jest.fn(),
+                    warn: jest.fn(),
+                    error: jest.fn()
+                };
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'test.txt': { content: 'original', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
+                    mutable: true,
+                    autoSync: true,
+                    logger
+                })).orThrow();
+                accessors._deleteFileFromDisk = async () => {
+                    throw new Error('simulated delete throw');
+                };
+                accessors.deleteFile('/test.txt').orThrow();
+                await new Promise((resolve) => setTimeout(resolve, 0));
+                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('simulated delete throw'));
             });
-            const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: false })).orThrow();
-            const result = accessors.fileIsMutable('/test.txt');
-            expect(result).toFailWithDetail(/mutability is disabled/i, 'not-mutable');
         });
-    });
-    describe('integration with FileApiTreeAccessors', () => {
-        test('createPersistent creates FileTree with persistent accessors', async () => {
-            const dirHandle = createMockDirectoryHandle('/', {
-                'test.txt': { content: 'test content', type: 'text/plain' }
+        describe('fileIsMutable', () => {
+            test('returns persistent detail when write permission granted', async () => {
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'test.txt': { content: 'test', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
+                const result = accessors.fileIsMutable('/test.txt');
+                expect(result).toSucceedWithDetail(true, 'persistent');
             });
-            const result = await FileApiTreeAccessors.createPersistent(dirHandle, { mutable: true });
-            expect(result).toSucceed();
-            const tree = result.orThrow();
-            expect(tree).toBeInstanceOf(FileTree.FileTree);
-            expect(FileTree.isPersistentAccessors(tree.hal)).toBe(true);
-            const file = tree.getFile('/test.txt').orThrow();
-            expect(file.getIsMutable()).toSucceedWithDetail(true, 'persistent');
-        });
-        test('createPersistent with autoSync option', async () => {
-            const dirHandle = createMockDirectoryHandle('/', {
-                'test.txt': { content: 'original', type: 'text/plain' }
+            test('returns transient detail when write permission not granted', async () => {
+                const dirHandle = createMockDirectoryHandle('/', { 'test.txt': { content: 'test', type: 'text/plain' } }, { hasWritePermission: false });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
+                    mutable: true,
+                    requireWritePermission: false
+                })).orThrow();
+                const result = accessors.fileIsMutable('/test.txt');
+                expect(result).toSucceedWithDetail(true, 'transient');
             });
-            const result = await FileApiTreeAccessors.createPersistent(dirHandle, {
-                mutable: true,
-                autoSync: true
+            test('returns not-mutable when mutability disabled', async () => {
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'test.txt': { content: 'test', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: false })).orThrow();
+                const result = accessors.fileIsMutable('/test.txt');
+                expect(result).toFailWithDetail(/mutability is disabled/i, 'not-mutable');
             });
-            expect(result).toSucceedAndSatisfy((tree) => {
+        });
+        describe('integration with FileApiTreeAccessors', () => {
+            test('createPersistent creates FileTree with persistent accessors', async () => {
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'test.txt': { content: 'test content', type: 'text/plain' }
+                });
+                const result = await FileApiTreeAccessors.createPersistent(dirHandle, { mutable: true });
+                expect(result).toSucceed();
+                const tree = result.orThrow();
                 expect(tree).toBeInstanceOf(FileTree.FileTree);
+                expect(FileTree.isPersistentAccessors(tree.hal)).toBe(true);
+                const file = tree.getFile('/test.txt').orThrow();
+                expect(FileTree.isMutableFileItem(file)).toBe(true);
+                if (FileTree.isMutableFileItem(file)) {
+                    expect(file.getIsMutable()).toSucceedWithDetail(true, 'persistent');
+                }
             });
-            const tree = result.orThrow();
-            const file = tree.getFile('/test.txt').orThrow();
-            file.setRawContents('modified').orThrow();
-            // Give auto-sync time to complete
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            // Verify file was written
-            const fileHandle = await dirHandle.getFileHandle('test.txt');
-            const diskFile = await fileHandle.getFile();
-            const content = await diskFile.text();
-            expect(content).toBe('modified');
-        });
-        test('createPersistent fails with appropriate error', async () => {
-            const dirHandle = createMockDirectoryHandle('/', { 'test.txt': { content: 'test', type: 'text/plain' } }, { hasWritePermission: false });
-            const result = await FileApiTreeAccessors.createPersistent(dirHandle, {
-                requireWritePermission: true
+            test('createPersistent with autoSync option', async () => {
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'test.txt': { content: 'original', type: 'text/plain' }
+                });
+                const result = await FileApiTreeAccessors.createPersistent(dirHandle, {
+                    mutable: true,
+                    autoSync: true
+                });
+                expect(result).toSucceedAndSatisfy((tree) => {
+                    expect(tree).toBeInstanceOf(FileTree.FileTree);
+                });
+                const tree = result.orThrow();
+                const file = tree.getFile('/test.txt').orThrow();
+                expect(FileTree.isMutableFileItem(file)).toBe(true);
+                if (FileTree.isMutableFileItem(file)) {
+                    file.setRawContents('modified').orThrow();
+                }
+                // Give auto-sync time to complete
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                // Verify file was written
+                const fileHandle = await dirHandle.getFileHandle('test.txt');
+                const diskFile = await fileHandle.getFile();
+                const content = await diskFile.text();
+                expect(content).toBe('modified');
             });
-            expect(result).toFailWith(/write permission required/i);
-        });
-    });
-    describe('error handling', () => {
-        test('handles permission query errors gracefully', async () => {
-            const dirHandle = createMockDirectoryHandle('/', { 'test.txt': { content: 'test', type: 'text/plain' } }, { permissionError: true });
-            const result = await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
-                requireWritePermission: false
+            test('createPersistent fails with appropriate error', async () => {
+                const dirHandle = createMockDirectoryHandle('/', { 'test.txt': { content: 'test', type: 'text/plain' } }, { hasWritePermission: false });
+                const result = await FileApiTreeAccessors.createPersistent(dirHandle, {
+                    requireWritePermission: true
+                });
+                expect(result).toFailWith(/write permission required/i);
             });
-            // Should succeed but without write permission due to error
-            expect(result).toSucceed();
         });
-        test('handles permission status "prompt" by requesting permission', async () => {
-            const dirHandle = createMockDirectoryHandle('/', { 'test.txt': { content: 'test', type: 'text/plain' } }, { permissionStatus: 'prompt', requestGranted: true });
-            const result = await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
-                requireWritePermission: true
+        describe('error handling', () => {
+            test('handles permission query errors gracefully', async () => {
+                const dirHandle = createMockDirectoryHandle('/', { 'test.txt': { content: 'test', type: 'text/plain' } }, { permissionError: true });
+                const result = await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
+                    requireWritePermission: false
+                });
+                // Should succeed but without write permission due to error
+                expect(result).toSucceed();
             });
-            expect(result).toSucceedAndSatisfy((accessors) => {
-                expect(accessors).toBeInstanceOf(FileSystemAccessTreeAccessors);
+            test('handles permission status "prompt" by requesting permission', async () => {
+                const dirHandle = createMockDirectoryHandle('/', { 'test.txt': { content: 'test', type: 'text/plain' } }, { permissionStatus: 'prompt', requestGranted: true });
+                const result = await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, {
+                    requireWritePermission: true
+                });
+                expect(result).toSucceedAndSatisfy((accessors) => {
+                    expect(accessors).toBeInstanceOf(FileSystemAccessTreeAccessors);
+                });
             });
-        });
-        test('handles sync failures with aggregated errors', async () => {
-            const dirHandle = createMockDirectoryHandle('/', {
-                'file1.txt': { content: 'content1', type: 'text/plain' },
-                'file2.txt': { content: 'content2', type: 'text/plain' }
-            });
-            const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
-            // Modify files
-            accessors.saveFileContents('/file1.txt', 'modified1').orThrow();
-            accessors.saveFileContents('/file2.txt', 'modified2').orThrow();
-            // Replace the file handles with ones that fail to write
-            const handles = accessors._handles;
-            for (const [, handle] of handles) {
-                handle.createWritable = jest.fn().mockRejectedValue(new Error('Write permission denied'));
-            }
-            const syncResult = await accessors.syncToDisk();
-            expect(syncResult).toFailWith(/Failed to sync 2 file\(s\)/i);
-        });
-        test('handles getFileContents failure during sync', async () => {
-            const dirHandle = createMockDirectoryHandle('/', {
-                'test.txt': { content: 'original', type: 'text/plain' }
-            });
-            const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
-            // Add a new file
-            accessors.saveFileContents('/newfile.txt', 'new content').orThrow();
-            // Override getFileContents to fail
-            const originalGetFileContents = accessors.getFileContents.bind(accessors);
-            accessors.getFileContents = jest.fn((path) => {
-                if (path === '/newfile.txt') {
-                    return { isSuccess: () => false, isFailure: () => true, message: 'File read error' };
+            test('handles sync failures with aggregated errors', async () => {
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'file1.txt': { content: 'content1', type: 'text/plain' },
+                    'file2.txt': { content: 'content2', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
+                // Modify files
+                accessors.saveFileContents('/file1.txt', 'modified1').orThrow();
+                accessors.saveFileContents('/file2.txt', 'modified2').orThrow();
+                // Replace the file handles with ones that fail to write
+                const handles = accessors._handles;
+                for (const [, handle] of handles) {
+                    handle.createWritable = jest.fn().mockRejectedValue(new Error('Write permission denied'));
                 }
-                return originalGetFileContents(path);
+                const syncResult = await accessors.syncToDisk();
+                expect(syncResult).toFailWith(/Failed to sync 2 file\(s\)/i);
             });
-            const syncResult = await accessors.syncToDisk();
-            expect(syncResult).toFailWith(/File read error/i);
-        });
-        test('handles file write failure during sync', async () => {
-            const dirHandle = createMockDirectoryHandle('/', {
-                'test.txt': { content: 'original', type: 'text/plain' }
-            });
-            const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
-            accessors.saveFileContents('/test.txt', 'modified').orThrow();
-            // Replace the handle with one that fails to write
-            const handles = accessors._handles;
-            const handle = handles.get('/test.txt');
-            handle.createWritable = jest.fn().mockRejectedValue(new Error('Disk full'));
-            const syncResult = await accessors.syncToDisk();
-            expect(syncResult).toFailWith(/Failed to write file.*Disk full/i);
-        });
-        test('handles invalid file path with no filename', async () => {
-            const dirHandle = createMockDirectoryHandle('/', {
-                'existing.txt': { content: 'existing', type: 'text/plain' }
-            });
-            const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
-            // Override resolveAbsolutePath to return an empty path to trigger the error
-            const originalResolveAbsolutePath = accessors.resolveAbsolutePath.bind(accessors);
-            accessors.resolveAbsolutePath = jest.fn((path) => {
-                if (path === '/badpath') {
-                    return ''; // This will result in no parts after split
+            test('handles getFileContents failure during sync', async () => {
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'test.txt': { content: 'original', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
+                // Add a new file
+                accessors.saveFileContents('/newfile.txt', 'new content').orThrow();
+                // Override getFileContents to fail
+                const originalGetFileContents = accessors.getFileContents.bind(accessors);
+                accessors.getFileContents = jest.fn((path) => {
+                    if (path === '/newfile.txt') {
+                        return { isSuccess: () => false, isFailure: () => true, message: 'File read error' };
+                    }
+                    return originalGetFileContents(path);
+                });
+                const syncResult = await accessors.syncToDisk();
+                expect(syncResult).toFailWith(/File read error/i);
+            });
+            test('handles file write failure during sync', async () => {
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'test.txt': { content: 'original', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
+                accessors.saveFileContents('/test.txt', 'modified').orThrow();
+                // Replace the handle with one that fails to write
+                const handles = accessors._handles;
+                const handle = handles.get('/test.txt');
+                handle.createWritable = jest.fn().mockRejectedValue(new Error('Disk full'));
+                const syncResult = await accessors.syncToDisk();
+                expect(syncResult).toFailWith(/Failed to write file.*Disk full/i);
+            });
+            test('handles invalid file path with no filename', async () => {
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'existing.txt': { content: 'existing', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
+                // Override resolveAbsolutePath to return an empty path to trigger the error
+                const originalResolveAbsolutePath = accessors.resolveAbsolutePath.bind(accessors);
+                accessors.resolveAbsolutePath = jest.fn((path) => {
+                    if (path === '/badpath') {
+                        return ''; // This will result in no parts after split
+                    }
+                    return originalResolveAbsolutePath(path);
+                });
+                // Create a new file with the bad path - don't throw if it fails
+                const saveResult = accessors.saveFileContents('/badpath', 'content');
+                if (saveResult.isFailure()) {
+                    // saveFileContents itself might reject the path
+                    expect(saveResult).toFailWith(/invalid file path/i);
+                }
+                else {
+                    // If save succeeded, sync should fail
+                    const syncResult = await accessors.syncToDisk();
+                    expect(syncResult).toFailWith(/Invalid file path/i);
                 }
-                return originalResolveAbsolutePath(path);
-            });
-            // Create a new file with the bad path - don't throw if it fails
-            const saveResult = accessors.saveFileContents('/badpath', 'content');
-            if (saveResult.isFailure()) {
-                // saveFileContents itself might reject the path
-                expect(saveResult).toFailWith(/invalid file path/i);
-            }
-            else {
-                // If save succeeded, sync should fail
+            });
+            test('handles file creation failure in _createAndWriteFile', async () => {
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'existing.txt': { content: 'existing', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
+                // Add a new file that will need to be created
+                accessors.saveFileContents('/newdir/newfile.txt', 'new content').orThrow();
+                // Mock getDirectoryHandle to fail
+                const rootDir = accessors._rootDir;
+                rootDir.getDirectoryHandle = jest.fn().mockRejectedValue(new Error('Permission denied'));
                 const syncResult = await accessors.syncToDisk();
-                expect(syncResult).toFailWith(/Invalid file path/i);
-            }
-        });
-        test('handles file creation failure in _createAndWriteFile', async () => {
-            const dirHandle = createMockDirectoryHandle('/', {
-                'existing.txt': { content: 'existing', type: 'text/plain' }
-            });
-            const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
-            // Add a new file that will need to be created
-            accessors.saveFileContents('/newdir/newfile.txt', 'new content').orThrow();
-            // Mock getDirectoryHandle to fail
-            const rootDir = accessors._rootDir;
-            rootDir.getDirectoryHandle = jest.fn().mockRejectedValue(new Error('Permission denied'));
-            const syncResult = await accessors.syncToDisk();
-            expect(syncResult).toFailWith(/Failed to create file.*Permission denied/i);
+                expect(syncResult).toFailWith(/Failed to create file.*Permission denied/i);
+            });
+            test('successfully deletes a root-level file from disk via syncToDisk pending deletions', async () => {
+                // Covers lines 329-333: the pending deletions loop in syncToDisk
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'toDelete.txt': { content: 'will be deleted', type: 'text/plain' },
+                    'keep.txt': { content: 'stays', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
+                // Delete the file from in-memory tree
+                accessors.deleteFile('/toDelete.txt').orThrow();
+                expect(accessors.isDirty()).toBe(true);
+                expect(accessors.getDirtyPaths()).toContain('/toDelete.txt');
+                // syncToDisk should process the pending deletion
+                const syncResult = await accessors.syncToDisk();
+                expect(syncResult).toSucceed();
+                expect(accessors.isDirty()).toBe(false);
+            });
+            test('successfully deletes a nested file from disk via syncToDisk (navigates parent dirs)', async () => {
+                // Covers lines 468-469: getDirectoryHandle navigation loop in _deleteFileFromDisk
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'src/utils/helper.txt': { content: 'to be deleted', type: 'text/plain' },
+                    'src/index.txt': { content: 'stays', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
+                // Delete the nested file
+                accessors.deleteFile('/src/utils/helper.txt').orThrow();
+                expect(accessors.isDirty()).toBe(true);
+                const syncResult = await accessors.syncToDisk();
+                expect(syncResult).toSucceed();
+                expect(accessors.isDirty()).toBe(false);
+            });
+            test('aggregates deletion errors when _deleteFileFromDisk fails during syncToDisk', async () => {
+                // Covers lines 330-332: the error aggregation when _deleteFileFromDisk returns failure
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'toDelete.txt': { content: 'content', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
+                accessors.deleteFile('/toDelete.txt').orThrow();
+                // Make removeEntry fail to trigger the error path in _deleteFileFromDisk
+                const rootDir = accessors._rootDir;
+                rootDir.removeEntry = jest.fn().mockRejectedValue(new Error('Cannot delete: file locked'));
+                const syncResult = await accessors.syncToDisk();
+                expect(syncResult).toFailWith(/Failed to sync 1 file/i);
+                expect(syncResult).toFailWith(/delete.*toDelete\.txt/i);
+            });
+            test('catch block in _deleteFileFromDisk when removeEntry throws', async () => {
+                // Covers lines 473-476: the catch block in _deleteFileFromDisk
+                const dirHandle = createMockDirectoryHandle('/', {
+                    'target.txt': { content: 'content', type: 'text/plain' }
+                });
+                const accessors = (await FileSystemAccessTreeAccessors.fromDirectoryHandle(dirHandle, { mutable: true })).orThrow();
+                accessors.deleteFile('/target.txt').orThrow();
+                // Directly make _rootDir.removeEntry throw a non-Error value to test the catch branch
+                const rootDir = accessors._rootDir;
+                rootDir.removeEntry = jest.fn().mockRejectedValue('non-error string');
+                const syncResult = await accessors.syncToDisk();
+                expect(syncResult).toFailWith(/Failed to delete file.*non-error string/i);
+            });
         });
     });
 });