@flusys/nestjs-storage 6.0.2 → 6.1.1

package/cjs/middlewares/file-serve.middleware.spec.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _events = require("events");
+const _path = require("path");
+const _fileservemiddleware = require("./file-serve.middleware");
+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 mockCreateReadStream = jest.fn();
+const mockExistsSync = jest.fn();
+const mockStatSync = jest.fn();
+jest.mock('fs', ()=>({
+        ...jest.requireActual('fs'),
+        createReadStream: (...args)=>mockCreateReadStream(...args),
+        existsSync: (...args)=>mockExistsSync(...args),
+        statSync: (...args)=>mockStatSync(...args)
+    }));
+const mockMimeLookup = jest.fn();
+jest.mock('mime-types', ()=>({
+        lookup: (...args)=>mockMimeLookup(...args)
+    }));
+let FakeStream = class FakeStream extends _events.EventEmitter {
+    constructor(...args){
+        super(...args), _define_property(this, "pipe", jest.fn()), _define_property(this, "destroy", jest.fn());
+    }
+};
+function buildRes() {
+    const listeners = {};
+    return {
+        headersSent: false,
+        set: jest.fn(),
+        status: jest.fn().mockReturnThis(),
+        json: jest.fn(),
+        on: jest.fn((event, cb)=>{
+            listeners[event] = listeners[event] || [];
+            listeners[event].push(cb);
+        }),
+        emitClose: ()=>(listeners['close'] || []).forEach((cb)=>cb())
+    };
+}
+function buildReq(urlPath) {
+    return {
+        path: urlPath,
+        url: urlPath
+    };
+}
+describe('FileServeMiddleware', ()=>{
+    let middleware;
+    let mockUploadService;
+    let next;
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockUploadService = {
+            getLocalStorageBasePath: jest.fn().mockResolvedValue(null)
+        };
+        middleware = new _fileservemiddleware.FileServeMiddleware(mockUploadService);
+        next = jest.fn();
+    });
+    it('responds 404 when the file path segment is missing from the URL', async ()=>{
+        const res = buildRes();
+        await middleware.use(buildReq('/storage/upload/file/'), res, next);
+        expect(res.status).toHaveBeenCalledWith(404);
+        expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
+            success: false,
+            statusCode: 404
+        }));
+        expect(mockExistsSync).not.toHaveBeenCalled();
+    });
+    it('blocks path traversal attempts that resolve outside the upload directory', async ()=>{
+        const res = buildRes();
+        mockExistsSync.mockReturnValue(false);
+        await middleware.use(buildReq('/storage/upload/file/../../etc/passwd'), res, next);
+        expect(res.status).toHaveBeenCalledWith(404);
+        expect(mockStatSync).not.toHaveBeenCalled();
+    });
+    it('serves a file that exists directly under the upload directory with inline disposition for viewable types', async ()=>{
+        const res = buildRes();
+        mockExistsSync.mockReturnValue(true);
+        mockStatSync.mockReturnValue({
+            isFile: ()=>true,
+            size: 1234
+        });
+        mockMimeLookup.mockReturnValue('application/pdf');
+        const stream = new FakeStream();
+        mockCreateReadStream.mockReturnValue(stream);
+        await middleware.use(buildReq('/storage/upload/file/report.pdf'), res, next);
+        expect(res.set).toHaveBeenCalledWith(expect.objectContaining({
+            'Content-Type': 'application/pdf',
+            'Content-Length': 1234,
+            'Content-Disposition': 'inline'
+        }));
+        expect(stream.pipe).toHaveBeenCalledWith(res);
+    });
+    it('sets an attachment content-disposition with the filename for non-viewable mime types', async ()=>{
+        const res = buildRes();
+        mockExistsSync.mockReturnValue(true);
+        mockStatSync.mockReturnValue({
+            isFile: ()=>true,
+            size: 500
+        });
+        mockMimeLookup.mockReturnValue('application/zip');
+        mockCreateReadStream.mockReturnValue(new FakeStream());
+        await middleware.use(buildReq('/storage/upload/file/archive.zip'), res, next);
+        expect(res.set).toHaveBeenCalledWith(expect.objectContaining({
+            'Content-Disposition': expect.stringContaining('attachment; filename="archive.zip"')
+        }));
+    });
+    it('always serves .svg files as image/svg+xml regardless of mime-types lookup', async ()=>{
+        const res = buildRes();
+        mockExistsSync.mockReturnValue(true);
+        mockStatSync.mockReturnValue({
+            isFile: ()=>true,
+            size: 200
+        });
+        mockCreateReadStream.mockReturnValue(new FakeStream());
+        await middleware.use(buildReq('/storage/upload/file/logo.svg'), res, next);
+        expect(mockMimeLookup).not.toHaveBeenCalled();
+        expect(res.set).toHaveBeenCalledWith(expect.objectContaining({
+            'Content-Type': 'image/svg+xml'
+        }));
+    });
+    it('returns 404 when the resolved path exists but is not a regular file', async ()=>{
+        const res = buildRes();
+        mockExistsSync.mockReturnValue(true);
+        mockStatSync.mockReturnValue({
+            isFile: ()=>false
+        });
+        await middleware.use(buildReq('/storage/upload/file/some-dir'), res, next);
+        expect(res.status).toHaveBeenCalledWith(404);
+        expect(mockCreateReadStream).not.toHaveBeenCalled();
+    });
+    it('falls back to the configured local storage base path (strategy 2: path already prefixed with base)', async ()=>{
+        const res = buildRes();
+        const fallbackPath = (0, _path.join)('uploads', 'report.pdf');
+        mockUploadService.getLocalStorageBasePath.mockResolvedValue('./uploads');
+        mockExistsSync.mockImplementation((p)=>p === fallbackPath);
+        mockStatSync.mockReturnValue({
+            isFile: ()=>true,
+            size: 10
+        });
+        mockMimeLookup.mockReturnValue('application/pdf');
+        mockCreateReadStream.mockReturnValue(new FakeStream());
+        await middleware.use(buildReq('/storage/upload/file/uploads/report.pdf'), res, next);
+        expect(mockCreateReadStream).toHaveBeenCalledWith(fallbackPath);
+    });
+    it('falls back to the configured local storage base path (strategy 3: legacy path without base prefix)', async ()=>{
+        const res = buildRes();
+        const fallbackPath = (0, _path.join)('uploads', 'report.pdf');
+        mockUploadService.getLocalStorageBasePath.mockResolvedValue('uploads');
+        mockExistsSync.mockImplementation((p)=>p === fallbackPath);
+        mockStatSync.mockReturnValue({
+            isFile: ()=>true,
+            size: 10
+        });
+        mockMimeLookup.mockReturnValue('application/pdf');
+        mockCreateReadStream.mockReturnValue(new FakeStream());
+        await middleware.use(buildReq('/storage/upload/file/report.pdf'), res, next);
+        expect(mockCreateReadStream).toHaveBeenCalledWith(fallbackPath);
+    });
+    it('returns the underlying not-found message when no direct or fallback path resolves', async ()=>{
+        const res = buildRes();
+        mockExistsSync.mockReturnValue(false);
+        mockUploadService.getLocalStorageBasePath.mockResolvedValue(null);
+        await middleware.use(buildReq('/storage/upload/file/missing.pdf'), res, next);
+        expect(res.status).toHaveBeenCalledWith(404);
+        expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
+            message: expect.stringContaining('File not found'),
+            statusCode: 404
+        }));
+    });
+    it('sends a 404 if the file stream errors before headers are sent', async ()=>{
+        const res = buildRes();
+        mockExistsSync.mockReturnValue(true);
+        mockStatSync.mockReturnValue({
+            isFile: ()=>true,
+            size: 10
+        });
+        mockMimeLookup.mockReturnValue('application/pdf');
+        const stream = new FakeStream();
+        mockCreateReadStream.mockReturnValue(stream);
+        await middleware.use(buildReq('/storage/upload/file/report.pdf'), res, next);
+        stream.emit('error', new Error('boom'));
+        expect(res.status).toHaveBeenCalledWith(404);
+    });
+    it('destroys the stream when the response is closed early', async ()=>{
+        const res = buildRes();
+        mockExistsSync.mockReturnValue(true);
+        mockStatSync.mockReturnValue({
+            isFile: ()=>true,
+            size: 10
+        });
+        mockMimeLookup.mockReturnValue('application/pdf');
+        const stream = new FakeStream();
+        mockCreateReadStream.mockReturnValue(stream);
+        await middleware.use(buildReq('/storage/upload/file/report.pdf'), res, next);
+        res.emitClose();
+        expect(stream.destroy).toHaveBeenCalled();
+    });
+});

