backend-manager 5.2.19 → 5.3.1

package/test/helpers/content/ghostii-blocks.js

@@ -0,0 +1,134 @@
+/**
+ * Test: content/ghostii.blocksToPost()
+ * Unit tests for the Ghostii-JSON → BEM-post transform.
+ *
+ * Run: npx mgr test helpers/content/ghostii-blocks
+ *
+ * Ghostii is unopinionated about BEM: its /write/article response is a generic
+ * block array ([{ name, content }], name ∈ heading-1..6/image/paragraph/blockquote/list).
+ * blocksToPost() is the SSOT that turns those blocks into what admin/post wants —
+ * title + header image as SEPARATE fields, body = content only.
+ *
+ * Pure function (no I/O) → required directly and called with plain inputs. NOT a mock.
+ *
+ * Contract:
+ *   - title          ← first heading-1 block, leading markdown `#` stripped
+ *   - headerImageUrl ← first image block's URL (from `![alt](url)`)
+ *   - body           ← every remaining block, joined with blank lines, trimmed
+ *   - the title block and the header-image block are EXCLUDED from body
+ *   - section images (non-first image blocks) STAY in the body
+ *   - non-array / empty input → all empty strings
+ */
+const { blocksToPost } = require('../../../src/manager/libraries/content/ghostii.js');
+
+module.exports = {
+  description: 'content/ghostii.blocksToPost()',
+  type: 'group',
+
+  tests: [
+    {
+      name: 'extracts-title-from-heading-1-stripping-marker',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-1', content: '# My Great Article' },
+          { name: 'paragraph', content: 'Body.' },
+        ]);
+        assert.equal(result.title, 'My Great Article');
+      },
+    },
+
+    {
+      name: 'extracts-header-image-url-from-first-image-block',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-1', content: '# Title' },
+          { name: 'image', content: '![Title](https://images.unsplash.com/photo-abc?w=1080)' },
+          { name: 'paragraph', content: 'Body.' },
+        ]);
+        assert.equal(result.headerImageUrl, 'https://images.unsplash.com/photo-abc?w=1080');
+      },
+    },
+
+    {
+      name: 'body-excludes-title-and-header-image',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-1', content: '# Title' },
+          { name: 'image', content: '![Title](https://img/header.jpg)' },
+          { name: 'heading-2', content: '## First Section' },
+          { name: 'paragraph', content: 'First paragraph.' },
+        ]);
+        assert.equal(result.body, '## First Section\n\nFirst paragraph.', 'body is content only');
+        assert.notMatch(result.body, /^#\s/m, 'no H1 title in body');
+        assert.notMatch(result.body, /^!\[Title\]\(https:\/\/img\/header\.jpg\)/m, 'no header image in body');
+      },
+    },
+
+    {
+      name: 'keeps-section-images-in-body',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-1', content: '# Title' },
+          { name: 'image', content: '![Title](https://img/header.jpg)' },
+          { name: 'heading-2', content: '## Section' },
+          { name: 'paragraph', content: 'Text.' },
+          { name: 'image', content: '![Section](https://img/section.jpg)' },
+          { name: 'paragraph', content: 'More text.' },
+        ]);
+        // Only the FIRST image is the header; later images belong to the body.
+        assert.ok(result.body.includes('![Section](https://img/section.jpg)'), 'section image stays in body');
+        assert.equal((result.body.match(/!\[/g) || []).length, 1, 'exactly one (section) image in body');
+      },
+    },
+
+    {
+      name: 'preserves-blockquotes-and-lists-in-body',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-1', content: '# Title' },
+          { name: 'heading-2', content: '## Section' },
+          { name: 'blockquote', content: '> A pithy quote.' },
+          { name: 'list', content: '- one\n- two' },
+        ]);
+        assert.ok(result.body.includes('> A pithy quote.'), 'blockquote kept');
+        assert.ok(result.body.includes('- one\n- two'), 'list kept');
+      },
+    },
+
+    {
+      name: 'handles-missing-heading-1-and-image-gracefully',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-2', content: '## Only Section' },
+          { name: 'paragraph', content: 'Text.' },
+        ]);
+        assert.equal(result.title, '', 'no title when no heading-1');
+        assert.equal(result.headerImageUrl, '', 'no header image when no image block');
+        assert.equal(result.body, '## Only Section\n\nText.', 'body is all blocks when nothing excluded');
+      },
+    },
+
+    {
+      name: 'uses-only-the-first-image-as-header',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'image', content: '![first](https://img/first.jpg)' },
+          { name: 'paragraph', content: 'Text.' },
+          { name: 'image', content: '![second](https://img/second.jpg)' },
+        ]);
+        assert.equal(result.headerImageUrl, 'https://img/first.jpg', 'first image is the header');
+        assert.ok(result.body.includes('https://img/second.jpg'), 'second image stays in body');
+        assert.ok(!result.body.includes('https://img/first.jpg'), 'first image not in body');
+      },
+    },
+
+    {
+      name: 'non-array-or-empty-input-returns-empty-strings',
+      async run({ assert }) {
+        assert.deepEqual(blocksToPost([]), { title: '', headerImageUrl: '', body: '' }, 'empty array');
+        assert.deepEqual(blocksToPost(null), { title: '', headerImageUrl: '', body: '' }, 'null');
+        assert.deepEqual(blocksToPost(undefined), { title: '', headerImageUrl: '', body: '' }, 'undefined');
+      },
+    },
+  ],
+};

