@dereekb/firebase 13.6.6 → 13.6.7

package/test/index.esm.js

@@ -1,8 +1,8 @@
 import { performAsyncTasks, cachedGetter, bitwiseObjectDencoder, modelFieldConversions, waitForMs, isEvenNumber, unique, arrayFactory, mapGetter, randomNumberFactory, randomFromArrayFactory, idBatchFactory, arrayContainsDuplicateValue, useCallback, readableStreamToBuffer, SLASH_PATH_SEPARATOR } from '@dereekb/util';
-import { AbstractTestContextFixture, testContextBuilder, instanceWrapTestContextFactory, AbstractWrappedFixtureWithInstance, itShouldFail, expectFail, callbackTest } from '@dereekb/util/test';
 import { initializeTestEnvironment } from '@firebase/rules-unit-testing';
-import { firebaseStorageClientDrivers, firebaseFirestoreClientDrivers, firestoreContextFactory, firebaseStorageContextFactory, firestoreModelIdentity, snapshotConverterFunctions, firestoreBoolean, optionalFirestoreNumber, optionalFirestoreDate, optionalFirestoreArray, optionalFirestoreString, firestoreDate, firestoreBitwiseObjectMap, firestoreUniqueStringArray, firestoreNumber, firestoreString, firestoreUID, copyUserRelatedDataAccessorFactoryFunction, firestoreSubObject, AbstractFirestoreDocument, AbstractFirestoreDocumentWithParent, firebaseModelServiceFactory, grantFullAccessIfAdmin, firebaseModelsService, systemStateFirestoreCollection, allChildDocumentsUnderParent, where, makeDocuments, getDocumentSnapshotPairs, useDocumentSnapshot, useDocumentSnapshotData, firestoreIdBatchVerifierFactory, limit, orderBy, limitToLast, whereDocumentId, loadAllFirestoreDocumentSnapshotPairs, loadAllFirestoreDocumentSnapshot, iterateFirestoreDocumentSnapshotPairs, iterateFirestoreDocumentSnapshots, iterateFirestoreDocumentSnapshotPairBatches, iterateFirestoreDocumentSnapshotBatches, whereStringHasRootIdentityModelKey, whereStringValueHasPrefix, whereDateIsAfterWithSort, whereDateIsBeforeWithSort, whereDateIsOnOrAfterWithSort, whereDateIsOnOrBeforeWithSort, whereDateIsInRange, whereDateIsBetween, startAt, orderByDocumentId, startAtValue, startAfter, endAt, endAtValue, endBefore, streamFromOnSnapshot, latestSnapshotsFromDocuments, newDocuments, loadDocumentsForDocumentReferences, loadDocumentsForDocumentReferencesFromValues, loadDocumentsForKeys, loadDocumentsForKeysFromValues, loadDocumentsForIds, loadDocumentsForIdsFromValues, firestoreDocumentLoader, setIdAndKeyFromKeyIdRefOnDocumentData, firestoreModelIdFromDocument, firestoreModelIdsFromDocuments, firestoreModelKeyFromDocument, firestoreModelKeysFromDocuments, documentReferenceFromDocument, documentReferencesFromDocuments, limitedFirestoreDocumentAccessorSnapshotCache, mapLatestSnapshotsFromDocuments, streamDocumentSnapshotsData, dataFromDocumentSnapshots, streamDocumentSnapshotDataPairs, streamDocumentSnapshotDataPairsWithData, getDocumentSnapshots, getDocumentSnapshotPair, getDocumentSnapshotDataPair, getDocumentSnapshotDataPairs, getDocumentSnapshotDataPairsWithData, getDocumentSnapshotDataTuples, getDocumentSnapshotData, getDocumentSnapshotsData, getDataFromDocumentSnapshots, loadDocumentsForSnapshots, firestoreDocumentSnapshotPairsLoader, documentData, documentDataFunction, documentDataWithIdAndKey, setIdAndKeyFromSnapshotOnDocumentData, firebaseQuerySnapshotAccumulator, firebaseQueryItemAccumulator, uploadFileWithStream, iterateStorageListFilesByEachFile } from '@dereekb/firebase';
+import { firebaseStorageContextFactory, firestoreContextFactory, firebaseFirestoreClientDrivers, firebaseStorageClientDrivers, firestoreModelIdentity, snapshotConverterFunctions, firestoreBoolean, optionalFirestoreNumber, optionalFirestoreDate, optionalFirestoreArray, optionalFirestoreString, firestoreDate, firestoreBitwiseObjectMap, firestoreUniqueStringArray, firestoreNumber, firestoreString, firestoreUID, copyUserRelatedDataAccessorFactoryFunction, firestoreSubObject, AbstractFirestoreDocument, AbstractFirestoreDocumentWithParent, firebaseModelServiceFactory, grantFullAccessIfAdmin, firebaseModelsService, systemStateFirestoreCollection, allChildDocumentsUnderParent, where, makeDocuments, getDocumentSnapshotPairs, useDocumentSnapshot, useDocumentSnapshotData, firestoreIdBatchVerifierFactory, limit, orderBy, limitToLast, whereDocumentId, loadAllFirestoreDocumentSnapshotPairs, loadAllFirestoreDocumentSnapshot, iterateFirestoreDocumentSnapshotPairs, iterateFirestoreDocumentSnapshots, iterateFirestoreDocumentSnapshotPairBatches, iterateFirestoreDocumentSnapshotBatches, whereStringHasRootIdentityModelKey, whereStringValueHasPrefix, whereDateIsAfterWithSort, whereDateIsBeforeWithSort, whereDateIsOnOrAfterWithSort, whereDateIsOnOrBeforeWithSort, whereDateIsInRange, whereDateIsBetween, startAt, orderByDocumentId, startAtValue, startAfter, endAt, endAtValue, endBefore, streamFromOnSnapshot, latestSnapshotsFromDocuments, newDocuments, loadDocumentsForDocumentReferences, loadDocumentsForDocumentReferencesFromValues, loadDocumentsForKeys, loadDocumentsForKeysFromValues, loadDocumentsForIds, loadDocumentsForIdsFromValues, firestoreDocumentLoader, setIdAndKeyFromKeyIdRefOnDocumentData, firestoreModelIdFromDocument, firestoreModelIdsFromDocuments, firestoreModelKeyFromDocument, firestoreModelKeysFromDocuments, documentReferenceFromDocument, documentReferencesFromDocuments, limitedFirestoreDocumentAccessorSnapshotCache, mapLatestSnapshotsFromDocuments, streamDocumentSnapshotsData, dataFromDocumentSnapshots, streamDocumentSnapshotDataPairs, streamDocumentSnapshotDataPairsWithData, getDocumentSnapshots, getDocumentSnapshotPair, getDocumentSnapshotDataPair, getDocumentSnapshotDataPairs, getDocumentSnapshotDataPairsWithData, getDocumentSnapshotDataTuples, getDocumentSnapshotData, getDocumentSnapshotsData, getDataFromDocumentSnapshots, loadDocumentsForSnapshots, firestoreDocumentSnapshotPairsLoader, documentData, documentDataFunction, documentDataWithIdAndKey, setIdAndKeyFromSnapshotOnDocumentData, firebaseQuerySnapshotAccumulator, firebaseQueryItemAccumulator, uploadFileWithStream, iterateStorageListFilesByEachFile } from '@dereekb/firebase';
 import { setLogLevel } from 'firebase/firestore';