package/cjs/modules/storage.module.spec.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _storagemodule = require("./storage.module");
+const _storageconstants = require("../config/storage.constants");
+const _controllers = require("../controllers");
+const _middlewares = require("../middlewares");
+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;
+}
+function providerTokens(providers) {
+    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
+}
+describe('StorageModule', ()=>{
+    describe('forRoot', ()=>{
+        it('should default to a non-global module with all controllers registered', ()=>{
+            const dynamicModule = _storagemodule.StorageModule.forRoot({});
+            expect(dynamicModule.module).toBe(_storagemodule.StorageModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                _controllers.FileManagerController,
+                _controllers.FolderController,
+                _controllers.StorageConfigController,
+                _controllers.UploadController
+            ]);
+        });
+        it('should respect global: true', ()=>{
+            expect(_storagemodule.StorageModule.forRoot({
+                global: true
+            }).global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            expect(_storagemodule.StorageModule.forRoot({
+                includeController: false
+            }).controllers).toEqual([]);
+        });
+        it('should register controllers when includeController is anything other than exactly false', ()=>{
+            expect(_storagemodule.StorageModule.forRoot({
+                includeController: true
+            }).controllers).toHaveLength(4);
+            expect(_storagemodule.StorageModule.forRoot({}).controllers).toHaveLength(4);
+        });
+        it('should register a STORAGE_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            };
+            const dynamicModule = _storagemodule.StorageModule.forRoot(options);
+            const provider = dynamicModule.providers.find((p)=>p.provide === _storageconstants.STORAGE_MODULE_OPTIONS);
+            expect(provider.useValue).toBe(options);
+        });
+        it('should always export the same fixed set of services', ()=>{
+            const dynamicModule = _storagemodule.StorageModule.forRoot({});
+            expect(dynamicModule.exports).toHaveLength(7);
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                imports: [
+                    FakeImportedModule
+                ]
+            });
+            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
+                FakeImportedModule
+            ]));
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                includeController: false
+            });
+            expect(dynamicModule.controllers).toEqual([]);
+        });
+        it('useFactory: builds a STORAGE_MODULE_OPTIONS provider that merges resolved config into the static options', async ()=>{
+            const useFactory = jest.fn().mockResolvedValue({
+                maxFileSize: 1024
+            });
+            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const provider = dynamicModule.providers.find((p)=>p.provide === _storageconstants.STORAGE_MODULE_OPTIONS);
+            expect(provider.inject).toEqual([
+                'SOME_TOKEN'
+            ]);
+            const resolved = await provider.useFactory('injected');
+            expect(useFactory).toHaveBeenCalledWith('injected');
+            expect(resolved.config).toEqual({
+                maxFileSize: 1024
+            });
+        });
+        it('useClass: registers both the class provider and an options provider calling createStorageOptions()', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createStorageOptions", jest.fn().mockResolvedValue({
+                        maxFileSize: 2048
+                    }));
+                }
+            };
+            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useClass: MyOptionsFactory
+            });
+            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
+            expect(classProvider.useClass).toBe(MyOptionsFactory);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _storageconstants.STORAGE_MODULE_OPTIONS);
+            const instance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(instance);
+            expect(instance.createStorageOptions).toHaveBeenCalled();
+            expect(resolved.config).toEqual({
+                maxFileSize: 2048
+            });
+        });
+        it('useExisting: registers a single options provider without a duplicate class registration', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createStorageOptions", jest.fn().mockResolvedValue({
+                        maxFileSize: 4096
+                    }));
+                }
+            };
+            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useExisting: MyOptionsFactory
+            });
+            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _storageconstants.STORAGE_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+        });
+        it('should register no STORAGE_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
+            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
+                bootstrapAppConfig: {}
+            });
+            expect(providerTokens(dynamicModule.providers)).not.toContain(_storageconstants.STORAGE_MODULE_OPTIONS);
+        });
+        it('should still register the fixed exported services as providers alongside async options', ()=>{
+            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useFactory: jest.fn()
+            });
+            expect(dynamicModule.providers).toEqual(expect.arrayContaining([
+                ...dynamicModule.exports
+            ]));
+        });
+    });
+    describe('configure (NestModule)', ()=>{
+        it('should wire FileServeMiddleware to the file GET route', ()=>{
+            const forRoutes = jest.fn();
+            const apply = jest.fn().mockReturnValue({
+                forRoutes
+            });
+            const consumer = {
+                apply
+            };
+            new _storagemodule.StorageModule().configure(consumer);
+            expect(apply).toHaveBeenCalledWith(_middlewares.FileServeMiddleware);
+            expect(forRoutes).toHaveBeenCalledWith({
+                path: 'storage/upload/file/*',
+                method: expect.anything()
+            });
+        });
+    });
+});

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

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _azureprovideroptional = require("./azure-provider.optional");
+const _imagecompressorutil = require("../utils/image-compressor.util");
+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()
+        }
+    }));
+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 _azureprovideroptional.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 _azureprovideroptional.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 _azureprovideroptional.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 ()=>{
+            _imagecompressorutil.ImageCompressor.compress.mockResolvedValue({
+                buffer: Buffer.from('small'),
+                format: 'image/webp'
+            });
+            const file = buildMulterFile();
+            const result = await provider.uploadFile(file, {
+                compress: true
+            });
+            expect(_imagecompressorutil.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);
+        });
+    });
+});