@firebase-function-kits/bigquery-firestore-export 0.0.2-rc.1 → 0.0.2-rc.3

package/src/dts.ts

@@ -61,6 +61,21 @@ function transferConfigFields(config: TransferConfig) {
   return fields;
 }
 
+/**
+ * Full resource name of the topic DTS publishes run notifications to.
+ *
+ * PUB_SUB_TOPIC is validated as a bare topic ID when prompted, but values from
+ * a dotenv file reach us unvalidated, and both the Pub/Sub client and the
+ * trigger accept a full resource name, so accept one here too.
+ */
+export function notificationTopicName(
+  config: ResolvedBigqueryFirestoreExportConfig
+): string {
+  return config.pubSubTopic.startsWith("projects/")
+    ? config.pubSubTopic
+    : `projects/${config.projectId}/topics/${config.pubSubTopic}`;
+}
+
 function stringField(value: string | undefined): { stringValue: string } {
   return { stringValue: value ?? "" };
 }
@@ -93,7 +108,7 @@ export function createTransferConfigRequest(
         },
       },
       schedule: config.schedule,
-      notificationPubsubTopic: `projects/${config.projectId}/topics/${config.pubSubTopic}`,
+      notificationPubsubTopic: notificationTopicName(config),
     },
   };
 }
@@ -184,7 +199,7 @@ export async function constructUpdateTransferConfigRequest(
     updatedConfig.schedule = config.schedule;
   }
 
-  const expectedTopic = `projects/${config.projectId}/topics/${config.pubSubTopic}`;
+  const expectedTopic = notificationTopicName(config);
   if (expectedTopic !== transferConfig.notificationPubsubTopic) {
     updateMask.push("notification_pubsub_topic");
     updatedConfig.notificationPubsubTopic = expectedTopic;

package/src/handlers.ts

@@ -23,6 +23,8 @@ import {
   createTransferConfig,
   type DataTransferClient,
   getTransferConfig,
+  notificationTopicName,
+  PARTITIONING_FIELD_REMOVAL_ERROR_PREFIX,
   updateTransferConfig,
 } from "./dts";
 import type { ResolvedBigqueryFirestoreExportConfig } from "./export-config";
@@ -64,6 +66,13 @@ async function ensureNotificationTopic(ctx: HandlerContext): Promise<void> {
   }
 }
 
+function isPartitioningFieldRemovalError(err: unknown): err is Error {
+  return (
+    err instanceof Error &&
+    err.message.includes(PARTITIONING_FIELD_REMOVAL_ERROR_PREFIX)
+  );
+}
+
 async function storeTransferConfig(
   ctx: HandlerContext,
   transferConfig: Awaited<ReturnType<typeof getTransferConfig>>
@@ -105,8 +114,19 @@ export async function handleUpsertTransferConfig(
       ctx.config.transferConfigName
     );
     if (!linked) {
-      throw new Error(
-        `Transfer config not found: ${ctx.config.transferConfigName}`
+      // Only a redeploy with a corrected TRANSFER_CONFIG_NAME can resolve this,
+      // so retrying the task cannot help.
+      logs.linkedTransferConfigMissing(ctx.config.transferConfigName);
+      return;
+    }
+    // A linked config is adopted as-is, so a topic mismatch is the user's to
+    // resolve: rewriting it would repoint a config this deployment did not create.
+    const expectedTopic = notificationTopicName(ctx.config);
+    if (linked.notificationPubsubTopic !== expectedTopic) {
+      logs.linkedTopicMismatch(
+        ctx.config.transferConfigName,
+        linked.notificationPubsubTopic,
+        expectedTopic
       );
     }
     await storeTransferConfig(ctx, linked);
@@ -128,14 +148,21 @@ export async function handleUpsertTransferConfig(
   const transferConfigName = existing.docs[0].data().name;
   if (typeof transferConfigName !== "string" || !transferConfigName) {
     throw new Error(
-      `Existing transfer config document in ${ctx.config.firestoreCollection} is missing required 'name' field.`
+      `Existing transfer config document in ${ctx.config.firestoreCollection} is missing required 'name' field. Delete the document so a new scheduled query is created, then redeploy.`
     );
   }
 
-  const updated = await updateTransferConfig(
-    ctx.dataTransfer,
-    transferConfigName,
-    ctx.config
-  );
-  await storeTransferConfig(ctx, updated);
+  try {
+    const updated = await updateTransferConfig(
+      ctx.dataTransfer,
+      transferConfigName,
+      ctx.config
+    );
+    await storeTransferConfig(ctx, updated);
+  } catch (err) {
+    if (!isPartitioningFieldRemovalError(err)) throw err;
+    // The guard rejects the update while building the request, so nothing was
+    // sent and a retry hits the same guard.
+    logs.partitioningFieldRemovalAborted(err.message);
+  }
 }

package/src/helper.ts

@@ -227,6 +227,7 @@ export async function writeRunResultsToFirestore(
     message.json.destinationDatasetId,
     tableName
   );
+  logs.writeRunResultsToFirestore(runId);
   const collection = db.collection(
     `${config.firestoreCollection}/${transferConfigId}/runs/${runId}/output`
   );

package/src/logs.ts

@@ -70,6 +70,10 @@ export function bigqueryQueryFailed(
   });
 }
 