+import { AbstractTestContextFixture, instanceWrapTestContextFactory, AbstractWrappedFixtureWithInstance, itShouldFail, expectFail, callbackTest } from '@dereekb/util/test';
 import { firstValueFrom, filter, skip, from, first, map, switchMap } from 'rxjs';
 import { SubscriptionObject, iteratorNextPageUntilPage, flattenAccumulatorResultItemArray, accumulatorCurrentPageListLoadingState, isLoadingStateFinishedLoading, accumulatorFlattenPageListLoadingState } from '@dereekb/rxjs';
 import { addDays, startOfDay, addHours } from 'date-fns';
@@ -936,71 +936,113 @@ function _ts_generator$5(thisArg, body) {
  * A TestContextBuilderFunction for building firebase test context factories using @firebase/firebase and @firebase/rules-unit-testing. This means CLIENT TESTING ONLY. For server testing, look at @dereekb/firestore-server.
  *
  * This can be used to easily build a testing context that sets up RulesTestEnvironment for tests that sets itself up and tears itself down.
- */ var firebaseRulesUnitTestBuilder = testContextBuilder({
-    buildConfig: function buildConfig(input) {
-        var _ref;
-        var config = {
-            testEnvironment: (_ref = input === null || input === void 0 ? void 0 : input.testEnvironment) !== null && _ref !== void 0 ? _ref : {},
-            rulesContext: input === null || input === void 0 ? void 0 : input.rulesContext
-        };
-        return config;
-    },
-    buildFixture: function buildFixture() {
-        return new RulesUnitTestFirebaseTestingContextFixture();
-    },
-    setupInstance: function setupInstance(config) {
-        return _async_to_generator$5(function() {
-            var drivers, testEnvironment, rulesTestEnv, rulesTestContext;
-            return _ts_generator$5(this, function(_state) {
-                switch(_state.label){
-                    case 0:
+ *
+ * The {@link RulesTestEnvironment} is initialized once per test suite (`beforeAll`) and cleaned up
+ * once (`afterAll`), while fresh drivers and a {@link RulesTestContext} are created per test (`beforeEach`). This avoids
+ * repeated calls to `initializeTestEnvironment` (which hits the emulator's `PUT /internal/setRules` endpoint),
+ * preventing interference between parallel workers sharing the same Firebase Storage emulator. The Storage
+ * emulator maintains rules globally (not per-project), so concurrent `setRules` calls from multiple workers
+ * can momentarily leave the emulator in a transitional state that causes `storage/unauthorized` errors.
+ */ var firebaseRulesUnitTestBuilder = function firebaseRulesUnitTestBuilder(inputConfig) {
+    var _ref;
+    var config = {
+        testEnvironment: (_ref = inputConfig === null || inputConfig === void 0 ? void 0 : inputConfig.testEnvironment) !== null && _ref !== void 0 ? _ref : {},
+        rulesContext: inputConfig === null || inputConfig === void 0 ? void 0 : inputConfig.rulesContext
+    };
+    return function(buildTests) {
+        var fixture = new RulesUnitTestFirebaseTestingContextFixture();
+        var rulesTestEnvironment;
+        // Initialize the emulator environment once per test suite.
+        // This is the expensive operation that hits the emulator's REST API (e.g. PUT /internal/setRules).
+        beforeAll(function() {
+            return _async_to_generator$5(function() {
+                return _ts_generator$5(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                initializeTestEnvironment(config.testEnvironment)
+                            ];
+                        case 1:
+                            rulesTestEnvironment = _state.sent();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        // Clean up the emulator environment once after all tests complete.
+        afterAll(function() {
+            return _async_to_generator$5(function() {
+                return _ts_generator$5(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            if (!rulesTestEnvironment) return [
+                                3,
+                                2
+                            ];
+                            return [
+                                4,
+                                rulesTestEnvironment.cleanup().catch(function(e) {
+                                    console.warn('firebaseRulesUnitTestBuilder(): Failed to cleanup rules test environment', e);
+                                    throw e;
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            _state.label = 2;
+                        case 2:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        // Create fresh drivers and RulesTestContext per test.
+        // Drivers are recreated per test because the Firestore testing driver fuzzes collection names
+        // (via makeTestingFirestoreAccesorDriver) to provide data isolation between tests.
+        var clearInstance = null;
+        beforeEach(function() {
+            return _async_to_generator$5(function() {
+                var drivers, rulesTestContext, instance;
+                return _ts_generator$5(this, function(_state) {
+                    try {
                         drivers = _object_spread$1({}, makeTestingFirestoreDrivers(firebaseFirestoreClientDrivers()), makeTestingFirebaseStorageDrivers(firebaseStorageClientDrivers(), {
                             useTestDefaultBucket: true
                         }));
-                        testEnvironment = config.testEnvironment;
                         if (config.testEnvironment.collectionNames) {
                             drivers.firestoreAccessorDriver.initWithCollectionNames(config.testEnvironment.collectionNames);
-                            testEnvironment = _object_spread_props(_object_spread$1({}, testEnvironment), {
-                                firestore: rewriteEmulatorConfigRulesForFuzzedCollectionNames(testEnvironment.firestore)
-                            });
                         }
-                        return [
-                            4,
-                            initializeTestEnvironment(config.testEnvironment)
-                        ];
-                    case 1:
-                        rulesTestEnv = _state.sent();
-                        rulesTestContext = rulesTestContextForConfig(rulesTestEnv, config.rulesContext);
-                        return [
-                            2,
-                            new RulesUnitTestTestFirebaseInstance(drivers, rulesTestEnv, rulesTestContext)
-                        ];
-                }
-            });
-        })();
-    },
-    teardownInstance: function teardownInstance(instance, config) {
-        return _async_to_generator$5(function() {
-            return _ts_generator$5(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            instance.rulesTestEnvironment.cleanup().catch(function(e) {
-                                console.warn('firebaseRulesUnitTestBuilder(): Failed to cleanup rules test environment', e);
-                                throw e;
-                            })
-                        ];
-                    case 1:
-                        _state.sent();
-                        return [
-                            2
-                        ];
-                }
-            });
-        })();
-    }
-});
+                        rulesTestContext = rulesTestContextForConfig(rulesTestEnvironment, config.rulesContext);
+                        instance = new RulesUnitTestTestFirebaseInstance(drivers, rulesTestEnvironment, rulesTestContext);
+                        clearInstance = fixture.setInstance(instance);
+                    } catch (e) {
+                        console.error('firebaseRulesUnitTestBuilder(): Failed building a test instance. Error: ', e);
+                        if (clearInstance) {
+                            clearInstance();
+                            clearInstance = null;
+                        }
+                        throw e;
+                    }
+                    return [
+                        2
+                    ];
+                });
+            })();
+        });
+        // Declare tests
+        buildTests(fixture);
+        // Clear the instance reference after each test.
+        afterEach(function() {
+            if (clearInstance) {
+                clearInstance();
+                clearInstance = null;
+            }
+        });
+    };
+};
 // MARK: Internal
 function rulesTestContextForConfig(rulesTestEnv, testingRulesConfig) {
     var rulesTestContext;
@@ -1012,18 +1054,6 @@ function rulesTestContextForConfig(rulesTestEnv, testingRulesConfig) {
     }
     return rulesTestContext;
 }
-function rewriteEmulatorConfigRulesForFuzzedCollectionNames(config, fuzzedCollectionNamesMap) {
-    if (config && config.rules) {
-        config = _object_spread_props(_object_spread$1({}, config), {
-            rules: rewriteRulesForFuzzedCollectionNames(config.rules)
-        });
-    }
-    return config;
-}
-function rewriteRulesForFuzzedCollectionNames(rules, fuzzedCollectionNamesMap) {
-    // TODO: rewrite the rules using regex matching/replacement.
-    return rules;
-}
 // MARK: Utility
 /**
  * Registers `beforeAll`/`afterAll` hooks to suppress verbose Firestore log output during tests.
@@ -1042,24 +1072,56 @@ function rewriteRulesForFuzzedCollectionNames(rules, fuzzedCollectionNamesMap) {
 /**
  * Default user ID used for the authenticated context in client-side Firebase tests.
  */ var TESTING_AUTHORIZED_FIREBASE_USER_ID = '0';
+/**
+ * Permissive Firestore security rules that allow all reads and writes.
+ */ var AUTHORIZED_FIRESTORE_RULES = "\nrules_version = '2';\nservice cloud.firestore {\n  match /databases/{database}/documents {\n    match /{document=**} {\n      allow read, write: if true;\n    }\n  }\n}\n";
+/**
+ * Permissive Firebase Storage security rules that allow all reads and writes.
+ */ var AUTHORIZED_STORAGE_RULES = "\nrules_version = '2';\nservice firebase.storage {\n  match /b/{bucket}/o {\n    match /{allPaths=**} {\n      allow read, write: if true;\n    }\n  }\n}\n";
 /**
  * Pre-configured {@link FirebaseTestContextFactory} that provides a fully authorized (all reads/writes allowed)
  * Firebase emulator context for both Firestore and Storage.
  *
  * Uses permissive security rules and authenticates as {@link TESTING_AUTHORIZED_FIREBASE_USER_ID}.
- * This is the most common base factory for client-side mock item tests.
+ *
+ * **Important:** Only use this factory for tests that actually need Firebase Storage access.
+ * Firestore-only tests should use {@link authorizedFirestoreOnlyFactory} instead to avoid
+ * interfering with the storage emulator's global rules endpoint during parallel test execution.
  *
  * @example
  * ```ts
- * const f = testWithMockItemCollectionFixture()(authorizedFirebaseFactory);
+ * const f = testWithMockItemStorageFixture()(authorizedFirebaseFactory);
  * ```
  */ var authorizedFirebaseFactory = firebaseRulesUnitTestBuilder({
     testEnvironment: {
         firestore: {
-            rules: "\n      rules_version = '2';\n      service cloud.firestore {\n        match /databases/{database}/documents {\n          match /{document=**} {\n            allow read, write: if true;\n          }\n        }\n      }\n      "
+            rules: AUTHORIZED_FIRESTORE_RULES
         },
         storage: {
-            rules: "\n      rules_version = '2';\n      service firebase.storage {\n        match /b/{bucket}/o {\n          match /{allPaths=**} {\n            allow read, write: if true;\n          }\n        }\n      }\n      "
+            rules: AUTHORIZED_STORAGE_RULES
+        }
+    },
+    rulesContext: {
+        userId: TESTING_AUTHORIZED_FIREBASE_USER_ID
+    }
+});
+/**
+ * Pre-configured {@link FirebaseTestContextFactory} that provides a fully authorized Firestore-only
+ * emulator context without configuring Storage rules.
+ *
+ * Use this for Firestore-only tests when running with parallel workers. The Firebase Storage
+ * emulator maintains rules globally (not per-project like Firestore), so `initializeTestEnvironment`
+ * calls that include storage rules from non-storage workers will hit `PUT /internal/setRules`
+ * concurrently, which can cause transient `storage/unauthorized` errors in the storage test worker.
+ *
+ * @example
+ * ```ts
+ * const f = testWithMockItemCollectionFixture()(authorizedFirestoreOnlyFactory);
+ * ```
+ */ var authorizedFirestoreOnlyFactory = firebaseRulesUnitTestBuilder({
+    testEnvironment: {
+        firestore: {
+            rules: AUTHORIZED_FIRESTORE_RULES
         }
     },
     rulesContext: {
@@ -2133,8 +2195,11 @@ function _is_native_reflect_construct$2() {
 /**
  * Convenience mock instance for collection tests within an authorized firebase context.
  *
+ * Uses {@link authorizedFirestoreOnlyFactory} to avoid touching the Storage emulator's
+ * global rules endpoint, preventing interference with parallel storage test workers.
+ *
  * Uses @firebase/firestore. This is ONLY for the client.
- */ var authorizedTestWithMockItemCollection = testWithMockItemCollectionFixture()(authorizedFirebaseFactory);
+ */ var authorizedTestWithMockItemCollection = testWithMockItemCollectionFixture()(authorizedFirestoreOnlyFactory);
 /**
  * Convenience mock instance for storage tests within an authorized firebase context.
  *
@@ -12481,4 +12546,4 @@ function _ts_generator(thisArg, body) {
     });
 }
 
-export { MOCK_FIREBASE_MODEL_SERVICE_FACTORIES, MOCK_SYSTEM_STATE_TYPE, MockItemCollectionFixture, MockItemCollectionFixtureInstance, MockItemCollections, MockItemDocument, MockItemPrivateDocument, MockItemSettingsItemEnum, MockItemStorageFixture, MockItemStorageFixtureInstance, MockItemSubItemDeepDocument, MockItemSubItemDocument, MockItemUserDocument, RulesUnitTestFirebaseTestingContextFixture, RulesUnitTestTestFirebaseInstance, TESTING_AUTHORIZED_FIREBASE_USER_ID, TestFirebaseContextFixture, TestFirebaseInstance, TestFirebaseStorageContextFixture, TestFirebaseStorageInstance, TestFirestoreContextFixture, TestFirestoreInstance, allChildMockItemSubItemDeepsWithinMockItem, authorizedFirebaseFactory, authorizedTestWithMockItemCollection, authorizedTestWithMockItemStorage, changeFirestoreLogLevelBeforeAndAfterTests, clearTestFirestoreContextCollections, describeFirebaseStorageAccessorDriverTests, describeFirestoreAccessorDriverTests, describeFirestoreDocumentAccessorTests, describeFirestoreDocumentUtilityTests, describeFirestoreIterationTests, describeFirestoreQueryDriverTests, firebaseRulesUnitTestBuilder, makeMockItemCollections, makeRulesTestFirebaseStorageContext, makeRulesTestFirestoreContext, makeTestingFirebaseStorageAccesorDriver, makeTestingFirebaseStorageDrivers, makeTestingFirestoreAccesorDriver, makeTestingFirestoreDrivers, mockFirebaseModelServices, mockItemCollectionReference, mockItemConverter, mockItemFirebaseModelServiceFactory, mockItemFirestoreCollection, mockItemIdentity, mockItemPrivateCollectionReference, mockItemPrivateCollectionReferenceFactory, mockItemPrivateConverter, mockItemPrivateFirebaseModelServiceFactory, mockItemPrivateFirestoreCollection, mockItemPrivateFirestoreCollectionGroup, mockItemPrivateIdentity, mockItemSettingsItemDencoder, mockItemSubItemCollectionReference, mockItemSubItemCollectionReferenceFactory, mockItemSubItemConverter, mockItemSubItemDeepCollectionReference, mockItemSubItemDeepCollectionReferenceFactory, mockItemSubItemDeepConverter, mockItemSubItemDeepFirebaseModelServiceFactory, mockItemSubItemDeepFirestoreCollection, mockItemSubItemDeepFirestoreCollectionGroup, mockItemSubItemDeepIdentity, mockItemSubItemFirebaseModelServiceFactory, mockItemSubItemFirestoreCollection, mockItemSubItemFirestoreCollectionGroup, mockItemSubItemIdentity, mockItemSystemDataConverter, mockItemSystemStateFirebaseModelServiceFactory, mockItemSystemStateStoredDataConverterMap, mockItemUserAccessorFactory, mockItemUserCollectionName, mockItemUserCollectionReference, mockItemUserCollectionReferenceFactory, mockItemUserConverter, mockItemUserFirebaseModelServiceFactory, mockItemUserFirestoreCollection, mockItemUserFirestoreCollectionGroup, mockItemUserIdentifier, mockItemUserIdentity, mockItemWithTestValue, mockItemWithValue, testWithMockItemCollectionFixture, testWithMockItemStorageFixture };
+export { AUTHORIZED_FIRESTORE_RULES, AUTHORIZED_STORAGE_RULES, MOCK_FIREBASE_MODEL_SERVICE_FACTORIES, MOCK_SYSTEM_STATE_TYPE, MockItemCollectionFixture, MockItemCollectionFixtureInstance, MockItemCollections, MockItemDocument, MockItemPrivateDocument, MockItemSettingsItemEnum, MockItemStorageFixture, MockItemStorageFixtureInstance, MockItemSubItemDeepDocument, MockItemSubItemDocument, MockItemUserDocument, RulesUnitTestFirebaseTestingContextFixture, RulesUnitTestTestFirebaseInstance, TESTING_AUTHORIZED_FIREBASE_USER_ID, TestFirebaseContextFixture, TestFirebaseInstance, TestFirebaseStorageContextFixture, TestFirebaseStorageInstance, TestFirestoreContextFixture, TestFirestoreInstance, allChildMockItemSubItemDeepsWithinMockItem, authorizedFirebaseFactory, authorizedFirestoreOnlyFactory, authorizedTestWithMockItemCollection, authorizedTestWithMockItemStorage, changeFirestoreLogLevelBeforeAndAfterTests, clearTestFirestoreContextCollections, describeFirebaseStorageAccessorDriverTests, describeFirestoreAccessorDriverTests, describeFirestoreDocumentAccessorTests, describeFirestoreDocumentUtilityTests, describeFirestoreIterationTests, describeFirestoreQueryDriverTests, firebaseRulesUnitTestBuilder, makeMockItemCollections, makeRulesTestFirebaseStorageContext, makeRulesTestFirestoreContext, makeTestingFirebaseStorageAccesorDriver, makeTestingFirebaseStorageDrivers, makeTestingFirestoreAccesorDriver, makeTestingFirestoreDrivers, mockFirebaseModelServices, mockItemCollectionReference, mockItemConverter, mockItemFirebaseModelServiceFactory, mockItemFirestoreCollection, mockItemIdentity, mockItemPrivateCollectionReference, mockItemPrivateCollectionReferenceFactory, mockItemPrivateConverter, mockItemPrivateFirebaseModelServiceFactory, mockItemPrivateFirestoreCollection, mockItemPrivateFirestoreCollectionGroup, mockItemPrivateIdentity, mockItemSettingsItemDencoder, mockItemSubItemCollectionReference, mockItemSubItemCollectionReferenceFactory, mockItemSubItemConverter, mockItemSubItemDeepCollectionReference, mockItemSubItemDeepCollectionReferenceFactory, mockItemSubItemDeepConverter, mockItemSubItemDeepFirebaseModelServiceFactory, mockItemSubItemDeepFirestoreCollection, mockItemSubItemDeepFirestoreCollectionGroup, mockItemSubItemDeepIdentity, mockItemSubItemFirebaseModelServiceFactory, mockItemSubItemFirestoreCollection, mockItemSubItemFirestoreCollectionGroup, mockItemSubItemIdentity, mockItemSystemDataConverter, mockItemSystemStateFirebaseModelServiceFactory, mockItemSystemStateStoredDataConverterMap, mockItemUserAccessorFactory, mockItemUserCollectionName, mockItemUserCollectionReference, mockItemUserCollectionReferenceFactory, mockItemUserConverter, mockItemUserFirebaseModelServiceFactory, mockItemUserFirestoreCollection, mockItemUserFirestoreCollectionGroup, mockItemUserIdentifier, mockItemUserIdentity, mockItemWithTestValue, mockItemWithValue, testWithMockItemCollectionFixture, testWithMockItemStorageFixture };

package/test/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dereekb/firebase/test",
-  "version": "13.6.6",
+  "version": "13.6.7",
   "peerDependencies": {
-    "@dereekb/date": "13.6.6",
-    "@dereekb/firebase": "13.6.6",
-    "@dereekb/model": "13.6.6",
-    "@dereekb/rxjs": "13.6.6",
-    "@dereekb/util": "13.6.6",
+    "@dereekb/date": "13.6.7",
+    "@dereekb/firebase": "13.6.7",
+    "@dereekb/model": "13.6.7",
+    "@dereekb/rxjs": "13.6.7",
+    "@dereekb/util": "13.6.7",
     "@firebase/rules-unit-testing": "5.0.0",
     "date-fns": "^4.0.0",
     "firebase": "^12.0.0",

package/test/src/lib/client/firebase.authorized.d.ts

@@ -8,16 +8,42 @@ export declare const TESTING_AUTHORIZED_FIREBASE_USER_ID = "0";
  * Convenience type alias for a test context factory that produces {@link RulesUnitTestFirebaseTestingContextFixture} instances.
  */
 export type FirebaseTestContextFactory = TestContextFactory<RulesUnitTestFirebaseTestingContextFixture>;
+/**
+ * Permissive Firestore security rules that allow all reads and writes.
+ */
+export declare const AUTHORIZED_FIRESTORE_RULES = "\nrules_version = '2';\nservice cloud.firestore {\n  match /databases/{database}/documents {\n    match /{document=**} {\n      allow read, write: if true;\n    }\n  }\n}\n";
+/**
+ * Permissive Firebase Storage security rules that allow all reads and writes.
+ */
+export declare const AUTHORIZED_STORAGE_RULES = "\nrules_version = '2';\nservice firebase.storage {\n  match /b/{bucket}/o {\n    match /{allPaths=**} {\n      allow read, write: if true;\n    }\n  }\n}\n";
 /**
  * Pre-configured {@link FirebaseTestContextFactory} that provides a fully authorized (all reads/writes allowed)
  * Firebase emulator context for both Firestore and Storage.
  *
  * Uses permissive security rules and authenticates as {@link TESTING_AUTHORIZED_FIREBASE_USER_ID}.
- * This is the most common base factory for client-side mock item tests.
+ *
+ * **Important:** Only use this factory for tests that actually need Firebase Storage access.
+ * Firestore-only tests should use {@link authorizedFirestoreOnlyFactory} instead to avoid
+ * interfering with the storage emulator's global rules endpoint during parallel test execution.
  *
  * @example
  * ```ts
- * const f = testWithMockItemCollectionFixture()(authorizedFirebaseFactory);
+ * const f = testWithMockItemStorageFixture()(authorizedFirebaseFactory);
  * ```
  */
 export declare const authorizedFirebaseFactory: FirebaseTestContextFactory;
+/**
+ * Pre-configured {@link FirebaseTestContextFactory} that provides a fully authorized Firestore-only
+ * emulator context without configuring Storage rules.
+ *
+ * Use this for Firestore-only tests when running with parallel workers. The Firebase Storage
+ * emulator maintains rules globally (not per-project like Firestore), so `initializeTestEnvironment`
+ * calls that include storage rules from non-storage workers will hit `PUT /internal/setRules`
+ * concurrently, which can cause transient `storage/unauthorized` errors in the storage test worker.
+ *
+ * @example
+ * ```ts
+ * const f = testWithMockItemCollectionFixture()(authorizedFirestoreOnlyFactory);
+ * ```
+ */
+export declare const authorizedFirestoreOnlyFactory: FirebaseTestContextFactory;

package/test/src/lib/client/firebase.d.ts

@@ -1,5 +1,6 @@
 import { type TestFirestoreContext, type TestingFirestoreDrivers } from '../common/firestore/firestore';
 import { type Maybe } from '@dereekb/util';
+import { type TestContextBuilderFunction } from '@dereekb/util/test';
 import { type TestEnvironmentConfig, type RulesTestEnvironment, type RulesTestContext, type TokenOptions, type EmulatorConfig } from '@firebase/rules-unit-testing';
 import { type FirebaseStorage, type Firestore } from '@dereekb/firebase';
 import { type TestFirebaseStorageContext, type TestingFirebaseStorageDrivers } from '../common/storage/storage';
@@ -104,8 +105,15 @@ export declare class RulesUnitTestFirebaseTestingContextFixture extends TestFire
  * A TestContextBuilderFunction for building firebase test context factories using @firebase/firebase and @firebase/rules-unit-testing. This means CLIENT TESTING ONLY. For server testing, look at @dereekb/firestore-server.
  *
  * This can be used to easily build a testing context that sets up RulesTestEnvironment for tests that sets itself up and tears itself down.
+ *
+ * The {@link RulesTestEnvironment} is initialized once per test suite (`beforeAll`) and cleaned up
+ * once (`afterAll`), while fresh drivers and a {@link RulesTestContext} are created per test (`beforeEach`). This avoids
+ * repeated calls to `initializeTestEnvironment` (which hits the emulator's `PUT /internal/setRules` endpoint),
+ * preventing interference between parallel workers sharing the same Firebase Storage emulator. The Storage
+ * emulator maintains rules globally (not per-project), so concurrent `setRules` calls from multiple workers
+ * can momentarily leave the emulator in a transitional state that causes `storage/unauthorized` errors.
  */
-export declare const firebaseRulesUnitTestBuilder: import("@dereekb/util/test").TestContextBuilderFunction<RulesUnitTestTestFirebaseInstance, RulesUnitTestFirebaseTestingContextFixture, RulesUnitTestingConfig>;
+export declare const firebaseRulesUnitTestBuilder: TestContextBuilderFunction<RulesUnitTestTestFirebaseInstance, RulesUnitTestFirebaseTestingContextFixture, RulesUnitTestingConfig>;
 /**
  * Registers `beforeAll`/`afterAll` hooks to suppress verbose Firestore log output during tests.
  *

package/test/src/lib/client/firestore.mock.item.fixture.authorized.d.ts

@@ -1,6 +1,9 @@
 /**
  * Convenience mock instance for collection tests within an authorized firebase context.
  *
+ * Uses {@link authorizedFirestoreOnlyFactory} to avoid touching the Storage emulator's
+ * global rules endpoint, preventing interference with parallel storage test workers.
+ *
  * Uses @firebase/firestore. This is ONLY for the client.
  */
 export declare const authorizedTestWithMockItemCollection: import("@dereekb/util/test").TestContextFactory<import("..").MockItemCollectionFixture>;