@programisto/edrm-storage 0.3.1 → 1.0.0

package/dist/modules/edrm-storage/tests/edrm-storage.service.test.js

@@ -1,143 +0,0 @@
-import { EdrmStorageService } from '../services/edrm-storage.service.js';
-import { FileProvider, FileStatus } from '../models/file.model.js';
-describe('EdrmStorageService', () => {
-    let storageService;
-    beforeEach(() => {
-        storageService = new EdrmStorageService();
-    });
-    describe('initUpload', () => {
-        it('devrait initialiser un upload avec succès', async () => {
-            const mockData = {
-                originalName: 'test.pdf',
-                mimeType: 'application/pdf',
-                size: 1024000,
-                tenantId: 'test-tenant',
-                entityName: 'test-entity',
-                entityId: 'test-id'
-            };
-            // Mock du provider S3
-            const mockProvider = {
-                initUpload: jest.fn().mockResolvedValue({
-                    uploadId: 'test-upload-id',
-                    presignedUrl: 'https://test-url.com',
-                    expiresAt: new Date(),
-                    bucket: 'test-bucket',
-                    key: 'test-key'
-                })
-            };
-            // Mock du modèle File
-            const mockFileModel = {
-                save: jest.fn().mockResolvedValue({
-                    _id: 'test-file-id',
-                    ...mockData
-                })
-            };
-            // Injecter les mocks
-            storageService.providers.set(FileProvider.S3, mockProvider);
-            jest.spyOn(require('../models/file.model.js'), 'default').mockImplementation(() => mockFileModel);
-            const result = await storageService.initUpload(mockData.originalName, mockData.mimeType, mockData.size, mockData.tenantId, mockData.entityName, mockData.entityId);
-            expect(result).toBeDefined();
-            expect(result.fileId).toBe('test-file-id');
-            expect(mockProvider.initUpload).toHaveBeenCalled();
-        });
-        it('devrait rejeter avec une erreur si les paramètres sont manquants', async () => {
-            await expect(storageService.initUpload('', 'application/pdf', 1024000, 'test-tenant', 'test-entity', 'test-id')).rejects.toThrow();
-        });
-    });
-    describe('completeUpload', () => {
-        it('devrait finaliser un upload avec succès', async () => {
-            const mockFileRecord = {
-                _id: 'test-file-id',
-                status: FileStatus.PENDING,
-                bucket: 'test-bucket',
-                key: 'test-key',
-                provider: FileProvider.S3,
-                save: jest.fn().mockResolvedValue(true)
-            };
-            const mockProvider = {
-                getFileMetadata: jest.fn().mockResolvedValue({
-                    size: 1024000,
-                    etag: 'test-etag',
-                    lastModified: new Date(),
-                    contentType: 'application/pdf'
-                })
-            };
-            // Mock du modèle File
-            jest.spyOn(require('../models/file.model.js'), 'default').mockImplementation(() => ({
-                findById: jest.fn().mockResolvedValue(mockFileRecord)
-            }));
-            storageService.providers.set(FileProvider.S3, mockProvider);
-            const result = await storageService.completeUpload('test-file-id');
-            expect(result.status).toBe(FileStatus.COMPLETED);
-            expect(mockProvider.getFileMetadata).toHaveBeenCalled();
-        });
-        it('devrait rejeter si le fichier n\'existe pas', async () => {
-            jest.spyOn(require('../models/file.model.js'), 'default').mockImplementation(() => ({
-                findById: jest.fn().mockResolvedValue(null)
-            }));
-            await expect(storageService.completeUpload('non-existent-id')).rejects.toThrow('Fichier non trouvé');
-        });
-    });
-    describe('getDownloadUrl', () => {
-        it('devrait générer une URL de téléchargement', async () => {
-            const mockFileRecord = {
-                _id: 'test-file-id',
-                status: FileStatus.COMPLETED,
-                bucket: 'test-bucket',
-                key: 'test-key',
-                provider: FileProvider.S3,
-                originalName: 'test.pdf',
-                accessCount: 0,
-                save: jest.fn().mockResolvedValue(true)
-            };
-            const mockProvider = {
-                getDownloadUrl: jest.fn().mockResolvedValue({
-                    url: 'https://download-url.com',
-                    expiresAt: new Date(),
-                    filename: 'test.pdf',
-                    contentType: 'application/pdf'
-                })
-            };
-            jest.spyOn(require('../models/file.model.js'), 'default').mockImplementation(() => ({
-                findById: jest.fn().mockResolvedValue(mockFileRecord)
-            }));
-            storageService.providers.set(FileProvider.S3, mockProvider);
-            const result = await storageService.getDownloadUrl('test-file-id');
-            expect(result.url).toBeDefined();
-            expect(mockProvider.getDownloadUrl).toHaveBeenCalled();
-        });
-        it('devrait rejeter si le fichier n\'est pas finalisé', async () => {
-            const mockFileRecord = {
-                _id: 'test-file-id',
-                status: FileStatus.PENDING
-            };
-            jest.spyOn(require('../models/file.model.js'), 'default').mockImplementation(() => ({
-                findById: jest.fn().mockResolvedValue(mockFileRecord)
-            }));
-            await expect(storageService.getDownloadUrl('test-file-id')).rejects.toThrow('Fichier non encore finalisé');
-        });
-    });
-    describe('listFiles', () => {
-        it('devrait lister les fichiers avec pagination', async () => {
-            const mockFiles = [
-                { _id: 'file-1', filename: 'test1.pdf' },
-                { _id: 'file-2', filename: 'test2.pdf' }
-            ];
-            jest.spyOn(require('../models/file.model.js'), 'default').mockImplementation(() => ({
-                find: jest.fn().mockReturnValue({
-                    sort: jest.fn().mockReturnValue({
-                        skip: jest.fn().mockReturnValue({
-                            limit: jest.fn().mockReturnValue({
-                                exec: jest.fn().mockResolvedValue(mockFiles)
-                            })
-                        })
-                    })
-                }),
-                countDocuments: jest.fn().mockResolvedValue(2)
-            }));
-            const result = await storageService.listFiles('test-tenant', 'test-entity', 'test-id');
-            expect(result.files).toHaveLength(2);
-            expect(result.total).toBe(2);
-        });
-    });
-});