package/test/helpers/environment.js

@@ -0,0 +1,230 @@
+/**
+ * Test: environment detection + URL helpers
+ * Covers the Manager's getEnvironment() SSOT, the derived is*() checks, the URL
+ * builders (getApiUrl / getFunctionsUrl / getWebsiteUrl + parent variants), and the
+ * assistant→Manager forwarding.
+ *
+ * Run: npx mgr test bem:helpers/environment
+ *
+ * Contract (see docs/environment-detection.md):
+ *   - getEnvironment() is the SINGLE SOURCE OF TRUTH — the only reader of the raw env
+ *     vars (BEM_TESTING / ENVIRONMENT / FUNCTIONS_EMULATOR / TERM_PROGRAM). Returns
+ *     exactly ONE of 'development' | 'testing' | 'production' (testing wins).
+ *   - isDevelopment()/isProduction()/isTesting() DERIVE from getEnvironment() — they
+ *     never read raw signals, so they can NEVER disagree with it. Exactly one is true.
+ *   - getApiUrl/getFunctionsUrl/getWebsiteUrl resolve LOCAL in dev OR testing, prod
+ *     otherwise. The parent helpers ALWAYS return the live URL (no localhost).
+ *   - The assistant forwards each method to its Manager (identical results).
+ */
+
+// Run a thunk with the env-detection vars cleared, restoring them afterward. These are
+// the only inputs getEnvironment() reads, so clearing them gives a clean slate per case.
+function withEnv(overrides, fn) {
+  const KEYS = ['BEM_TESTING', 'ENVIRONMENT', 'FUNCTIONS_EMULATOR', 'TERM_PROGRAM'];
+  const saved = {};
+  for (const k of KEYS) saved[k] = process.env[k];
+  try {
+    for (const k of KEYS) delete process.env[k];
+    for (const k of Object.keys(overrides)) process.env[k] = overrides[k];
+    return fn();
+  } finally {
+    for (const k of KEYS) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    }
+  }
+}
+
+module.exports = {
+  description: 'Environment detection + URL helpers',
+  type: 'group',
+
+  tests: [
+    // ─── getEnvironment() resolution + precedence ───
+
+    {
+      name: 'getEnvironment: testing wins over everything (BEM_TESTING=true)',
+      async run({ Manager, assert }) {
+        withEnv({ BEM_TESTING: 'true', ENVIRONMENT: 'production' }, () => {
+          assert.equal(Manager.getEnvironment(), 'testing');
+        });
+      },
+    },
+    {
+      name: 'getEnvironment: production when ENVIRONMENT=production (not testing)',
+      async run({ Manager, assert }) {
+        withEnv({ ENVIRONMENT: 'production' }, () => {
+          assert.equal(Manager.getEnvironment(), 'production');
+        });
+      },
+    },
+    {
+      name: 'getEnvironment: development when ENVIRONMENT=development',
+      async run({ Manager, assert }) {
+        withEnv({ ENVIRONMENT: 'development' }, () => {
+          assert.equal(Manager.getEnvironment(), 'development');
+        });
+      },
+    },
+    {
+      name: 'getEnvironment: development when FUNCTIONS_EMULATOR is set',
+      async run({ Manager, assert }) {
+        withEnv({ FUNCTIONS_EMULATOR: 'true' }, () => {
+          assert.equal(Manager.getEnvironment(), 'development');
+        });
+      },
+    },
+    {
+      name: 'getEnvironment: defaults to production with no signal (deployed function)',
+      async run({ Manager, assert }) {
+        withEnv({}, () => {
+          assert.equal(Manager.getEnvironment(), 'production');
+        });
+      },
+    },
+
+    // ─── The KEY invariant: is*() derive from getEnvironment() and can NEVER disagree ───
+
+    {
+      name: 'invariant: is*() exactly matches getEnvironment() across every scenario',
+      async run({ Manager, assert }) {
+        const scenarios = [
+          { env: { BEM_TESTING: 'true', ENVIRONMENT: 'production' }, expect: 'testing' },
+          { env: { ENVIRONMENT: 'production' },                     expect: 'production' },
+          { env: { ENVIRONMENT: 'development' },                    expect: 'development' },
+          { env: { FUNCTIONS_EMULATOR: 'true' },                    expect: 'development' },
+          { env: {},                                                expect: 'production' },
+        ];
+        for (const s of scenarios) {
+          withEnv(s.env, () => {
+            const e = Manager.getEnvironment();
+            assert.equal(e, s.expect, `getEnvironment for ${JSON.stringify(s.env)}`);
+            // Each is*() must equal (getEnvironment() === its value) — no independent reads.
+            assert.equal(Manager.isDevelopment(), e === 'development', `isDevelopment for ${e}`);
+            assert.equal(Manager.isTesting(),     e === 'testing',     `isTesting for ${e}`);
+            assert.equal(Manager.isProduction(),  e === 'production',  `isProduction for ${e}`);
+          });
+        }
+      },
+    },
+    {
+      name: 'invariant: exactly one of is*() is true in every scenario (mutually exclusive)',
+      async run({ Manager, assert }) {
+        const envs = [
+          { BEM_TESTING: 'true' },
+          { ENVIRONMENT: 'production' },
+          { ENVIRONMENT: 'development' },
+          { FUNCTIONS_EMULATOR: 'true' },
+          {},
+        ];
+        for (const env of envs) {
+          withEnv(env, () => {
+            const trueCount = [Manager.isDevelopment(), Manager.isTesting(), Manager.isProduction()]
+              .filter(Boolean).length;
+            assert.equal(trueCount, 1, `exactly one true for ${JSON.stringify(env)}`);
+          });
+        }
+      },
+    },
+    {
+      name: 'isProduction is a real positive check (NOT just !isDevelopment) — false in testing',
+      async run({ Manager, assert }) {
+        withEnv({ BEM_TESTING: 'true' }, () => {
+          assert.equal(Manager.isDevelopment(), false, 'isDevelopment false in testing');
+          assert.equal(Manager.isProduction(),  false, 'isProduction false in testing');
+          assert.equal(Manager.isTesting(),     true,  'isTesting true in testing');
+        });
+      },
+    },
+
+    // ─── assistant forwards to the Manager (identical results) ───
+
+    {
+      name: 'assistant forwards getEnvironment()/is*() to the Manager (identical)',
+      async run({ Manager, assistant, assert }) {
+        const cases = [
+          { BEM_TESTING: 'true' },
+          { ENVIRONMENT: 'production' },
+          { ENVIRONMENT: 'development' },
+        ];
+        for (const env of cases) {
+          withEnv(env, () => {
+            assert.equal(assistant.getEnvironment(), Manager.getEnvironment(), 'getEnvironment forward');
+            assert.equal(assistant.isDevelopment(), Manager.isDevelopment(), 'isDevelopment forward');
+            assert.equal(assistant.isTesting(),     Manager.isTesting(),     'isTesting forward');
+            assert.equal(assistant.isProduction(),  Manager.isProduction(),  'isProduction forward');
+          });
+        }
+      },
+    },
+
+    // ─── URL helpers: local in dev/testing, production otherwise ───
+
+    {
+      name: 'getApiUrl: localhost in development AND testing, prod otherwise',
+      async run({ Manager, assert }) {
+        withEnv({ FUNCTIONS_EMULATOR: 'true' }, () => {
+          assert.equal(Manager.getApiUrl(), 'http://localhost:5002', 'dev → localhost');
+        });
+        withEnv({ BEM_TESTING: 'true' }, () => {
+          assert.equal(Manager.getApiUrl(), 'http://localhost:5002', 'testing → localhost');
+        });
+        withEnv({ ENVIRONMENT: 'production' }, () => {
+          assert.match(Manager.getApiUrl(), /^https:\/\/api\./, 'prod → api.<domain>');
+        });
+      },
+    },
+    {
+      name: 'getApiUrl: explicit env arg overrides current environment',
+      async run({ Manager, assert }) {
+        // Under the test harness we're in 'testing', but an explicit arg forces the mapping.
+        assert.equal(Manager.getApiUrl('development'), 'http://localhost:5002', "arg 'development' → localhost");
+        assert.match(Manager.getApiUrl('production'), /^https:\/\/api\./, "arg 'production' → prod");
+      },
+    },
+    {
+      name: 'getFunctionsUrl: localhost in development AND testing, cloudfunctions otherwise',
+      async run({ Manager, assert }) {
+        withEnv({ FUNCTIONS_EMULATOR: 'true' }, () => {
+          assert.match(Manager.getFunctionsUrl(), /^http:\/\/localhost:5001\//, 'dev → localhost:5001');
+        });
+        withEnv({ BEM_TESTING: 'true' }, () => {
+          assert.match(Manager.getFunctionsUrl(), /^http:\/\/localhost:5001\//, 'testing → localhost:5001');
+        });
+        withEnv({ ENVIRONMENT: 'production' }, () => {
+          assert.match(Manager.getFunctionsUrl(), /cloudfunctions\.net$/, 'prod → cloudfunctions.net');
+        });
+      },
+    },
+    {
+      name: 'getWebsiteUrl: localhost:4000 in development AND testing, brand.url otherwise',
+      async run({ Manager, assert }) {
+        withEnv({ FUNCTIONS_EMULATOR: 'true' }, () => {
+          assert.equal(Manager.getWebsiteUrl(), 'https://localhost:4000', 'dev → localhost:4000');
+        });
+        withEnv({ BEM_TESTING: 'true' }, () => {
+          assert.equal(Manager.getWebsiteUrl(), 'https://localhost:4000', 'testing → localhost:4000');
+        });
+        withEnv({ ENVIRONMENT: 'production' }, () => {
+          const url = Manager.getWebsiteUrl();
+          assert.equal(url.startsWith('https://localhost'), false, 'prod → NOT localhost');
+        });
+      },
+    },
+
+    // ─── Parent helpers ALWAYS resolve live (never localhost), even in dev/testing ───
+
+    {
+      name: 'getParentApiUrl / getParentUrl never redirect to localhost (always live)',
+      async run({ Manager, assert }) {
+        // Even under the test harness ('testing'), the parent is a real remote server.
+        const parentUrl = Manager.getParentUrl();
+        const parentApi = Manager.getParentApiUrl();
+        assert.equal((parentUrl || '').includes('localhost'), false, 'getParentUrl not localhost');
+        assert.equal((parentApi || '').includes('localhost'), false, 'getParentApiUrl not localhost');
+        // When set, the parent API URL carries the api. subdomain.
+        if (parentApi) assert.match(parentApi, /^https:\/\/api\./, 'parent api uses api. subdomain');
+      },
+    },
+  ],
+};

package/test/helpers/webhook-forward.js

@@ -21,7 +21,15 @@
 
 // Mock wonderful-fetch before requiring the route — the route does
 // `require('wonderful-fetch')` at module load time.
+//
+// CRITICAL: every test file is `require()`d into the SAME Node process by the
+// runner, so the require cache is shared. We MUST save the original
+// wonderful-fetch cache entry here and restore it in the suite-level `cleanup`
+// below — otherwise this mock leaks into every test file that runs afterwards
+// (e.g. emulator route tests whose `Manager.require('wonderful-fetch')` would
+// then return our stub instead of doing a real HTTP round-trip).
 const originalFetchPath = require.resolve('wonderful-fetch');
+const originalFetchCacheEntry = require.cache[originalFetchPath];
 const fetchCalls = [];
 let fetchMockBehavior = () => ({ received: true });
 
@@ -38,6 +46,17 @@ require.cache[originalFetchPath] = {
 
 const route = require('../../src/manager/routes/marketing/webhook/forward/post.js');
 
+// Restore the real wonderful-fetch in the require cache so the mock is confined
+// to this file. Without this, the stub leaks process-wide and poisons every
+// later test file's HTTP calls.
+function restoreFetch() {
+  if (originalFetchCacheEntry) {
+    require.cache[originalFetchPath] = originalFetchCacheEntry;
+  } else {
+    delete require.cache[originalFetchPath];
+  }
+}
+
 // --- Test scaffolding ---
 
 function makeFirestoreMock(brandDocs) {
@@ -114,6 +133,13 @@ function withEnv(envOverrides, fn) {
 module.exports = {
   description: 'webhook/forward unit tests (mocked admin + fetch)',
   type: 'group',
+
+  // Restore the real wonderful-fetch after this file's tests so the require-cache
+  // stub does not leak into any test file that runs later in the same process.
+  cleanup() {
+    restoreFetch();
+  },
+
   tests: [
     // ─── Gating ───
 

package/test/routes/marketing/webhook-forward.js

@@ -21,12 +21,13 @@ module.exports = {
     {
       name: 'forwarder-returns-404-on-non-parent-brand',
       auth: 'none',
-      async run({ http, assert, config }) {
-        // Sanity check: this brand should NOT be configured as the parent
-        assert.ok(
-          config.parent && config.parent !== 'self',
-          `Test brand should have config.parent set to a URL (got: ${config.parent})`
-        );
+      async run({ http, assert, config, skip }) {
+        // This gate only applies to CHILD brands. If this brand IS the parent
+        // (config.parent === 'self'), the forwarder route is visible by design,
+        // so there's nothing to assert here — skip rather than fail.
+        if (!config.parent || config.parent === 'self') {
+          skip('Brand is its own parent (config.parent === "self") — forwarder gate does not apply');
+        }
 
         const response = await http.as('none').post(
           `marketing/webhook/forward?provider=sendgrid&key=${process.env.BACKEND_MANAGER_WEBHOOK_KEY}`,
@@ -40,7 +41,13 @@ module.exports = {
     {
       name: 'forwarder-returns-404-even-with-valid-key',
       auth: 'none',
-      async run({ http, assert }) {
+      async run({ http, assert, config, skip }) {
+        // Only meaningful on a CHILD brand. On the parent itself the forwarder is
+        // visible by design, so skip rather than fail.
+        if (!config.parent || config.parent === 'self') {
+          skip('Brand is its own parent (config.parent === "self") — forwarder gate does not apply');
+        }
+
         // A valid key shouldn't unlock the forwarder — gate is on config.parent, not key.
         const response = await http.as('none').post(
           `marketing/webhook/forward?provider=beehiiv&key=${process.env.BACKEND_MANAGER_WEBHOOK_KEY}`,

package/test/routes/payments/cancel.js

@@ -92,9 +92,12 @@ module.exports = {
 
     {
       name: 'succeeds-with-test-processor',
-      async run({ http, assert, config, accounts, firestore, waitFor }) {
+      async run({ http, assert, config, accounts, firestore, waitFor, skip }) {
         const uid = accounts['route-cancel-success'].uid;
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices?.monthly);
+        if (!paidProduct) {
+          skip('No paid product with monthly price configured in this brand');
+        }
 
         // Step 1: Create a test subscription intent to set up a proper paid subscription
         const intentResponse = await http.as('route-cancel-success').post('payments/intent', {

package/test/routes/payments/dispute-alert.js

@@ -239,15 +239,18 @@ module.exports = {
       async run({ http, assert, firestore }) {
         const alertId = '_test-dispute-duplicate';
 
-        // Send first alert
-        await http.as('none').post(`payments/dispute-alert?key=${process.env.BACKEND_MANAGER_WEBHOOK_KEY}`, {
+        // Pre-seed an in-flight dispute directly. We seed (rather than POST a first alert)
+        // because the route fires an async on-write trigger that, for synthetic test data
+        // with no matching charge, can transition the doc to 'failed' — at which point the
+        // dedup contract intentionally treats it as RETRYABLE, not a duplicate. Racing a
+        // live POST against that trigger made this test flaky. Seeding 'processing' (a
+        // non-failed, in-flight state) deterministically exercises the dedup path.
+        await firestore.set(`payments-disputes/${alertId}`, {
           id: alertId,
-          card: '4242',
-          amount: 29.99,
-          transactionDate: '2026-03-07',
+          status: 'processing',
         });
 
-        // Send duplicate
+        // A subsequent identical alert must be reported as a duplicate (not reprocessed).
         const response = await http.as('none').post(`payments/dispute-alert?key=${process.env.BACKEND_MANAGER_WEBHOOK_KEY}`, {
           id: alertId,
           card: '4242',

package/test/routes/payments/intent.js

@@ -5,7 +5,9 @@
  * Validation tests use processor=stripe (fail at SDK step, proving validation logic)
  * Success tests use processor=test (full intent→webhook→trigger pipeline)
  *
- * Product-agnostic: resolves the first paid product from config.payment.products
+ * Product-agnostic: resolves the first paid product from config.payment.products.
+ * If the brand has no paid product configured, each test skips — this is a
+ * config-gap, not a code failure.
  */
 module.exports = {
   description: 'Payment intent creation',
@@ -16,8 +18,11 @@ module.exports = {
     {
       name: 'rejects-unauthenticated',
       auth: 'none',
-      async run({ http, assert, config }) {
+      async run({ http, assert, config, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('none').post('payments/intent', {
           processor: 'stripe',
@@ -31,8 +36,11 @@ module.exports = {
 
     {
       name: 'rejects-missing-processor',
-      async run({ http, assert, config }) {
+      async run({ http, assert, config, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('basic').post('payments/intent', {
           productId: paidProduct.id,
@@ -57,8 +65,11 @@ module.exports = {
 
     {
       name: 'rejects-missing-frequency-for-subscription',
-      async run({ http, assert, config }) {
+      async run({ http, assert, config, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.type === 'subscription' && p.prices);
+        if (!paidProduct) {
+          skip('No paid subscription product configured in this brand');
+        }
 
         const response = await http.as('basic').post('payments/intent', {
           processor: 'stripe',
@@ -72,8 +83,11 @@ module.exports = {
     {
       name: 'rejects-active-paid-user',
       auth: 'premium-active',
-      async run({ http, assert, config }) {
+      async run({ http, assert, config, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('premium-active').post('payments/intent', {
           processor: 'stripe',
@@ -88,8 +102,11 @@ module.exports = {
     {
       name: 'rejects-suspended-user',
       auth: 'premium-suspended',
-      async run({ http, assert, config }) {
+      async run({ http, assert, config, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('premium-suspended').post('payments/intent', {
           processor: 'stripe',
@@ -104,8 +121,11 @@ module.exports = {
     {
       name: 'rejects-cancelling-user',
       auth: 'premium-cancelling',
-      async run({ http, assert, config }) {
+      async run({ http, assert, config, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('premium-cancelling').post('payments/intent', {
           processor: 'stripe',
@@ -120,8 +140,11 @@ module.exports = {
     {
       name: 'allows-cancelled-user',
       auth: 'premium-expired',
-      async run({ http, assert, config }) {
+      async run({ http, assert, config, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('premium-expired').post('payments/intent', {
           processor: 'test',
@@ -148,8 +171,11 @@ module.exports = {
 
     {
       name: 'rejects-unknown-processor',
-      async run({ http, assert, config }) {
+      async run({ http, assert, config, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('basic').post('payments/intent', {
           processor: 'unknown-processor',
@@ -163,8 +189,11 @@ module.exports = {
 
     {
       name: 'rejects-invalid-discount-code',
-      async run({ http, assert, config }) {
+      async run({ http, assert, config, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('basic').post('payments/intent', {
           processor: 'stripe',
@@ -179,8 +208,11 @@ module.exports = {
 
     {
       name: 'saves-discount-to-intent-doc',
-      async run({ http, assert, config, firestore }) {
+      async run({ http, assert, config, firestore, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('journey-payments-intent-discount').post('payments/intent', {
           processor: 'test',
@@ -202,8 +234,11 @@ module.exports = {
 
     {
       name: 'saves-attribution-and-supplemental-to-intent-doc',
-      async run({ http, assert, config, firestore }) {
+      async run({ http, assert, config, firestore, skip }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('journey-payments-intent-attribution').post('payments/intent', {
           processor: 'test',
@@ -223,9 +258,12 @@ module.exports = {
 
     {
       name: 'succeeds-with-test-processor',
-      async run({ http, assert, config, firestore, accounts, waitFor }) {
+      async run({ http, assert, config, firestore, accounts, waitFor, skip }) {
         const uid = accounts['journey-payments-intent'].uid;
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         const response = await http.as('journey-payments-intent').post('payments/intent', {
           processor: 'test',
@@ -256,9 +294,12 @@ module.exports = {
 
     {
       name: 'downgrades-trial-for-user-with-history',
-      async run({ http, assert, config, accounts, firestore, waitFor }) {
+      async run({ http, assert, config, accounts, firestore, waitFor, skip }) {
         const uid = accounts['journey-payments-intent-trial'].uid;
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
         const orderDocPath = `payments-orders/_test-order-history-${uid}`;
 
         // Create fake subscription history so user is ineligible for trial