+export function writeRunResultsToFirestore(runId: string): void {
+  logger.debug("Writing BigQuery results to Firestore", { runId });
+}
+
 export function runResultsWrittenToFirestore(
   runId: string,
   successCount: number,
@@ -140,6 +144,30 @@ export function partitioningFieldRemovalAttempted(
   });
 }
 
+export function linkedTransferConfigMissing(name: string): void {
+  logger.error(
+    "The scheduled query named by TRANSFER_CONFIG_NAME does not exist, so nothing was linked. Set it to a scheduled query that exists in this project and redeploy, or clear it to have this deployment create its own.",
+    { name }
+  );
+}
+
+// The reason carries the remediation, and an Error passed as structured data
+// serialises to {}, so it goes in the message.
+export function partitioningFieldRemovalAborted(reason: string): void {
+  logger.error(`Stopped without updating the scheduled query. ${reason}`);
+}
+
 export function topicCreated(name: string): void {
   logger.info("Created Pub/Sub topic for transfer notifications", { name });
 }
+
+export function linkedTopicMismatch(
+  name: string,
+  linkedTopic: string | null | undefined,
+  expectedTopic: string
+): void {
+  logger.warn(
+    "Linked transfer config notifies a different Pub/Sub topic, so its runs will not reach this kit. Set PUB_SUB_TOPIC to the linked topic, or point the transfer config at the configured one.",
+    { name, linkedTopic: linkedTopic ?? "", expectedTopic }
+  );
+}

package/tests/config.test.ts