package/dist/modules/edrm-storage/tests/integration.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/modules/edrm-storage/tests/integration.test.js

@@ -1,141 +0,0 @@
-import { EdrmStorageService } from '../services/edrm-storage.service.js';
-import { FileProvider } from '../models/file.model.js';
-import { validateEdrmStorageConfig } from '../config/environment.example.js';
-describe('EDRM Storage Integration Tests', () => {
-    let storageService;
-    beforeAll(async () => {
-        // Vérifier la configuration
-        const configValidation = validateEdrmStorageConfig();
-        if (!configValidation.valid) {
-            console.warn('Configuration invalide:', configValidation.errors);
-        }
-        storageService = new EdrmStorageService();
-    });
-    describe('Configuration', () => {
-        it('devrait valider la configuration d\'environnement', () => {
-            const validation = validateEdrmStorageConfig();
-            expect(validation.valid).toBeDefined();
-            expect(Array.isArray(validation.errors)).toBe(true);
-        });
-    });
-    describe('Service Initialization', () => {
-        it('devrait initialiser le service sans erreur', () => {
-            expect(storageService).toBeDefined();
-            expect(storageService).toBeInstanceOf(EdrmStorageService);
-        });
-    });
-    describe('Upload Flow', () => {
-        it('devrait initialiser un upload avec succès', async () => {
-            const testData = {
-                originalName: 'test-integration.pdf',
-                mimeType: 'application/pdf',
-                size: 1024,
-                tenantId: 'test-tenant',
-                entityName: 'test-entity',
-                entityId: 'test-id-123'
-            };
-            try {
-                const result = await storageService.initUpload(testData.originalName, testData.mimeType, testData.size, testData.tenantId, testData.entityName, testData.entityId, FileProvider.S3);
-                expect(result).toBeDefined();
-                expect(result.fileId).toBeDefined();
-                expect(result.presignedUrl).toBeDefined();
-                expect(result.bucket).toBeDefined();
-                expect(result.key).toBeDefined();
-                console.log('Upload initialisé avec succès:', {
-                    fileId: result.fileId,
-                    bucket: result.bucket,
-                    key: result.key
-                });
-            }
-            catch (error) {
-                // Si les credentials AWS ne sont pas configurés, c'est normal
-                console.log('Test d\'upload ignoré - credentials AWS non configurés');
-            }
-        }, 10000);
-        it('devrait gérer les erreurs de paramètres invalides', async () => {
-            await expect(storageService.initUpload('', // nom vide
-            'application/pdf', 1024, 'tenant', 'entity', 'id')).rejects.toThrow();
-        });
-    });
-    describe('File Management', () => {
-        it('devrait lister les fichiers', async () => {
-            try {
-                const result = await storageService.listFiles('test-tenant', 'test-entity', 'test-id', undefined, 1, 10);
-                expect(result).toBeDefined();
-                expect(result.files).toBeDefined();
-                expect(Array.isArray(result.files)).toBe(true);
-                expect(result.total).toBeDefined();
-                expect(result.page).toBe(1);
-                expect(result.totalPages).toBeDefined();
-            }
-            catch (error) {
-                console.log('Test de listing ignoré - base de données non connectée');
-            }
-        });
-        it('devrait gérer les erreurs de fichier inexistant', async () => {
-            await expect(storageService.getFileById('non-existent-id')).rejects.toThrow('Fichier non trouvé');
-        });
-    });
-    describe('Provider Management', () => {
-        it('devrait supporter le provider S3', () => {
-            // Le provider S3 devrait être disponible par défaut
-            expect(FileProvider.S3).toBe('S3');
-        });
-        it('devrait gérer les providers non supportés', async () => {
-            // Test avec un provider inexistant
-            await expect(storageService.initUpload('test.pdf', 'application/pdf', 1024, 'tenant', 'entity', 'id', 'INVALID_PROVIDER')).rejects.toThrow('Provider INVALID_PROVIDER non supporté');
-        });
-    });
-    describe('Error Handling', () => {
-        it('devrait gérer les erreurs de connexion S3', async () => {
-            // Test avec des credentials invalides
-            const originalAccessKey = process.env.AWS_ACCESS_KEY_ID;
-            const originalSecretKey = process.env.AWS_SECRET_ACCESS_KEY;
-            // Simuler des credentials invalides
-            process.env.AWS_ACCESS_KEY_ID = 'invalid';
-            process.env.AWS_SECRET_ACCESS_KEY = 'invalid';
-            try {
-                await storageService.initUpload('test.pdf', 'application/pdf', 1024, 'tenant', 'entity', 'id');
-            }
-            catch (error) {
-                expect(error).toBeDefined();
-                console.log('Erreur S3 attendue avec credentials invalides');
-            }
-            finally {
-                // Restaurer les credentials originaux
-                if (originalAccessKey)
-                    process.env.AWS_ACCESS_KEY_ID = originalAccessKey;
-                if (originalSecretKey)
-                    process.env.AWS_SECRET_ACCESS_KEY = originalSecretKey;
-            }
-        });
-    });
-    describe('Performance', () => {
-        it('devrait gérer les uploads multiples', async () => {
-            const uploads = [];
-            const testData = {
-                originalName: 'test-multiple.pdf',
-                mimeType: 'application/pdf',
-                size: 1024,
-                tenantId: 'test-tenant',
-                entityName: 'test-entity',
-                entityId: 'test-id'
-            };
-            try {
-                // Créer plusieurs uploads simultanés
-                for (let i = 0; i < 3; i++) {
-                    uploads.push(storageService.initUpload(`${testData.originalName}-${i}`, testData.mimeType, testData.size, testData.tenantId, testData.entityName, `${testData.entityId}-${i}`));
-                }
-                const results = await Promise.all(uploads);
-                expect(results).toHaveLength(3);
-                results.forEach((result, index) => {
-                    expect(result.fileId).toBeDefined();
-                    expect(result.presignedUrl).toBeDefined();
-                });
-            }
-            catch (error) {
-                console.log('Test de performance ignoré - credentials AWS non configurés');
-            }
-        }, 15000);
-    });
-});