@flusys/nestjs-storage 7.0.2 → 8.0.0-beta.1

package/fesm/services/upload.service.spec.js

@@ -1,422 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { EventBusRegistry } from '@flusys/nestjs-shared/classes';
-import { UploadService } from './upload.service';
-import { StorageFactoryService } from '../providers/storage-factory.service';
-import { StorageConfigService } from './storage-config.service';
-import { StorageProviderConfigService } from './storage-provider-config.service';
-import { FileLocationEnum } from '../enums/file-location.enum';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-function buildMulterFile(overrides = {}) {
-    return {
-        fieldname: 'file',
-        originalname: 'photo.jpg',
-        encoding: '7bit',
-        mimetype: 'image/jpeg',
-        buffer: Buffer.from([
-            0xff,
-            0xd8,
-            0xff,
-            0xe0
-        ]),
-        size: 1024,
-        stream: undefined,
-        destination: '',
-        filename: '',
-        path: '',
-        ...overrides
-    };
-}
-describe('UploadService', ()=>{
-    let service;
-    let mockStorageFactory;
-    let mockStorageConfigService;
-    let mockStorageProviderConfigService;
-    let mockProvider;
-    beforeEach(async ()=>{
-        mockProvider = {
-            uploadFile: jest.fn().mockResolvedValue({
-                name: 'photo.jpg',
-                key: 'uploads/photo.jpg',
-                size: 1024,
-                contentType: 'image/jpeg'
-            }),
-            uploadMultipleFiles: jest.fn().mockResolvedValue([]),
-            deleteFile: jest.fn().mockResolvedValue(undefined),
-            deleteMultipleFiles: jest.fn().mockResolvedValue(undefined),
-            generatePresignedUrl: jest.fn().mockResolvedValue('https://signed.example.com/uploads/photo.jpg')
-        };
-        mockStorageFactory = {
-            createProvider: jest.fn().mockResolvedValue(mockProvider),
-            getLocalProviderBasePath: jest.fn().mockReturnValue(null)
-        };
-        mockStorageConfigService = {
-            validateFileSize: jest.fn().mockReturnValue({
-                valid: true
-            }),
-            validateFileType: jest.fn().mockReturnValue({
-                valid: true
-            }),
-            getAllowedFileTypes: jest.fn().mockReturnValue([
-                '*/*'
-            ]),
-            getDefaultLocalStoragePath: jest.fn().mockReturnValue('./uploads'),
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
-        };
-        mockStorageProviderConfigService = {
-            findByIdDirect: jest.fn(),
-            getDefaultConfig: jest.fn(),
-            getConfigByType: jest.fn()
-        };
-        const module = await Test.createTestingModule({
-            providers: [
-                UploadService,
-                {
-                    provide: StorageFactoryService,
-                    useValue: mockStorageFactory
-                },
-                {
-                    provide: StorageConfigService,
-                    useValue: mockStorageConfigService
-                },
-                {
-                    provide: StorageProviderConfigService,
-                    useValue: mockStorageProviderConfigService
-                }
-            ]
-        }).compile();
-        service = await module.resolve(UploadService);
-    });
-    describe('uploadSingleFile', ()=>{
-        it('validates, resolves the default storage config, and uploads via the resolved provider', async ()=>{
-            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
-                id: 'cfg-default',
-                storage: 'local',
-                config: {}
-            });
-            const result = await service.uploadSingleFile(buildMulterFile(), {}, buildMockUser());
-            expect(mockStorageConfigService.validateFileSize).toHaveBeenCalled();
-            expect(mockStorageConfigService.validateFileType).toHaveBeenCalled();
-            expect(mockProvider.uploadFile).toHaveBeenCalled();
-            expect(result.location).toBe('local');
-            expect(result.storageConfigId).toBe('cfg-default');
-        });
-        it('throws BadRequestException when file size exceeds the configured maximum', async ()=>{
-            mockStorageConfigService.validateFileSize.mockReturnValue({
-                valid: false,
-                message: 'too big',
-                messageKey: 'upload.file.too.large'
-            });
-            await expect(service.uploadSingleFile(buildMulterFile(), {}, buildMockUser())).rejects.toThrow();
-        });
-        it('throws BadRequestException when the declared MIME type is not allowed', async ()=>{
-            mockStorageConfigService.validateFileType.mockReturnValue({
-                valid: false,
-                message: 'not allowed',
-                messageKey: 'upload.invalid.type'
-            });
-            await expect(service.uploadSingleFile(buildMulterFile(), {}, buildMockUser())).rejects.toThrow();
-        });
-        it('rejects a file whose content does not match its declared MIME type (spoofing protection)', async ()=>{
-            const file = buildMulterFile({
-                mimetype: 'application/pdf',
-                buffer: Buffer.from([
-                    0xff,
-                    0xd8,
-                    0xff
-                ])
-            });
-            await expect(service.uploadSingleFile(file, {}, buildMockUser())).rejects.toThrow();
-        });
-        it('sanitizes the original filename to prevent path traversal before uploading', async ()=>{
-            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
-                id: 'cfg-default',
-                storage: 'local',
-                config: {}
-            });
-            const file = buildMulterFile({
-                originalname: '../../etc/passwd.jpg'
-            });
-            await service.uploadSingleFile(file, {}, buildMockUser());
-            expect(file.originalname).toBe('passwd.jpg');
-        });
-        it('uses an explicit storageConfigId when provided and validates company ownership', async ()=>{
-            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
-                id: 'cfg-1',
-                storage: 'aws',
-                config: {}
-            });
-            const result = await service.uploadSingleFile(buildMulterFile(), {
-                storageConfigId: 'cfg-1'
-            }, buildMockUser());
-            expect(mockStorageProviderConfigService.findByIdDirect).toHaveBeenCalledWith('cfg-1');
-            expect(result.location).toBe('aws');
-        });
-        it('throws NotFoundException when the explicit storageConfigId does not resolve to a config', async ()=>{
-            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue(null);
-            await expect(service.uploadSingleFile(buildMulterFile(), {
-                storageConfigId: 'missing'
-            }, buildMockUser())).rejects.toThrow();
-        });
-        it('throws NotFoundException when no default storage config exists and none was specified', async ()=>{
-            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue(null);
-            await expect(service.uploadSingleFile(buildMulterFile(), {}, buildMockUser())).rejects.toThrow();
-        });
-        it('rejects uploading a config belonging to a different company when company feature is enabled', async ()=>{
-            mockStorageConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
-            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
-                id: 'cfg-1',
-                storage: 'aws',
-                config: {},
-                companyId: 'other-company'
-            });
-            await expect(service.uploadSingleFile(buildMulterFile(), {
-                storageConfigId: 'cfg-1'
-            }, buildMockUser({
-                companyId: 'my-company'
-            }))).rejects.toThrow();
-        });
-    });
-    describe('uploadMultipleFiles', ()=>{
-        it('validates every file before uploading any', async ()=>{
-            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
-                id: 'cfg-default',
-                storage: 'local',
-                config: {}
-            });
-            mockProvider.uploadMultipleFiles.mockResolvedValue([
-                {
-                    name: 'a.jpg',
-                    key: 'a.jpg',
-                    size: 10,
-                    contentType: 'image/jpeg'
-                },
-                {
-                    name: 'b.jpg',
-                    key: 'b.jpg',
-                    size: 20,
-                    contentType: 'image/jpeg'
-                }
-            ]);
-            const files = [
-                buildMulterFile({
-                    originalname: 'a.jpg'
-                }),
-                buildMulterFile({
-                    originalname: 'b.jpg'
-                })
-            ];
-            const result = await service.uploadMultipleFiles(files, {}, buildMockUser());
-            expect(result).toHaveLength(2);
-            expect(mockStorageConfigService.validateFileSize).toHaveBeenCalledTimes(2);
-        });
-        it('rejects the whole batch if any single file fails validation', async ()=>{
-            mockStorageConfigService.validateFileSize.mockReturnValueOnce({
-                valid: true
-            }).mockReturnValueOnce({
-                valid: false,
-                message: 'too big',
-                messageKey: 'upload.file.too.large'
-            });
-            const files = [
-                buildMulterFile({
-                    originalname: 'a.jpg'
-                }),
-                buildMulterFile({
-                    originalname: 'b.jpg'
-                })
-            ];
-            await expect(service.uploadMultipleFiles(files, {}, buildMockUser())).rejects.toThrow();
-            expect(mockProvider.uploadMultipleFiles).not.toHaveBeenCalled();
-        });
-    });
-    describe('deleteSingleFile', ()=>{
-        it('throws BadRequestException when no key is provided', async ()=>{
-            await expect(service.deleteSingleFile('')).rejects.toThrow();
-        });
-        it('resolves a provider by storageConfigId and deletes the file', async ()=>{
-            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
-                id: 'cfg-1',
-                storage: 'aws',
-                config: {}
-            });
-            const result = await service.deleteSingleFile('uploads/photo.jpg', 'cfg-1', buildMockUser());
-            expect(mockProvider.deleteFile).toHaveBeenCalledWith('uploads/photo.jpg');
-            expect(result).toBe(true);
-        });
-        it('falls back to a matching config by locationHint when storageConfigId is missing/invalid', async ()=>{
-            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue(null);
-            mockStorageProviderConfigService.getConfigByType.mockResolvedValue([
-                {
-                    id: 'cfg-2',
-                    storage: 'local',
-                    config: {}
-                }
-            ]);
-            const result = await service.deleteSingleFile('uploads/photo.jpg', 'stale-id', buildMockUser(), 'local');
-            expect(mockStorageProviderConfigService.getConfigByType).toHaveBeenCalledWith('local', buildMockUser());
-            expect(result).toBe(true);
-        });
-        it('falls back to a local provider when locationHint is local and no config matches', async ()=>{
-            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue(null);
-            mockStorageProviderConfigService.getConfigByType.mockResolvedValue([]);
-            await service.deleteSingleFile('uploads/photo.jpg', undefined, buildMockUser(), FileLocationEnum.LOCAL);
-            expect(mockStorageFactory.createProvider).toHaveBeenCalledWith(expect.objectContaining({
-                provider: FileLocationEnum.LOCAL
-            }));
-        });
-        it('falls back to the default config as a last resort', async ()=>{
-            mockStorageProviderConfigService.getConfigByType.mockResolvedValue([]);
-            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
-                id: 'cfg-default',
-                storage: 'aws',
-                config: {}
-            });
-            await service.deleteSingleFile('uploads/photo.jpg', undefined, buildMockUser(), 'aws');
-            expect(mockStorageProviderConfigService.getDefaultConfig).toHaveBeenCalled();
-        });
-    });
-    describe('deleteMultipleFile', ()=>{
-        it('throws BadRequestException when no keys are provided', async ()=>{
-            await expect(service.deleteMultipleFile([])).rejects.toThrow();
-        });
-        it('deletes all provided keys via the resolved provider', async ()=>{
-            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
-                id: 'cfg-1',
-                storage: 'aws',
-                config: {}
-            });
-            const result = await service.deleteMultipleFile([
-                'a.jpg',
-                'b.jpg'
-            ], 'cfg-1', buildMockUser());
-            expect(mockProvider.deleteMultipleFiles).toHaveBeenCalledWith([
-                'a.jpg',
-                'b.jpg'
-            ]);
-            expect(result).toBe(true);
-        });
-    });
-    describe('bytesToKb', ()=>{
-        it('converts bytes to kilobytes rounded to 2 decimals', ()=>{
-            expect(service.bytesToKb(1024)).toBe(1.02);
-        });
-        it('returns 0 for a 0-byte file', ()=>{
-            expect(service.bytesToKb(0)).toBe(0);
-        });
-    });
-    describe('getLocalStorageBasePath', ()=>{
-        it('returns the cached basePath if already available', async ()=>{
-            mockStorageFactory.getLocalProviderBasePath.mockReturnValue('./cached-uploads');
-            const result = await service.getLocalStorageBasePath();
-            expect(result).toBe('./cached-uploads');
-            expect(mockStorageProviderConfigService.getConfigByType).not.toHaveBeenCalled();
-        });
-        it('initializes the local provider from DB config when not yet cached', async ()=>{
-            mockStorageFactory.getLocalProviderBasePath.mockReturnValueOnce(null).mockReturnValueOnce('./db-uploads');
-            mockStorageProviderConfigService.getConfigByType.mockResolvedValue([
-                {
-                    id: 'cfg-local',
-                    storage: 'local',
-                    config: {
-                        basePath: './db-uploads'
-                    }
-                }
-            ]);
-            const result = await service.getLocalStorageBasePath();
-            expect(result).toBe('./db-uploads');
-        });
-        it('returns null when there is no local config in the database', async ()=>{
-            mockStorageProviderConfigService.getConfigByType.mockResolvedValue([]);
-            const result = await service.getLocalStorageBasePath();
-            expect(result).toBeNull();
-        });
-        it('returns null (swallows errors) instead of throwing when lookup fails', async ()=>{
-            mockStorageProviderConfigService.getConfigByType.mockRejectedValue(new Error('db down'));
-            await expect(service.getLocalStorageBasePath()).resolves.toBeNull();
-        });
-    });
-    describe('makeFileUrl', ()=>{
-        it('delegates to the provider generatePresignedUrl when supported', async ()=>{
-            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
-                id: 'cfg-1',
-                storage: 'aws',
-                config: {}
-            });
-            const url = await service.makeFileUrl('uploads/photo.jpg', 'cfg-1', 900, buildMockUser());
-            expect(mockProvider.generatePresignedUrl).toHaveBeenCalledWith('uploads/photo.jpg', 900);
-            expect(url).toBe('https://signed.example.com/uploads/photo.jpg');
-        });
-        it('returns the raw key when the provider does not support presigned URLs', async ()=>{
-            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
-                id: 'cfg-1',
-                storage: 'sftp',
-                config: {}
-            });
-            delete mockProvider.generatePresignedUrl;
-            const url = await service.makeFileUrl('uploads/photo.jpg', 'cfg-1', 900, buildMockUser());
-            expect(url).toBe('uploads/photo.jpg');
-        });
-        it('defaults expiry to 3600 seconds when not specified', async ()=>{
-            mockStorageProviderConfigService.findByIdDirect.mockResolvedValue({
-                id: 'cfg-1',
-                storage: 'aws',
-                config: {}
-            });
-            await service.makeFileUrl('uploads/photo.jpg', 'cfg-1');
-            expect(mockProvider.generatePresignedUrl).toHaveBeenCalledWith('uploads/photo.jpg', 3600);
-        });
-    });
-    describe('domain events', ()=>{
-        let publish;
-        beforeEach(()=>{
-            publish = jest.fn().mockResolvedValue(undefined);
-            EventBusRegistry.reset();
-            EventBusRegistry.setBus({
-                publish,
-                subscribe: jest.fn(),
-                close: jest.fn()
-            });
-            EventBusRegistry.configureModule('storage', {
-                enabled: true
-            });
-            mockStorageProviderConfigService.getDefaultConfig.mockResolvedValue({
-                id: 'cfg-default',
-                storage: 'local',
-                config: {}
-            });
-        });
-        afterEach(()=>{
-            EventBusRegistry.reset();
-        });
-        it('publishes storage.file_manager.uploaded after a single upload', async ()=>{
-            await service.uploadSingleFile(buildMulterFile(), {}, buildMockUser());
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'storage.file_manager.uploaded',
-                payload: expect.objectContaining({
-                    metadata: expect.objectContaining({
-                        count: 1,
-                        storageConfigId: 'cfg-default'
-                    })
-                })
-            }));
-        });
-        it('publishes storage.file_manager.removed after a delete', async ()=>{
-            await service.deleteSingleFile('uploads/photo.jpg', 'cfg-1', buildMockUser());
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'storage.file_manager.removed',
-                payload: expect.objectContaining({
-                    ids: [
-                        'uploads/photo.jpg'
-                    ]
-                })
-            }));
-        });
-        it('does not publish when the storage module has events disabled', async ()=>{
-            EventBusRegistry.configureModule('storage', {
-                enabled: false
-            });
-            await service.uploadSingleFile(buildMulterFile(), {}, buildMockUser());
-            expect(publish).not.toHaveBeenCalled();
-        });
-    });
-});