@@ -23,12 +23,41 @@ afterEach(() => {
 });
 
 describe("CONFIG_EXPRESSIONS", () => {
-  test("namespaces the Pub/Sub topic with the required instance id", () => {
+  test("binds the trigger to the Pub/Sub topic parameter", () => {
     expect(CONFIG_EXPRESSIONS.pubSubTopic).toBeInstanceOf(Expression);
     expect((CONFIG_EXPRESSIONS.pubSubTopic as Expression<string>).toCEL()).toBe(
-      "kit-{{ params.INSTANCE_ID }}-processMessages"
+      "{{ params.PUB_SUB_TOPIC }}"
     );
   });
+
+  test("defaults the topic parameter to the instance-namespaced kit topic", () => {
+    const spec = (
+      CONFIG_EXPRESSIONS.pubSubTopic as unknown as {
+        toSpec: () => { default?: string };
+      }
+    ).toSpec();
+    expect(spec.default).toBe("kit-{{ params.INSTANCE_ID }}-processMessages");
+  });
+
+  test("accepts a topic ID but rejects a full resource name", () => {
+    const spec = (
+      CONFIG_EXPRESSIONS.pubSubTopic as unknown as {
+        toSpec: () => { input?: { text?: { validationRegex?: string } } };
+      }
+    ).toSpec();
+    const pattern = spec.input?.text?.validationRegex;
+    expect(pattern).toBeTypeOf("string");
+    const validate = (value: string) =>
+      new RegExp(pattern as string).test(value);
+
+    expect(validate("ext-users-export-processMessages")).toBe(true);
+    expect(validate("kit-users-export-processMessages")).toBe(true);
+    expect(
+      validate("projects/test-project/topics/ext-users-export-processMessages")
+    ).toBe(false);
+    expect(validate("")).toBe(false);
+    expect(validate("goog-reserved-prefix")).toBe(false);
+  });
 });
 
 describe("configFromEnv", () => {
@@ -47,6 +76,8 @@ describe("configFromEnv", () => {
     vi.stubEnv("COLLECTION_PATH", "transferConfigs");
     vi.stubEnv("LOG_LEVEL", "info");
 
+    vi.stubEnv("PUB_SUB_TOPIC", "kit-users-export-processMessages");
+
     expect(configFromEnv()).toMatchObject({
       projectId: "test-project",
       instanceId: "users-export",
@@ -58,4 +89,25 @@ describe("configFromEnv", () => {
       logLevel: "info",
     });
   });
+
+  test("passes through a topic pointing at the extension's own topic", () => {
+    vi.stubEnv(
+      "FIREBASE_CONFIG",
+      JSON.stringify({ projectId: "test-project" })
+    );
+    vi.stubEnv("INSTANCE_ID", "users-export");
+    vi.stubEnv("BIGQUERY_DATASET_LOCATION", "EU");
+    vi.stubEnv("DATASET_ID", "analytics");
+    vi.stubEnv("TABLE_NAME", "users");
+    vi.stubEnv("QUERY_STRING", "SELECT * FROM source.users");
+    vi.stubEnv("DISPLAY_NAME", "Users export");
+    vi.stubEnv("SCHEDULE", "every 24 hours");
+    vi.stubEnv("COLLECTION_PATH", "transferConfigs");
+    vi.stubEnv("LOG_LEVEL", "info");
+    vi.stubEnv("PUB_SUB_TOPIC", "ext-users-export-processMessages");
+
+    expect(configFromEnv().pubSubTopic).toBe(
+      "ext-users-export-processMessages"
+    );
+  });
 });

package/tests/dts-transfer-config.test.ts

@@ -0,0 +1,400 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as bigqueryDataTransfer from "@google-cloud/bigquery-data-transfer";
+import { describe, expect, test, vi } from "vitest";
+import {
+  constructUpdateTransferConfigRequest,
+  createTransferConfig,
+  type DataTransferClient,
+  getTransferConfig,
+  type TransferConfig,
+  updateTransferConfig,
+} from "../src/dts";
+import { resolveConfig } from "../src/export-config";
+
+vi.mock("../src/logs", () => ({
+  createTransferConfig: vi.fn(),
+  getTransferConfigFailed: vi.fn(),
+  partitioningFieldRemovalAttempted: vi.fn(),
+  transferConfigCreated: vi.fn(),
+  transferConfigNotFound: vi.fn(),
+  transferConfigUpdated: vi.fn(),
+  updateTransferConfig: vi.fn(),
+}));
+
+const { UpdateTransferConfigRequest } =
+  bigqueryDataTransfer.protos.google.cloud.bigquery.datatransfer.v1;
+
+const TRANSFER_CONFIG_NAME =
+  "projects/test-project/locations/us/transferConfigs/642f3a36-0000-2fbb-ad1d-001a114e2fa6";
+const EXPECTED_TOPIC =
+  "projects/test-project/topics/kit-users-export-processMessages";
+const GRPC_NOT_FOUND = 5;
+
+const config = resolveConfig({
+  bigqueryDatasetLocation: "US",
+  projectId: "test-project",
+  instanceId: "users-export",
+  datasetId: "analytics",
+  tableName: "users",
+  queryString: "SELECT * FROM source.users",
+  displayName: "Users export",
+  schedule: "every 24 hours",
+});
+
+/** A stored config that already matches `config` in every comparable field. */
+function unchangedTransferConfig(): TransferConfig {
+  return {
+    name: TRANSFER_CONFIG_NAME,
+    dataSourceId: "scheduled_query",
+    destinationDatasetId: "analytics",
+    displayName: "Users export",
+    notificationPubsubTopic: EXPECTED_TOPIC,
+    schedule: "every 24 hours",
+    params: {
+      fields: {
+        query: { stringValue: "SELECT * FROM source.users" },
+        destination_table_name_template: {
+          stringValue: 'users_{run_time|"%H%M%S"}',
+        },
+        write_disposition: { stringValue: "WRITE_TRUNCATE" },
+        partitioning_field: { stringValue: "" },
+      },
+    },
+  } as TransferConfig;
+}
+
+/**
+ * The stored config with only `delta` applied, so a change case can assert the
+ * whole updated config and catch edits the update mask does not mention.
+ */
+function transferConfigWithDelta(
+  delta: (transferConfig: TransferConfig) => void
+): TransferConfig {
+  const expected = unchangedTransferConfig();
+  delta(expected);
+  return expected;
+}
+
+function clientReturning(transferConfig: TransferConfig | null) {
+  return {
+    getTransferConfig: vi.fn().mockResolvedValue([transferConfig]),
+    createTransferConfig: vi.fn(),
+    updateTransferConfig: vi.fn(),
+  } as unknown as DataTransferClient & {
+    getTransferConfig: ReturnType<typeof vi.fn>;
+    createTransferConfig: ReturnType<typeof vi.fn>;
+    updateTransferConfig: ReturnType<typeof vi.fn>;
+  };
+}
+
+function clientRejecting(err: unknown) {
+  return {
+    getTransferConfig: vi.fn().mockRejectedValue(err),
+  } as unknown as DataTransferClient;
+}
+
+function grpcNotFound(): Error {
+  return Object.assign(new Error("Transfer config not found"), {
+    code: GRPC_NOT_FOUND,
+  });
+}
+
+describe("constructUpdateTransferConfigRequest change detection", () => {
+  test("rejects when the stored config cannot be read", async () => {
+    await expect(
+      constructUpdateTransferConfigRequest(
+        clientReturning(null),
+        TRANSFER_CONFIG_NAME,
+        config
+      )
+    ).rejects.toThrow("Transfer config not found");
+  });
+
+  test("produces an empty update mask when nothing changed", async () => {
+    const request = await constructUpdateTransferConfigRequest(
+      clientReturning(unchangedTransferConfig()),
+      TRANSFER_CONFIG_NAME,
+      config
+    );
+
+    expect(request.updateMask?.paths).toEqual([]);
+    expect(request.transferConfig).toEqual(unchangedTransferConfig());
+  });
+
+  test("masks the schedule alone when only the schedule changed", async () => {
+    const request = await constructUpdateTransferConfigRequest(
+      clientReturning(unchangedTransferConfig()),
+      TRANSFER_CONFIG_NAME,
+      { ...config, schedule: "every 15 minutes" }
+    );
+
+    expect(request.updateMask?.paths).toEqual(["schedule"]);
+    expect(request.transferConfig).toEqual(
+      transferConfigWithDelta((expected) => {
+        expected.schedule = "every 15 minutes";
+      })
+    );
+  });
+
+  test("masks params when the destination table name changed", async () => {
+    const request = await constructUpdateTransferConfigRequest(
+      clientReturning(unchangedTransferConfig()),
+      TRANSFER_CONFIG_NAME,
+      { ...config, tableName: "different_table" }
+    );
+
+    expect(request.updateMask?.paths).toEqual(["params"]);
+    expect(request.transferConfig).toEqual(
+      transferConfigWithDelta((expected) => {
+        expected.params.fields.destination_table_name_template.stringValue =
+          'different_table_{run_time|"%H%M%S"}';
+      })
+    );
+  });
+
+  test("masks params when the query changed", async () => {
+    const request = await constructUpdateTransferConfigRequest(
+      clientReturning(unchangedTransferConfig()),
+      TRANSFER_CONFIG_NAME,
+      { ...config, queryString: "SELECT * FROM source.accounts" }
+    );
+
+    expect(request.updateMask?.paths).toEqual(["params"]);
+    expect(request.transferConfig).toEqual(
+      transferConfigWithDelta((expected) => {
+        expected.params.fields.query.stringValue =
+          "SELECT * FROM source.accounts";
+      })
+    );
+  });
+
+  test("leaves an unset partitioning field untouched when other params change", async () => {
+    const request = await constructUpdateTransferConfigRequest(
+      clientReturning(unchangedTransferConfig()),
+      TRANSFER_CONFIG_NAME,
+      {
+        ...config,
+        partitioningField: undefined,
+        queryString: "SELECT * FROM source.accounts",
+      }
+    );
+
+    expect(request.updateMask?.paths).toEqual(["params"]);
+    expect(request.transferConfig).toEqual(
+      transferConfigWithDelta((expected) => {
+        expected.params.fields.query.stringValue =
+          "SELECT * FROM source.accounts";
+      })
+    );
+  });
+
+  test("masks the notification topic when the stored one drifted", async () => {
+    const stored = unchangedTransferConfig();
+    stored.notificationPubsubTopic = "projects/test-project/topics/wrong-topic";
+
+    const request = await constructUpdateTransferConfigRequest(
+      clientReturning(stored),
+      TRANSFER_CONFIG_NAME,
+      { ...config, schedule: "every 15 minutes" }
+    );
+
+    expect(request.updateMask?.paths).toEqual([
+      "schedule",
+      "notification_pubsub_topic",
+    ]);
+    expect(request.transferConfig).toEqual(
+      transferConfigWithDelta((expected) => {
+        expected.schedule = "every 15 minutes";
+      })
+    );
+  });
+
+  test("leaves an extension-named topic alone when PUB_SUB_TOPIC matches it", async () => {
+    const extensionTopic =
+      "projects/test-project/topics/ext-users-export-processMessages";
+    const stored = unchangedTransferConfig();
+    stored.notificationPubsubTopic = extensionTopic;
+
+    const request = await constructUpdateTransferConfigRequest(
+      clientReturning(stored),
+      TRANSFER_CONFIG_NAME,
+      { ...config, pubSubTopic: "ext-users-export-processMessages" }
+    );
+
+    expect(request.updateMask?.paths).toEqual([]);
+    expect(request.transferConfig?.notificationPubsubTopic).toBe(
+      extensionTopic
+    );
+  });
+
+  test("masks the destination dataset when it changed", async () => {
+    const request = await constructUpdateTransferConfigRequest(
+      clientReturning(unchangedTransferConfig()),
+      TRANSFER_CONFIG_NAME,
+      { ...config, datasetId: "new_dataset_id" }
+    );
+
+    expect(request.updateMask?.paths).toEqual(["destination_dataset_id"]);
+    expect(request.transferConfig).toEqual(
+      transferConfigWithDelta((expected) => {
+        expected.destinationDatasetId = "new_dataset_id";
+      })
+    );
+  });
+
+  test("adds a partitioning field that was not previously set", async () => {
+    const request = await constructUpdateTransferConfigRequest(
+      clientReturning(unchangedTransferConfig()),
+      TRANSFER_CONFIG_NAME,
+      { ...config, partitioningField: "created_at" }
+    );
+
+    expect(request.updateMask?.paths).toEqual(["params"]);
+    expect(request.transferConfig).toEqual(
+      transferConfigWithDelta((expected) => {
+        expected.params.fields.partitioning_field.stringValue = "created_at";
+      })
+    );
+  });
+
+  test("rejects a stored config without params.fields", async () => {
+    const stored = unchangedTransferConfig();
+    delete stored.params;
+
+    await expect(
+      constructUpdateTransferConfigRequest(
+        clientReturning(stored),
+        TRANSFER_CONFIG_NAME,
+        config
+      )
+    ).rejects.toThrow("missing params.fields");
+  });
+});
+
+describe("getTransferConfig", () => {
+  test("returns the transfer config when found", async () => {
+    const client = clientReturning(unchangedTransferConfig());
+
+    const result = await getTransferConfig(client, TRANSFER_CONFIG_NAME);
+
+    expect(result).toEqual(unchangedTransferConfig());
+    expect(client.getTransferConfig).toHaveBeenCalledWith({
+      name: TRANSFER_CONFIG_NAME,
+    });
+  });
+
+  test("returns null on a gRPC NOT_FOUND", async () => {
+    const result = await getTransferConfig(
+      clientRejecting(grpcNotFound()),
+      TRANSFER_CONFIG_NAME
+    );
+
+    expect(result).toBeNull();
+  });
+
+  test("rethrows any other API failure", async () => {
+    await expect(
+      getTransferConfig(
+        clientRejecting(new Error("API Error")),
+        TRANSFER_CONFIG_NAME
+      )
+    ).rejects.toThrow("API Error");
+  });
+});
+
+describe("createTransferConfig", () => {
+  test("returns the created transfer config", async () => {
+    const created = { name: TRANSFER_CONFIG_NAME };
+    const client = clientReturning(null);
+    client.createTransferConfig.mockResolvedValue([created]);
+
+    const result = await createTransferConfig(client, config);
+
+    expect(result).toEqual(created);
+    expect(client.createTransferConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ parent: "projects/test-project" })
+    );
+  });
+
+  test("rejects when the API returns a config without a name", async () => {
+    const client = clientReturning(null);
+    client.createTransferConfig.mockResolvedValue([{}]);
+
+    await expect(createTransferConfig(client, config)).rejects.toThrow(
+      "BigQuery API returned a transfer config without a name"
+    );
+  });
+});
+
+describe("updateTransferConfig", () => {
+  test("returns the updated transfer config", async () => {
+    const updated = {
+      name: TRANSFER_CONFIG_NAME,
+      schedule: "every 15 minutes",
+    };
+    const client = clientReturning(unchangedTransferConfig());
+    client.updateTransferConfig.mockResolvedValue([updated]);
+
+    const result = await updateTransferConfig(client, TRANSFER_CONFIG_NAME, {
+      ...config,
+      schedule: "every 15 minutes",
+    });
+
+    expect(result).toEqual(updated);
+    expect(client.updateTransferConfig).toHaveBeenCalledWith(
+      UpdateTransferConfigRequest.fromObject({
+        transferConfig: transferConfigWithDelta((expected) => {
+          expected.schedule = "every 15 minutes";
+        }),
+        updateMask: { paths: ["schedule"] },
+      })
+    );
+  });
+
+  test("still sends the update, with an empty mask, when nothing changed", async () => {
+    const client = clientReturning(unchangedTransferConfig());
+    client.updateTransferConfig.mockResolvedValue([unchangedTransferConfig()]);
+
+    await updateTransferConfig(client, TRANSFER_CONFIG_NAME, config);
+
+    const sent = client.updateTransferConfig.mock.calls[0][0];
+    expect(sent.updateMask?.paths).toEqual([]);
+    // On the wire the empty path list serializes as an empty FieldMask.
+    expect(sent.toJSON().updateMask).toEqual({});
+  });
+
+  test("rejects when the transfer config no longer exists", async () => {
+    const client = clientReturning(null);
+
+    await expect(
+      updateTransferConfig(client, TRANSFER_CONFIG_NAME, config)
+    ).rejects.toThrow("Transfer config not found");
+    expect(client.updateTransferConfig).not.toHaveBeenCalled();
+  });
+
+  test("rethrows a failure from the update call", async () => {
+    const client = clientReturning(unchangedTransferConfig());
+    client.updateTransferConfig.mockRejectedValue(
+      new Error("Update API Error")
+    );
+
+    await expect(
+      updateTransferConfig(client, TRANSFER_CONFIG_NAME, config)
+    ).rejects.toThrow("Update API Error");
+  });
+});

package/tests/dts.test.ts

@@ -19,6 +19,7 @@ import {
   constructUpdateTransferConfigRequest,
   createTransferConfigRequest,
   type DataTransferClient,
+  notificationTopicName,
   PARTITIONING_FIELD_REMOVAL_ERROR,
 } from "../src/dts";
 import { resolveConfig } from "../src/export-config";
@@ -63,6 +64,22 @@ describe("createTransferConfigRequest", () => {
   });
 });
 
+describe("notificationTopicName", () => {
+  test("qualifies a bare topic ID with the project", () => {
+    expect(notificationTopicName(config)).toBe(
+      "projects/test-project/topics/kit-users-export-processMessages"
+    );
+  });
+
+  test("passes through a topic already given as a resource name", () => {
+    const qualified = "projects/other-project/topics/ext-users-processMessages";
+
+    expect(notificationTopicName({ ...config, pubSubTopic: qualified })).toBe(
+      qualified
+    );
+  });
+});
+
 describe("constructUpdateTransferConfigRequest", () => {
   test("deduplicates the params update mask", async () => {
     const client = clientWithTransferConfig({