@causa/runtime-google 0.39.1 → 1.0.0-rc.1

package/README.md

@@ -52,7 +52,7 @@ The `FirebaseModule` is a NestJS module which exports various Firebase services
 
 Outside of a NestJS context, `getDefaultFirebaseApp()` can be used to retrieve a consistently initialized singleton app.
 
-For testing, `overrideFirebaseApp` can be set as an `overrides` option for `makeTestAppFactory()`, which ensures the default Firebase application is used across tests and avoids lifecycle issues (repeatedly creating and tearing down new applications).
+For testing, the `FirebaseFixture` can be used, which ensures the default Firebase application is used across tests and avoids lifecycle issues (repeatedly creating and tearing down new applications).
 
 ### Firestore
 
@@ -60,7 +60,7 @@ The `makeFirestoreDataConverter` is a utility that returns a `FirestoreDataConve
 
 The `FirestoreCollectionsModule` builds upon the `FirebaseModule` and provides Firestore collections for the listed document types. In services, the `@InjectFirestoreCollection` decorator can be used to retrieve a Firestore collection, prepared with the aforementioned converter.
 
-Testing utilities are also provided. `clearFirestoreCollection()` can be used in between tests to reinitialize the collection. `overrideFirestoreCollections` can be used as an `overrides` option for `makeTestAppFactory()` to replace collections with temporary ones. This ensures separate collections are used for each test and avoids conflicts.
+Testing utilities are also provided with `FirestoreFixture`. It replaces injected collections with temporary ones, to ensure separate collections are used for each test suite and avoid conflicts. Also, collections are cleared between tests.
 
 ### NestJS health checks
 
@@ -86,9 +86,7 @@ For services being triggered by Pub/Sub messages, the `PubSubEventHandlerModule`
 
 The `PubSubHealthIndicator` is a `HealthIndicator` which can be used in a health check controller, such as the `GoogleHealthcheckModule`. It attempts to list topics using the Pub/Sub client to check connectivity to the Pub/Sub API.
 
-To test publishers, the `PubSubFixture` handles the creation and deletion of temporary topics. The `PubSubFixture.createWithOverrider()` method is especially useful when used in combination with the `makeTestAppFactory()` utility.
-
-To test event handlers, the `makePubSubRequester()` utility returns a function which can be used to make HTTP requests in the same way a Pub/Sub push subscription would.
+To test publishers, the `PubSubFixture` handles the creation and deletion of temporary topics, and provides `expect*` utilities to check for published messages. To test event handlers, it also provides the `makeRequester()` utility, which returns a function that can be used to make HTTP requests in the same way a Pub/Sub push subscription would.
 
 ### Spanner
 
@@ -98,25 +96,20 @@ The `SpannerModule` provides a `Database` instance configured using the `SPANNER
 
 The `SpannerHealthIndicator` is a `HealthIndicator` which can be used in a health check controller, such as the `GoogleHealthcheckModule`. It runs a dummy `SELECT 1` query against the database to check connectivity.
 
-For testing, the `createDatabase` utility creates a temporary database, copying the DDL from the configured database (set with the `SPANNER_DATABASE` environment variable). `overrideDatabase` can be used as an `overrides` option for `makeTestAppFactory` to substitute the database with a temporary one.
+For testing, the `createDatabase` utility creates a temporary database, copying the DDL from the configured database (set with the `SPANNER_DATABASE` environment variable). The `SpannerFixture` uses this mechanism, and also clears the specified tables between tests.
 
 ### GCP-based Causa transaction runners
 
 This package provides the following `TransactionRunner`s:
 
-- `SpannerPubSubTransactionRunner`
 - `FirestorePubSubTransactionRunner`
 - `SpannerOutboxTransactionRunner`
 
