feat: ensure destination folder exists before creating write stream in streamFileToDisk

Author: egalvis27

src/backend/features/fuse/on-read/stream-file-to-disk.test.ts

@@ -1,77 +1,111 @@
 import fs from 'node:fs';
 import { PassThrough } from 'node:stream';
+import * as ensureFolderExistsModule from '../../../../apps/shared/fs/ensure-folder-exists';
 import { streamFileToDisk } from './stream-file-to-disk';
-import { deepMocked } from '../../../../../tests/vitest/utils.helper';
+import { call, calls, partialSpyOn } from '../../../../../tests/vitest/utils.helper';
 
-vi.mock(import('node:fs'));
+describe('stream-file-to-disk', () => {
+  const createWriteStreamMock = partialSpyOn(fs, 'createWriteStream');
+  const ensureFolderExistsMock = partialSpyOn(ensureFolderExistsModule, 'ensureFolderExists');
 
-const fsMock = deepMocked(fs);
-
-describe('streamFileToDisk', () => {
   let fakeWriteStream: PassThrough & { bytesWritten: number };
 
   beforeEach(() => {
     fakeWriteStream = Object.assign(new PassThrough(), { bytesWritten: 0 });
-    fsMock.createWriteStream.mockReturnValue(fakeWriteStream as any);
+    createWriteStreamMock.mockReturnValue(fakeWriteStream as unknown as fs.WriteStream);
   });
 
-  it('should create a write stream at the given file path', () => {
+  it('should ensure the destination folder exists before creating the stream', () => {
+    // Given
     const readable = new PassThrough();
 
-    streamFileToDisk(readable, '/tmp/file', vi.fn());
+    // When
+    streamFileToDisk(readable, '/home/dev/.config/internxt/downloaded/file-id', vi.fn());
 
-    expect(fsMock.createWriteStream).toHaveBeenCalledWith('/tmp/file');
+    // Then
+    call(ensureFolderExistsMock).toBe('/home/dev/.config/internxt/downloaded');
+    call(createWriteStreamMock).toBe('/home/dev/.config/internxt/downloaded/file-id');
   });
 
   it('should pipe the readable into the write stream', () => {
+    // Given
     const readable = new PassThrough();
-    const pipeSpy = vi.spyOn(readable, 'pipe');
+    const pipeSpy = partialSpyOn(readable, 'pipe', false);
 
+    // When
     streamFileToDisk(readable, '/tmp/file', vi.fn());
 
-    expect(pipeSpy).toHaveBeenCalledWith(fakeWriteStream);
+    // Then
+    call(pipeSpy).toBe(fakeWriteStream);
   });
 
   it('should call onProgress with bytesWritten when data is received', () => {
+    // Given
     const readable = new PassThrough();
     const onProgress = vi.fn();
     fakeWriteStream.bytesWritten = 100;
 
+    // When
     streamFileToDisk(readable, '/tmp/file', onProgress);
     readable.emit('data', Buffer.alloc(100));
 
-    expect(onProgress).toHaveBeenCalledWith(100);
+    // Then
+    call(onProgress).toBe(100);
   });
 
   it('should call onProgress with bytesWritten on drain', () => {
+    // Given
     const readable = new PassThrough();
     const onProgress = vi.fn();
     fakeWriteStream.bytesWritten = 200;
 
+    // When
     streamFileToDisk(readable, '/tmp/file', onProgress);
     fakeWriteStream.emit('drain');
 
-    expect(onProgress).toHaveBeenCalledWith(200);
+    // Then
+    call(onProgress).toBe(200);
   });
 
   it('should return the write stream', () => {
+    // Given
     const readable = new PassThrough();
 
+    // When
     const result = streamFileToDisk(readable, '/tmp/file', vi.fn());
 
+    // Then
     expect(result.writeStream).toBe(fakeWriteStream);
   });
 
   it('should return getBytesWritten that tracks progress', () => {
+    // Given
     const readable = new PassThrough();
 
+    // When
     const result = streamFileToDisk(readable, '/tmp/file', vi.fn());
 
+    // Then
     expect(result.getBytesWritten()).toBe(0);
 
+    // Given
     fakeWriteStream.bytesWritten = 500;
+
+    // When
     readable.emit('data', Buffer.alloc(500));
 
+    // Then
     expect(result.getBytesWritten()).toBe(500);
   });
+
+  it('should create the write stream once', () => {
+    // Given
+    const readable = new PassThrough();
+
+    // When
+    streamFileToDisk(readable, '/tmp/file', vi.fn());
+
+    // Then
+    calls(createWriteStreamMock).toHaveLength(1);
+  });
 });

src/backend/features/fuse/on-read/stream-file-to-disk.ts

@@ -1,9 +1,13 @@
 import fs from 'node:fs';
+import { dirname } from 'node:path';
 import { type Readable } from 'node:stream';
+import { ensureFolderExists } from '../../../../apps/shared/fs/ensure-folder-exists';
 
 export function streamFileToDisk(readable: Readable, filePath: string, onProgress: (bytesWritten: number) => void) {
   let bytesWritten = 0;
 
+  ensureFolderExists(dirname(filePath));
+
   const writeStream = fs.createWriteStream(filePath);
 
   readable.pipe(writeStream);