@causa/runtime-google 0.40.0 → 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/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;
 }

package/dist/pubsub/{testing/fixture.d.ts → testing.d.ts}

@@ -1,7 +1,7 @@
 import { type ObjectSerializer } from '@causa/runtime';
-import type { NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
+import type { AppFixture, EventFixture, Fixture, NestJsModuleOverrider } from '@causa/runtime/nestjs/testing';
 import { PubSub, Subscription, Topic } from '@google-cloud/pubsub';
-import type { Type } from '@nestjs/common';
+import { type Type } from '@nestjs/common';
 /**
  * A received Pub/Sub message that was deserialized.
  */
@@ -20,27 +20,51 @@ export type ReceivedPubSubEvent = {
     event: any;
 };
 /**
- * Options for the {@link PubSubFixture.expectMessageInTopic} method.
+ * Options for the {@link PubSubFixture.expectMessage} method.
  */
-type ExpectMessageInTopicOptions = {
+export type ExpectMessageOptions = {
     /**
      * The maximum time (in milliseconds) to wait for a message before giving up.
      * Defaults to `2000`.
      */
     timeout?: number;
 };
+/**
+ * Options when making a request to an endpoint handling Pub/Sub events using an {@link EventRequester}.
+ */
+export type EventRequesterOptions = {
+    /**
+     * The attributes to add to the Pub/Sub message.
+     * Using `undefined` values allows removing the attributes set by default.
+     */
+    attributes?: Record<string, string | undefined>;
+    /**
+     * The expected status code when making the request.
+     * Default is `200`.
+     */
+    expectedStatus?: number;
+    /**
+     * The time to set as the publication time of the Pub/Sub message.
+     */
+    publishTime?: Date;
+};
+/**
+ * A function that makes a query to an endpoint handling Pub/Sub events and tests the response.
+ */
+export type EventRequester = (event: object, options?: EventRequesterOptions) => Promise<void>;
 /**
  * A utility class managing temporary Pub/Sub topics and listening to messages published to them.
  */
-export declare class PubSubFixture {
+export declare class PubSubFixture implements Fixture, EventFixture {
+    private readonly topicsAndTypes;
     /**
-     * The Pub/Sub client to use.
+     * The parent {@link AppFixture}.
      */
-    readonly pubSub: PubSub;
+    private appFixture;
     /**
-     * Whether the Pub/Sub client is managed by the fixture.
+     * The Pub/Sub client to use.
      */
-    private readonly isManagedClient;
+    readonly pubSub: PubSub;
     /**
      * The (de)serializer to use for Pub/Sub messages.
      */
@@ -49,7 +73,7 @@ export declare class PubSubFixture {
      * The dictionary of monitored temporary topics.
      * The key is the name of the event topic (not broker-specific).
      */
-    readonly fixtures: Record<string, {
+    readonly topics: Record<string, {
         /**
          * The created temporary Pub/Sub topic.
          */
@@ -66,13 +90,10 @@ export declare class PubSubFixture {
     /**
      * Creates a new {@link PubSubFixture}.
      *
+     * @param topicsAndTypes The dictionary of topics to test and their event types.
      * @param options Options for the fixture.
      */
-    constructor(options?: {
-        /**
-         * The Pub/Sub client to use.
-         */
-        pubSub?: PubSub;
+    constructor(topicsAndTypes: Record<string, Type>, options?: {
         /**
          * The (de)serializer to use for Pub/Sub messages.
          */
@@ -81,44 +102,46 @@ export declare class PubSubFixture {
     /**
      * Creates a new temporary topic and starts listening to messages published to it.
      *
-     * @param sourceTopicName The original name of the topic, i.e. the one used in production.
+     * @param sourceTopic The original name of the topic, i.e. the one used in production.
      * @param eventType The type of the event published to the topic, used for deserialization.
      * @returns The configuration key and value for the created temporary topic.
      */
-    create(sourceTopicName: string, eventType: Type): Promise<Record<string, string>>;
-    /**
-     * Creates several temporary topics and returns the configuration (environment variables) for the
-     *
-     * @param topicsAndTypes A dictionary of topics and their corresponding event types.
-     * @returns The configuration for Pub/Sub topics, with the IDs of the created topics.
-     */
-    createMany(topicsAndTypes: Record<string, Type>): Promise<Record<string, string>>;
+    private create;
+    init(appFixture: AppFixture): Promise<NestJsModuleOverrider>;
     /**
-     * Uses {@link PubSubFixture.createMany} to create temporary topics and returns a {@link NestJsModuleOverrider} to
-     * override the Pub/Sub publisher configuration.
+     * Creates an {@link EventRequester} for an endpoint handling Pub/Sub messages.
+     * If the `event` passed to the {@link EventRequester} conforms to the `Event` interface (if it has `producedAt`,
+     * `name` and / or `id` properties), the default attributes are set in the Pub/Sub message. Default attributes can be
+     * overridden (or removed by passing `undefined`) using {@link EventRequesterOptions.attributes}.
      *
-     * @param topicsAndTypes A dictionary of topics and their corresponding event types.
-     * @returns The {@link NestJsModuleOverrider} to use to override the Pub/Sub publisher configuration.
+     * @param endpoint The endpoint to query.
+     * @param options Options when creating the requester.
+     * @returns The {@link EventRequester}.
      */
-    createWithOverrider(topicsAndTypes: Record<string, Type>): Promise<NestJsModuleOverrider>;
+    makeRequester(endpoint: string, options?: {
+        /**
+         * The default expected status code when making a request.
+         */
+        expectedStatus?: number;
+    }): EventRequester;
     /**
      * Checks that the given message has been published to the specified topic.
      *
-     * @param sourceTopicName The original name of the event topic.
+     * @param topic The original name of the event topic.
      * @param expectedMessage The message expected to have been published.
      *   This can be an `expect` expression, e.g. `expect.objectContaining({})`.
      * @param options Options for the expectation.
      */
-    expectMessageInTopic(sourceTopicName: string, expectedMessage: any, options?: ExpectMessageInTopicOptions): Promise<void>;
+    expectMessage(topic: string, expectedMessage: any, options?: ExpectMessageOptions): Promise<void>;
     /**
-     * Uses {@link PubSubFixture.expectMessageInTopic} to check that the given event has been published to the specified
+     * Uses {@link PubSubFixture.expectMessage} to check that the given event has been published to the specified
      * topic. The `expectedEvent` is the payload of the message, i.e. the `event` property.
      *
-     * @param sourceTopicName The original name of the event topic.
+     * @param topic The original name of the event topic.
      * @param expectedEvent The event expected to have been published.
      * @param options Options for the expectation.
      */
-    expectEventInTopic(sourceTopicName: string, expectedEvent: any, options?: ExpectMessageInTopicOptions & {
+    expectEvent(topic: string, expectedEvent: any, options?: ExpectMessageOptions & {
         /**
          * The attributes expected to have been published with the event.
          * This may contain only a subset of the attributes.
@@ -130,29 +153,22 @@ export declare class PubSubFixture {
      * By default, because publishing (and receiving) the messages is asynchronous, a small delay is added before checking
      * that no message has been received. This delay can be removed or increased by passing the `delay` option.
      *
-     * @param sourceTopicName The original name of the topic, i.e. the one used in production.
+     * @param topic The original name of the topic, i.e. the one used in production.
      * @param options Options for the expectation.
      */
-    expectNoMessageInTopic(sourceTopicName: string, options?: {
+    expectNoMessage(topic: string, options?: {
         /**
          * The delay (in milliseconds) before checking that no message has been received.
          */
         delay?: number;
     }): Promise<void>;
-    /**
-     * Clears all the messages received from the temporary topics.
-     */
-    clear(): void;
+    expectNoEvent(topic: string): Promise<void>;
+    clear(): Promise<void>;
     /**
      * Deletes the temporary topic for the corresponding "production" topic.
      *
-     * @param sourceTopicName The original name of the topic, i.e. the one used in production.
-     */
-    delete(sourceTopicName: string): Promise<void>;
-    /**
-     * Deletes all previously created temporary topics.
-     * If the Pub/Sub client was managed by the fixture (it wasn't passed as an option), it is also closed.
+     * @param topic The original name of the topic, i.e. the one used in production.
      */
-    deleteAll(): Promise<void>;
+    deleteTopic(topic: string): Promise<void>;
+    delete(): Promise<void>;
 }
-export {};