@flusys/nestjs-storage 6.0.2 → 6.1.0

package/fesm/providers/azure-provider.optional.spec.js

@@ -0,0 +1,224 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+const mockCreateIfNotExists = jest.fn();
+const mockBlockBlobUpload = jest.fn();
+const mockDeleteIfExists = jest.fn();
+const mockContainerExists = jest.fn();
+function buildBlockBlobClient() {
+    return {
+        upload: mockBlockBlobUpload,
+        deleteIfExists: mockDeleteIfExists,
+        url: 'https://account.blob.core.windows.net/container/blob-key.jpg',
+        credential: 'shared-key-credential'
+    };
+}
+const mockGetBlockBlobClient = jest.fn().mockImplementation(()=>buildBlockBlobClient());
+const mockGetContainerClient = jest.fn().mockImplementation(()=>({
+        createIfNotExists: mockCreateIfNotExists,
+        getBlockBlobClient: mockGetBlockBlobClient,
+        exists: mockContainerExists
+    }));
+const mockFromConnectionString = jest.fn().mockImplementation(()=>({
+        getContainerClient: mockGetContainerClient
+    }));
+const mockBlobServiceClientCtor = jest.fn().mockImplementation(()=>({
+        getContainerClient: mockGetContainerClient
+    }));
+mockBlobServiceClientCtor.fromConnectionString = mockFromConnectionString;
+const mockGenerateBlobSASQueryParameters = jest.fn().mockReturnValue({
+    toString: ()=>'sv=2022&sig=abc123'
+});
+let MockStorageSharedKeyCredential = class MockStorageSharedKeyCredential {
+    constructor(accountName, accountKey){
+        _define_property(this, "accountName", void 0);
+        _define_property(this, "accountKey", void 0);
+        this.accountName = accountName;
+        this.accountKey = accountKey;
+    }
+};
+let MockBlobSASPermissions = class MockBlobSASPermissions {
+    static parse(input) {
+        return {
+            permissions: input
+        };
+    }
+};
+jest.mock('@azure/storage-blob', ()=>({
+        BlobServiceClient: mockBlobServiceClientCtor,
+        StorageSharedKeyCredential: MockStorageSharedKeyCredential,
+        BlobSASPermissions: MockBlobSASPermissions,
+        generateBlobSASQueryParameters: (...args)=>mockGenerateBlobSASQueryParameters(...args)
+    }));
+jest.mock('../utils/image-compressor.util', ()=>({
+        ImageCompressor: {
+            compress: jest.fn()
+        }
+    }));
+import { AzureProvider } from './azure-provider.optional';
+import { ImageCompressor } from '../utils/image-compressor.util';
+function buildMulterFile(overrides = {}) {
+    return {
+        fieldname: 'file',
+        originalname: 'photo.jpg',
+        encoding: '7bit',
+        mimetype: 'image/jpeg',
+        buffer: Buffer.from('file-bytes'),
+        size: 10,
+        stream: undefined,
+        destination: '',
+        filename: '',
+        path: '',
+        ...overrides
+    };
+}
+describe('AzureProvider', ()=>{
+    let provider;
+    beforeEach(async ()=>{
+        jest.clearAllMocks();
+        mockCreateIfNotExists.mockResolvedValue(undefined);
+        mockBlockBlobUpload.mockResolvedValue(undefined);
+        mockDeleteIfExists.mockResolvedValue(undefined);
+        mockContainerExists.mockResolvedValue(true);
+        mockGetBlockBlobClient.mockImplementation(()=>buildBlockBlobClient());
+        mockGetContainerClient.mockImplementation(()=>({
+                createIfNotExists: mockCreateIfNotExists,
+                getBlockBlobClient: mockGetBlockBlobClient,
+                exists: mockContainerExists
+            }));
+        provider = new AzureProvider();
+        await provider.initialize({
+            accountName: 'myaccount',
+            accountKey: 'key123',
+            containerName: 'my-container'
+        });
+    });
+    describe('initialize', ()=>{
+        it('builds a BlobServiceClient using an account key credential when no connection string is given', ()=>{
+            expect(mockBlobServiceClientCtor).toHaveBeenCalledWith('https://myaccount.blob.core.windows.net', expect.any(MockStorageSharedKeyCredential));
+            expect(mockCreateIfNotExists).toHaveBeenCalled();
+        });
+        it('builds a BlobServiceClient from a connection string when provided', async ()=>{
+            jest.clearAllMocks();
+            mockCreateIfNotExists.mockResolvedValue(undefined);
+            const p = new AzureProvider();
+            await p.initialize({
+                accountName: 'acct2',
+                accountKey: 'key2',
+                containerName: 'container2',
+                connectionString: 'DefaultEndpointsProtocol=https;AccountName=acct2;AccountKey=key2'
+            });
+            expect(mockFromConnectionString).toHaveBeenCalledWith('DefaultEndpointsProtocol=https;AccountName=acct2;AccountKey=key2');
+        });
+        it('throws InternalServerErrorException when the Azure SDK cannot be initialized', async ()=>{
+            mockBlobServiceClientCtor.mockImplementationOnce(()=>{
+                throw new Error('boom');
+            });
+            const brokenProvider = new AzureProvider();
+            await expect(brokenProvider.initialize({
+                accountName: 'a',
+                accountKey: 'b',
+                containerName: 'c'
+            })).rejects.toThrow('Azure Storage SDK not found');
+        });
+    });
+    describe('uploadFile', ()=>{
+        it('uploads the blob and returns file metadata', async ()=>{
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {});
+            expect(mockBlockBlobUpload).toHaveBeenCalledWith(file.buffer, file.buffer.length, expect.objectContaining({
+                blobHTTPHeaders: {
+                    blobContentType: 'image/jpeg'
+                }
+            }));
+            expect(result.name).toMatch(/photo\.jpg$/);
+            expect(result.key).toBe(result.name);
+        });
+        it('prefixes blob name with folderPath when provided', async ()=>{
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {
+                folderPath: 'docs'
+            });
+            expect(result.key).toMatch(/^docs\//);
+        });
+        it('compresses image files when options.compress is true', async ()=>{
+            ImageCompressor.compress.mockResolvedValue({
+                buffer: Buffer.from('small'),
+                format: 'image/webp'
+            });
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {
+                compress: true
+            });
+            expect(ImageCompressor.compress).toHaveBeenCalled();
+            expect(result.contentType).toBe('image/webp');
+        });
+    });
+    describe('uploadMultipleFiles', ()=>{
+        it('uploads all files', async ()=>{
+            const files = [
+                buildMulterFile({
+                    originalname: 'a.jpg'
+                }),
+                buildMulterFile({
+                    originalname: 'b.jpg'
+                })
+            ];
+            const results = await provider.uploadMultipleFiles(files, {});
+            expect(results).toHaveLength(2);
+            expect(mockBlockBlobUpload).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('deleteFile', ()=>{
+        it('calls deleteIfExists on the block blob client for the given key', async ()=>{
+            await provider.deleteFile('blob-key.jpg');
+            expect(mockGetBlockBlobClient).toHaveBeenCalledWith('blob-key.jpg');
+            expect(mockDeleteIfExists).toHaveBeenCalled();
+        });
+    });
+    describe('deleteMultipleFiles', ()=>{
+        it('deletes every provided key', async ()=>{
+            await provider.deleteMultipleFiles([
+                'a.jpg',
+                'b.jpg'
+            ]);
+            expect(mockDeleteIfExists).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('generatePresignedUrl', ()=>{
+        it('generates a SAS URL appended with the query string', async ()=>{
+            const url = await provider.generatePresignedUrl('blob-key.jpg', 1800);
+            expect(mockGenerateBlobSASQueryParameters).toHaveBeenCalledWith(expect.objectContaining({
+                containerName: 'my-container',
+                blobName: 'blob-key.jpg'
+            }), 'shared-key-credential');
+            expect(url).toBe('https://account.blob.core.windows.net/container/blob-key.jpg?sv=2022&sig=abc123');
+        });
+        it('defaults the expiry window to 3600 seconds', async ()=>{
+            await provider.generatePresignedUrl('blob-key.jpg');
+            const call = mockGenerateBlobSASQueryParameters.mock.calls[0][0];
+            const diffSeconds = (call.expiresOn.getTime() - call.startsOn.getTime()) / 1000;
+            expect(diffSeconds).toBeCloseTo(3600, 0);
+        });
+    });
+    describe('healthCheck', ()=>{
+        it('returns true when the container exists', async ()=>{
+            mockContainerExists.mockResolvedValue(true);
+            await expect(provider.healthCheck()).resolves.toBe(true);
+        });
+        it('returns false when checking existence throws', async ()=>{
+            mockContainerExists.mockRejectedValue(new Error('network error'));
+            await expect(provider.healthCheck()).resolves.toBe(false);
+        });
+    });
+});

package/fesm/providers/local-provider.spec.js

@@ -0,0 +1,194 @@
+const mockMkdir = jest.fn();
+const mockWriteFile = jest.fn();
+const mockAccess = jest.fn();
+const mockUnlink = jest.fn();
+jest.mock('fs/promises', ()=>({
+        mkdir: (...args)=>mockMkdir(...args),
+        writeFile: (...args)=>mockWriteFile(...args),
+        access: (...args)=>mockAccess(...args),
+        unlink: (...args)=>mockUnlink(...args)
+    }));
+jest.mock('../utils/image-compressor.util', ()=>({
+        ImageCompressor: {
+            compress: jest.fn()
+        }
+    }));
+import * as path from 'path';
+import { LocalProvider } from './local-provider';
+import { ImageCompressor } from '../utils/image-compressor.util';
+function buildMulterFile(overrides = {}) {
+    return {
+        fieldname: 'file',
+        originalname: 'photo.jpg',
+        encoding: '7bit',
+        mimetype: 'image/jpeg',
+        buffer: Buffer.from('file-bytes'),
+        size: 10,
+        stream: undefined,
+        destination: '',
+        filename: '',
+        path: '',
+        ...overrides
+    };
+}
+describe('LocalProvider', ()=>{
+    let provider;
+    beforeEach(async ()=>{
+        jest.clearAllMocks();
+        mockMkdir.mockResolvedValue(undefined);
+        mockWriteFile.mockResolvedValue(undefined);
+        mockAccess.mockResolvedValue(undefined);
+        mockUnlink.mockResolvedValue(undefined);
+        provider = new LocalProvider();
+        await provider.initialize({
+            basePath: './uploads-test',
+            baseUrl: 'http://localhost:2002'
+        });
+    });
+    describe('initialize', ()=>{
+        it('resolves the base path and ensures the directory exists', async ()=>{
+            expect(mockMkdir).toHaveBeenCalledWith(path.resolve('./uploads-test'), expect.objectContaining({
+                recursive: true
+            }));
+        });
+        it('defaults basePath to ./uploads when not provided', async ()=>{
+            mockMkdir.mockClear();
+            const defaultProvider = new LocalProvider();
+            await defaultProvider.initialize({});
+            expect(mockMkdir).toHaveBeenCalledWith(path.resolve('./uploads'), expect.objectContaining({
+                recursive: true
+            }));
+        });
+    });
+    describe('uploadFile', ()=>{
+        it('writes the file to disk and returns metadata with a self-contained key', async ()=>{
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {});
+            expect(mockWriteFile).toHaveBeenCalled();
+            expect(result.name).toMatch(/photo\.jpg$/);
+            expect(result.key).toContain('uploads-test');
+            expect(result.size).toBe(file.buffer.length);
+            expect(result.contentType).toBe('image/jpeg');
+        });
+        it('nests the file under folderPath when provided', async ()=>{
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {
+                folderPath: 'avatars'
+            });
+            expect(result.key).toContain('avatars');
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('avatars'), expect.objectContaining({
+                recursive: true
+            }));
+        });
+        it('compresses image files when options.compress is true', async ()=>{
+            ImageCompressor.compress.mockResolvedValue({
+                buffer: Buffer.from('compressed'),
+                format: 'image/webp'
+            });
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {
+                compress: true,
+                maxWidth: 800,
+                maxHeight: 600,
+                quality: 70
+            });
+            expect(ImageCompressor.compress).toHaveBeenCalledWith(file.buffer, 'image/jpeg', expect.objectContaining({
+                maxWidth: 800,
+                maxHeight: 600,
+                quality: 70
+            }));
+            expect(result.contentType).toBe('image/webp');
+            expect(result.size).toBe(Buffer.from('compressed').length);
+        });
+        it('does not compress non-image mimetypes even when compress=true', async ()=>{
+            const file = buildMulterFile({
+                mimetype: 'application/pdf',
+                originalname: 'doc.pdf'
+            });
+            await provider.uploadFile(file, {
+                compress: true
+            });
+            expect(ImageCompressor.compress).not.toHaveBeenCalled();
+        });
+        it('rejects a folderPath that attempts to escape the base directory via path traversal', async ()=>{
+            const file = buildMulterFile();
+            await expect(provider.uploadFile(file, {
+                folderPath: '../../../etc'
+            })).rejects.toThrow();
+        });
+    });
+    describe('uploadMultipleFiles', ()=>{
+        it('uploads all files and returns their metadata', async ()=>{
+            const files = [
+                buildMulterFile({
+                    originalname: 'a.jpg'
+                }),
+                buildMulterFile({
+                    originalname: 'b.jpg'
+                })
+            ];
+            const results = await provider.uploadMultipleFiles(files, {});
+            expect(results).toHaveLength(2);
+            expect(mockWriteFile).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('deleteFile', ()=>{
+        it('deletes a file that exists at the resolved key path', async ()=>{
+            const key = path.join('uploads-test', 'some-uuid-photo.jpg');
+            await provider.deleteFile(key);
+            expect(mockUnlink).toHaveBeenCalled();
+        });
+        it('falls back to basePath-prefixed lookup when the direct key path does not exist', async ()=>{
+            mockAccess.mockRejectedValueOnce(new Error('ENOENT')).mockResolvedValueOnce(undefined);
+            await provider.deleteFile('uploads-test/some-uuid-photo.jpg');
+            expect(mockUnlink).toHaveBeenCalled();
+        });
+        it('silently returns (no throw, no unlink) when the file does not exist at either location', async ()=>{
+            mockAccess.mockRejectedValue(new Error('ENOENT'));
+            await expect(provider.deleteFile('uploads-test/missing-file.jpg')).resolves.toBeUndefined();
+            expect(mockUnlink).not.toHaveBeenCalled();
+        });
+        it('rejects an empty key', async ()=>{
+            await expect(provider.deleteFile('')).rejects.toThrow();
+        });
+        it('rejects a key containing a null byte', async ()=>{
+            await expect(provider.deleteFile('evil\0.txt')).rejects.toThrow();
+        });
+        it('re-throws path traversal security errors rather than silently swallowing them', async ()=>{
+            await expect(provider.deleteFile('../../../etc/passwd')).rejects.toThrow(/Invalid/);
+        });
+    });
+    describe('deleteMultipleFiles', ()=>{
+        it('deletes every provided key', async ()=>{
+            await provider.deleteMultipleFiles([
+                'uploads-test/a.jpg',
+                'uploads-test/b.jpg'
+            ]);
+            expect(mockUnlink).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('generatePresignedUrl', ()=>{
+        it('builds a full URL using the configured baseUrl', async ()=>{
+            const url = await provider.generatePresignedUrl('uploads-test/photo.jpg');
+            expect(url).toBe('http://localhost:2002/storage/upload/file/uploads-test/photo.jpg');
+        });
+        it('returns a relative path when no baseUrl was configured', async ()=>{
+            const noUrlProvider = new LocalProvider();
+            await noUrlProvider.initialize({
+                basePath: './uploads-test2'
+            });
+            const url = await noUrlProvider.generatePresignedUrl('uploads-test2/photo.jpg');
+            expect(url).toBe('/storage/upload/file/uploads-test2/photo.jpg');
+        });
+    });
+    describe('healthCheck', ()=>{
+        it('returns true when the base path is accessible', async ()=>{
+            mockAccess.mockResolvedValue(undefined);
+            await expect(provider.healthCheck()).resolves.toBe(true);
+        });
+        it('returns false when the base path is not accessible', async ()=>{
+            mockAccess.mockRejectedValue(new Error('ENOENT'));
+            await expect(provider.healthCheck()).resolves.toBe(false);
+        });
+    });
+});

package/fesm/providers/s3-provider.optional.spec.js

@@ -0,0 +1,239 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+const mockS3ClientSend = jest.fn();
+const mockS3ClientCtor = jest.fn().mockImplementation(()=>({
+        send: mockS3ClientSend
+    }));
+let MockDeleteObjectCommand = class MockDeleteObjectCommand {
+    constructor(input){
+        _define_property(this, "input", void 0);
+        this.input = input;
+    }
+};
+let MockDeleteObjectsCommand = class MockDeleteObjectsCommand {
+    constructor(input){
+        _define_property(this, "input", void 0);
+        this.input = input;
+    }
+};
+let MockGetObjectCommand = class MockGetObjectCommand {
+    constructor(input){
+        _define_property(this, "input", void 0);
+        this.input = input;
+    }
+};
+let MockHeadBucketCommand = class MockHeadBucketCommand {
+    constructor(input){
+        _define_property(this, "input", void 0);
+        this.input = input;
+    }
+};
+jest.mock('@aws-sdk/client-s3', ()=>({
+        S3Client: mockS3ClientCtor,
+        DeleteObjectCommand: MockDeleteObjectCommand,
+        DeleteObjectsCommand: MockDeleteObjectsCommand,
+        GetObjectCommand: MockGetObjectCommand,
+        HeadBucketCommand: MockHeadBucketCommand
+    }));
+const mockUploadDone = jest.fn();
+const mockUploadCtor = jest.fn().mockImplementation(()=>({
+        done: mockUploadDone
+    }));
+jest.mock('@aws-sdk/lib-storage', ()=>({
+        Upload: mockUploadCtor
+    }));
+const mockGetSignedUrl = jest.fn();
+jest.mock('@aws-sdk/s3-request-presigner', ()=>({
+        getSignedUrl: (...args)=>mockGetSignedUrl(...args)
+    }));
+jest.mock('../utils/image-compressor.util', ()=>({
+        ImageCompressor: {
+            compress: jest.fn()
+        }
+    }));
+import { S3Provider } from './s3-provider.optional';
+import { ImageCompressor } from '../utils/image-compressor.util';
+function buildMulterFile(overrides = {}) {
+    return {
+        fieldname: 'file',
+        originalname: 'photo.jpg',
+        encoding: '7bit',
+        mimetype: 'image/jpeg',
+        buffer: Buffer.from('file-bytes'),
+        size: 10,
+        stream: undefined,
+        destination: '',
+        filename: '',
+        path: '',
+        ...overrides
+    };
+}
+describe('S3Provider', ()=>{
+    let provider;
+    beforeEach(async ()=>{
+        jest.clearAllMocks();
+        mockUploadDone.mockResolvedValue(undefined);
+        provider = new S3Provider();
+        await provider.initialize({
+            region: 'us-east-1',
+            bucket: 'my-bucket'
+        });
+    });
+    describe('initialize', ()=>{
+        it('creates an S3Client with region/endpoint/credentials', async ()=>{
+            jest.clearAllMocks();
+            const p = new S3Provider();
+            await p.initialize({
+                region: 'eu-west-1',
+                bucket: 'bucket-2',
+                accessKeyId: 'AKIA...',
+                secretAccessKey: 'secret',
+                endpoint: 'https://s3.custom.example.com'
+            });
+            expect(mockS3ClientCtor).toHaveBeenCalledWith(expect.objectContaining({
+                region: 'eu-west-1',
+                endpoint: 'https://s3.custom.example.com',
+                credentials: {
+                    accessKeyId: 'AKIA...',
+                    secretAccessKey: 'secret'
+                }
+            }));
+        });
+        it('omits credentials when access key / secret are not provided', async ()=>{
+            jest.clearAllMocks();
+            const p = new S3Provider();
+            await p.initialize({
+                region: 'us-east-1',
+                bucket: 'bucket-3'
+            });
+            expect(mockS3ClientCtor).toHaveBeenCalledWith(expect.objectContaining({
+                credentials: undefined
+            }));
+        });
+        it('throws InternalServerErrorException when the AWS SDK cannot be initialized', async ()=>{
+            mockS3ClientCtor.mockImplementationOnce(()=>{
+                throw new Error('module not found');
+            });
+            const brokenProvider = new S3Provider();
+            await expect(brokenProvider.initialize({
+                region: 'us-east-1',
+                bucket: 'x'
+            })).rejects.toThrow('AWS SDK not found');
+        });
+    });
+    describe('uploadFile', ()=>{
+        it('uploads via the S3 Upload helper and returns file metadata', async ()=>{
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {});
+            expect(mockUploadCtor).toHaveBeenCalledWith(expect.objectContaining({
+                params: expect.objectContaining({
+                    Bucket: 'my-bucket',
+                    ContentType: 'image/jpeg'
+                })
+            }));
+            expect(mockUploadDone).toHaveBeenCalled();
+            expect(result.name).toMatch(/photo\.jpg$/);
+            expect(result.key).toBe(result.name);
+        });
+        it('prefixes the key with folderPath when provided', async ()=>{
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {
+                folderPath: 'avatars'
+            });
+            expect(result.key).toMatch(/^avatars\//);
+        });
+        it('compresses image files before upload when options.compress is true', async ()=>{
+            ImageCompressor.compress.mockResolvedValue({
+                buffer: Buffer.from('compressed'),
+                format: 'image/webp'
+            });
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {
+                compress: true
+            });
+            expect(ImageCompressor.compress).toHaveBeenCalled();
+            expect(result.contentType).toBe('image/webp');
+        });
+    });
+    describe('uploadMultipleFiles', ()=>{
+        it('uploads each file and returns metadata for all', async ()=>{
+            const files = [
+                buildMulterFile({
+                    originalname: 'a.jpg'
+                }),
+                buildMulterFile({
+                    originalname: 'b.jpg'
+                })
+            ];
+            const results = await provider.uploadMultipleFiles(files, {});
+            expect(results).toHaveLength(2);
+            expect(mockUploadCtor).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('deleteFile', ()=>{
+        it('sends a DeleteObjectCommand with bucket and key', async ()=>{
+            await provider.deleteFile('some/key.jpg');
+            expect(mockS3ClientSend).toHaveBeenCalledWith(expect.any(MockDeleteObjectCommand));
+            const sentCommand = mockS3ClientSend.mock.calls[0][0];
+            expect(sentCommand.input).toEqual({
+                Bucket: 'my-bucket',
+                Key: 'some/key.jpg'
+            });
+        });
+    });
+    describe('deleteMultipleFiles', ()=>{
+        it('sends a DeleteObjectsCommand containing all keys', async ()=>{
+            await provider.deleteMultipleFiles([
+                'a.jpg',
+                'b.jpg'
+            ]);
+            const sentCommand = mockS3ClientSend.mock.calls[0][0];
+            expect(sentCommand.input.Delete.Objects).toEqual([
+                {
+                    Key: 'a.jpg'
+                },
+                {
+                    Key: 'b.jpg'
+                }
+            ]);
+        });
+    });
+    describe('generatePresignedUrl', ()=>{
+        it('delegates to getSignedUrl with the configured expiry', async ()=>{
+            mockGetSignedUrl.mockResolvedValue('https://signed.example.com/some/key.jpg');
+            const url = await provider.generatePresignedUrl('some/key.jpg', 900);
+            expect(mockGetSignedUrl).toHaveBeenCalledWith(expect.anything(), expect.any(MockGetObjectCommand), {
+                expiresIn: 900
+            });
+            expect(url).toBe('https://signed.example.com/some/key.jpg');
+        });
+        it('defaults expiry to 3600 seconds when not provided', async ()=>{
+            mockGetSignedUrl.mockResolvedValue('https://signed.example.com/x');
+            await provider.generatePresignedUrl('x');
+            expect(mockGetSignedUrl).toHaveBeenCalledWith(expect.anything(), expect.anything(), {
+                expiresIn: 3600
+            });
+        });
+    });
+    describe('healthCheck', ()=>{
+        it('returns true when HeadBucketCommand succeeds', async ()=>{
+            mockS3ClientSend.mockResolvedValue({});
+            await expect(provider.healthCheck()).resolves.toBe(true);
+        });
+        it('returns false when HeadBucketCommand rejects (bucket missing/unauthorized)', async ()=>{
+            mockS3ClientSend.mockRejectedValue(new Error('Forbidden'));
+            await expect(provider.healthCheck()).resolves.toBe(false);
+        });
+    });
+});