@dereekb/firebase 12.6.21 → 13.0.0

package/test/src/lib/common/storage/test.driver.accessor.js

@@ -1,669 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.describeFirebaseStorageAccessorDriverTests = describeFirebaseStorageAccessorDriverTests;
-const test_1 = require("@dereekb/util/test");
-const util_1 = require("@dereekb/util");
-const firebase_1 = require("@dereekb/firebase");
-const stream_1 = require("stream");
-const fs_1 = require("fs");
-/**
- * Describes accessor driver tests, using a MockItemCollectionFixture.
- *
- * @param f
- */
-function describeFirebaseStorageAccessorDriverTests(f) {
-    describe('FirebaseStorageAccessor', () => {
-        describe('file()', () => {
-            const secondBucket = 'second-bucket';
-            const doesNotExistFilePath = 'test.png';
-            let doesNotExistFile;
-            const existsFilePath = 'test/exists.txt';
-            const existsFileContent = 'Hello! \ud83d\ude0a';
-            const existsFileContentType = 'text/plain';
-            let existsFile;
-            let secondBucketTarget;
-            beforeEach(async () => {
-                doesNotExistFile = f.storageContext.file(doesNotExistFilePath);
-                existsFile = f.storageContext.file(existsFilePath);
-                await existsFile.upload(existsFileContent, { stringFormat: 'raw', contentType: existsFileContentType }); // re-upload for each test
-                // delete the does not exist file and second bucket target if it exists
-                await doesNotExistFile.delete().catch(() => null);
-                secondBucketTarget = f.storageContext.file({ bucketId: secondBucket, pathString: doesNotExistFilePath });
-                await secondBucketTarget.delete().catch(() => null);
-            });
-            describe('uploading', () => {
-                let uploadFile;
-                beforeEach(() => {
-                    uploadFile = f.storageContext.file('upload.txt');
-                });
-                describe('upload()', () => {
-                    describe('string types', () => {
-                        (0, test_1.itShouldFail)('if stringFormat is not defined in the options', async () => {
-                            const contentType = 'text/plain';
-                            const data = existsFileContent;
-                            await (0, test_1.expectFail)(() => uploadFile.upload(data, { contentType }));
-                        });
-                        it('should upload a raw UTF-16 string.', async () => {
-                            const contentType = 'text/plain';
-                            const data = existsFileContent;
-                            await uploadFile.upload(data, { stringFormat: 'raw', contentType });
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.contentType).toBe(contentType);
-                            const result = await uploadFile.getBytes();
-                            expect(result).toBeDefined();
-                            const decoded = Buffer.from(result).toString('utf-8');
-                            expect(decoded).toBe(data);
-                        });
-                        it('should upload a base64 string.', async () => {
-                            const bytes = await existsFile.getBytes();
-                            const data = Buffer.from(bytes).toString('base64');
-                            const contentType = 'text/plain';
-                            await uploadFile.upload(data, { stringFormat: 'base64', contentType });
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.contentType).toBe(contentType);
-                            const result = await uploadFile.getBytes();
-                            expect(result).toBeDefined();
-                            const decoded = Buffer.from(result).toString('utf-8');
-                            expect(decoded).toBe(existsFileContent);
-                        });
-                        it('should upload a base64url string.', async () => {
-                            const bytes = await existsFile.getBytes();
-                            const data = Buffer.from(bytes).toString('base64url');
-                            const contentType = 'text/plain';
-                            await uploadFile.upload(data, { stringFormat: 'base64url', contentType });
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.contentType).toBe(contentType);
-                            const result = await uploadFile.getBytes();
-                            expect(result).toBeDefined();
-                            const decoded = Buffer.from(result).toString('utf-8');
-                            expect(decoded).toBe(existsFileContent);
-                        });
-                    });
-                    describe('data types', () => {
-                        // NOTE: We can really only test how a NodeJS environment will behave here.
-                        it('should upload a Uint8Array', async () => {
-                            const dataBuffer = Buffer.from(existsFileContent, 'utf-8');
-                            const data = new Uint8Array(dataBuffer);
-                            const contentType = 'text/plain';
-                            await uploadFile.upload(data, { contentType });
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.contentType).toBe(contentType);
-                        });
-                        it('should upload a Buffer', async () => {
-                            const buffer = Buffer.from(existsFileContent, 'utf-8');
-                            const contentType = 'text/plain';
-                            await uploadFile.upload(buffer, { contentType });
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.contentType).toBe(contentType);
-                        });
-                        it('should upload a Blob', async () => {
-                            const buffer = Buffer.from(existsFileContent, 'utf-8');
-                            const data = new Uint8Array(buffer);
-                            const blob = data.buffer; // blob-like
-                            const contentType = 'text/plain';
-                            await uploadFile.upload(blob, { contentType });
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.contentType).toBe(contentType);
-                        });
-                        // NOTE: File extends Blob, so above test should cover it ok.
-                    });
-                    // TODO(TEST): Test uploading other types.
-                    describe('custom metadata', () => {
-                        it('should upload custom metadata via customMetadata', async () => {
-                            const customMetadataKey = 'x-amz-meta-custom-key';
-                            const customMetadataValue = 'custom-value';
-                            const customMetadata = {
-                                [customMetadataKey]: customMetadataValue
-                            };
-                            const contentType = 'text/plain';
-                            const data = existsFileContent;
-                            await uploadFile.upload(data, { stringFormat: 'raw', contentType, customMetadata });
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.customMetadata).toEqual(customMetadata);
-                        });
-                        it('should upload custom metadata via metadata', async () => {
-                            const customMetadataKey = 'x-amz-meta-custom-key';
-                            const customMetadataValue = 'custom-value';
-                            const customMetadata = {
-                                [customMetadataKey]: customMetadataValue
-                            };
-                            const contentType = 'text/plain';
-                            const data = existsFileContent;
-                            await uploadFile.upload(data, { stringFormat: 'raw', contentType, metadata: { customMetadata } });
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.customMetadata).toEqual(customMetadata);
-                        });
-                        it('should upload the merged custom metadatas', async () => {
-                            const customMetadataAKey = 'x-amz-meta-custom-key';
-                            const customMetadataAValue = '1';
-                            const customMetadataBKey = 'x-axx-meta-custom-key';
-                            const customMetadataBValue = 'true';
-                            const customMetadataA = {
-                                [customMetadataAKey]: customMetadataAValue
-                            };
-                            const customMetadataB = {
-                                [customMetadataBKey]: customMetadataBValue
-                            };
-                            const contentType = 'text/plain';
-                            const data = existsFileContent;
-                            await uploadFile.upload(data, { stringFormat: 'raw', contentType, customMetadata: customMetadataA, metadata: { customMetadata: customMetadataB } });
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.customMetadata).toEqual({ ...customMetadataA, ...customMetadataB });
-                        });
-                    });
-                });
-                describe('uploadStream()', () => {
-                    it('should upload a string using a WritableStream', async () => {
-                        if (uploadFile.uploadStream != null) {
-                            const contentType = 'text/plain';
-                            const data = existsFileContent;
-                            const stream = uploadFile.uploadStream();
-                            await (0, util_1.useCallback)((cb) => stream.write(data, 'utf-8', cb));
-                            await (0, util_1.useCallback)((cb) => stream.end(cb));
-                            const exists = await uploadFile.exists();
-                            expect(exists).toBe(true);
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.contentType).toBe(contentType);
-                            const result = await uploadFile.getBytes();
-                            expect(result).toBeDefined();
-                            const decoded = Buffer.from(result).toString('utf-8');
-                            expect(decoded).toBe(data);
-                        }
-                    });
-                    it('should upload a string using a stream using a WritableStream', async () => {
-                        if (uploadFile.uploadStream != null) {
-                            const myText = 'This is a test string.';
-                            // Create a readable stream from the string
-                            const readableStream = stream_1.Readable.from(myText, { encoding: 'utf-8' });
-                            await (0, firebase_1.uploadFileWithStream)(uploadFile, readableStream);
-                            const exists = await uploadFile.exists();
-                            expect(exists).toBe(true);
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.contentType).toBe('text/plain');
-                            const result = await uploadFile.getBytes();
-                            expect(result).toBeDefined();
-                            const decoded = Buffer.from(result).toString('utf-8');
-                            expect(decoded).toBe(myText);
-                        }
-                    });
-                    it('should upload a png using a stream using a WritableStream', async () => {
-                        if (uploadFile.uploadStream != null) {
-                            const testFilePath = `${__dirname}/assets/testpng.png`;
-                            const contentType = 'image/png';
-                            const testFileStream = (0, fs_1.createReadStream)(testFilePath, {});
-                            await (0, firebase_1.uploadFileWithStream)(uploadFile, testFileStream, { contentType });
-                            const exists = await uploadFile.exists();
-                            expect(exists).toBe(true);
-                            const metadata = await uploadFile.getMetadata();
-                            expect(metadata.contentType).toBe(contentType);
-                            const result = await uploadFile.getBytes();
-                            expect(result).toBeDefined();
-                        }
-                    });
-                });
-            });
-            describe('copy()', () => {
-                it('should copy the file to a new location in the same bucket.', async () => {
-                    if (existsFile.copy != null) {
-                        const exists = await doesNotExistFile.exists();
-                        expect(exists).toBe(false);
-                        const targetPath = doesNotExistFile.storagePath;
-                        const result = await existsFile.copy(targetPath);
-                        expect(result.storagePath.pathString).toBe(targetPath.pathString);
-                        const doesNotExistFileExists = await doesNotExistFile.exists();
-                        expect(doesNotExistFileExists).toBe(true);
-                        const existsStillExists = await existsFile.exists();
-                        expect(existsStillExists).toBe(true); // original still exists
-                    }
-                });
-                it('should copy the file to a new location to a different bucket.', async () => {
-                    if (existsFile.copy != null) {
-                        const secondBucket = {
-                            bucketId: 'second-bucket',
-                            pathString: secondBucketTarget.storagePath.pathString
-                        };
-                        const targetFile = f.storageContext.file(secondBucket);
-                        const exists = await targetFile.exists();
-                        expect(exists).toBe(false);
-                        const targetPath = targetFile.storagePath;
-                        const result = await existsFile.copy(targetPath);
-                        expect(result.storagePath.pathString).toBe(targetPath.pathString);
-                        const targetFileExists = await targetFile.exists();
-                        expect(targetFileExists).toBe(true);
-                        const doesNotExistExists = await doesNotExistFile.exists();
-                        expect(doesNotExistExists).toBe(false); // on a different bucket
-                        const existsStillExists = await existsFile.exists();
-                        expect(existsStillExists).toBe(true); // original still exists
-                    }
-                });
-            });
-            describe('move()', () => {
-                it('should move the file to a new location in the same bucket.', async () => {
-                    if (existsFile.move != null) {
-                        const exists = await doesNotExistFile.exists();
-                        expect(exists).toBe(false);
-                        const targetPath = doesNotExistFile.storagePath;
-                        const result = await existsFile.move(targetPath);
-                        expect(result.storagePath.pathString).toBe(targetPath.pathString);
-                        const doesNotExistExists = await doesNotExistFile.exists();
-                        expect(doesNotExistExists).toBe(true);
-                        const existsStillExists = await existsFile.exists();
-                        expect(existsStillExists).toBe(false); // check was moved
-                    }
-                });
-                it('should move the file to a new location to a different bucket.', async () => {
-                    if (existsFile.move != null) {
-                        const secondBucket = {
-                            bucketId: 'second-bucket',
-                            pathString: doesNotExistFile.storagePath.pathString
-                        };
-                        const targetFile = f.storageContext.file(secondBucket);
-                        const exists = await targetFile.exists();
-                        expect(exists).toBe(false);
-                        const targetPath = targetFile.storagePath;
-                        const result = await existsFile.move(targetPath);
-                        expect(result.storagePath.pathString).toBe(targetPath.pathString);
-                        const targetFileExists = await targetFile.exists();
-                        expect(targetFileExists).toBe(true);
-                        const doesNotExistStillDoesNotExists = await doesNotExistFile.exists();
-                        expect(doesNotExistStillDoesNotExists).toBe(false);
-                        const existsStillExists = await existsFile.exists();
-                        expect(existsStillExists).toBe(false); // check was moved
-                    }
-                });
-            });
-            describe('exists()', () => {
-                it('should return true if the file exists.', async () => {
-                    const result = await existsFile.exists();
-                    expect(result).toBe(true);
-                });
-                it('should return false if the file exists.', async () => {
-                    const result = await doesNotExistFile.exists();
-                    expect(result).toBe(false);
-                });
-            });
-            describe('getMetadata()', () => {
-                (0, test_1.itShouldFail)('if the file does not exist.', async () => {
-                    await (0, test_1.expectFail)(() => doesNotExistFile.getMetadata());
-                });
-                it('should return the metadata.', async () => {
-                    const result = await existsFile.getMetadata();
-                    expect(result.bucket).toBe(existsFile.storagePath.bucketId);
-                    expect(result.fullPath).toBe(existsFilePath);
-                    expect(typeof result.size).toBe('number');
-                    expect(result.size).toBeGreaterThan(0);
-                    expect(result.contentType).toBe(existsFileContentType);
-                    expect(result).toBeDefined();
-                });
-            });
-            describe('setMetadata()', () => {
-                (0, test_1.itShouldFail)('if the file does not exist.', async () => {
-                    await (0, test_1.expectFail)(() => doesNotExistFile.setMetadata({}));
-                });
-                it('should replace the content type field.', async () => {
-                    const currentMetadata = await existsFile.getMetadata();
-                    expect(currentMetadata.contentType).toBe(existsFileContentType);
-                    const nextContentType = 'application/json';
-                    const result = await existsFile.setMetadata({
-                        contentType: nextContentType
-                    });
-                    expect(result.contentType).toBe(nextContentType);
-                    const updatedMetadata = await existsFile.getMetadata();
-                    expect(updatedMetadata.contentType).toBe(nextContentType);
-                });
-                it('should replace the metadata for only the provided fields.', async () => {
-                    const currentMetadata = await existsFile.getMetadata();
-                    expect(currentMetadata.contentType).toBe(existsFileContentType);
-                    const customMetadataA = {
-                        foo: 'bar'
-                    };
-                    const result = await existsFile.setMetadata({
-                        contentType: undefined, // should not change
-                        customMetadata: customMetadataA
-                    });
-                    expect(result.contentType).toBe(existsFileContentType);
-                    expect(result.customMetadata).toEqual(customMetadataA);
-                    const updatedMetadata = await existsFile.getMetadata();
-                    expect(updatedMetadata.contentType).toBe(existsFileContentType);
-                    expect(updatedMetadata.customMetadata).toEqual(customMetadataA);
-                    // update again. All custom metadata is replaced
-                    const customMetadataB = {
-                        foo: 'baz'
-                    };
-                    const result2 = await existsFile.setMetadata({
-                        customMetadata: customMetadataB
-                    });
-                    expect(result2.contentType).toBe(existsFileContentType);
-                    expect(result2.customMetadata).toEqual(customMetadataB);
-                    const updatedMetadata2 = await existsFile.getMetadata();
-                    expect(updatedMetadata2.contentType).toBe(existsFileContentType);
-                    expect(updatedMetadata2.customMetadata).toEqual(customMetadataB);
-                });
-            });
-            describe('getBytes()', () => {
-                (0, test_1.itShouldFail)('if the file does not exist.', async () => {
-                    await (0, test_1.expectFail)(() => doesNotExistFile.getBytes());
-                });
-                it('should download the file.', async () => {
-                    const result = await existsFile.getBytes();
-                    expect(result).toBeDefined();
-                    const decoded = Buffer.from(result).toString('utf-8');
-                    expect(decoded).toBe(existsFileContent);
-                });
-                describe('with maxDownloadSizeBytes configuration', () => {
-                    it('should download up to the maxDownloadSizeBytes number of bytes', async () => {
-                        const charactersToTake = 5;
-                        const result = await existsFile.getBytes(charactersToTake); // each normal utf-8 character is 1 byte
-                        expect(result).toBeDefined();
-                        const decoded = Buffer.from(result).toString('utf-8');
-                        expect(decoded).toBe(existsFileContent.substring(0, charactersToTake));
-                    });
-                });
-            });
-            describe('getStream()', () => {
-                it('should download the file.', async () => {
-                    if (existsFile.getStream != null) {
-                        // only test if the driver/file has getStream available
-                        const stream = existsFile.getStream();
-                        expect(stream).toBeDefined();
-                        const buffer = await (0, util_1.readableStreamToBuffer)(stream);
-                        const decoded = buffer.toString('utf-8');
-                        expect(decoded).toBe(existsFileContent);
-                    }
-                });
-            });
-            describe('getDownloadUrl()', () => {
-                (0, test_1.itShouldFail)('if the file does not exist.', async () => {
-                    const doesNotExistFileExists = await doesNotExistFile.exists();
-                    expect(doesNotExistFileExists).toBe(false);
-                    await (0, test_1.expectFail)(() => doesNotExistFile.getDownloadUrl());
-                });
-                it('should return the download url.', async () => {
-                    const result = await existsFile.getDownloadUrl();
-                    expect(result).toBeDefined();
-                    expect(typeof result).toBe('string');
-                });
-            });
-            // Cannot be tested, will throw "Could not load the default credentials. Browse to https://cloud.google.com/docs/authentication/getting-started for more information."
-            describe('getSignedUrl()', () => {
-                it('should return the signed read url.', async () => {
-                    if (existsFile.getSignedUrl) {
-                        const result = await existsFile.getSignedUrl({});
-                        expect(result).toBeDefined();
-                        expect(typeof result).toBe('string');
-                    }
-                });
-            });
-            describe('makePublic()', () => {
-                beforeEach(async () => {
-                    await existsFile.delete();
-                    await existsFile.upload(existsFileContent, { stringFormat: 'raw', contentType: existsFileContentType }); // re-upload for each test
-                });
-                it('should make the file public.', async () => {
-                    if (existsFile.makePublic && existsFile.isPublic && existsFile.getAcls) {
-                        // TODO: firestore emulator files seem to always be public and ACLs do not change?
-                        // let isPublic = await existsFile.isPublic();
-                        // expect(isPublic).toBe(false);
-                        // TODO: Not implemented in the emulator properly either
-                        // const acls = await existsFile.getAcls();
-                        // console.log({ acls });
-                        await existsFile.makePublic(true);
-                        // TODO: doesn't really test it properly since true is always returned by the emulator...
-                        const isPublic = await existsFile.isPublic();
-                        expect(isPublic).toBe(true);
-                        // TODO: Not implemented in the emulator
-                        // await existsFile.makePublic(false);
-                        // isPublic = await existsFile.isPublic();
-                        // expect(isPublic).toBe(false);
-                    }
-                });
-            });
-            // TODO: getAcls() and related functions cannot be tested in the emulator currently
-            describe('delete()', () => {
-                (0, test_1.itShouldFail)('if the file does not exist.', async () => {
-                    await (0, test_1.expectFail)(() => doesNotExistFile.delete());
-                });
-                it('should delete the file at the path.', async () => {
-                    await existsFile.delete();
-                    const result = await existsFile.exists();
-                    expect(result).toBe(false);
-                });
-                describe('ignoreNotFound=true', () => {
-                    it('should not throw an error if the file does not exist.', async () => {
-                        await doesNotExistFile.delete({ ignoreNotFound: true });
-                    });
-                });
-            });
-        });
-        describe('folder()', () => {
-            const doesNotExistFolderPath = '/doesnotexist/';
-            let doesNotExistFolder;
-            const existsFolderPath = '/test/two/';
-            let existsFolder;
-            const existsFileName = 'exists.txt';
-            const existsFilePath = existsFolderPath + existsFileName;
-            const existsFileContent = 'Hello! \ud83d\ude0a';
-            let existsFile;
-            beforeEach(async () => {
-                doesNotExistFolder = f.storageContext.folder(doesNotExistFolderPath);
-                existsFolder = f.storageContext.folder(existsFolderPath);
-                existsFile = f.storageContext.file(existsFilePath);
-                await existsFile.upload(existsFileContent, { stringFormat: 'raw', contentType: 'text/plain' });
-            });
-            describe('exists()', () => {
-                it('should return false if there are no items in the folder.', async () => {
-                    const exists = await doesNotExistFolder.exists();
-                    expect(exists).toBe(false);
-                });
-                it('should return true if there are items in the folder.', async () => {
-                    const exists = await existsFolder.exists();
-                    expect(exists).toBe(true);
-                });
-            });
-            describe('list()', () => {
-                const existsBFileName = 'a.txt';
-                const existsBFilePath = existsFolderPath + existsBFileName;
-                const existsCFolderPath = existsFolderPath + 'c/';
-                const existsCFilePath = existsCFolderPath + 'c.txt';
-                const otherFolderPath = '/other/';
-                const otherFolderFilePath = otherFolderPath + 'other.txt';
-                beforeEach(async () => {
-                    await f.storageContext.file(existsBFilePath).upload(existsFileContent, { stringFormat: 'raw', contentType: 'text/plain' });
-                    await f.storageContext.file(existsCFilePath).upload(existsFileContent, { stringFormat: 'raw', contentType: 'text/plain' });
-                    await f.storageContext.file(otherFolderFilePath).upload(existsFileContent, { stringFormat: 'raw', contentType: 'text/plain' });
-                });
-                describe('options', () => {
-                    describe('listAll', () => {
-                        describe('=false/unset', () => {
-                            it('should list all the direct files and folders that exist on the test path.', async () => {
-                                const result = await existsFolder.list();
-                                expect(result).toBeDefined();
-                                const files = result.files();
-                                expect(files.length).toBe(2);
-                                const fileNames = new Set(files.map((x) => x.name));
-                                expect(fileNames).toContain(existsFileName);
-                                expect(fileNames).toContain(existsBFileName);
-                                const folders = result.folders();
-                                expect(folders.length).toBe(1);
-                                const folderNames = new Set(folders.map((x) => x.name));
-                                expect(folderNames).toContain('c');
-                            });
-                            it('should list all the direct folders that exist at the root.', async () => {
-                                const rootFolder = await f.storageContext.folder('/');
-                                const result = await rootFolder.list();
-                                expect(result).toBeDefined();
-                                const files = result.files();
-                                expect(files.length).toBe(0); // files are under /test/ and /other/
-                                const folders = result.folders();
-                                expect(folders.length).toBe(2);
-                                const names = new Set(folders.map((x) => x.name));
-                                expect(names).toContain('test');
-                                expect(names).toContain('other');
-                            });
-                        });
-                        describe('=true', () => {
-                            it('should list all files and folders that exist on the test path.', async () => {
-                                const result = await existsFolder.list({ includeNestedResults: true });
-                                expect(result).toBeDefined();
-                                const files = result.files();
-                                expect(files.length).toBe(3);
-                                const filePaths = new Set(files.map((x) => `${util_1.SLASH_PATH_SEPARATOR}${x.storagePath.pathString}`));
-                                expect(filePaths).toContain(existsFilePath);
-                                expect(filePaths).toContain(existsBFilePath);
-                                expect(filePaths).toContain(existsCFilePath);
-                                expect(filePaths).not.toContain(otherFolderFilePath);
-                                // folders are not counted/returned
-                                const folders = result.folders();
-                                expect(folders.length).toBe(0);
-                            });
-                            it('should list all the folders that exist at the root.', async () => {
-                                const rootFolder = await f.storageContext.folder('/');
-                                const result = await rootFolder.list({ includeNestedResults: true });
-                                expect(result).toBeDefined();
-                                const files = result.files();
-                                expect(files.length).toBe(4); // all created files
-                                const folders = result.folders();
-                                expect(folders.length).toBe(0);
-                            });
-                            describe('maxResults', () => {
-                                it('should limit the number of results returned.', async () => {
-                                    const rootFolder = await f.storageContext.folder('/');
-                                    const limit = 2;
-                                    const result = await rootFolder.list({ includeNestedResults: true, maxResults: limit });
-                                    expect(result).toBeDefined();
-                                    if (f.storageContext.drivers.storageAccessorDriver.type === 'server') {
-                                        // Currently only the server can properly limit the number of results returned.
-                                        // The client-side will limit the results somewhat, but if folders are returned then it will return the results of those folders as well.
-                                        const files = result.files();
-                                        expect(files.length).toBe(limit);
-                                        const nextPage = await result.next();
-                                        const nextPageFiles = nextPage.files();
-                                        expect(nextPageFiles.length).toBe(limit);
-                                    }
-                                    const folders = result.folders();
-                                    expect(folders.length).toBe(0);
-                                });
-                            });
-                        });
-                    });
-                });
-                describe('file()', () => {
-                    it('should return the file for the result.', async () => {
-                        const result = await existsFolder.list();
-                        expect(result).toBeDefined();
-                        const files = result.files();
-                        const fileResult = files.find((x) => x.name === existsFileName);
-                        const file = fileResult.file();
-                        const exists = await file.exists();
-                        expect(exists).toBe(true);
-                    });
-                });
-                describe('folder()', () => {
-                    it('should return the folder for the result.', async () => {
-                        const rootFolder = await f.storageContext.folder('/');
-                        const result = await rootFolder.list();
-                        expect(result).toBeDefined();
-                        const folders = result.folders();
-                        const folderResult = folders.find((x) => x.name === 'test');
-                        const folder = folderResult.folder();
-                        const exists = await folder.exists();
-                        expect(exists).toBe(true);
-                    });
-                });
-                describe('next()', () => {
-                    it('should return the next set of results.', async () => {
-                        const maxResults = 1;
-                        const rootFolder = await f.storageContext.folder(existsFolderPath);
-                        const result = await rootFolder.list({ maxResults });
-                        expect(result).toBeDefined();
-                        const files = result.files();
-                        expect(files.length).toBe(maxResults);
-                        const next = await result.next();
-                        expect(next).toBeDefined();
-                        const nextFiles = next.files();
-                        expect(nextFiles.length).toBe(maxResults);
-                        expect(nextFiles[0].storagePath.pathString).not.toBe(files[0].storagePath.pathString);
-                        expect(next.hasNext).toBe(false);
-                    });
-                    (0, test_1.itShouldFail)('if next() is called and hasNext was false.', async () => {
-                        const rootFolder = await f.storageContext.folder(existsFolderPath);
-                        const result = await rootFolder.list({});
-                        expect(result.hasNext).toBe(false);
-                        await (0, test_1.expectFail)(() => result.next());
-                    });
-                });
-                describe('maxResults', () => {
-                    it('should respect the max results.', async () => {
-                        const maxResults = 1;
-                        const rootFolder = await f.storageContext.folder(existsFolderPath);
-                        const result = await rootFolder.list({ maxResults });
-                        expect(result).toBeDefined();
-                        const files = result.files();
-                        expect(files.length).toBe(maxResults);
-                        const folders = result.folders();
-                        expect(folders.length).toBe(1);
-                        const names = new Set(folders.map((x) => x.name));
-                        expect(names).toContain('c');
-                    });
-                    it('prefixes/folders are unaffected by maxResults.', async () => {
-                        const maxResults = 1;
-                        const rootFolder = await f.storageContext.folder('/');
-                        const result = await rootFolder.list({ maxResults });
-                        expect(result).toBeDefined();
-                        const files = result.files();
-                        expect(files.length).toBe(0); // files are under /test/ and /other/
-                        const folders = result.folders();
-                        expect(folders.length).toBe(2);
-                        const names = new Set(folders.map((x) => x.name));
-                        expect(names).toContain('test');
-                        expect(names).toContain('other');
-                    });
-                });
-                describe('utilities', () => {
-                    describe('iterateStorageListFilesByEachFile()', () => {
-                        it('should iterate through all the files in the current folder one at a time', async () => {
-                            const visitedFiles = [];
-                            const result = await (0, firebase_1.iterateStorageListFilesByEachFile)({
-                                folder: existsFolder,
-                                readItemsFromPageResult: (x) => x.result.files(),
-                                iterateEachPageItem: async (file) => {
-                                    visitedFiles.push(file);
-                                }
-                            });
-                            const visitedFilePathStrings = visitedFiles.map((x) => `${util_1.SLASH_PATH_SEPARATOR}${x.storagePath.pathString}`);
-                            expect(visitedFilePathStrings).toContain(existsFilePath);
-                            expect(visitedFilePathStrings).toContain(existsBFilePath);
-                            expect(visitedFilePathStrings).not.toContain(existsCFilePath);
-                            expect(visitedFilePathStrings).not.toContain(otherFolderFilePath);
-                            expect(result).toBeDefined();
-                            expect(result.totalItemsLoaded).toBe(2);
-                            expect(result.totalItemsVisited).toBe(visitedFiles.length);
-                        });
-                        describe('includeNestedResults=true', () => {
-                            it('should iterate through all the files and nested files under the current folder one at a time', async () => {
-                                const visitedFiles = [];
-                                const result = await (0, firebase_1.iterateStorageListFilesByEachFile)({
-                                    folder: existsFolder,
-                                    includeNestedResults: true,
-                                    readItemsFromPageResult: (x) => x.result.files(),
-                                    iterateEachPageItem: async (file) => {
-                                        visitedFiles.push(file);
-                                    }
-                                });
-                                const visitedFilePathStrings = visitedFiles.map((x) => `${util_1.SLASH_PATH_SEPARATOR}${x.storagePath.pathString}`);
-                                expect(result).toBeDefined();
-                                expect(result.totalItemsLoaded).toBe(3);
-                                expect(result.totalItemsVisited).toBe(visitedFiles.length);
-                                expect(visitedFilePathStrings).toContain(existsFilePath);
-                                expect(visitedFilePathStrings).toContain(existsBFilePath);
-                                expect(visitedFilePathStrings).toContain(existsCFilePath);
-                                expect(visitedFilePathStrings).not.toContain(otherFolderFilePath);
-                            });
-                        });
-                    });
-                });
-            });
-        });
-    });
-}
-//# sourceMappingURL=test.driver.accessor.js.map