no Billing Portal configuration, so portal sessions 400

"""Report a missing or unusable Stripe Billing Portal configuration.

Read only. Two GETs and no writes: give this a RESTRICTED key with read access to
the Customer Portal and Subscriptions. The repair is printed, never performed,
because this script holds a credential to a live payments account.
"""
import argparse
import logging
import os
import sys

import requests

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("stripe_portal_configuration")

API = "https://api.stripe.com/v1"

PORTAL_SETTINGS = "https://dashboard.stripe.com/settings/billing/portal"


def verdict(configurations, active_subscriptions=0):
    """Classify the account's portal configuration. Pure, so it is testable offline.

    `configurations` is the list from /v1/billing_portal/configurations and
    `active_subscriptions` the number of customers who can press the button.
    Returns (state, detail).
    """
    configs = list(configurations or [])
    usable = [c for c in configs if c.get("is_default") and c.get("active")]
    if usable:
        return ("configured",
                "default configuration %s is active; portal sessions resolve"
                % usable[0].get("id", "<no id>"))
    if not configs:
        if active_subscriptions:
            return ("erroring",
                    "no portal configuration exists and %d active subscription(s) "
                    "can reach the portal: every session create is failing with 400 "
                    "right now" % active_subscriptions)
        return ("missing",
                "no portal configuration exists. The first session created without "
                "an explicit configuration will fail with 400.")
    active = [c for c in configs if c.get("active")]
    if active:
        return ("explicit-only",
                "%d active configuration(s) but none is the default (%s). A session "
                "created without configuration=... fails with 400."
                % (len(active), ", ".join(c.get("id", "?") for c in active[:3])))
    return ("inactive-default",
            "%d configuration(s) exist and none of them is active, so none can be "
            "used to open the portal" % len(configs))


def get(session, path, params=None):
    r = session.get(API + path, params=params or {}, timeout=30)
    if r.status_code == 401:
        raise SystemExit("401 from Stripe: the key is wrong, or is for the other mode")
    r.raise_for_status()
    return r.json()


def configurations(session):
    """Every portal configuration on the account, in whichever mode the key is for."""
    out = []
    params = {"limit": 100}
    while True:
        page = get(session, "/billing_portal/configurations", params)
        data = page.get("data", [])
        out.extend(data)
        if not data or not page.get("has_more"):
            break
        params["starting_after"] = data[-1]["id"]
    return out


def active_subscription_count(session, cap):
    count = 0
    params = {"status": "active", "limit": 100}
    while True:
        page = get(session, "/subscriptions", params)
        data = page.get("data", [])
        count += len(data)
        if not data or not page.get("has_more") or count >= cap:
            break
        params["starting_after"] = data[-1]["id"]
    return count


def main():
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--max-subscriptions", type=int, default=2000,
                    help="stop counting active subscriptions after this many")
    args = ap.parse_args()

    key = os.environ.get("STRIPE_API_KEY")
    if not key:
        log.error("set STRIPE_API_KEY (use a restricted, read-only key)")
        return 2
    if key.startswith("sk_test") or key.startswith("rk_test"):
        log.warning("this is a test-mode key: a result here says nothing about live, "
                    "which is where this failure happens")

    s = requests.Session()
    s.headers.update({"Authorization": "Bearer " + key})

    configs = configurations(s)
    subs = active_subscription_count(s, args.max_subscriptions)
    state, detail = verdict(configs, subs)

    line = "%-16s %s" % (state, detail)
    if state == "configured":
        log.info(line)
        return 0

    log.warning(line)
    log.warning("  %d active subscription(s) can reach the portal", subs)
    log.warning("  repair: save the portal settings once, in this mode, at %s",
                PORTAL_SETTINGS)
    log.warning("  or create one over the API and pass its id explicitly:")
    log.warning("  POST %s/billing_portal/configurations -d "
                "\"features[invoice_history][enabled]=true\" ...", API)
    log.warning("  then POST %s/billing_portal/sessions -d customer=cus_... "
                "-d configuration=bpc_...", API)
    return 1


if __name__ == "__main__":
    sys.exit(main())

/**
 * Report a missing or unusable Stripe Billing Portal configuration.
 *
 * Read only. Two GETs and no writes: give this a RESTRICTED key with read access
 * to the Customer Portal and Subscriptions. The repair is printed, never performed.
 */
const API = 'https://api.stripe.com/v1';

const PORTAL_SETTINGS = 'https://dashboard.stripe.com/settings/billing/portal';

/**
 * Classify the account's portal configuration. Pure, so it is testable offline.
 * A default that is not active satisfies a naive check and still fails every call.
 */
export function verdict(configurations, activeSubscriptions = 0) {
  const configs = configurations ?? [];
  const usable = configs.filter((c) => c.is_default && c.active);
  if (usable.length) {
    return ['configured',
      `default configuration ${usable[0].id ?? '<no id>'} is active; portal ` +
      'sessions resolve'];
  }
  if (configs.length === 0) {
    if (activeSubscriptions) {
      return ['erroring',
        `no portal configuration exists and ${activeSubscriptions} active ` +
        'subscription(s) can reach the portal: every session create is failing ' +
        'with 400 right now'];
    }
    return ['missing',
      'no portal configuration exists. The first session created without an ' +
      'explicit configuration will fail with 400.'];
  }
  const active = configs.filter((c) => c.active);
  if (active.length) {
    return ['explicit-only',
      `${active.length} active configuration(s) but none is the default ` +
      `(${active.slice(0, 3).map((c) => c.id ?? '?').join(', ')}). A session ` +
      'created without configuration=... fails with 400.'];
  }
  return ['inactive-default',
    `${configs.length} configuration(s) exist and none of them is active, so ` +
    'none can be used to open the portal'];
}