-The first two use Pub/Sub and a `BufferEventTransaction` to publish events. They only differ by the service used to store the state.
-
-The `SpannerPubSubTransactionRunner` uses a Spanner transaction as the underlying transaction for the `SpannerTransaction`, while the `FirestorePubSubTransactionRunner` uses a Firestore transaction for the `FirestorePubSubTransaction`. Both state transactions implement the `FindReplaceStateTransaction` interface, and therefore the runners can be used with the `VersionedEntityManager`.
-
-One feature sets the `FirestorePubSubTransactionRunner` and its `FirestoreStateTransaction` apart: the handling of deleted entities using a separate, "soft-deleted document collection". Entities with a non-null `deletedAt` property are moved to a collection suffixed with `$deleted`, and an `_expirationDate` field is added to them. A TTL is expected to be set on this field. The `@SoftDeletedFirestoreCollection` decorator must be added to document classes that are meant to be handled using the `FirestorePubSubTransactionRunner`.
+The `FirestorePubSubTransactionRunner` uses a Firestore transaction as the underlying state transaction for the `FirestorePubSubTransaction`. One feature sets the `FirestorePubSubTransactionRunner` and its `FirestoreStateTransaction` apart: the handling of deleted entities using a separate, "soft-deleted document collection". Entities with a non-null `deletedAt` property are moved to a collection suffixed with `$deleted`, and an `_expirationDate` field is added to them. A TTL is expected to be set on this field. The `@SoftDeletedFirestoreCollection` decorator must be added to document classes that are meant to be handled using the `FirestorePubSubTransactionRunner`.
 
 > [!CAUTION]
 >
