More tests in upload file service to improve the coverage

Author: AlexisMora

test/services/network/upload/upload-file.service.test.ts

@@ -171,6 +171,38 @@ describe('UploadFileService', () => {
       expect(emitProgress).toHaveBeenCalledTimes(2);
       uploadFileWithRetrySpy.mockRestore();
     });
+    it('should skip files when parent folder is not found in folderMap', async () => {
+      const bucket = 'test-bucket';
+      const destinationFolderUuid = 'dest-uuid';
+      const folderMap = new Map<string, string>();
+      const files = [
+        createFileSystemNodeFixture({
+          type: 'file',
+          name: 'nested.txt',
+          relativePath: 'subfolder/nested.txt',
+          size: 100,
+        }),
+      ];
+      const { currentProgress, emitProgress } = createProgressFixtures();
+
+      const uploadFileWithRetrySpy = vi.spyOn(sut, 'uploadFileWithRetry');
+
+      const result = await sut.uploadFilesInChunks({
+        network: mockNetworkFacade,
+        filesToUpload: files,
+        folderMap,
+        bucket,
+        destinationFolderUuid,
+        currentProgress,
+        emitProgress,
+      });
+
+      expect(result).toBe(0);
+      expect(logger.warn).toHaveBeenCalledWith('Parent folder not found for subfolder/nested.txt, skipping...');
+      expect(uploadFileWithRetrySpy).not.toHaveBeenCalled();
+
+      uploadFileWithRetrySpy.mockRestore();
+    });
   });
   describe('uploadFileWithRetry', () => {
     const bucket = 'test-bucket';
@@ -255,5 +287,115 @@ describe('UploadFileService', () => {
 
       vi.useRealTimers();
     });
+
+    it('should skip empty files and return null', async () => {
+      const file = createFileSystemNodeFixture({
+        type: 'file',
+        name: 'empty.txt',
+        relativePath: 'empty.txt',
+        size: 0,
+      });
+
+      vi.mocked(stat).mockResolvedValue(createMockStats(0) as Awaited<ReturnType<typeof stat>>);
+
+      const result = await sut.uploadFileWithRetry({
+        file,
+        network: mockNetworkFacade,
+        bucket,
+        parentFolderUuid: destinationFolderUuid,
+      });
+
+      expect(result).toBeNull();
+      expect(logger.warn).toHaveBeenCalledWith('Skipping empty file: empty.txt');
+      expect(mockNetworkFacade.uploadFile).not.toHaveBeenCalled();
+    });
+
+    it('should call tryUploadThumbnail when bufferStream is present', async () => {
+      const mockBufferStream = { getBuffer: vi.fn() };
+      vi.mocked(createFileStreamWithBuffer).mockReturnValue({
+        fileStream: createMockReadStream() as ReturnType<typeof createReadStream>,
+        bufferStream: mockBufferStream as unknown as ReturnType<typeof createFileStreamWithBuffer>['bufferStream'],
+      });
+
+      const file = createFileSystemNodeFixture({
+        type: 'file',
+        name: 'image.png',
+        relativePath: 'image.png',
+        size: 1024,
+      });
+
+      await sut.uploadFileWithRetry({
+        file,
+        network: mockNetworkFacade,
+        bucket,
+        parentFolderUuid: destinationFolderUuid,
+      });
+
+      expect(tryUploadThumbnail).toHaveBeenCalledWith({
+        bufferStream: mockBufferStream,
+        fileType: 'png',
+        userBucket: bucket,
+        fileUuid: 'mock-file-uuid',
+        networkFacade: mockNetworkFacade,
+      });
+    });
+
+    it('should return null when file already exists', async () => {
+      vi.mocked(isAlreadyExistsError).mockReturnValue(true);
+      vi.mocked(mockNetworkFacade.uploadFile).mockImplementation((_stream, _size, _bucket, callback) => {
+        callback(new Error('File already exists'), null);
+        return { stop: vi.fn() } as unknown as ReturnType<typeof mockNetworkFacade.uploadFile>;
+      });
+
+      const file = createFileSystemNodeFixture({
+        type: 'file',
+        name: 'duplicate.txt',
+        relativePath: 'duplicate.txt',
+        size: 1024,
+      });
+
+      const result = await sut.uploadFileWithRetry({
+        file,
+        network: mockNetworkFacade,
+        bucket,
+        parentFolderUuid: destinationFolderUuid,
+      });
+
+      expect(result).toBeNull();
+      expect(logger.info).toHaveBeenCalledWith('File duplicate.txt already exists, skipping...');
+    });
+
+    it('should return null after max retries exceeded', async () => {
+      vi.useFakeTimers();
+      const file = createFileSystemNodeFixture({
+        type: 'file',
+        name: 'fail.txt',
+        relativePath: 'fail.txt',
+        size: 1024,
+      });
+      const error = new Error('Network error');
+
+      vi.mocked(mockNetworkFacade.uploadFile).mockImplementation((_stream, _size, _bucket, callback) => {
+        callback(error, null);
+        return { stop: vi.fn() } as unknown as ReturnType<typeof mockNetworkFacade.uploadFile>;
+      });
+
+      const resultPromise = sut.uploadFileWithRetry({
+        file,
+        network: mockNetworkFacade,
+        bucket,
+        parentFolderUuid: destinationFolderUuid,
+      });
+
+      await vi.runAllTimersAsync();
+
+      const result = await resultPromise;
+
+      expect(result).toBeNull();
+      expect(logger.error).toHaveBeenCalledWith('Failed to upload file fail.txt after 3 attempts');
+      expect(mockNetworkFacade.uploadFile).toHaveBeenCalledTimes(3);
+
+      vi.useRealTimers();
+    });
   });
 });