@tellescope/sdk 1.256.2 → 1.256.3

package/lib/cjs/tests/api_tests/stripe_webhook_triggers.test.js

@@ -0,0 +1,964 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripe_webhook_triggers_tests = void 0;
+require('source-map-support').install();
+var sdk_1 = require("../../sdk");
+var testing_1 = require("@tellescope/testing");
+var setup_1 = require("../setup");
+var stripe_webhook_helpers_1 = require("../stripe_webhook_helpers");
+var host = process.env.API_URL || "http://localhost:8080";
+/**
+ * End-to-end coverage of the custom Stripe webhook -> automation trigger path, driven by synthetic
+ * but genuinely-signed payloads (see ../stripe_webhook_helpers).
+ *
+ * Fixture rules, all forced by handle_actions_for_triggers:
+ *  - 'Add Tags' is the action because it applies inline via $addToSet, with no worker involved.
+ *  - Every webhook POST gets its own enduser: triggers throttle per (trigger, enduser) for 60s, and
+ *    neither handle_payment_failed nor handle_subscription_ended opts out.
+ *  - No journeyId (the handler skips the action entirely for journey-scoped triggers), no
+ *    oncePerEnduser, no enduserCondition, no weeklyAvailabilities.
+ *  - Tags are run-unique, so a stale tag can't satisfy an assertion and 'Add Tags' can't no-op.
+ */
+var stripe_webhook_triggers_tests = function (_a) {
+    var sdk = _a.sdk, sdkNonAdmin = _a.sdkNonAdmin;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var RUN, tag, createdEnduserIds, createdTriggerIds, createdProductIds, _b, stripePublicKey, webhooksSecret, cleanup, new_enduser, new_trigger, new_product, poll_for_tag, expect_fired, expect_not_fired, B1_TAG, b1Enduser, b1Event, b1Res, b2Res, B3_TAG, b3Enduser, b3Res, B4_TAG, b4Enduser, b4Res, stripeProductA_1, stripeProductB, productA, productB, B5_TAG, b5Enduser, b5Res, B6_TAG, b6Enduser, B7_TAG, b7Enduser, B8_TAG, b8Enduser, run_scoped_payment_failed_case, f7Scoped, f7Fetched, rejectedInvalidProductId, e_1, run_pause_case, p14Scoped, p14Fetched, rejectedInvalidPausedProductId, e_2;
+        var _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    (0, testing_1.log_header)("Stripe Webhook Triggers");
+                    RUN = "".concat(Date.now());
+                    tag = function (name) { return "stripe-wh-".concat(name, "-").concat(RUN); };
+                    createdEnduserIds = [];
+                    createdTriggerIds = [];
+                    createdProductIds = [];
+                    return [4 /*yield*/, (0, stripe_webhook_helpers_1.setup_stripe_test_integration)(sdk)
+                        // Each enduser is matched by the handler on stripeCustomerId, so it must be unique per case.
+                    ];
+                case 1:
+                    _b = _e.sent(), stripePublicKey = _b.stripePublicKey, webhooksSecret = _b.webhooksSecret, cleanup = _b.cleanup;
+                    new_enduser = function (label) { return __awaiter(void 0, void 0, void 0, function () {
+                        var stripeCustomerId, enduser;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    stripeCustomerId = "cus_test_".concat(label, "_").concat(RUN);
+                                    return [4 /*yield*/, sdk.api.endusers.createOne({
+                                            fname: 'Stripe',
+                                            lname: "Webhook ".concat(label),
+                                            email: "stripe-webhook-".concat(label, "-").concat(RUN, "@tellescope.com"),
+                                            // settable by a staff session, but declared readonly in the client types
+                                            stripeCustomerId: stripeCustomerId,
+                                        })];
+                                case 1:
+                                    enduser = _a.sent();
+                                    createdEnduserIds.push(enduser.id);
+                                    return [2 /*return*/, { id: enduser.id, stripeCustomerId: stripeCustomerId }];
+                            }
+                        });
+                    }); };
+                    new_trigger = function (_a) {
+                        var title = _a.title, event = _a.event, tags = _a.tags;
+                        return __awaiter(void 0, void 0, void 0, function () {
+                            var trigger;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0: return [4 /*yield*/, sdk.api.automation_triggers.createOne({
+                                            title: title,
+                                            status: 'Active',
+                                            event: event,
+                                            action: { type: 'Add Tags', info: { tags: tags } },
+                                        })];
+                                    case 1:
+                                        trigger = _b.sent();
+                                        createdTriggerIds.push(trigger.id);
+                                        return [2 /*return*/, trigger];
+                                }
+                            });
+                        });
+                    };
+                    new_product = function (label, stripeProductId) { return __awaiter(void 0, void 0, void 0, function () {
+                        var product;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sdk.api.products.createOne({
+                                        title: "Stripe Webhook Test ".concat(label, " ").concat(RUN),
+                                        cost: { amount: 1999, currency: 'USD' },
+                                        processor: 'Stripe',
+                                        stripeSubscriptionId: stripeProductId,
+                                    })];
+                                case 1:
+                                    product = _a.sent();
+                                    createdProductIds.push(product.id);
+                                    return [2 /*return*/, product];
+                            }
+                        });
+                    }); };
+                    poll_for_tag = function (enduserId, expected, iterations) {
+                        if (iterations === void 0) { iterations = 20; }
+                        return __awaiter(void 0, void 0, void 0, function () {
+                            var i, enduser;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        i = 0;
+                                        _b.label = 1;
+                                    case 1:
+                                        if (!(i < iterations)) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, (0, testing_1.wait)(undefined, 500)];
+                                    case 2:
+                                        _b.sent();
+                                        return [4 /*yield*/, sdk.api.endusers.getOne(enduserId)];
+                                    case 3:
+                                        enduser = _b.sent();
+                                        if ((_a = enduser.tags) === null || _a === void 0 ? void 0 : _a.includes(expected))
+                                            return [2 /*return*/, true];
+                                        _b.label = 4;
+                                    case 4:
+                                        i++;
+                                        return [3 /*break*/, 1];
+                                    case 5: return [2 /*return*/, false];
+                                }
+                            });
+                        });
+                    };
+                    expect_fired = function (enduserId, expected, title) { return __awaiter(void 0, void 0, void 0, function () {
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0:
+                                    _a = testing_1.assert;
+                                    return [4 /*yield*/, poll_for_tag(enduserId, expected)];
+                                case 1:
+                                    _a.apply(void 0, [_b.sent(), "expected tag ".concat(expected, " to be added by the trigger"), title]);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); };
+                    expect_not_fired = function (enduserId, expected, title) { return __awaiter(void 0, void 0, void 0, function () {
+                        var enduser;
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0: return [4 /*yield*/, (0, testing_1.wait)(undefined, 2500)];
+                                case 1:
+                                    _b.sent();
+                                    return [4 /*yield*/, sdk.api.endusers.getOne(enduserId)];
+                                case 2:
+                                    enduser = _b.sent();
+                                    (0, testing_1.assert)(!((_a = enduser.tags) === null || _a === void 0 ? void 0 : _a.includes(expected)), "expected the trigger NOT to fire, but tag ".concat(expected, " was added"), title);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); };
+                    _e.label = 2;
+                case 2:
+                    _e.trys.push([2, , 69, 72]);
+                    B1_TAG = tag('b1-bad-signature');
+                    return [4 /*yield*/, new_enduser('b1')];
+                case 3:
+                    b1Enduser = _e.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe payment failed (bad signature) ".concat(RUN),
+                            event: { type: 'Subscription Payment Failed', info: {} },
+                            tags: [B1_TAG],
+                        })];
+                case 4:
+                    _e.sent();
+                    b1Event = (0, stripe_webhook_helpers_1.invoice_payment_failed_event)({ stripeCustomerId: b1Enduser.stripeCustomerId });
+                    return [4 /*yield*/, (0, stripe_webhook_helpers_1.post_stripe_webhook)({
+                            stripePublicKey: stripePublicKey,
+                            secret: webhooksSecret,
+                            event: b1Event,
+                            signature: (0, stripe_webhook_helpers_1.sign_stripe_payload)('{"tampered":true}', webhooksSecret),
+                        })];
+                case 5:
+                    b1Res = _e.sent();
+                    (0, testing_1.assert)(b1Res.status === 400, "expected 400 for a mismatched signature, got ".concat(b1Res.status), 'invalid signature rejected');
+                    return [4 /*yield*/, expect_not_fired(b1Enduser.id, B1_TAG, 'invalid signature does not fire triggers')
+                        // B2: unknown public key in the URL -> no integration -> 404
+                    ];
+                case 6:
+                    _e.sent();
+                    return [4 /*yield*/, (0, stripe_webhook_helpers_1.post_stripe_webhook)({
+                            stripePublicKey: "pk_test_missing_".concat(RUN),
+                            secret: webhooksSecret,
+                            event: (0, stripe_webhook_helpers_1.invoice_payment_failed_event)({ stripeCustomerId: "cus_test_missing_".concat(RUN) }),
+                        })];
+                case 7:
+                    b2Res = _e.sent();
+                    (0, testing_1.assert)(b2Res.status === 404, "expected 404 for an unknown public key, got ".concat(b2Res.status), 'unknown integration rejected');
+                    B3_TAG = tag('b3-unknown-customer');
+                    return [4 /*yield*/, new_enduser('b3')];
+                case 8:
+                    b3Enduser = _e.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe payment failed (unknown customer) ".concat(RUN),
+                            event: { type: 'Subscription Payment Failed', info: {} },
+                            tags: [B3_TAG],
+                        })];
+                case 9:
+                    _e.sent();
+                    return [4 /*yield*/, (0, stripe_webhook_helpers_1.post_stripe_webhook)({
+                            stripePublicKey: stripePublicKey,
+                            secret: webhooksSecret,
+                            event: (0, stripe_webhook_helpers_1.invoice_payment_failed_event)({ stripeCustomerId: "cus_test_nobody_".concat(RUN) }),
+                        })];
+                case 10:
+                    b3Res = _e.sent();
+                    (0, testing_1.assert)(b3Res.status === 200, "expected 200 for an unmatched customer, got ".concat(b3Res.status), 'unmatched customer accepted');
+                    return [4 /*yield*/, expect_not_fired(b3Enduser.id, B3_TAG, 'unmatched customer does not fire triggers')
+                        // B4: the baseline behavior the productIds feature must preserve — a Subscription Payment Failed
+                        // trigger with no product scoping fires for any failed invoice.
+                    ];
+                case 11:
+                    _e.sent();
+                    B4_TAG = tag('b4-unscoped');
+                    return [4 /*yield*/, new_enduser('b4')];
+                case 12:
+                    b4Enduser = _e.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe payment failed (unscoped) ".concat(RUN),
+                            event: { type: 'Subscription Payment Failed', info: {} },
+                            tags: [B4_TAG],
+                        })];
+                case 13:
+                    _e.sent();
+                    return [4 /*yield*/, (0, stripe_webhook_helpers_1.post_stripe_webhook)({
+                            stripePublicKey: stripePublicKey,
+                            secret: webhooksSecret,
+                            event: (0, stripe_webhook_helpers_1.invoice_payment_failed_event)({
+                                stripeCustomerId: b4Enduser.stripeCustomerId,
+                                lines: [(0, stripe_webhook_helpers_1.line_with_price_product)("prod_test_b4_".concat(RUN))],
+                            }),
+                        })];
+                case 14:
+                    b4Res = _e.sent();
+                    (0, testing_1.assert)(b4Res.status === 200, "expected 200, got ".concat(b4Res.status, " (").concat(b4Res.data, ")"), 'payment failed webhook accepted');
+                    return [4 /*yield*/, expect_fired(b4Enduser.id, B4_TAG, 'unscoped Subscription Payment Failed trigger fires')
+                        /* ===================== customer.subscription.deleted ===================== */
+                        // Products A and B exist to distinguish "the subscription's product" from "some other product".
+                    ];
+                case 15:
+                    _e.sent();
+                    stripeProductA_1 = "prod_test_a_".concat(RUN);
+                    stripeProductB = "prod_test_b_".concat(RUN);
+                    return [4 /*yield*/, new_product('A', stripeProductA_1)];
+                case 16:
+                    productA = _e.sent();
+                    return [4 /*yield*/, new_product('B', stripeProductB)
+                        // B5: unscoped Subscription Ended fires
+                    ];
+                case 17:
+                    productB = _e.sent();
+                    B5_TAG = tag('b5-ended-unscoped');
+                    return [4 /*yield*/, new_enduser('b5')];
+                case 18:
+                    b5Enduser = _e.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe subscription ended (unscoped) ".concat(RUN),
+                            event: { type: 'Subscription Ended', info: {} },
+                            tags: [B5_TAG],
+                        })];
+                case 19:
+                    _e.sent();
+                    return [4 /*yield*/, (0, stripe_webhook_helpers_1.post_stripe_webhook)({
+                            stripePublicKey: stripePublicKey,
+                            secret: webhooksSecret,
+                            event: (0, stripe_webhook_helpers_1.subscription_deleted_event)({
+                                stripeCustomerId: b5Enduser.stripeCustomerId,
+                                stripeProductIds: [stripeProductA_1],
+                            }),
+                        })];
+                case 20:
+                    b5Res = _e.sent();
+                    (0, testing_1.assert)(b5Res.status === 200, "expected 200, got ".concat(b5Res.status, " (").concat(b5Res.data, ")"), 'subscription deleted webhook accepted');
+                    return [4 /*yield*/, expect_fired(b5Enduser.id, B5_TAG, 'unscoped Subscription Ended trigger fires')
+                        // B6: an explicitly empty productIds list means "all products"
+                    ];
+                case 21:
+                    _e.sent();
+                    B6_TAG = tag('b6-ended-empty-list');
+                    return [4 /*yield*/, new_enduser('b6')];
+                case 22:
+                    b6Enduser = _e.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe subscription ended (empty productIds) ".concat(RUN),
+                            event: { type: 'Subscription Ended', info: { productIds: [] } },
+                            tags: [B6_TAG],
+                        })];
+                case 23:
+                    _e.sent();
+                    return [4 /*yield*/, (0, stripe_webhook_helpers_1.post_stripe_webhook)({
+                            stripePublicKey: stripePublicKey,
+                            secret: webhooksSecret,
+                            event: (0, stripe_webhook_helpers_1.subscription_deleted_event)({
+                                stripeCustomerId: b6Enduser.stripeCustomerId,
+                                stripeProductIds: [stripeProductA_1],
+                            }),
+                        })];
+                case 24:
+                    _e.sent();
+                    return [4 /*yield*/, expect_fired(b6Enduser.id, B6_TAG, 'Subscription Ended trigger with empty productIds fires')
+                        // B7/B8 pin the existing product-matching semantics end-to-end, so any refactor of the
+                        // productIds query clause is provably behavior-preserving.
+                        // B7: productIds matching the subscription's product fires
+                    ];
+                case 25:
+                    _e.sent();
+                    B7_TAG = tag('b7-ended-matching');
+                    return [4 /*yield*/, new_enduser('b7')];
+                case 26:
+                    b7Enduser = _e.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe subscription ended (matching product) ".concat(RUN),
+                            event: { type: 'Subscription Ended', info: { productIds: [productA.id] } },
+                            tags: [B7_TAG],
+                        })];
+                case 27:
+                    _e.sent();
+                    return [4 /*yield*/, (0, stripe_webhook_helpers_1.post_stripe_webhook)({
+                            stripePublicKey: stripePublicKey,
+                            secret: webhooksSecret,
+                            event: (0, stripe_webhook_helpers_1.subscription_deleted_event)({
+                                stripeCustomerId: b7Enduser.stripeCustomerId,
+                                stripeProductIds: [stripeProductA_1],
+                            }),
+                        })];
+                case 28:
+                    _e.sent();
+                    return [4 /*yield*/, expect_fired(b7Enduser.id, B7_TAG, 'Subscription Ended trigger scoped to the matching product fires')
+                        // B8: productIds naming a different product does not fire
+                    ];
+                case 29:
+                    _e.sent();
+                    B8_TAG = tag('b8-ended-nonmatching');
+                    return [4 /*yield*/, new_enduser('b8')];
+                case 30:
+                    b8Enduser = _e.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe subscription ended (other product) ".concat(RUN),
+                            event: { type: 'Subscription Ended', info: { productIds: [productB.id] } },
+                            tags: [B8_TAG],
+                        })];
+                case 31:
+                    _e.sent();
+                    return [4 /*yield*/, (0, stripe_webhook_helpers_1.post_stripe_webhook)({
+                            stripePublicKey: stripePublicKey,
+                            secret: webhooksSecret,
+                            event: (0, stripe_webhook_helpers_1.subscription_deleted_event)({
+                                stripeCustomerId: b8Enduser.stripeCustomerId,
+                                stripeProductIds: [stripeProductA_1],
+                            }),
+                        })];
+                case 32:
+                    _e.sent();
+                    return [4 /*yield*/, expect_not_fired(b8Enduser.id, B8_TAG, 'Subscription Ended trigger scoped to another product does not fire')
+                        /* ============ invoice.payment_failed, scoped to products ============ */
+                        // Shared shape for the cases below: a trigger scoped to productA, and an invoice whose line
+                        // items are varied per case to cover how Stripe can reference a product.
+                    ];
+                case 33:
+                    _e.sent();
+                    run_scoped_payment_failed_case = function (_a) {
+                        var label = _a.label, productIds = _a.productIds, lines = _a.lines, shouldFire = _a.shouldFire, title = _a.title;
+                        return __awaiter(void 0, void 0, void 0, function () {
+                            var caseTag, enduser, res;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        caseTag = tag(label);
+                                        return [4 /*yield*/, new_enduser(label)];
+                                    case 1:
+                                        enduser = _b.sent();
+                                        return [4 /*yield*/, new_trigger({
+                                                title: "Stripe payment failed (".concat(label, ") ").concat(RUN),
+                                                event: { type: 'Subscription Payment Failed', info: { productIds: productIds } },
+                                                tags: [caseTag],
+                                            })];
+                                    case 2:
+                                        _b.sent();
+                                        return [4 /*yield*/, (0, stripe_webhook_helpers_1.post_stripe_webhook)({
+                                                stripePublicKey: stripePublicKey,
+                                                secret: webhooksSecret,
+                                                event: (0, stripe_webhook_helpers_1.invoice_payment_failed_event)({ stripeCustomerId: enduser.stripeCustomerId, lines: lines }),
+                                            })];
+                                    case 3:
+                                        res = _b.sent();
+                                        (0, testing_1.assert)(res.status === 200, "expected 200, got ".concat(res.status, " (").concat(res.data, ")"), "".concat(label, " webhook accepted"));
+                                        if (!shouldFire) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, expect_fired(enduser.id, caseTag, title)];
+                                    case 4:
+                                        _b.sent();
+                                        return [3 /*break*/, 7];
+                                    case 5: return [4 /*yield*/, expect_not_fired(enduser.id, caseTag, title)];
+                                    case 6:
+                                        _b.sent();
+                                        _b.label = 7;
+                                    case 7: return [2 /*return*/];
+                                }
+                            });
+                        });
+                    };
+                    // F1: the feature — a trigger scoped to the product that actually failed fires
+                    return [4 /*yield*/, run_scoped_payment_failed_case({
+                            label: 'f1-matching',
+                            productIds: [productA.id],
+                            lines: [(0, stripe_webhook_helpers_1.line_with_price_product)(stripeProductA_1)],
+                            shouldFire: true,
+                            title: 'Subscription Payment Failed scoped to the failed product fires',
+                        })
+                        // F2: the point of the feature — a trigger scoped to a different product stays quiet
+                    ];
+                case 34:
+                    // F1: the feature — a trigger scoped to the product that actually failed fires
+                    _e.sent();
+                    // F2: the point of the feature — a trigger scoped to a different product stays quiet
+                    return [4 /*yield*/, run_scoped_payment_failed_case({
+                            label: 'f2-nonmatching',
+                            productIds: [productB.id],
+                            lines: [(0, stripe_webhook_helpers_1.line_with_price_product)(stripeProductA_1)],
+                            shouldFire: false,
+                            title: 'Subscription Payment Failed scoped to another product does not fire',
+                        })
+                        // F3: "leave blank for all" — an empty list is not a filter
+                    ];
+                case 35:
+                    // F2: the point of the feature — a trigger scoped to a different product stays quiet
+                    _e.sent();
+                    // F3: "leave blank for all" — an empty list is not a filter
+                    return [4 /*yield*/, run_scoped_payment_failed_case({
+                            label: 'f3-empty-list',
+                            productIds: [],
+                            lines: [(0, stripe_webhook_helpers_1.line_with_price_product)(stripeProductA_1)],
+                            shouldFire: true,
+                            title: 'Subscription Payment Failed with empty productIds fires',
+                        })
+                        // F4: price.product may arrive expanded as an object rather than a bare id
+                    ];
+                case 36:
+                    // F3: "leave blank for all" — an empty list is not a filter
+                    _e.sent();
+                    // F4: price.product may arrive expanded as an object rather than a bare id
+                    return [4 /*yield*/, run_scoped_payment_failed_case({
+                            label: 'f4-expanded-product',
+                            productIds: [productA.id],
+                            lines: [(0, stripe_webhook_helpers_1.line_with_expanded_price_product)(stripeProductA_1)],
+                            shouldFire: true,
+                            title: 'expanded price.product object resolves to the product',
+                        })
+                        // F5: subscription/proration lines can carry plan.product with no price
+                    ];
+                case 37:
+                    // F4: price.product may arrive expanded as an object rather than a bare id
+                    _e.sent();
+                    // F5: subscription/proration lines can carry plan.product with no price
+                    return [4 /*yield*/, run_scoped_payment_failed_case({
+                            label: 'f5-plan-product',
+                            productIds: [productA.id],
+                            lines: [(0, stripe_webhook_helpers_1.line_with_plan_product)(stripeProductA_1)],
+                            shouldFire: true,
+                            title: 'plan.product fallback resolves to the product',
+                        })
+                        // F6: one matching line among several is enough
+                    ];
+                case 38:
+                    // F5: subscription/proration lines can carry plan.product with no price
+                    _e.sent();
+                    // F6: one matching line among several is enough
+                    return [4 /*yield*/, run_scoped_payment_failed_case({
+                            label: 'f6-multi-line',
+                            productIds: [productA.id],
+                            lines: [(0, stripe_webhook_helpers_1.line_with_price_product)(stripeProductB), (0, stripe_webhook_helpers_1.line_with_price_product)(stripeProductA_1)],
+                            shouldFire: true,
+                            title: 'a matching line among several fires the scoped trigger',
+                        })
+                        /* ===================== validator ===================== */
+                        // F7: productIds must round-trip, and an omitted info must stay valid — it was accepted before
+                        // productIds existed, so requiring it would break existing API clients.
+                    ];
+                case 39:
+                    // F6: one matching line among several is enough
+                    _e.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe payment failed (validator round-trip) ".concat(RUN),
+                            event: { type: 'Subscription Payment Failed', info: { productIds: [productA.id] } },
+                            tags: [tag('f7')],
+                        })];
+                case 40:
+                    f7Scoped = _e.sent();
+                    return [4 /*yield*/, sdk.api.automation_triggers.getOne(f7Scoped.id)];
+                case 41:
+                    f7Fetched = _e.sent();
+                    (0, testing_1.assert)(JSON.stringify((_c = f7Fetched.event.info) === null || _c === void 0 ? void 0 : _c.productIds) === JSON.stringify([productA.id]), "expected productIds to round-trip, got ".concat(JSON.stringify(f7Fetched.event)), 'productIds round-trips through the validator');
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe payment failed (empty info) ".concat(RUN),
+                            event: { type: 'Subscription Payment Failed', info: {} },
+                            tags: [tag('f7-empty-info')],
+                        })];
+                case 42:
+                    _e.sent();
+                    (0, testing_1.assert)(true, '', 'empty info accepted');
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe payment failed (no info) ".concat(RUN),
+                            event: { type: 'Subscription Payment Failed' },
+                            tags: [tag('f7-no-info')],
+                        })];
+                case 43:
+                    _e.sent();
+                    (0, testing_1.assert)(true, '', 'omitted info still accepted');
+                    rejectedInvalidProductId = false;
+                    _e.label = 44;
+                case 44:
+                    _e.trys.push([44, 46, , 47]);
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe payment failed (invalid productId) ".concat(RUN),
+                            event: { type: 'Subscription Payment Failed', info: { productIds: ['not-a-mongo-id'] } },
+                            tags: [tag('f7-invalid')],
+                        })];
+                case 45:
+                    _e.sent();
+                    return [3 /*break*/, 47];
+                case 46:
+                    e_1 = _e.sent();
+                    rejectedInvalidProductId = true;
+                    return [3 /*break*/, 47];
+                case 47:
+                    (0, testing_1.assert)(rejectedInvalidProductId, 'expected a non-ObjectId productId to be rejected', 'invalid productId rejected');
+                    run_pause_case = function (_a) {
+                        var label = _a.label, type = _a.type, productIds = _a.productIds, buildEvent = _a.event, shouldFire = _a.shouldFire, title = _a.title;
+                        return __awaiter(void 0, void 0, void 0, function () {
+                            var caseTag, enduser, res;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        caseTag = tag(label);
+                                        return [4 /*yield*/, new_enduser(label)];
+                                    case 1:
+                                        enduser = _b.sent();
+                                        return [4 /*yield*/, new_trigger({
+                                                title: "Stripe ".concat(type, " (").concat(label, ") ").concat(RUN),
+                                                event: __assign({ type: type }, productIds !== undefined ? { info: { productIds: productIds } } : {}),
+                                                tags: [caseTag],
+                                            })];
+                                    case 2:
+                                        _b.sent();
+                                        return [4 /*yield*/, (0, stripe_webhook_helpers_1.post_stripe_webhook)({
+                                                stripePublicKey: stripePublicKey,
+                                                secret: webhooksSecret,
+                                                event: buildEvent(enduser.stripeCustomerId),
+                                            })];
+                                    case 3:
+                                        res = _b.sent();
+                                        (0, testing_1.assert)(res.status === 200, "expected 200, got ".concat(res.status, " (").concat(res.data, ")"), "".concat(label, " webhook accepted"));
+                                        if (!shouldFire) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, expect_fired(enduser.id, caseTag, title)];
+                                    case 4:
+                                        _b.sent();
+                                        return [3 /*break*/, 7];
+                                    case 5: return [4 /*yield*/, expect_not_fired(enduser.id, caseTag, title)];
+                                    case 6:
+                                        _b.sent();
+                                        _b.label = 7;
+                                    case 7: return [2 /*return*/];
+                                }
+                            });
+                        });
+                    };
+                    // P1: the core pause path — pause_collection goes null -> set on customer.subscription.updated.
+                    // This is how a pause from the billing portal or dashboard actually arrives; there is no
+                    // dedicated event for it.
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p1-pause-collection-set',
+                            type: 'Subscription Paused',
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_updated_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                previousAttributes: { pause_collection: null },
+                                pauseCollection: stripe_webhook_helpers_1.PAUSE_COLLECTION,
+                            }); },
+                            shouldFire: true,
+                            title: 'pause_collection null -> set fires Subscription Paused',
+                        })
+                        // P2: the mirror — pause_collection cleared is a resume
+                    ];
+                case 48:
+                    // P1: the core pause path — pause_collection goes null -> set on customer.subscription.updated.
+                    // This is how a pause from the billing portal or dashboard actually arrives; there is no
+                    // dedicated event for it.
+                    _e.sent();
+                    // P2: the mirror — pause_collection cleared is a resume
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p2-pause-collection-cleared',
+                            type: 'Subscription Resumed',
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_updated_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                previousAttributes: { pause_collection: stripe_webhook_helpers_1.PAUSE_COLLECTION },
+                                pauseCollection: null,
+                            }); },
+                            shouldFire: true,
+                            title: 'pause_collection set -> null fires Subscription Resumed',
+                        })
+                        // P3: a pause that is only *modified* (behavior or resumes_at changed) is neither a pause nor a
+                        // resume — firing here would re-trigger every time a customer adjusts an existing pause
+                    ];
+                case 49:
+                    // P2: the mirror — pause_collection cleared is a resume
+                    _e.sent();
+                    // P3: a pause that is only *modified* (behavior or resumes_at changed) is neither a pause nor a
+                    // resume — firing here would re-trigger every time a customer adjusts an existing pause
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p3-pause-modified',
+                            type: 'Subscription Paused',
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_updated_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                previousAttributes: { pause_collection: { behavior: 'void', resumes_at: null } },
+                                pauseCollection: { behavior: 'keep_as_draft', resumes_at: null },
+                            }); },
+                            shouldFire: false,
+                            title: 'a modified pause_collection fires neither trigger',
+                        })
+                        // P4: the volume guard. customer.subscription.updated fires on every renewal, price change and
+                        // cancel_at_period_end toggle; with no pause_collection key in previous_attributes the handler
+                        // must do nothing (and, in the API, must not even reach the enduser lookup).
+                    ];
+                case 50:
+                    // P3: a pause that is only *modified* (behavior or resumes_at changed) is neither a pause nor a
+                    // resume — firing here would re-trigger every time a customer adjusts an existing pause
+                    _e.sent();
+                    // P4: the volume guard. customer.subscription.updated fires on every renewal, price change and
+                    // cancel_at_period_end toggle; with no pause_collection key in previous_attributes the handler
+                    // must do nothing (and, in the API, must not even reach the enduser lookup).
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p4-unrelated-update',
+                            type: 'Subscription Paused',
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_updated_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                previousAttributes: { items: { object: 'list', data: [] } },
+                            }); },
+                            shouldFire: false,
+                            title: 'an unrelated subscription update fires neither trigger',
+                        })
+                        // P4b: the idempotency case. previous_attributes carries only what changed, so an unrelated
+                        // update to an already-paused subscription has no pause_collection key even though
+                        // pause_collection is currently set. Firing here would re-trigger on every renewal, quantity
+                        // change and coupon edit for the whole duration of a pause — which is what would happen if the
+                        // gate were ever "simplified" to read current state instead of the transition.
+                    ];
+                case 51:
+                    // P4: the volume guard. customer.subscription.updated fires on every renewal, price change and
+                    // cancel_at_period_end toggle; with no pause_collection key in previous_attributes the handler
+                    // must do nothing (and, in the API, must not even reach the enduser lookup).
+                    _e.sent();
+                    // P4b: the idempotency case. previous_attributes carries only what changed, so an unrelated
+                    // update to an already-paused subscription has no pause_collection key even though
+                    // pause_collection is currently set. Firing here would re-trigger on every renewal, quantity
+                    // change and coupon edit for the whole duration of a pause — which is what would happen if the
+                    // gate were ever "simplified" to read current state instead of the transition.
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p4b-update-while-paused',
+                            type: 'Subscription Paused',
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_updated_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                previousAttributes: { quantity: 1 },
+                                pauseCollection: stripe_webhook_helpers_1.PAUSE_COLLECTION,
+                            }); },
+                            shouldFire: false,
+                            title: 'an unrelated update while already paused does not re-fire Subscription Paused',
+                        })
+                        // P5/P6: the dedicated events, which Stripe emits for status='paused' transitions only
+                    ];
+                case 52:
+                    // P4b: the idempotency case. previous_attributes carries only what changed, so an unrelated
+                    // update to an already-paused subscription has no pause_collection key even though
+                    // pause_collection is currently set. Firing here would re-trigger on every renewal, quantity
+                    // change and coupon edit for the whole duration of a pause — which is what would happen if the
+                    // gate were ever "simplified" to read current state instead of the transition.
+                    _e.sent();
+                    // P5/P6: the dedicated events, which Stripe emits for status='paused' transitions only
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p5-dedicated-paused',
+                            type: 'Subscription Paused',
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_paused_event)({ stripeCustomerId: stripeCustomerId }); },
+                            shouldFire: true,
+                            title: 'customer.subscription.paused fires Subscription Paused',
+                        })];
+                case 53:
+                    // P5/P6: the dedicated events, which Stripe emits for status='paused' transitions only
+                    _e.sent();
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p6-dedicated-resumed',
+                            type: 'Subscription Resumed',
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_resumed_event)({ stripeCustomerId: stripeCustomerId }); },
+                            shouldFire: true,
+                            title: 'customer.subscription.resumed fires Subscription Resumed',
+                        })
+                        // P7: a Paused trigger must not fire on a resume, and vice versa — the two are separate types
+                    ];
+                case 54:
+                    _e.sent();
+                    // P7: a Paused trigger must not fire on a resume, and vice versa — the two are separate types
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p7-wrong-direction',
+                            type: 'Subscription Paused',
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_resumed_event)({ stripeCustomerId: stripeCustomerId }); },
+                            shouldFire: false,
+                            title: 'a resume does not fire a Subscription Paused trigger',
+                        })
+                        // P8: the dedupe guard — the .updated that accompanies a status='paused' transition must not
+                        // fire on top of the dedicated event. Stripe isn't expected to send this combination at all;
+                        // the case pins the guard so a future refactor can't quietly drop it.
+                    ];
+                case 55:
+                    // P7: a Paused trigger must not fire on a resume, and vice versa — the two are separate types
+                    _e.sent();
+                    // P8: the dedupe guard — the .updated that accompanies a status='paused' transition must not
+                    // fire on top of the dedicated event. Stripe isn't expected to send this combination at all;
+                    // the case pins the guard so a future refactor can't quietly drop it.
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p8-paused-status-suppressed',
+                            type: 'Subscription Paused',
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_updated_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                previousAttributes: { pause_collection: null, status: 'trialing' },
+                                pauseCollection: stripe_webhook_helpers_1.PAUSE_COLLECTION,
+                                status: 'paused',
+                            }); },
+                            shouldFire: false,
+                            title: 'a pause_collection change coinciding with status=paused is suppressed',
+                        })
+                        /* ---- product scoping, over the pause_collection path ---- */
+                        // P9-P12: the same matrix the payment-failed cases cover, applied to the new triggers
+                    ];
+                case 56:
+                    // P8: the dedupe guard — the .updated that accompanies a status='paused' transition must not
+                    // fire on top of the dedicated event. Stripe isn't expected to send this combination at all;
+                    // the case pins the guard so a future refactor can't quietly drop it.
+                    _e.sent();
+                    /* ---- product scoping, over the pause_collection path ---- */
+                    // P9-P12: the same matrix the payment-failed cases cover, applied to the new triggers
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p9-scoped-matching',
+                            type: 'Subscription Paused',
+                            productIds: [productA.id],
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_updated_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                items: [(0, stripe_webhook_helpers_1.item_with_price_product)(stripeProductA_1)],
+                                previousAttributes: { pause_collection: null },
+                                pauseCollection: stripe_webhook_helpers_1.PAUSE_COLLECTION,
+                            }); },
+                            shouldFire: true,
+                            title: 'Subscription Paused scoped to the paused product fires',
+                        })];
+                case 57:
+                    /* ---- product scoping, over the pause_collection path ---- */
+                    // P9-P12: the same matrix the payment-failed cases cover, applied to the new triggers
+                    _e.sent();
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p10-scoped-nonmatching',
+                            type: 'Subscription Paused',
+                            productIds: [productB.id],
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_updated_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                items: [(0, stripe_webhook_helpers_1.item_with_price_product)(stripeProductA_1)],
+                                previousAttributes: { pause_collection: null },
+                                pauseCollection: stripe_webhook_helpers_1.PAUSE_COLLECTION,
+                            }); },
+                            shouldFire: false,
+                            title: 'Subscription Paused scoped to another product does not fire',
+                        })];
+                case 58:
+                    _e.sent();
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p11-empty-list',
+                            type: 'Subscription Paused',
+                            productIds: [],
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_updated_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                items: [(0, stripe_webhook_helpers_1.item_with_price_product)(stripeProductA_1)],
+                                previousAttributes: { pause_collection: null },
+                                pauseCollection: stripe_webhook_helpers_1.PAUSE_COLLECTION,
+                            }); },
+                            shouldFire: true,
+                            title: 'Subscription Paused with empty productIds fires',
+                        })
+                        // plan.product and expanded price.product objects both have to resolve, same as the invoice path
+                    ];
+                case 59:
+                    _e.sent();
+                    // plan.product and expanded price.product objects both have to resolve, same as the invoice path
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p12-plan-product',
+                            type: 'Subscription Resumed',
+                            productIds: [productA.id],
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_updated_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                items: [(0, stripe_webhook_helpers_1.item_with_plan_product)(stripeProductA_1)],
+                                previousAttributes: { pause_collection: stripe_webhook_helpers_1.PAUSE_COLLECTION },
+                                pauseCollection: null,
+                            }); },
+                            shouldFire: true,
+                            title: 'plan.product resolves for a scoped Subscription Resumed trigger',
+                        })];
+                case 60:
+                    // plan.product and expanded price.product objects both have to resolve, same as the invoice path
+                    _e.sent();
+                    return [4 /*yield*/, run_pause_case({
+                            label: 'p13-expanded-product',
+                            type: 'Subscription Resumed',
+                            productIds: [productA.id],
+                            event: function (stripeCustomerId) { return (0, stripe_webhook_helpers_1.subscription_resumed_event)({
+                                stripeCustomerId: stripeCustomerId,
+                                items: [(0, stripe_webhook_helpers_1.item_with_expanded_price_product)(stripeProductA_1)],
+                            }); },
+                            shouldFire: true,
+                            title: 'expanded price.product resolves on the dedicated resumed event',
+                        })
+                        /* ---- validator ---- */
+                        // P14: same round-trip guarantees as F7, for both new types
+                    ];
+                case 61:
+                    _e.sent();
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe subscription paused (validator round-trip) ".concat(RUN),
+                            event: { type: 'Subscription Paused', info: { productIds: [productA.id] } },
+                            tags: [tag('p14')],
+                        })];
+                case 62:
+                    p14Scoped = _e.sent();
+                    return [4 /*yield*/, sdk.api.automation_triggers.getOne(p14Scoped.id)];
+                case 63:
+                    p14Fetched = _e.sent();
+                    (0, testing_1.assert)(JSON.stringify((_d = p14Fetched.event.info) === null || _d === void 0 ? void 0 : _d.productIds) === JSON.stringify([productA.id]), "expected productIds to round-trip, got ".concat(JSON.stringify(p14Fetched.event)), 'Subscription Paused productIds round-trips through the validator');
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe subscription resumed (no info) ".concat(RUN),
+                            event: { type: 'Subscription Resumed' },
+                            tags: [tag('p14-no-info')],
+                        })];
+                case 64:
+                    _e.sent();
+                    (0, testing_1.assert)(true, '', 'Subscription Resumed with omitted info accepted');
+                    rejectedInvalidPausedProductId = false;
+                    _e.label = 65;
+                case 65:
+                    _e.trys.push([65, 67, , 68]);
+                    return [4 /*yield*/, new_trigger({
+                            title: "Stripe subscription paused (invalid productId) ".concat(RUN),
+                            event: { type: 'Subscription Paused', info: { productIds: ['not-a-mongo-id'] } },
+                            tags: [tag('p14-invalid')],
+                        })];
+                case 66:
+                    _e.sent();
+                    return [3 /*break*/, 68];
+                case 67:
+                    e_2 = _e.sent();
+                    rejectedInvalidPausedProductId = true;
+                    return [3 /*break*/, 68];
+                case 68:
+                    (0, testing_1.assert)(rejectedInvalidPausedProductId, 'expected a non-ObjectId productId to be rejected', 'invalid Subscription Paused productId rejected');
+                    console.log("All Stripe webhook trigger tests passed!");
+                    return [3 /*break*/, 72];
+                case 69: 
+                // Best-effort only: the harness exits the process on the first failed assertion, which skips
+                // this block. setup_stripe_test_integration clears integration residue on the next run.
+                return [4 /*yield*/, cleanup().catch(console.error)];
+                case 70:
+                    // Best-effort only: the harness exits the process on the first failed assertion, which skips
+                    // this block. setup_stripe_test_integration clears integration residue on the next run.
+                    _e.sent();
+                    return [4 /*yield*/, Promise.all(__spreadArray(__spreadArray(__spreadArray([], createdTriggerIds.map(function (id) { return sdk.api.automation_triggers.deleteOne(id).catch(console.error); }), true), createdProductIds.map(function (id) { return sdk.api.products.deleteOne(id).catch(console.error); }), true), createdEnduserIds.map(function (id) { return sdk.api.endusers.deleteOne(id).catch(console.error); }), true))];
+                case 71:
+                    _e.sent();
+                    return [7 /*endfinally*/];
+                case 72: return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.stripe_webhook_triggers_tests = stripe_webhook_triggers_tests;
+// Allow running this test file independently
+if (require.main === module) {
+    console.log("Using API URL: ".concat(host));
+    var sdk_2 = new sdk_1.Session({ host: host });
+    var sdkNonAdmin_1 = new sdk_1.Session({ host: host });
+    var runTests = function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, setup_1.setup_tests)(sdk_2, sdkNonAdmin_1)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, exports.stripe_webhook_triggers_tests)({ sdk: sdk_2, sdkNonAdmin: sdkNonAdmin_1 })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    runTests()
+        .then(function () {
+        console.log("Stripe webhook triggers test suite completed successfully");
+        process.exit(0);
+    })
+        .catch(function (error) {
+        console.error("Stripe webhook triggers test suite failed:", error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=stripe_webhook_triggers.test.js.map