@scality/data-browser-library 1.0.0-preview.8 → 1.0.1

package/dist/utils/__tests__/s3Client.test.js

@@ -0,0 +1,340 @@
+import { S3Client } from "@aws-sdk/client-s3";
+import { createProxyMiddleware } from "../proxyMiddleware.js";
+import { createS3Client } from "../s3Client.js";
+jest.mock('@aws-sdk/client-s3');
+jest.mock('../proxyMiddleware', ()=>({
+        createProxyMiddleware: jest.fn(),
+        resolveProxyEndpoint: jest.fn((endpoint)=>{
+            if ('origin' === endpoint) return 'http://localhost';
+            if (endpoint.startsWith('/')) return 'http://localhost' + endpoint;
+            return endpoint;
+        })
+    }));
+const MockedS3Client = S3Client;
+const mockedCreateProxyMiddleware = createProxyMiddleware;
+describe('createS3Client', ()=>{
+    let mockMiddlewareStack;
+    const baseCredentials = {
+        accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
+        secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'
+    };
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockMiddlewareStack = {
+            use: jest.fn()
+        };
+        MockedS3Client.mockImplementation(()=>({
+                middlewareStack: mockMiddlewareStack
+            }));
+        mockedCreateProxyMiddleware.mockReturnValue({
+            applyToStack: jest.fn()
+        });
+    });
+    describe('Basic S3Client configuration', ()=>{
+        it('should create S3Client with all provided parameters', ()=>{
+            const config = {
+                endpoint: 'https://s3.us-west-2.amazonaws.com',
+                region: 'us-west-2',
+                forcePathStyle: true,
+                credentials: baseCredentials
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledTimes(1);
+            expect(MockedS3Client).toHaveBeenCalledWith({
+                endpoint: 'https://s3.us-west-2.amazonaws.com',
+                region: 'us-west-2',
+                forcePathStyle: true,
+                credentials: baseCredentials
+            });
+        });
+        it('should default forcePathStyle to true when omitted', ()=>{
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'eu-west-1',
+                credentials: baseCredentials
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledWith({
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'eu-west-1',
+                forcePathStyle: true,
+                credentials: baseCredentials
+            });
+        });
+        it('should respect explicit forcePathStyle false', ()=>{
+            const config = {
+                endpoint: 'https://bucket.s3.amazonaws.com',
+                region: 'us-east-1',
+                forcePathStyle: false,
+                credentials: baseCredentials
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledWith(expect.objectContaining({
+                forcePathStyle: false
+            }));
+        });
+        it('should handle config without endpoint', ()=>{
+            const config = {
+                region: 'ap-southeast-1',
+                credentials: baseCredentials
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledWith({
+                endpoint: void 0,
+                region: 'ap-southeast-1',
+                forcePathStyle: true,
+                credentials: baseCredentials
+            });
+        });
+    });
+    describe('Proxy endpoint selection', ()=>{
+        it('should use proxy endpoint when proxy is enabled', ()=>{
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-east-1',
+                credentials: baseCredentials,
+                proxy: {
+                    enabled: true,
+                    endpoint: 'http://localhost:3000/api/s3',
+                    target: 'https://s3.amazonaws.com'
+                }
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledWith({
+                endpoint: 'http://localhost:3000/api/s3',
+                region: 'us-east-1',
+                forcePathStyle: true,
+                credentials: baseCredentials
+            });
+        });
+        it('should use real S3 endpoint when proxy.enabled is false', ()=>{
+            const config = {
+                endpoint: 'https://s3.eu-central-1.amazonaws.com',
+                region: 'eu-central-1',
+                credentials: baseCredentials,
+                proxy: {
+                    enabled: false,
+                    endpoint: 'http://localhost:3000/api/s3'
+                }
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledWith({
+                endpoint: 'https://s3.eu-central-1.amazonaws.com',
+                region: 'eu-central-1',
+                forcePathStyle: true,
+                credentials: baseCredentials
+            });
+        });
+        it('should use real S3 endpoint when proxy config is absent', ()=>{
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-west-1',
+                credentials: baseCredentials
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledWith({
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-west-1',
+                forcePathStyle: true,
+                credentials: baseCredentials
+            });
+        });
+    });
+    describe('Proxy middleware application', ()=>{
+        it('should apply proxy middleware when enabled with target', ()=>{
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-east-1',
+                credentials: baseCredentials,
+                proxy: {
+                    enabled: true,
+                    endpoint: 'http://localhost:3000/api/s3',
+                    target: 'http://s3.internal.local'
+                }
+            };
+            createS3Client(config);
+            expect(mockedCreateProxyMiddleware).toHaveBeenCalledTimes(1);
+            expect(mockedCreateProxyMiddleware).toHaveBeenCalledWith({
+                enabled: true,
+                endpoint: 'http://localhost:3000/api/s3',
+                target: 'http://s3.internal.local'
+            });
+            expect(mockMiddlewareStack.use).toHaveBeenCalledTimes(1);
+        });
+        it('should not apply middleware when proxy.target is not provided', ()=>{
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-east-1',
+                credentials: baseCredentials,
+                proxy: {
+                    enabled: false,
+                    endpoint: 'http://localhost:3000/api/s3'
+                }
+            };
+            createS3Client(config);
+            expect(mockedCreateProxyMiddleware).not.toHaveBeenCalled();
+            expect(mockMiddlewareStack.use).not.toHaveBeenCalled();
+        });
+        it('should pass proxy middleware to client middleware stack', ()=>{
+            const mockProxyMiddleware = {
+                applyToStack: jest.fn()
+            };
+            mockedCreateProxyMiddleware.mockReturnValue(mockProxyMiddleware);
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-east-1',
+                credentials: baseCredentials,
+                proxy: {
+                    enabled: true,
+                    endpoint: 'http://localhost:8080/proxy',
+                    target: 'https://s3.amazonaws.com'
+                }
+            };
+            createS3Client(config);
+            expect(mockMiddlewareStack.use).toHaveBeenCalledWith(mockProxyMiddleware);
+        });
+        it('should not create proxy middleware when proxy is disabled', ()=>{
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-east-1',
+                credentials: baseCredentials,
+                proxy: {
+                    enabled: false,
+                    endpoint: 'http://localhost:3000/api/s3'
+                }
+            };
+            createS3Client(config);
+            expect(mockedCreateProxyMiddleware).not.toHaveBeenCalled();
+            expect(mockMiddlewareStack.use).not.toHaveBeenCalled();
+        });
+        it('should not create proxy middleware when proxy config is absent', ()=>{
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-east-1',
+                credentials: baseCredentials
+            };
+            createS3Client(config);
+            expect(mockedCreateProxyMiddleware).not.toHaveBeenCalled();
+            expect(mockMiddlewareStack.use).not.toHaveBeenCalled();
+        });
+        it('should throw error when proxy is enabled but target is missing', ()=>{
+            const config = {
+                region: 'us-east-1',
+                credentials: baseCredentials,
+                proxy: {
+                    enabled: true,
+                    endpoint: 'http://localhost:3000/api/s3'
+                }
+            };
+            expect(()=>createS3Client(config)).toThrow('Proxy configuration error: "target" is required when proxy is enabled');
+        });
+    });
+    describe('Edge cases', ()=>{
+        it('should handle minimal valid configuration', ()=>{
+            const config = {
+                region: 'us-east-1',
+                credentials: baseCredentials
+            };
+            const client = createS3Client(config);
+            expect(client).toBeDefined();
+            expect(MockedS3Client).toHaveBeenCalledWith({
+                endpoint: void 0,
+                region: 'us-east-1',
+                forcePathStyle: true,
+                credentials: baseCredentials
+            });
+        });
+        it('should return S3Client with middleware stack', ()=>{
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-east-1',
+                credentials: baseCredentials
+            };
+            const client = createS3Client(config);
+            expect(client).toBeDefined();
+            expect(client.middlewareStack).toBeDefined();
+            expect(typeof client.middlewareStack.use).toBe('function');
+        });
+        it('should handle proxy config with undefined endpoint property', ()=>{
+            const config = {
+                region: 'us-east-1',
+                credentials: baseCredentials,
+                proxy: {
+                    enabled: false,
+                    endpoint: 'http://localhost:3000/api/s3'
+                }
+            };
+            createS3Client(config);
+            expect(mockedCreateProxyMiddleware).not.toHaveBeenCalled();
+        });
+        it('should handle custom S3-compatible endpoint', ()=>{
+            const config = {
+                endpoint: 'http://minio.local:9000',
+                region: 'us-east-1',
+                credentials: baseCredentials,
+                forcePathStyle: true
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledWith({
+                endpoint: 'http://minio.local:9000',
+                region: 'us-east-1',
+                forcePathStyle: true,
+                credentials: baseCredentials
+            });
+        });
+        it('should handle proxy with custom S3-compatible endpoint', ()=>{
+            const config = {
+                endpoint: 'http://minio.local:9000',
+                region: 'us-east-1',
+                credentials: baseCredentials,
+                proxy: {
+                    enabled: true,
+                    endpoint: 'http://localhost:3000/minio-proxy',
+                    target: 'http://minio.local:9000'
+                }
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledWith(expect.objectContaining({
+                endpoint: 'http://localhost:3000/minio-proxy'
+            }));
+            expect(mockedCreateProxyMiddleware).toHaveBeenCalledWith({
+                enabled: true,
+                endpoint: 'http://localhost:3000/minio-proxy',
+                target: 'http://minio.local:9000'
+            });
+        });
+    });
+    describe('Credentials handling', ()=>{
+        it('should pass credentials object correctly', ()=>{
+            const credentials = {
+                accessKeyId: 'CUSTOM_ACCESS_KEY',
+                secretAccessKey: 'custom-secret-key-123'
+            };
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-east-1',
+                credentials
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledWith(expect.objectContaining({
+                credentials
+            }));
+        });
+        it('should handle credentials with session token', ()=>{
+            const credentials = {
+                accessKeyId: 'ASIATEMP',
+                secretAccessKey: 'temp-secret',
+                sessionToken: 'FwoGZXIvYXdz...'
+            };
+            const config = {
+                endpoint: 'https://s3.amazonaws.com',
+                region: 'us-east-1',
+                credentials
+            };
+            createS3Client(config);
+            expect(MockedS3Client).toHaveBeenCalledWith(expect.objectContaining({
+                credentials
+            }));
+        });
+    });
+});

package/dist/utils/__tests__/s3ConfigIdentifier.test.d.ts

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