SES silently rejects real recipients because the account is still in the sandbox

"""Fail if any SES region is still in the sandbox.

Written to run in CI: exits non-zero when a region cannot mail arbitrary
recipients, so a deploy stops before a customer finds out for you.
"""
import argparse
import logging
import sys

import boto3

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

SANDBOX_DAILY_QUOTA = 200.0


def assess(account):
    """Pure decision function over a GetAccount response.

    Production access and enforcement are separate: an account can be out of the
    sandbox and still be SHUTDOWN or UNDER_REVIEW, which fails sends just as hard.
    """
    production = bool(account.get("ProductionAccessEnabled"))
    enforcement = (account.get("EnforcementStatus") or "HEALTHY").upper()
    quota = float(account.get("SendQuota", {}).get("Max24HourSend") or 0)

    problems = []
    if not production:
        problems.append("still in the sandbox: recipients must be verified identities")
    if enforcement != "HEALTHY":
        problems.append(f"enforcement status is {enforcement}")
    if production and quota <= SANDBOX_DAILY_QUOTA:
        problems.append(f"production access is on but the quota is only {quota:.0f}/24h")
    return problems


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--regions", nargs="+", default=["us-east-1"])
    args = ap.parse_args()

    failed = False
    for region in args.regions:
        account = boto3.client("sesv2", region_name=region).get_account()
        problems = assess(account)
        quota = account.get("SendQuota", {})
        if problems:
            failed = True
            for p in problems:
                log.error("%s: %s", region, p)
        else:
            log.info("%s: production access, %.0f/24h at %.0f/sec",
                     region, quota.get("Max24HourSend", 0), quota.get("MaxSendRate", 0))
    return 1 if failed else 0


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

/**
 * Fail if any SES region is still in the sandbox.
 *
 * Written to run in CI: exits non-zero when a region cannot mail arbitrary
 * recipients, so a deploy stops before a customer finds out for you.
 */
import { SESv2Client, GetAccountCommand } from '@aws-sdk/client-sesv2';

const SANDBOX_DAILY_QUOTA = 200;

/**
 * Pure decision function over a GetAccount response.
 *
 * Production access and enforcement are separate: an account can be out of the
 * sandbox and still be SHUTDOWN or UNDER_REVIEW, which fails sends just as hard.
 */
export function assess(account) {
  const production = Boolean(account.ProductionAccessEnabled);
  const enforcement = (account.EnforcementStatus ?? 'HEALTHY').toUpperCase();
  const quota = Number(account.SendQuota?.Max24HourSend ?? 0);

  const problems = [];
  if (!production) problems.push('still in the sandbox: recipients must be verified identities');
  if (enforcement !== 'HEALTHY') problems.push(`enforcement status is ${enforcement}`);
  if (production && quota <= SANDBOX_DAILY_QUOTA) {
    problems.push(`production access is on but the quota is only ${quota}/24h`);
  }
  return problems;
}

async function main() {
  const regions = process.argv.slice(2).filter((a) => !a.startsWith('--'));
  const targets = regions.length ? regions : ['us-east-1'];

  let failed = false;
  for (const region of targets) {
    const account = await new SESv2Client({ region }).send(new GetAccountCommand({}));
    const problems = assess(account);
    if (problems.length) {
      failed = true;
      for (const p of problems) console.error(`${region}: ${p}`);
    } else {
      console.log(`${region}: production access, ${account.SendQuota?.Max24HourSend}/24h`);
    }
  }
  process.exit(failed ? 1 : 0);
}

if (import.meta.url === `file://${process.argv[1]}`) main();

from ses_sandbox_check import assess


def healthy():
    return {"ProductionAccessEnabled": True, "EnforcementStatus": "HEALTHY",
            "SendQuota": {"Max24HourSend": 50000.0, "MaxSendRate": 14.0}}


def test_healthy_account_has_no_problems():
    assert assess(healthy()) == []


def test_sandbox_is_reported():
    acct = healthy() | {"ProductionAccessEnabled": False}
    assert any("sandbox" in p for p in assess(acct))


def test_enforcement_is_separate_from_sandbox():
    """Out of the sandbox but SHUTDOWN still cannot send."""
    acct = healthy() | {"EnforcementStatus": "SHUTDOWN"}
    assert any("SHUTDOWN" in p for p in assess(acct))


def test_production_access_with_sandbox_quota_is_suspicious():
    acct = healthy() | {"SendQuota": {"Max24HourSend": 200.0, "MaxSendRate": 1.0}}
    assert any("quota" in p for p in assess(acct))


def test_missing_enforcement_defaults_to_healthy():
    acct = healthy()
    del acct["EnforcementStatus"]
    assert assess(acct) == []

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { assess } from './ses-sandbox-check.mjs';

const healthy = () => ({
  ProductionAccessEnabled: true,
  EnforcementStatus: 'HEALTHY',
  SendQuota: { Max24HourSend: 50000, MaxSendRate: 14 },
});

test('a healthy account has no problems', () => {
  assert.deepEqual(assess(healthy()), []);
});

test('the sandbox is reported', () => {
  const problems = assess({ ...healthy(), ProductionAccessEnabled: false });
  assert.ok(problems.some((p) => p.includes('sandbox')));
});

test('enforcement is separate from the sandbox', () => {
  const problems = assess({ ...healthy(), EnforcementStatus: 'SHUTDOWN' });
  assert.ok(problems.some((p) => p.includes('SHUTDOWN')));
});

test('production access with a sandbox quota is suspicious', () => {
  const problems = assess({ ...healthy(), SendQuota: { Max24HourSend: 200, MaxSendRate: 1 } });
  assert.ok(problems.some((p) => p.includes('quota')));
});