-> `SpannerPubSubTransactionRunner` and `FirestorePubSubTransactionRunner` do not provide atomic guarantees between the state and the events being committed. This could result in events being lost, as they are published once the state transaction successfully committed. Prefer the `SpannerOutboxTransactionRunner` when applicable.
+> `FirestorePubSubTransactionRunner` does not provide atomic guarantees between the state and the events being committed. This could result in events being lost, as they are published once the state transaction successfully committed. Prefer the `SpannerOutboxTransactionRunner` when applicable.
 
 `SpannerOutboxTransactionRunner` implements the outbox pattern (from the base runtime's `OutboxTransactionRunner`), and uses the default injected `EventPublisher` (which can be the `PubSubPublisher`, if the corresponding module is imported). It requires an outbox table to be created in each database using the runner. See the documentation of the `SpannerOutboxEvent` for more information.
 
@@ -126,4 +119,4 @@ The `@IsValidFirestoreId` validation decorator checks that a property is a strin
 
 ### More testing utilities
 
-Additionally to the testing utilities provided alongside many features in this package, the `GoogleAppFixture` ties many of those together to provide a smooth experience when testing a full NestJS application using Google services (Spanner, Pub/Sub, Firestore, Identity Platform) together. It manages the setup and tear down of all these services locally and provides a single entrypoint to interact with GCP-related fixtures in tests.
+To include all fixtures provided in this package as part of an `AppFixture`, use the `createGoogleFixtures` function, which is a convenience method to create the fixtures with sensible defaults. This will also automatically provide a `VersionedEntityFixture` configured with the `SpannerOutboxTransactionRunner`.

package/dist/app-check/testing.d.ts

@@ -1,6 +1,6 @@
-import type { NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
+import type { Fixture, NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
 /**
- * A {@link NestJsModuleOverrider} that disables the {@link AppCheckGuard}.
+ * A {@link Fixture} that disables the {@link AppCheckGuard}.
  *
  * If used as an app-level guard, the {@link AppCheckGuard} should be defined as a provider first, and the app guard
  * should reuse the existing instance:
@@ -9,4 +9,8 @@ import type { NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
  * { provide: APP_GUARD, useExisting: AppCheckGuard }
  * ```
  */
-export declare const overrideAppCheck: NestJsModuleOverrider;
+export declare class AppCheckFixture implements Fixture {
+    init(): Promise<NestJsModuleOverrider>;
+    clear(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/app-check/testing.js

@@ -1,6 +1,6 @@
 import { AppCheckGuard } from './guard.js';
 /**
- * A {@link NestJsModuleOverrider} that disables the {@link AppCheckGuard}.
+ * A {@link Fixture} that disables the {@link AppCheckGuard}.
  *
  * If used as an app-level guard, the {@link AppCheckGuard} should be defined as a provider first, and the app guard
  * should reuse the existing instance:
@@ -9,8 +9,11 @@ import { AppCheckGuard } from './guard.js';
  * { provide: APP_GUARD, useExisting: AppCheckGuard }
  * ```
  */
-export const overrideAppCheck = (builder) => builder.overrideProvider(AppCheckGuard).useValue({
-    canActivate() {
-        return true;
-    },
-});
+export class AppCheckFixture {
+    async init() {
+        const mockGuard = { canActivate: () => true };
+        return (builder) => builder.overrideProvider(AppCheckGuard).useValue(mockGuard);
+    }
+    async clear() { }
+    async delete() { }
+}

package/dist/firebase/module.d.ts

@@ -1,9 +1,20 @@
 import { type DynamicModule } from '@nestjs/common';
 import { type AppOptions } from 'firebase-admin/app';
+import { type Settings } from 'firebase-admin/firestore';
+/**
+ * Options for the various Firebase services (other than the base Firebase app).
+ */
+export type FirebaseModuleServiceOptions = {
+    /**
+     * Options for the Firestore client.
+     * The default configuration sets {@link Settings.ignoreUndefinedProperties} to `true`.
+     */
+    firestore?: Settings;
+};
 /**
  * Options when configuring the {@link FirebaseModule}.
  */
-export type FirebaseModuleOptions = AppOptions & {
+export type FirebaseModuleOptions = AppOptions & FirebaseModuleServiceOptions & {
     /**
      * The name of the Firebase app to initialize.
      */
@@ -36,7 +47,8 @@ export declare class FirebaseModule {
      * {@link initializeApp}.
      * When testing, this avoids repeatedly initializing the same app, which would result in an error.
      *
+     * @param options Options for the Firebase services (other than the base Firebase app).
      * @returns The module.
      */
-    static forTesting(): DynamicModule;
+    static forTesting(options?: FirebaseModuleServiceOptions): DynamicModule;
 }

package/dist/firebase/module.js

@@ -9,22 +9,48 @@ import { Module, } from '@nestjs/common';
 import { initializeApp } from 'firebase-admin/app';
 import { AppCheck, getAppCheck } from 'firebase-admin/app-check';
 import { Auth, getAuth } from 'firebase-admin/auth';
-import { Firestore, getFirestore } from 'firebase-admin/firestore';
-import { Messaging, getMessaging } from 'firebase-admin/messaging';
+import { Firestore, getFirestore, } from 'firebase-admin/firestore';
+import { getMessaging, Messaging } from 'firebase-admin/messaging';
 import { getDefaultFirebaseApp } from './app.js';
 import { FirestoreAdminClient } from './firestore-admin-client.type.js';
 import { FIREBASE_APP_TOKEN } from './inject-firebase-app.decorator.js';
 import { FirebaseLifecycleService } from './lifecycle.service.js';
+/**
+ * The NestJS injection token for Firestore settings.
+ */
+const FIRESTORE_SETTINGS_TOKEN = 'CAUSA_FIRESTORE_SETTINGS';
+/**
+ * The default Firestore settings to use when initializing the Firestore client.
+ */
+const DEFAULT_FIRESTORE_SETTINGS = {
+    ignoreUndefinedProperties: true,
+};
 /**
  * The providers for service-specific Firebase clients.
- * Those do not have any options as they inherit them from the `App`.
+ * Options for the services can be passed using injection tokens.
  */
 const childProviders = [
     { provide: Auth, useFactory: getAuth, inject: [FIREBASE_APP_TOKEN] },
     {
         provide: Firestore,
-        useFactory: getFirestore,
-        inject: [FIREBASE_APP_TOKEN],
+        useFactory: (app, settings) => {
+            const firestore = getFirestore(app);
+            try {
+                // Firestore settings can only be set once, but we cannot know if they've already been set without using private
+                // APIs. Calling this several times could occur in testing, when the default app is reused.
+                firestore.settings(settings);
+                return firestore;
+            }
+            catch (error) {
+                // The Firestore SDK does not type the error more precisely.
+                if (error instanceof Error &&
+                    error.message.includes('Firestore has already been initialized.')) {
+                    return firestore;
+                }
+                throw error;
+            }
+        },
+        inject: [FIREBASE_APP_TOKEN, FIRESTORE_SETTINGS_TOKEN],
     },
     { provide: AppCheck, useFactory: getAppCheck, inject: [FIREBASE_APP_TOKEN] },
     {
@@ -40,20 +66,22 @@ const childProviders = [
 /**
  * Creates the module metadata for the {@link FirebaseModule}.
  *
+ * @param useDefaultFactory Whether to use {@link getDefaultFirebaseApp} to (re)use the default Firebase app.
  * @param options Options when configuring the {@link FirebaseModule}.
- *   If set to `default`, the default Firebase app will be (re)used using {@link getDefaultFirebaseApp}.
+ *   If the default Firebase app is used, app options are ignored.
  * @returns The module metadata.
  */
-function createModuleMetadata(options = {}) {
-    const useDefaultFactory = options === 'default';
-    const { appName, ...appOptions } = useDefaultFactory
-        ? {}
-        : options;
+function createModuleMetadata(useDefaultFactory, options) {
+    const { appName, firestore, ...appOptions } = options;
     const appFactory = useDefaultFactory
         ? getDefaultFirebaseApp
         : () => initializeApp(appOptions, appName);
     const providers = [
         { provide: FIREBASE_APP_TOKEN, useFactory: appFactory },
+        {
+            provide: FIRESTORE_SETTINGS_TOKEN,
+            useValue: { ...DEFAULT_FIRESTORE_SETTINGS, ...firestore },
+        },
         ...childProviders,
     ];
     if (!useDefaultFactory) {
@@ -79,7 +107,7 @@ let FirebaseModule = FirebaseModule_1 = class FirebaseModule {
      */
     static forRoot(options = {}) {
         return {
-            ...createModuleMetadata(options),
+            ...createModuleMetadata(false, options),
             module: FirebaseModule_1,
             global: true,
         };
@@ -92,7 +120,7 @@ let FirebaseModule = FirebaseModule_1 = class FirebaseModule {
      */
     static register(options = {}) {
         return {
-            ...createModuleMetadata(options),
+            ...createModuleMetadata(false, options),
             module: FirebaseModule_1,
         };
     }
@@ -102,17 +130,18 @@ let FirebaseModule = FirebaseModule_1 = class FirebaseModule {
      * {@link initializeApp}.
      * When testing, this avoids repeatedly initializing the same app, which would result in an error.
      *
+     * @param options Options for the Firebase services (other than the base Firebase app).
      * @returns The module.
      */
-    static forTesting() {
+    static forTesting(options = {}) {
         return {
-            ...createModuleMetadata('default'),
+            ...createModuleMetadata(true, options),
             module: FirebaseModule_1,
             global: true,
         };
     }
 };
 FirebaseModule = FirebaseModule_1 = __decorate([
-    Module(createModuleMetadata())
+    Module(createModuleMetadata(false, {}))
 ], FirebaseModule);
 export { FirebaseModule };

package/dist/firebase/testing.d.ts

@@ -1,6 +1,9 @@
-import type { NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
+import type { Fixture, NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
 /**
- * A {@link NestJsModuleOverrider} that reuses {@link getDefaultFirebaseApp} and prevents the deletion of the Firebase
- * application upon shutdown.
+ * A {@link Fixture} that reuses the default Firebase application and prevents its deletion upon shutdown.
  */
-export declare const overrideFirebaseApp: NestJsModuleOverrider;
+export declare class FirebaseFixture implements Fixture {
+    init(): Promise<NestJsModuleOverrider>;
+    clear(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/firebase/testing.js

@@ -2,11 +2,16 @@ import { getDefaultFirebaseApp } from './app.js';
 import { FIREBASE_APP_TOKEN } from './inject-firebase-app.decorator.js';
 import { FirebaseLifecycleService } from './lifecycle.service.js';
 /**
- * A {@link NestJsModuleOverrider} that reuses {@link getDefaultFirebaseApp} and prevents the deletion of the Firebase
- * application upon shutdown.
+ * A {@link Fixture} that reuses the default Firebase application and prevents its deletion upon shutdown.
  */
-export const overrideFirebaseApp = (builder) => builder
-    .overrideProvider(FIREBASE_APP_TOKEN)
-    .useValue(getDefaultFirebaseApp())
-    .overrideProvider(FirebaseLifecycleService)
-    .useValue({});
+export class FirebaseFixture {
+    async init() {
+        return (builder) => builder
+            .overrideProvider(FIREBASE_APP_TOKEN)
+            .useValue(getDefaultFirebaseApp())
+            .overrideProvider(FirebaseLifecycleService)
+            .useValue({});
+    }
+    async clear() { }
+    async delete() { }
+}

package/dist/firestore/testing.d.ts

@@ -1,5 +1,5 @@
-import type { NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
-import type { INestApplicationContext, Type } from '@nestjs/common';
+import type { AppFixture, Fixture, NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
+import type { Type } from '@nestjs/common';
 import { CollectionReference, Firestore } from 'firebase-admin/firestore';
 /**
  * Creates a new collection prefixed with a random ID.
@@ -17,19 +17,34 @@ export declare function createFirestoreTemporaryCollection<T>(firestore: Firesto
  */
 export declare function clearFirestoreCollection(collectionRef: CollectionReference): Promise<void>;
 /**
- * Overrides the providers for Firestore collections with temporary collections.
- *
- * @param documentTypes The types of documents corresponding to Firestore collections, for which collections should be
- *   overridden.
- * @returns The {@link NestJsModuleOverrider} that can be used to override the Firestore collections.
- */
-export declare function overrideFirestoreCollections(...documentTypes: Type[]): NestJsModuleOverrider;
-/**
- * Returns the {@link CollectionReference} of the Firestore collection corresponding to the given class.
- * Retrieving it from the module or application ensures the "mocked" collection is used.
- *
- * @param context The NestJS module or application from which the Firestore collection should be retrieved.
- * @param documentType The type of document stored in the collection.
- * @returns The {@link CollectionReference} of the Firestore collection.
+ * A {@link Fixture} that replaces Firestore collections with temporary collections, and clears them when requested.
  */
-export declare function getFirestoreCollectionFromModule<T>(context: INestApplicationContext, documentType: Type<T>): CollectionReference<T>;
+export declare class FirestoreFixture implements Fixture {
+    /**
+     * The types of documents that should be stored in temporary collections and cleared.
+     */
+    readonly types: Type[];
+    /**
+     * The parent {@link AppFixture}.
+     */
+    private appFixture;
+    constructor(
+    /**
+     * The types of documents that should be stored in temporary collections and cleared.
+     */
+    types: Type[]);
+    init(appFixture: AppFixture): Promise<NestJsModuleOverrider>;
+    clear(): Promise<void>;
+    delete(): Promise<void>;
+    /**
+     * The underlying {@link Firestore} instance used by this fixture.
+     */
+    get firestore(): Firestore;
+    /**
+     * Returns the (temporary) collection for the given document type.
+     *
+     * @param documentType The type of the document.
+     * @returns The {@link CollectionReference} for the given document type.
+     */
+    collection<T>(documentType: Type<T>): CollectionReference<T>;
+}

package/dist/firestore/testing.js

@@ -26,37 +26,53 @@ export function createFirestoreTemporaryCollection(firestore, documentType) {
 export async function clearFirestoreCollection(collectionRef) {
     const batch = collectionRef.firestore.batch();
     const documents = await collectionRef.listDocuments();
-    documents.forEach((document) => batch.delete(document));
+    documents.forEach((d) => batch.delete(d));
     await batch.commit();
 }
 /**
- * Overrides the providers for Firestore collections with temporary collections.
- *
- * @param documentTypes The types of documents corresponding to Firestore collections, for which collections should be
- *   overridden.
- * @returns The {@link NestJsModuleOverrider} that can be used to override the Firestore collections.
- */
-export function overrideFirestoreCollections(...documentTypes) {
-    return (builder) => {
-        documentTypes.forEach((documentType) => {
-            builder = builder
-                .overrideProvider(getFirestoreCollectionInjectionName(documentType))
-                .useFactory({
-                factory: (firestore) => createFirestoreTemporaryCollection(firestore, documentType),
-                inject: [Firestore],
-            });
-        });
-        return builder;
-    };
-}
-/**
- * Returns the {@link CollectionReference} of the Firestore collection corresponding to the given class.
- * Retrieving it from the module or application ensures the "mocked" collection is used.
- *
- * @param context The NestJS module or application from which the Firestore collection should be retrieved.
- * @param documentType The type of document stored in the collection.
- * @returns The {@link CollectionReference} of the Firestore collection.
+ * A {@link Fixture} that replaces Firestore collections with temporary collections, and clears them when requested.
  */
-export function getFirestoreCollectionFromModule(context, documentType) {
-    return context.get(getFirestoreCollectionInjectionName(documentType));
+export class FirestoreFixture {
+    types;
+    /**
+     * The parent {@link AppFixture}.
+     */
+    appFixture;
+    constructor(
+    /**
+     * The types of documents that should be stored in temporary collections and cleared.
+     */
+    types) {
+        this.types = types;
+    }
+    async init(appFixture) {
+        this.appFixture = appFixture;
+        return (builder) => this.types.reduce((builder, t) => builder
+            .overrideProvider(getFirestoreCollectionInjectionName(t))
+            .useFactory({
+            factory: (f) => createFirestoreTemporaryCollection(f, t),
+            inject: [Firestore],
+        }), builder);
+    }
+    async clear() {
+        await Promise.all(this.types.map((t) => clearFirestoreCollection(this.collection(t))));
+    }
+    async delete() {
+        this.appFixture = undefined;
+    }
+    /**
+     * The underlying {@link Firestore} instance used by this fixture.
+     */
+    get firestore() {
+        return this.appFixture.get(Firestore);
+    }
+    /**
+     * Returns the (temporary) collection for the given document type.
+     *
+     * @param documentType The type of the document.
+     * @returns The {@link CollectionReference} for the given document type.
+     */
+    collection(documentType) {
+        return this.appFixture.get(getFirestoreCollectionInjectionName(documentType));
+    }
 }

package/dist/identity-platform/testing.d.ts

@@ -1,15 +1,16 @@
 import type { User } from '@causa/runtime';
+import type { AppFixture, Fixture } from '@causa/runtime/nestjs/testing';
 import { Auth } from 'firebase-admin/auth';
 import jwt from 'jsonwebtoken';
 /**
- * A helper to create and delete Identity Platform users in the emulator.
+ * A {@link Fixture} to create and delete Identity Platform users in the emulator.
  * It also creates an ID token for them.
  */
-export declare class AuthUsersFixture {
+export declare class AuthUsersFixture implements Fixture {
     /**
-     * The Firebase Auth client to use.
+     * The parent {@link AppFixture}.
      */
-    readonly auth: Auth;
+    private appFixture;
     /**
      * The list of created users.
      */
@@ -18,10 +19,21 @@ export declare class AuthUsersFixture {
      * The base payload required to form a JWT.
      */
     private readonly jwtBasePayload;
+    /**
+     * The Firebase Auth client to use.
+     * This is lazily initialized when the `auth` property is accessed, which avoids trying to fetch it during
+     * {@link AuthUsersFixture.init} and / or {@link AuthUsersFixture.delete}.
+     */
+    private lazyAuth?;
     /**
      * Creates a new {@link AuthUsersFixture}.
      */
     constructor();
+    init(appFixture: AppFixture): Promise<undefined>;
+    /**
+     * The Firebase Auth client to use.
+     */
+    get auth(): Auth;
     /**
      * Creates a new user if it doesn't already exist, and generates a corresponding JWT.
      *
@@ -33,8 +45,11 @@ export declare class AuthUsersFixture {
         user: User;
         token: string;
     }>;
+    clear(): Promise<void>;
     /**
-     * Deletes users created by this fixture from the Identity Platform emulator.
+     * Deletes all users created by this fixture.
+     * This does not delete the fixture itself.
      */
-    deleteAll(): Promise<void>;
+    deleteUsers(): Promise<void>;
+    delete(): Promise<void>;
 }

package/dist/identity-platform/testing.js

@@ -1,16 +1,15 @@
-import { Auth, getAuth } from 'firebase-admin/auth';
+import { Auth } from 'firebase-admin/auth';
 import jwt from 'jsonwebtoken';
 import * as uuid from 'uuid';
-import { getDefaultFirebaseApp } from '../firebase/index.js';
 /**
- * A helper to create and delete Identity Platform users in the emulator.
+ * A {@link Fixture} to create and delete Identity Platform users in the emulator.
  * It also creates an ID token for them.
  */
 export class AuthUsersFixture {
     /**
-     * The Firebase Auth client to use.
+     * The parent {@link AppFixture}.
      */
-    auth;
+    appFixture;
     /**
      * The list of created users.
      */
@@ -19,17 +18,34 @@ export class AuthUsersFixture {
      * The base payload required to form a JWT.
      */
     jwtBasePayload;
+    /**
+     * The Firebase Auth client to use.
+     * This is lazily initialized when the `auth` property is accessed, which avoids trying to fetch it during
+     * {@link AuthUsersFixture.init} and / or {@link AuthUsersFixture.delete}.
+     */
+    lazyAuth;
     /**
      * Creates a new {@link AuthUsersFixture}.
      */
     constructor() {
-        this.auth = getAuth(getDefaultFirebaseApp());
         const projectId = process.env.GOOGLE_CLOUD_PROJECT ?? '';
         this.jwtBasePayload = {
             aud: projectId,
             iss: `https://securetoken.google.com/${projectId}`,
         };
     }
+    async init(appFixture) {
+        this.appFixture = appFixture;
+    }
+    /**
+     * The Firebase Auth client to use.
+     */
+    get auth() {
+        if (!this.lazyAuth) {
+            this.lazyAuth = this.appFixture.get(Auth);
+        }
+        return this.lazyAuth;
+    }
     /**
      * Creates a new user if it doesn't already exist, and generates a corresponding JWT.
      *
@@ -52,11 +68,20 @@ export class AuthUsersFixture {
         const token = jwt.sign({ ...this.jwtBasePayload, sub: user.id, ...customClaims }, null, { ...tokenOptions, algorithm: 'none' });
         return { user, token };
     }
+    async clear() { }
     /**
-     * Deletes users created by this fixture from the Identity Platform emulator.
+     * Deletes all users created by this fixture.
+     * This does not delete the fixture itself.
      */
-    async deleteAll() {
-        await this.auth.deleteUsers(this.users.map((user) => user.id));
+    async deleteUsers() {
+        if (this.users.length === 0) {
+            return;
+        }
+        await this.auth.deleteUsers(this.users.map(({ id }) => id));
         this.users.length = 0;
     }
+    async delete() {
+        await this.deleteUsers();
+        this.appFixture = undefined;
+    }
 }

package/dist/pubsub/publisher.module.d.ts

@@ -14,5 +14,5 @@ export declare class PubSubPublisherModule {
      * @param options Options for the {@link PubSubPublisher}.
      * @returns The module.
      */
-    static forRoot(options?: Pick<PubSubPublisherOptions, 'publishOptions' | 'serializer'>): DynamicModule;
+    static forRoot(options?: Omit<PubSubPublisherOptions, 'pubSub' | 'configurationGetter'>): DynamicModule;
 }