async function get(key, path, params = {}) {
  const url = new URL(API + path);
  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
  const res = await fetch(url, { headers: { Authorization: `Bearer ${key}` } });
  if (res.status === 401) {
    throw new Error('401 from Stripe: the key is wrong, or is for the other mode');
  }
  if (!res.ok) throw new Error(`${res.status} from ${url.pathname}`);
  return res.json();
}

export async function configurations(key) {
  const out = [];
  const params = { limit: 100 };
  for (;;) {
    const page = await get(key, '/billing_portal/configurations', params);
    const data = page.data ?? [];
    out.push(...data);
    if (data.length === 0 || !page.has_more) break;
    params.starting_after = data[data.length - 1].id;
  }
  return out;
}

export async function activeSubscriptionCount(key, cap = 2000) {
  let count = 0;
  const params = { status: 'active', limit: 100 };
  for (;;) {
    const page = await get(key, '/subscriptions', params);
    const data = page.data ?? [];
    count += data.length;
    if (data.length === 0 || !page.has_more || count >= cap) break;
    params.starting_after = data[data.length - 1].id;
  }
  return count;
}

async function main() {
  const key = process.env.STRIPE_API_KEY;
  if (!key) {
    console.error('set STRIPE_API_KEY (use a restricted, read-only key)');
    process.exitCode = 2;
    return;
  }
  if (key.startsWith('sk_test') || key.startsWith('rk_test')) {
    console.warn('this is a test-mode key: a result here says nothing about live, ' +
                 'which is where this failure happens');
  }

  const configs = await configurations(key);
  const subs = await activeSubscriptionCount(key);
  const [state, detail] = verdict(configs, subs);

  const line = `${state.padEnd(16)} ${detail}`;
  if (state === 'configured') { console.log(line); return; }

  console.warn(line);
  console.warn(`  ${subs} active subscription(s) can reach the portal`);
  console.warn(`  repair: save the portal settings once, in this mode, at ${PORTAL_SETTINGS}`);
  console.warn('  or create one over the API and pass its id explicitly:');
  console.warn(`  POST ${API}/billing_portal/configurations -d ` +
               '"features[invoice_history][enabled]=true" ...');
  console.warn(`  then POST ${API}/billing_portal/sessions -d customer=cus_... ` +
               '-d configuration=bpc_...');
  process.exitCode = 1;
}

// Only run when invoked directly. The test file imports this module, and without
// the guard main() would run there too, fail on the missing key, and set a
// non-zero exit code that fails the whole test file even as every test passes.
if (import.meta.url === `file://${process.argv[1]}`) {
  main().catch((err) => { console.error(err.message); process.exitCode = 2; });
}

from stripe_portal_configuration import verdict

DEFAULT = {"id": "bpc_1", "is_default": True, "active": True}
EXPLICIT = {"id": "bpc_2", "is_default": False, "active": True}


def test_an_active_default_is_all_that_is_needed():
    state, detail = verdict([DEFAULT], 400)
    assert state == "configured"
    assert "bpc_1" in detail


def test_no_configuration_with_live_subscribers_is_an_outage():
    state, detail = verdict([], 400)
    assert state == "erroring"
    assert "400" in detail


def test_no_configuration_and_no_subscribers_is_only_waiting_to_break():
    assert verdict([], 0)[0] == "missing"


def test_an_explicit_only_setup_still_fails_without_the_id():
    # Counting the array would call this configured. Sessions created without a
    # configuration parameter still have no default to fall back to.
    state, detail = verdict([EXPLICIT], 400)
    assert state == "explicit-only"
    assert "bpc_2" in detail


def test_an_inactive_default_does_not_count():
    inactive = {"id": "bpc_3", "is_default": True, "active": False}
    assert verdict([inactive], 5)[0] == "inactive-default"

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { verdict } from './stripe-portal-configuration.mjs';

const DEFAULT = { id: 'bpc_1', is_default: true, active: true };
const EXPLICIT = { id: 'bpc_2', is_default: false, active: true };

test('an active default is all that is needed', () => {
  const [state, detail] = verdict([DEFAULT], 400);
  assert.equal(state, 'configured');
  assert.match(detail, /bpc_1/);
});

test('no configuration with live subscribers is an outage', () => {
  const [state, detail] = verdict([], 400);
  assert.equal(state, 'erroring');
  assert.match(detail, /400/);
});

test('no configuration and no subscribers is only waiting to break', () => {
  assert.equal(verdict([], 0)[0], 'missing');
});

test('an explicit only setup still fails without the id', () => {
  const [state, detail] = verdict([EXPLICIT], 400);
  assert.equal(state, 'explicit-only');
  assert.match(detail, /bpc_2/);
});

test('an inactive default does not count', () => {
  const inactive = { id: 'bpc_3', is_default: true, active: false };
  assert.equal(verdict([inactive], 5)[0], 'inactive-default');
});