From ad4c6fcd660bac031fb07b416f047713d983a292 Mon Sep 17 00:00:00 2001 From: HassanBahati Date: Fri, 23 Jan 2026 15:03:45 +0300 Subject: [PATCH 1/5] fix(v2/pubsub): support StringParam for topic in onMessagePublished --- spec/v2/providers/pubsub.spec.ts | 24 ++++++++++++++++++++++++ src/v2/providers/pubsub.ts | 4 ++-- 2 files changed, 26 insertions(+), 2 deletions(-) diff --git a/spec/v2/providers/pubsub.spec.ts b/spec/v2/providers/pubsub.spec.ts index d498b1b42..83394f1c5 100644 --- a/spec/v2/providers/pubsub.spec.ts +++ b/spec/v2/providers/pubsub.spec.ts @@ -3,6 +3,7 @@ import { expect } from "chai"; import { CloudEvent } from "../../../src/v2/core"; import * as options from "../../../src/v2/options"; import * as pubsub from "../../../src/v2/providers/pubsub"; +import { defineString } from "../../../src/params"; import { FULL_ENDPOINT, MINIMAL_V2_ENDPOINT, FULL_OPTIONS, FULL_TRIGGER } from "./fixtures"; const EVENT_TRIGGER = { @@ -193,4 +194,27 @@ describe("onMessagePublished", () => { (event: CloudEvent) => undefined ); }); + + it("should accept StringParam for topic", () => { + const topicParam = defineString("TOPIC_NAME"); + const result = pubsub.onMessagePublished( + { + topic: topicParam, + }, + () => 42 + ); + + expect(result.__endpoint).to.deep.equal({ + ...MINIMAL_V2_ENDPOINT, + platform: "gcfv2", + eventTrigger: { + eventType: "google.cloud.pubsub.topic.v1.messagePublished", + eventFilters: { + topic: topicParam, + }, + retry: false, + }, + labels: {}, + }); + }); }); diff --git a/src/v2/providers/pubsub.ts b/src/v2/providers/pubsub.ts index 6291114fc..b5bacc3f4 100644 --- a/src/v2/providers/pubsub.ts +++ b/src/v2/providers/pubsub.ts @@ -154,7 +154,7 @@ export interface MessagePublishedData { /** PubSubOptions extend EventHandlerOptions but must include a topic. */ export interface PubSubOptions extends options.EventHandlerOptions { /** The Pub/Sub topic to watch for message events */ - topic: string; + topic: string | Expression; /** * If true, do not deploy or emulate this function. @@ -287,7 +287,7 @@ export function onMessagePublished( topicOrOptions: string | PubSubOptions, handler: (event: CloudEvent>) => any | Promise ): CloudFunction>> { - let topic: string; + let topic: string | Expression; let opts: options.EventHandlerOptions; if (typeof topicOrOptions === "string") { topic = topicOrOptions; From b1f7220cafd41df0147ab7a30e494fc632262e74 Mon Sep 17 00:00:00 2001 From: HassanBahati Date: Fri, 23 Jan 2026 15:27:20 +0300 Subject: [PATCH 2/5] chore: Conditionally set __trigger.resource based on topic type --- spec/v2/providers/pubsub.spec.ts | 9 +++++++++ src/v2/providers/pubsub.ts | 8 +++++++- 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/spec/v2/providers/pubsub.spec.ts b/spec/v2/providers/pubsub.spec.ts index 83394f1c5..8774d091c 100644 --- a/spec/v2/providers/pubsub.spec.ts +++ b/spec/v2/providers/pubsub.spec.ts @@ -204,6 +204,7 @@ describe("onMessagePublished", () => { () => 42 ); + // __endpoint should include topic in eventFilters expect(result.__endpoint).to.deep.equal({ ...MINIMAL_V2_ENDPOINT, platform: "gcfv2", @@ -216,5 +217,13 @@ describe("onMessagePublished", () => { }, labels: {}, }); + + // __trigger should omit resource when topic is an Expression + // (resource path cannot be determined at definition time) + const trigger = result.__trigger as any; + expect(trigger.eventTrigger).to.not.have.property("resource"); + expect(trigger.eventTrigger.eventType).to.equal( + "google.cloud.pubsub.topic.v1.messagePublished" + ); }); }); diff --git a/src/v2/providers/pubsub.ts b/src/v2/providers/pubsub.ts index b5bacc3f4..a0eca42de 100644 --- a/src/v2/providers/pubsub.ts +++ b/src/v2/providers/pubsub.ts @@ -324,7 +324,13 @@ export function onMessagePublished( }, eventTrigger: { eventType: "google.cloud.pubsub.topic.v1.messagePublished", - resource: `projects/${process.env.GCLOUD_PROJECT}/topics/${topic}`, + // Only set resource when topic is a string (not an Expression) + // When topic is an Expression, the resource path cannot be determined + // at definition time. The __endpoint uses eventFilters which handles + // Expression correctly. + ...(typeof topic === "string" && { + resource: `projects/${process.env.GCLOUD_PROJECT}/topics/${topic}`, + }), }, }; }, From 6b8b2076eafe7db4475bad548b43d6828504cbd1 Mon Sep 17 00:00:00 2001 From: Izaak Gough Date: Wed, 15 Apr 2026 11:50:39 +0100 Subject: [PATCH 3/5] tests: fix tests and add additional test --- spec/v2/providers/pubsub.spec.ts | 402 +++++++++++++++++-------------- 1 file changed, 215 insertions(+), 187 deletions(-) diff --git a/spec/v2/providers/pubsub.spec.ts b/spec/v2/providers/pubsub.spec.ts index f3dbc9636..915d5e3a1 100644 --- a/spec/v2/providers/pubsub.spec.ts +++ b/spec/v2/providers/pubsub.spec.ts @@ -225,7 +225,37 @@ describe("onMessagePublished", () => { expect(trigger.eventTrigger.eventType).to.equal( "google.cloud.pubsub.topic.v1.messagePublished" ); - + }); + + it("should preserve __trigger.resource for string topic", () => { + const result = pubsub.onMessagePublished( + { + topic: "test-topic", + }, + () => 42 + ); + + // __endpoint should include topic in eventFilters + expect(result.__endpoint).to.deep.equal({ + ...MINIMAL_V2_ENDPOINT, + platform: "gcfv2", + eventTrigger: { + eventType: "google.cloud.pubsub.topic.v1.messagePublished", + eventFilters: { + topic: "test-topic", + }, + retry: false, + }, + labels: {}, + }); + + const trigger = result.__trigger as any; + expect(trigger.eventTrigger).to.have.property("resource"); + expect(trigger.eventTrigger.eventType).to.equal( + "google.cloud.pubsub.topic.v1.messagePublished" + ); + }); + it("preserves backward compatibility for user tests passing POJOs without v1 getters", async () => { // If the function signature expects a V1Compat event, passing a standard v2 CloudEvent // should still be accepted by the TypeScript compiler. @@ -251,224 +281,222 @@ describe("onMessagePublished", () => { const result = await func.run(vanillaV2Event); expect(result).to.deep.equal({ test: "data" }); }); +}); - describe("event.data.message wrapping (POJO -> Message instance)", () => { - const rawMessagePOJO = { - messageId: "pojo-msg-id", - data: Buffer.from(JSON.stringify({ regression: "test" })).toString("base64"), - attributes: { env: "test" }, - orderingKey: "key1", - publishTime: new Date().toISOString(), +describe("event.data.message wrapping (POJO -> Message instance)", () => { + const rawMessagePOJO = { + messageId: "pojo-msg-id", + data: Buffer.from(JSON.stringify({ regression: "test" })).toString("base64"), + attributes: { env: "test" }, + orderingKey: "key1", + publishTime: new Date().toISOString(), + }; + + function makeRawEvent( + message: any, + subscription = "projects/aProject/subscriptions/aSub" + ): CloudEvent { + return { + specversion: "1.0", + source: "//pubsub.googleapis.com/projects/aProject/topics/topic", + id: "raw-event-id", + type: EVENT_TRIGGER.eventType, + time: rawMessagePOJO.publishTime, + data: { message, subscription }, }; + } - function makeRawEvent( - message: any, - subscription = "projects/aProject/subscriptions/aSub" - ): CloudEvent { - return { - specversion: "1.0", - source: "//pubsub.googleapis.com/projects/aProject/topics/topic", - id: "raw-event-id", - type: EVENT_TRIGGER.eventType, - time: rawMessagePOJO.publishTime, - data: { message, subscription }, - }; - } + it("should convert a raw POJO message into a Message instance on event.data.message", async () => { + let capturedMessage: any; + const func = pubsub.onMessagePublished("topic", (event) => { + capturedMessage = event.data.message; + }); - it("should convert a raw POJO message into a Message instance on event.data.message", async () => { - let capturedMessage: any; - const func = pubsub.onMessagePublished("topic", (event) => { - capturedMessage = event.data.message; - }); + // Pass a raw POJO, NOT a Message instance — this is what the runtime delivers + await func(makeRawEvent({ ...rawMessagePOJO })); - // Pass a raw POJO, NOT a Message instance — this is what the runtime delivers - await func(makeRawEvent({ ...rawMessagePOJO })); + expect(capturedMessage).to.be.an.instanceOf(pubsub.Message); + }); - expect(capturedMessage).to.be.an.instanceOf(pubsub.Message); + it("should provide a working .json getter on event.data.message when input is a raw POJO", async () => { + let json: unknown; + const func = pubsub.onMessagePublished("topic", (event) => { + json = event.data.message.json; }); - it("should provide a working .json getter on event.data.message when input is a raw POJO", async () => { - let json: unknown; - const func = pubsub.onMessagePublished("topic", (event) => { - json = event.data.message.json; - }); + await func(makeRawEvent({ ...rawMessagePOJO })); - await func(makeRawEvent({ ...rawMessagePOJO })); + expect(json).to.deep.equal({ regression: "test" }); + }); - expect(json).to.deep.equal({ regression: "test" }); + it("should preserve all Message fields when wrapping a raw POJO", async () => { + let msg: any; + const func = pubsub.onMessagePublished("topic", (event) => { + msg = event.data.message; }); - it("should preserve all Message fields when wrapping a raw POJO", async () => { - let msg: any; - const func = pubsub.onMessagePublished("topic", (event) => { - msg = event.data.message; - }); + await func(makeRawEvent({ ...rawMessagePOJO })); - await func(makeRawEvent({ ...rawMessagePOJO })); + expect(msg.messageId).to.equal("pojo-msg-id"); + expect(msg.data).to.equal(rawMessagePOJO.data); + expect(msg.attributes).to.deep.equal({ env: "test" }); + expect(msg.orderingKey).to.equal("key1"); + expect(msg.publishTime).to.equal(rawMessagePOJO.publishTime); + }); - expect(msg.messageId).to.equal("pojo-msg-id"); - expect(msg.data).to.equal(rawMessagePOJO.data); - expect(msg.attributes).to.deep.equal({ env: "test" }); - expect(msg.orderingKey).to.equal("key1"); - expect(msg.publishTime).to.equal(rawMessagePOJO.publishTime); + it("should not re-wrap if event.data.message is already a Message instance", async () => { + const original = new pubsub.Message(rawMessagePOJO); + let capturedMessage: any; + const func = pubsub.onMessagePublished("topic", (event) => { + capturedMessage = event.data.message; }); - it("should not re-wrap if event.data.message is already a Message instance", async () => { - const original = new pubsub.Message(rawMessagePOJO); - let capturedMessage: any; - const func = pubsub.onMessagePublished("topic", (event) => { - capturedMessage = event.data.message; - }); + await func(makeRawEvent(original)); - await func(makeRawEvent(original)); + expect(capturedMessage).to.equal(original); // same reference + expect(capturedMessage.json).to.deep.equal({ regression: "test" }); + }); - expect(capturedMessage).to.equal(original); // same reference - expect(capturedMessage.json).to.deep.equal({ regression: "test" }); - }); + it("should throw on a malformed event without a message property", async () => { + const func = pubsub.onMessagePublished("topic", () => undefined); + const badEvent: CloudEvent = { + specversion: "1.0", + source: "//pubsub.googleapis.com/projects/aProject/topics/topic", + id: "bad-event", + type: EVENT_TRIGGER.eventType, + time: new Date().toISOString(), + data: { subscription: "sub" }, // no message! + }; - it("should throw on a malformed event without a message property", async () => { - const func = pubsub.onMessagePublished("topic", () => undefined); - const badEvent: CloudEvent = { - specversion: "1.0", - source: "//pubsub.googleapis.com/projects/aProject/topics/topic", - id: "bad-event", - type: EVENT_TRIGGER.eventType, - time: new Date().toISOString(), - data: { subscription: "sub" }, // no message! - }; - - try { - await func(badEvent); - expect.fail("should have thrown"); - } catch (err: any) { - expect(err.message).to.match(/missing 'message' property/i); - } - }); + try { + await func(badEvent); + expect.fail("should have thrown"); + } catch (err: any) { + expect(err.message).to.match(/missing 'message' property/i); + } + }); - it("should make event.data.message.json and event.message.json return the same value", async () => { - let v2Json: unknown; - let v1Json: unknown; - const func = pubsub.onMessagePublished("topic", (event) => { - v2Json = event.data.message.json; - v1Json = (event as any).message.json; - }); + it("should make event.data.message.json and event.message.json return the same value", async () => { + let v2Json: unknown; + let v1Json: unknown; + const func = pubsub.onMessagePublished("topic", (event) => { + v2Json = event.data.message.json; + v1Json = (event as any).message.json; + }); - await func(makeRawEvent({ ...rawMessagePOJO })); + await func(makeRawEvent({ ...rawMessagePOJO })); - expect(v2Json).to.deep.equal({ regression: "test" }); - expect(v1Json).to.deep.equal({ regression: "test" }); - }); + expect(v2Json).to.deep.equal({ regression: "test" }); + expect(v1Json).to.deep.equal({ regression: "test" }); }); +}); - describe("v1-compatible getters", () => { - let capturedEvent: any; - const messageData = { - messageId: "uuid-123", - data: Buffer.from(JSON.stringify({ foo: "bar" })).toString("base64"), - attributes: { attr1: "val1" }, - orderingKey: "order1", - publishTime: new Date(Date.now()).toISOString(), +describe("v1-compatible getters", () => { + let capturedEvent: any; + const messageData = { + messageId: "uuid-123", + data: Buffer.from(JSON.stringify({ foo: "bar" })).toString("base64"), + attributes: { attr1: "val1" }, + orderingKey: "order1", + publishTime: new Date(Date.now()).toISOString(), + }; + + beforeEach(async () => { + const v2MessageInstance = new pubsub.Message(messageData); + const publishData: pubsub.MessagePublishedData = { + message: v2MessageInstance, + subscription: "projects/aProject/subscriptions/aSubscription", + }; + const event: CloudEvent> = { + specversion: "1.0", + source: "//pubsub.googleapis.com/projects/aProject/topics/topic", + id: "event-id-456", + type: EVENT_TRIGGER.eventType, + time: messageData.publishTime, + data: publishData, }; - beforeEach(async () => { - const v2MessageInstance = new pubsub.Message(messageData); - const publishData: pubsub.MessagePublishedData = { - message: v2MessageInstance, - subscription: "projects/aProject/subscriptions/aSubscription", - }; - const event: CloudEvent> = { - specversion: "1.0", - source: "//pubsub.googleapis.com/projects/aProject/topics/topic", - id: "event-id-456", - type: EVENT_TRIGGER.eventType, - time: messageData.publishTime, - data: publishData, - }; - - const func = pubsub.onMessagePublished("topic", (e) => { - capturedEvent = e; - return Promise.resolve(); - }); - - await func(event); + const func = pubsub.onMessagePublished("topic", (e) => { + capturedEvent = e; + return Promise.resolve(); }); - it("should provide v1-compatible getters on the event object", () => { - // Test the context getter - expect(capturedEvent.context).to.deep.equal({ - eventId: messageData.messageId, - timestamp: messageData.publishTime, - eventType: "google.pubsub.topic.publish", - resource: { - service: "pubsub.googleapis.com", - name: "projects/aProject/topics/topic", - }, - params: {}, - }); - - // Test the message getter - expect(capturedEvent.message).to.be.an("object"); - expect(capturedEvent.message.data).to.equal(messageData.data); - expect(capturedEvent.message.attributes).to.deep.equal(messageData.attributes); - expect(capturedEvent.message.messageId).to.equal(messageData.messageId); - expect(capturedEvent.message.publishTime).to.equal(messageData.publishTime); - expect(capturedEvent.message.orderingKey).to.equal(messageData.orderingKey); - expect(capturedEvent.message.json).to.deep.equal({ foo: "bar" }); - expect(capturedEvent.message.toJSON()).to.deep.equal({ - data: messageData.data, - attributes: messageData.attributes, - messageId: messageData.messageId, - publishTime: messageData.publishTime, - orderingKey: messageData.orderingKey, - }); + await func(event); + }); + + it("should provide v1-compatible getters on the event object", () => { + // Test the context getter + expect(capturedEvent.context).to.deep.equal({ + eventId: messageData.messageId, + timestamp: messageData.publishTime, + eventType: "google.pubsub.topic.publish", + resource: { + service: "pubsub.googleapis.com", + name: "projects/aProject/topics/topic", + }, + params: {}, }); - it("should not affect standard v2 event property access", () => { - // Standard v2 access patterns - expect(capturedEvent.id).to.equal("event-id-456"); - expect(capturedEvent.source).to.equal( - "//pubsub.googleapis.com/projects/aProject/topics/topic" - ); - expect(capturedEvent.data.subscription).to.equal( - "projects/aProject/subscriptions/aSubscription" - ); - expect(capturedEvent.data.message.messageId).to.equal("uuid-123"); - expect(capturedEvent.data.message.json).to.deep.equal({ foo: "bar" }); - expect(capturedEvent.data.message.attributes).to.deep.equal({ attr1: "val1" }); + // Test the message getter + expect(capturedEvent.message).to.be.an("object"); + expect(capturedEvent.message.data).to.equal(messageData.data); + expect(capturedEvent.message.attributes).to.deep.equal(messageData.attributes); + expect(capturedEvent.message.messageId).to.equal(messageData.messageId); + expect(capturedEvent.message.publishTime).to.equal(messageData.publishTime); + expect(capturedEvent.message.orderingKey).to.equal(messageData.orderingKey); + expect(capturedEvent.message.json).to.deep.equal({ foo: "bar" }); + expect(capturedEvent.message.toJSON()).to.deep.equal({ + data: messageData.data, + attributes: messageData.attributes, + messageId: messageData.messageId, + publishTime: messageData.publishTime, + orderingKey: messageData.orderingKey, }); + }); + + it("should not affect standard v2 event property access", () => { + // Standard v2 access patterns + expect(capturedEvent.id).to.equal("event-id-456"); + expect(capturedEvent.source).to.equal("//pubsub.googleapis.com/projects/aProject/topics/topic"); + expect(capturedEvent.data.subscription).to.equal( + "projects/aProject/subscriptions/aSubscription" + ); + expect(capturedEvent.data.message.messageId).to.equal("uuid-123"); + expect(capturedEvent.data.message.json).to.deep.equal({ foo: "bar" }); + expect(capturedEvent.data.message.attributes).to.deep.equal({ attr1: "val1" }); + }); + + it("should provide an empty object for attributes if missing in the original message", async () => { + const messageDataNoAttrs = { + messageId: "uuid-456", + data: Buffer.from(JSON.stringify({ foo: "baz" })).toString("base64"), + // attributes property is missing + publishTime: new Date(Date.now()).toISOString(), + }; + const v2MessageInstance = new pubsub.Message(messageDataNoAttrs); + const publishData: pubsub.MessagePublishedData = { + message: v2MessageInstance, + subscription: "projects/aProject/subscriptions/aSubscription", + }; + const event: CloudEvent> = { + specversion: "1.0", + source: "//pubsub.googleapis.com/projects/aProject/topics/topic", + id: "event-id-789", + type: EVENT_TRIGGER.eventType, + time: messageDataNoAttrs.publishTime, + data: publishData, + }; - it("should provide an empty object for attributes if missing in the original message", async () => { - const messageDataNoAttrs = { - messageId: "uuid-456", - data: Buffer.from(JSON.stringify({ foo: "baz" })).toString("base64"), - // attributes property is missing - publishTime: new Date(Date.now()).toISOString(), - }; - const v2MessageInstance = new pubsub.Message(messageDataNoAttrs); - const publishData: pubsub.MessagePublishedData = { - message: v2MessageInstance, - subscription: "projects/aProject/subscriptions/aSubscription", - }; - const event: CloudEvent> = { - specversion: "1.0", - source: "//pubsub.googleapis.com/projects/aProject/topics/topic", - id: "event-id-789", - type: EVENT_TRIGGER.eventType, - time: messageDataNoAttrs.publishTime, - data: publishData, - }; - - let capturedEvent: any; - const func = pubsub.onMessagePublished("topic", (e) => { - capturedEvent = e; - return Promise.resolve(); - }); - - await func(event); - - // Test the message getter for attributes - expect(capturedEvent.message.attributes).to.deep.equal({}); - expect(capturedEvent.data.message.attributes).to.deep.equal({}); + let capturedEvent: any; + const func = pubsub.onMessagePublished("topic", (e) => { + capturedEvent = e; + return Promise.resolve(); }); + + await func(event); + + // Test the message getter for attributes + expect(capturedEvent.message.attributes).to.deep.equal({}); + expect(capturedEvent.data.message.attributes).to.deep.equal({}); }); }); From a61dfc4ce1c51bfb140b7198224a6b876070a8e4 Mon Sep 17 00:00:00 2001 From: Izaak Gough Date: Mon, 11 May 2026 15:32:24 +0100 Subject: [PATCH 4/5] fix(v2/pubsub): support StringParam as direct topic --- spec/v2/providers/pubsub.spec.ts | 25 +++++++++++++++++++++++++ src/v2/providers/pubsub.ts | 8 ++++---- 2 files changed, 29 insertions(+), 4 deletions(-) diff --git a/spec/v2/providers/pubsub.spec.ts b/spec/v2/providers/pubsub.spec.ts index 915d5e3a1..a67256588 100644 --- a/spec/v2/providers/pubsub.spec.ts +++ b/spec/v2/providers/pubsub.spec.ts @@ -227,6 +227,31 @@ describe("onMessagePublished", () => { ); }); + + it("should accept StringParam as direct topic argument", () => { + const topicParam = defineString("TOPIC_NAME"); + const result = pubsub.onMessagePublished(topicParam, () => 42); + + expect(result.__endpoint).to.deep.equal({ + ...MINIMAL_V2_ENDPOINT, + platform: "gcfv2", + eventTrigger: { + eventType: "google.cloud.pubsub.topic.v1.messagePublished", + eventFilters: { + topic: topicParam, + }, + retry: false, + }, + labels: {}, + }); + + const trigger = result.__trigger as any; + expect(trigger.eventTrigger).to.not.have.property("resource"); + expect(trigger.eventTrigger.eventType).to.equal( + "google.cloud.pubsub.topic.v1.messagePublished" + ); + }); + it("should preserve __trigger.resource for string topic", () => { const result = pubsub.onMessagePublished( { diff --git a/src/v2/providers/pubsub.ts b/src/v2/providers/pubsub.ts index a48acdf24..673b23acd 100644 --- a/src/v2/providers/pubsub.ts +++ b/src/v2/providers/pubsub.ts @@ -272,7 +272,7 @@ export interface PubSubOptions extends options.EventHandlerOptions { * @typeParam T - Type representing `Message.data`'s JSON format */ export function onMessagePublished( - topic: string, + topic: string | Expression, handler: ( event: CloudEvent> & V1Compat<"message", V1PubSubMessage> ) => any | Promise @@ -285,7 +285,7 @@ export function onMessagePublished( * @typeParam T - Type representing `Message.data`'s JSON format */ export function onMessagePublished( - topic: string, + topic: string | Expression, handler: (event: CloudEvent>) => any | Promise ): CloudFunction>>; @@ -320,14 +320,14 @@ export function onMessagePublished( * @typeParam T - Type representing `Message.data`'s JSON format */ export function onMessagePublished( - topicOrOptions: string | PubSubOptions, + topicOrOptions: string | Expression | PubSubOptions, handler: ( event: CloudEvent> & V1Compat<"message", V1PubSubMessage> ) => any | Promise ): CloudFunction>> { let topic: string | Expression; let opts: options.EventHandlerOptions; - if (typeof topicOrOptions === "string") { + if (typeof topicOrOptions === "string" || "value" in topicOrOptions) { topic = topicOrOptions; opts = {}; } else { From 46bd505ea84866aa53e5d68df22403f639cd223c Mon Sep 17 00:00:00 2001 From: Izaak Gough Date: Mon, 11 May 2026 15:40:03 +0100 Subject: [PATCH 5/5] chore: fix linting --- spec/v2/providers/pubsub.spec.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/spec/v2/providers/pubsub.spec.ts b/spec/v2/providers/pubsub.spec.ts index a67256588..bf041b497 100644 --- a/spec/v2/providers/pubsub.spec.ts +++ b/spec/v2/providers/pubsub.spec.ts @@ -227,7 +227,6 @@ describe("onMessagePublished", () => { ); }); - it("should accept StringParam as direct topic argument", () => { const topicParam = defineString("TOPIC_NAME"); const result = pubsub.onMessagePublished(topicParam, () => 42);