@wopr-network/platform-core 0.1.0

package/src/billing/stripe/stripe-payment-processor.ts

@@ -0,0 +1,255 @@
+import type Stripe from "stripe";
+import { Credit } from "../../credits/credit.js";
+import { chargeAutoTopup } from "../../credits/auto-topup-charge.js";
+import type { IAutoTopupEventLogRepository } from "../../credits/auto-topup-event-log-repository.js";
+import type { ICreditLedger } from "../../credits/credit-ledger.js";
+import {
+  type ChargeOpts,
+  type ChargeResult,
+  type CheckoutOpts,
+  type CheckoutSession,
+  type Invoice,
+  type IPaymentProcessor,
+  PaymentMethodOwnershipError,
+  type PortalOpts,
+  type SavedPaymentMethod,
+  type SetupResult,
+  type WebhookResult,
+} from "../payment-processor.js";
+import { createCreditCheckoutSession } from "./checkout.js";
+import type { CreditPriceMap } from "./credit-prices.js";
+import { createPortalSession } from "./portal.js";
+import { createSetupIntent } from "./setup-intent.js";
+import type { ITenantCustomerRepository } from "./tenant-store.js";
+
+/** Result from the consumer-supplied webhook handler. */
+export interface StripeWebhookHandlerResult {
+  handled: boolean;
+  event_type: string;
+  tenant?: string;
+  creditedCents?: number;
+  reactivatedBots?: string[];
+  duplicate?: boolean;
+}
+
+export interface StripePaymentProcessorDeps {
+  stripe: Stripe;
+  tenantRepo: ITenantCustomerRepository;
+  webhookSecret: string;
+  priceMap?: CreditPriceMap;
+  creditLedger: ICreditLedger;
+  autoTopupEventLog?: IAutoTopupEventLogRepository;
+  /** Consumer-supplied webhook handler (handles domain-specific event processing). */
+  webhookHandler?: (event: Stripe.Event) => Promise<StripeWebhookHandlerResult>;
+}
+
+export class StripePaymentProcessor implements IPaymentProcessor {
+  readonly name = "stripe";
+
+  private readonly stripe: Stripe;
+  private readonly tenantRepo: ITenantCustomerRepository;
+  private readonly webhookSecret: string;
+  private readonly priceMap: CreditPriceMap;
+  private readonly creditLedger: ICreditLedger;
+  private readonly autoTopupEventLog?: IAutoTopupEventLogRepository;
+  private readonly webhookHandler?: (event: Stripe.Event) => Promise<StripeWebhookHandlerResult>;
+
+  constructor(deps: StripePaymentProcessorDeps) {
+    this.stripe = deps.stripe;
+    this.tenantRepo = deps.tenantRepo;
+    this.webhookSecret = deps.webhookSecret;
+    this.priceMap = deps.priceMap ?? new Map();
+    this.creditLedger = deps.creditLedger;
+    this.autoTopupEventLog = deps.autoTopupEventLog;
+    this.webhookHandler = deps.webhookHandler;
+  }
+
+  async createCheckoutSession(opts: CheckoutOpts): Promise<CheckoutSession> {
+    let priceId: string | undefined = opts.priceId;
+
+    if (!priceId) {
+      // Fall back to looking up by amount when no explicit priceId provided.
+      const amountCents = opts.amount instanceof Credit ? opts.amount.toCentsFloor() : Number(opts.amount);
+
+      for (const [id, point] of this.priceMap.entries()) {
+        if (point.creditCents === amountCents || point.amountCents === amountCents) {
+          priceId = id;
+          break;
+        }
+      }
+
+      if (!priceId) {
+        throw new Error(
+          `No Stripe price tier matches amount ${amountCents} cents. Configure STRIPE_CREDIT_PRICE_* env vars.`,
+        );
+      }
+    }
+
+    const session = await createCreditCheckoutSession(
+      this.stripe,
+      this.tenantRepo as Parameters<typeof createCreditCheckoutSession>[1],
+      {
+        tenant: opts.tenant,
+        priceId,
+        successUrl: opts.successUrl,
+        cancelUrl: opts.cancelUrl,
+      },
+    );
+
+    return {
+      id: session.id,
+      url: session.url ?? "",
+    };
+  }
+
+  async handleWebhook(payload: Buffer, signature: string): Promise<WebhookResult> {
+    const event = this.stripe.webhooks.constructEvent(payload, signature, this.webhookSecret);
+
+    if (!this.webhookHandler) {
+      return { handled: false, eventType: event.type };
+    }
+
+    const result = await this.webhookHandler(event);
+
+    return {
+      handled: result.handled,
+      eventType: result.event_type,
+      tenant: result.tenant,
+      credited: result.creditedCents != null ? Credit.fromCents(result.creditedCents) : undefined,
+      reactivatedBots: result.reactivatedBots,
+      duplicate: result.duplicate,
+    };
+  }
+
+  supportsPortal(): boolean {
+    return true;
+  }
+
+  async createPortalSession(opts: PortalOpts): Promise<{ url: string }> {
+    const session = await createPortalSession(
+      this.stripe,
+      this.tenantRepo as Parameters<typeof createPortalSession>[1],
+      {
+        tenant: opts.tenant,
+        returnUrl: opts.returnUrl,
+      },
+    );
+
+    return { url: session.url };
+  }
+
+  async setupPaymentMethod(tenant: string): Promise<SetupResult> {
+    const intent = await createSetupIntent(this.stripe, this.tenantRepo as Parameters<typeof createSetupIntent>[1], {
+      tenant,
+    });
+
+    return {
+      clientSecret: intent.client_secret ?? "",
+    };
+  }
+
+  async listPaymentMethods(tenant: string): Promise<SavedPaymentMethod[]> {
+    const mapping = await this.tenantRepo.getByTenant(tenant);
+    if (!mapping) {
+      return [];
+    }
+
+    const methods = await this.stripe.customers.listPaymentMethods(mapping.processor_customer_id);
+
+    return methods.data.map((pm, index) => ({
+      id: pm.id,
+      label: formatPaymentMethodLabel(pm),
+      isDefault: index === 0,
+    }));
+  }
+
+  async detachPaymentMethod(tenant: string, paymentMethodId: string): Promise<void> {
+    const mapping = await this.tenantRepo.getByTenant(tenant);
+    if (!mapping) {
+      throw new Error(`No Stripe customer found for tenant: ${tenant}`);
+    }
+
+    const pm = await this.stripe.paymentMethods.retrieve(paymentMethodId);
+    if (!pm.customer || pm.customer !== mapping.processor_customer_id) {
+      throw new PaymentMethodOwnershipError();
+    }
+
+    await this.stripe.paymentMethods.detach(paymentMethodId);
+  }
+
+  async getCustomerEmail(tenantId: string): Promise<string> {
+    const mapping = await this.tenantRepo.getByTenant(tenantId);
+    if (!mapping) {
+      return "";
+    }
+
+    const customer = await this.stripe.customers.retrieve(mapping.processor_customer_id);
+    if (customer.deleted) {
+      return "";
+    }
+    return customer.email ?? "";
+  }
+
+  async updateCustomerEmail(tenantId: string, email: string): Promise<void> {
+    const mapping = await this.tenantRepo.getByTenant(tenantId);
+    if (!mapping) {
+      throw new Error(`No Stripe customer found for tenant: ${tenantId}`);
+    }
+
+    await this.stripe.customers.update(mapping.processor_customer_id, { email });
+  }
+
+  async listInvoices(tenantId: string): Promise<Invoice[]> {
+    const mapping = await this.tenantRepo.getByTenant(tenantId);
+    if (!mapping) {
+      return [];
+    }
+
+    const invoices = await this.stripe.invoices.list({
+      customer: mapping.processor_customer_id,
+      limit: 24,
+    });
+
+    return invoices.data.map((inv) => ({
+      id: inv.id,
+      date: new Date(inv.created * 1000).toISOString(),
+      amountCents: inv.amount_due,
+      status: inv.status ?? "unknown",
+      downloadUrl: inv.invoice_pdf ?? "",
+    }));
+  }
+
+  async charge(opts: ChargeOpts): Promise<ChargeResult> {
+    if (!this.autoTopupEventLog) {
+      throw new Error("autoTopupEventLog is required for charge()");
+    }
+
+    const amount = opts.amount instanceof Credit ? opts.amount : Credit.fromCents(Number(opts.amount));
+
+    const result = await chargeAutoTopup(
+      {
+        stripe: this.stripe,
+        tenantRepo: this.tenantRepo,
+        creditLedger: this.creditLedger,
+        eventLogRepo: this.autoTopupEventLog,
+      },
+      opts.tenant,
+      amount,
+      opts.source,
+    );
+
+    return {
+      success: result.success,
+      paymentReference: result.paymentReference,
+      error: result.error,
+    };
+  }
+}
+
+function formatPaymentMethodLabel(pm: Stripe.PaymentMethod): string {
+  if (pm.card) {
+    const brand = pm.card.brand.charAt(0).toUpperCase() + pm.card.brand.slice(1);
+    return `${brand} ending ${pm.card.last4}`;
+  }
+  return `Payment method ${pm.id}`;
+}

package/src/billing/stripe/tenant-store.test.ts

@@ -0,0 +1,124 @@
+import type { PGlite } from "@electric-sql/pglite";
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import type { PlatformDb } from "../../db/index.js";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../../test/db.js";
+import { TenantCustomerRepository } from "./tenant-store.js";
+
+describe("TenantCustomerRepository", () => {
+  let pool: PGlite;
+  let db: PlatformDb;
+  let store: TenantCustomerRepository;
+
+  beforeAll(async () => {
+    ({ db, pool } = await createTestDb());
+    await beginTestTransaction(pool);
+  });
+
+  afterAll(async () => {
+    await endTestTransaction(pool);
+    await pool.close();
+  });
+
+  beforeEach(async () => {
+    await rollbackTestTransaction(pool);
+    store = new TenantCustomerRepository(db);
+  });
+
+  describe("upsert and getByTenant", () => {
+    it("inserts a new tenant mapping", async () => {
+      await store.upsert({ tenant: "t-1", processorCustomerId: "cus_abc" });
+      const row = await store.getByTenant("t-1");
+
+      expect(row).not.toBeNull();
+      expect(row?.tenant).toBe("t-1");
+      expect(row?.processor_customer_id).toBe("cus_abc");
+      expect(row?.tier).toBe("free");
+    });
+
+    it("updates existing mapping on conflict", async () => {
+      await store.upsert({ tenant: "t-1", processorCustomerId: "cus_old" });
+      await store.upsert({ tenant: "t-1", processorCustomerId: "cus_new" });
+
+      const row = await store.getByTenant("t-1");
+      expect(row?.processor_customer_id).toBe("cus_new");
+    });
+
+    it("returns null for non-existent tenant", async () => {
+      expect(await store.getByTenant("nonexistent")).toBeNull();
+    });
+  });
+
+  describe("getByProcessorCustomerId", () => {
+    it("looks up by processor customer ID", async () => {
+      await store.upsert({ tenant: "t-1", processorCustomerId: "cus_lookup" });
+      const row = await store.getByProcessorCustomerId("cus_lookup");
+
+      expect(row).not.toBeNull();
+      expect(row?.tenant).toBe("t-1");
+    });
+
+    it("returns null for unknown processor customer", async () => {
+      expect(await store.getByProcessorCustomerId("cus_unknown")).toBeNull();
+    });
+  });
+
+  describe("setTier", () => {
+    it("updates the tier for a tenant", async () => {
+      await store.upsert({ tenant: "t-1", processorCustomerId: "cus_abc" });
+      await store.setTier("t-1", "enterprise");
+
+      const row = await store.getByTenant("t-1");
+      expect(row?.tier).toBe("enterprise");
+    });
+  });
+
+  describe("setBillingHold and hasBillingHold", () => {
+    it("sets and checks billing hold", async () => {
+      await store.upsert({ tenant: "t-1", processorCustomerId: "cus_abc" });
+
+      expect(await store.hasBillingHold("t-1")).toBe(false);
+
+      await store.setBillingHold("t-1", true);
+      expect(await store.hasBillingHold("t-1")).toBe(true);
+
+      await store.setBillingHold("t-1", false);
+      expect(await store.hasBillingHold("t-1")).toBe(false);
+    });
+
+    it("returns false for non-existent tenant", async () => {
+      expect(await store.hasBillingHold("nonexistent")).toBe(false);
+    });
+  });
+
+  describe("list", () => {
+    it("returns all tenant mappings", async () => {
+      await store.upsert({ tenant: "t-1", processorCustomerId: "cus_1" });
+      await store.upsert({ tenant: "t-2", processorCustomerId: "cus_2" });
+      await store.upsert({ tenant: "t-3", processorCustomerId: "cus_3" });
+
+      const rows = await store.list();
+      expect(rows).toHaveLength(3);
+    });
+
+    it("returns empty array when no tenants exist", async () => {
+      expect(await store.list()).toHaveLength(0);
+    });
+  });
+
+  describe("buildCustomerIdMap", () => {
+    it("builds a tenant->processorCustomerId map", async () => {
+      await store.upsert({ tenant: "t-1", processorCustomerId: "cus_1" });
+      await store.upsert({ tenant: "t-2", processorCustomerId: "cus_2" });
+
+      const map = await store.buildCustomerIdMap();
+      expect(map).toEqual({
+        "t-1": "cus_1",
+        "t-2": "cus_2",
+      });
+    });
+
+    it("returns empty object when no tenants exist", async () => {
+      expect(await store.buildCustomerIdMap()).toEqual({});
+    });
+  });
+});

package/src/billing/stripe/tenant-store.ts

@@ -0,0 +1,151 @@
+import { desc, eq } from "drizzle-orm";
+import type { PlatformDb } from "../../db/index.js";
+import { tenantCustomers } from "../../db/schema/tenant-customers.js";
+import type { TenantCustomerRow } from "./types.js";
+
+export interface ITenantCustomerRepository {
+  getByTenant(tenant: string): Promise<TenantCustomerRow | null>;
+  getByProcessorCustomerId(processorCustomerId: string): Promise<TenantCustomerRow | null>;
+  upsert(row: { tenant: string; processorCustomerId: string; tier?: string }): Promise<void>;
+  setTier(tenant: string, tier: string): Promise<void>;
+  setBillingHold(tenant: string, hold: boolean): Promise<void>;
+  hasBillingHold(tenant: string): Promise<boolean>;
+  getInferenceMode(tenant: string): Promise<string>;
+  setInferenceMode(tenant: string, mode: string): Promise<void>;
+  list(): Promise<TenantCustomerRow[]>;
+  buildCustomerIdMap(): Promise<Record<string, string>>;
+}
+
+/**
+ * Manages tenant-to-payment-processor customer mappings in PostgreSQL.
+ *
+ * This is the bridge between WOPR tenant IDs and processor customer IDs.
+ * All billing operations look up the processor customer via this store.
+ *
+ * Note: No subscription tracking — WOPR uses credits, not subscriptions.
+ * Credit balances are managed by ICreditLedger / DrizzleCreditLedger.
+ */
+export class DrizzleTenantCustomerRepository implements ITenantCustomerRepository {
+  constructor(private readonly db: PlatformDb) {}
+
+  /** Get a tenant's processor mapping. */
+  async getByTenant(tenant: string): Promise<TenantCustomerRow | null> {
+    const row = (await this.db.select().from(tenantCustomers).where(eq(tenantCustomers.tenant, tenant)))[0];
+    return row ? mapRow(row) : null;
+  }
+
+  /** Get a tenant mapping by processor customer ID. */
+  async getByProcessorCustomerId(processorCustomerId: string): Promise<TenantCustomerRow | null> {
+    const row = (
+      await this.db.select().from(tenantCustomers).where(eq(tenantCustomers.processorCustomerId, processorCustomerId))
+    )[0];
+    return row ? mapRow(row) : null;
+  }
+
+  /** Upsert a tenant-to-customer mapping. */
+  async upsert(row: { tenant: string; processorCustomerId: string; tier?: string }): Promise<void> {
+    const now = Date.now();
+    await this.db
+      .insert(tenantCustomers)
+      .values({
+        tenant: row.tenant,
+        processorCustomerId: row.processorCustomerId,
+        tier: row.tier ?? "free",
+        createdAt: now,
+        updatedAt: now,
+      })
+      .onConflictDoUpdate({
+        target: tenantCustomers.tenant,
+        set: {
+          processorCustomerId: row.processorCustomerId,
+          tier: row.tier !== undefined ? row.tier : undefined,
+          updatedAt: now,
+        },
+      });
+  }
+
+  /** Update the tier for a tenant. */
+  async setTier(tenant: string, tier: string): Promise<void> {
+    await this.db
+      .update(tenantCustomers)
+      .set({ tier, updatedAt: Date.now() })
+      .where(eq(tenantCustomers.tenant, tenant));
+  }
+
+  /** Set or clear the billing hold flag for a tenant. */
+  async setBillingHold(tenant: string, hold: boolean): Promise<void> {
+    await this.db
+      .update(tenantCustomers)
+      .set({ billingHold: hold ? 1 : 0, updatedAt: Date.now() })
+      .where(eq(tenantCustomers.tenant, tenant));
+  }
+
+  /** Check whether a tenant has an active billing hold. */
+  async hasBillingHold(tenant: string): Promise<boolean> {
+    const row = (
+      await this.db
+        .select({ billingHold: tenantCustomers.billingHold })
+        .from(tenantCustomers)
+        .where(eq(tenantCustomers.tenant, tenant))
+    )[0];
+    return row?.billingHold === 1;
+  }
+
+  /** Get inference mode for a tenant (defaults to "byok"). */
+  async getInferenceMode(tenant: string): Promise<string> {
+    const row = (
+      await this.db
+        .select({ inferenceMode: tenantCustomers.inferenceMode })
+        .from(tenantCustomers)
+        .where(eq(tenantCustomers.tenant, tenant))
+    )[0];
+    return row?.inferenceMode ?? "byok";
+  }
+
+  /** Set inference mode for a tenant. */
+  async setInferenceMode(tenant: string, mode: string): Promise<void> {
+    await this.db
+      .update(tenantCustomers)
+      .set({ inferenceMode: mode, updatedAt: Date.now() })
+      .where(eq(tenantCustomers.tenant, tenant));
+  }
+
+  /** List all tenants with processor mappings. */
+  async list(): Promise<TenantCustomerRow[]> {
+    const rows = await this.db.select().from(tenantCustomers).orderBy(desc(tenantCustomers.createdAt));
+    return rows.map(mapRow);
+  }
+
+  /** Build a tenant -> processor_customer_id map for use with UsageAggregationWorker. */
+  async buildCustomerIdMap(): Promise<Record<string, string>> {
+    const rows = await this.db
+      .select({
+        tenant: tenantCustomers.tenant,
+        processorCustomerId: tenantCustomers.processorCustomerId,
+      })
+      .from(tenantCustomers);
+
+    const map: Record<string, string> = {};
+    for (const row of rows) {
+      map[row.tenant] = row.processorCustomerId;
+    }
+    return map;
+  }
+}
+
+/** Map a Drizzle row to the TenantCustomerRow interface (snake_case field names). */
+function mapRow(row: typeof tenantCustomers.$inferSelect): TenantCustomerRow {
+  return {
+    tenant: row.tenant,
+    processor_customer_id: row.processorCustomerId,
+    processor: row.processor,
+    tier: row.tier,
+    billing_hold: row.billingHold,
+    inference_mode: row.inferenceMode,
+    created_at: row.createdAt,
+    updated_at: row.updatedAt,
+  };
+}
+
+// Backward-compat alias.
+export { DrizzleTenantCustomerRepository as TenantCustomerRepository };

package/src/billing/stripe/types.ts

@@ -0,0 +1,53 @@
+/** Tenant-to-payment-processor customer mapping stored in SQLite. */
+export interface TenantCustomerRow {
+  tenant: string;
+  processor_customer_id: string;
+  processor: string;
+  tier: string;
+  billing_hold: number;
+  inference_mode: string;
+  created_at: number;
+  updated_at: number;
+}
+
+/** Options for creating a Stripe credit purchase Checkout session. */
+export interface CreditCheckoutOpts {
+  /** Internal tenant ID. */
+  tenant: string;
+  /** Stripe Price ID for the credit purchase. */
+  priceId: string;
+  /** URL to redirect to after successful checkout. */
+  successUrl: string;
+  /** URL to redirect to if the user cancels checkout. */
+  cancelUrl: string;
+}
+
+/** Options for creating a Stripe Customer Portal session. */
+export interface PortalSessionOpts {
+  /** Internal tenant ID (used to look up Stripe customer). */
+  tenant: string;
+  /** URL to redirect to when the user is done managing billing. */
+  returnUrl: string;
+}
+
+/** Options for creating a Stripe VPS subscription Checkout session. */
+export interface VpsCheckoutOpts {
+  /** Internal tenant ID. */
+  tenant: string;
+  /** Bot instance ID being upgraded. */
+  botId: string;
+  /** Stripe Price ID for the VPS subscription. */
+  vpsPriceId: string;
+  /** URL to redirect to after successful checkout. */
+  successUrl: string;
+  /** URL to redirect to if the user cancels checkout. */
+  cancelUrl: string;
+}
+
+/** Configuration for the Stripe billing integration. */
+export interface StripeBillingConfig {
+  /** Stripe secret API key. */
+  secretKey: string;
+  /** Stripe webhook signing secret. */
+  webhookSecret: string;
+}

package/src/billing/webhook-seen-repository.ts

@@ -0,0 +1,24 @@
+import type { WebhookSeenEvent } from "../credits/repository-types.js";
+
+export interface IWebhookSeenRepository {
+  /** Returns true if the event ID + source combination has already been seen. */
+  isDuplicate(eventId: string, source: string): Promise<boolean>;
+  /** Mark an event ID + source as seen. */
+  markSeen(eventId: string, source: string): Promise<WebhookSeenEvent>;
+  /** Delete entries older than ttlMs. Returns count of deleted rows. */
+  purgeExpired(ttlMs: number): Promise<number>;
+}
+
+/**
+ * No-op replay guard that never reports duplicates.
+ * Use in tests that don't need deduplication behaviour.
+ */
+export const noOpReplayGuard: IWebhookSeenRepository = {
+  isDuplicate: async () => false,
+  markSeen: async (eventId: string, source: string): Promise<WebhookSeenEvent> => ({
+    eventId,
+    source,
+    seenAt: Date.now(),
+  }),
+  purgeExpired: async () => 0,
+};

package/src/config/billing-env.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+
+// We test the schema directly, not the singleton config export,
+// because the singleton is already parsed at import time.
+// Instead we test the schema shape by importing and re-parsing.
+
+describe("billing env validation", () => {
+  it("uses correct defaults when no env vars set", async () => {
+    // Dynamic import to test schema defaults
+    const { billingConfigSchema } = await import("./index.js");
+    const result = billingConfigSchema.parse({});
+    expect(result).toEqual({
+      affiliateMatchRate: 1.0,
+      affiliateMaxReferrals30d: 20,
+      affiliateMaxMatchCredits30d: 20000,
+      affiliateNewUserBonusRate: 0.2,
+      dividendMatchRate: 1.0,
+      meterMaxRetries: 3,
+    });
+  });
+
+  it("coerces valid string values to numbers", async () => {
+    const { billingConfigSchema } = await import("./index.js");
+    const result = billingConfigSchema.parse({
+      affiliateMatchRate: "0.5",
+      affiliateMaxReferrals30d: "10",
+      affiliateMaxMatchCredits30d: "5000",
+      affiliateNewUserBonusRate: "0.15",
+      dividendMatchRate: "0.75",
+      meterMaxRetries: "5",
+    });
+    expect(result.affiliateMatchRate).toBe(0.5);
+    expect(result.affiliateMaxReferrals30d).toBe(10);
+    expect(result.affiliateMaxMatchCredits30d).toBe(5000);
+    expect(result.affiliateNewUserBonusRate).toBe(0.15);
+    expect(result.dividendMatchRate).toBe(0.75);
+    expect(result.meterMaxRetries).toBe(5);
+  });
+
+  it("rejects non-numeric strings", async () => {
+    const { billingConfigSchema } = await import("./index.js");
+    expect(() => billingConfigSchema.parse({ affiliateMatchRate: "not-a-number" })).toThrow();
+  });
+
+  it("rejects negative rates", async () => {
+    const { billingConfigSchema } = await import("./index.js");
+    expect(() => billingConfigSchema.parse({ affiliateMatchRate: "-0.5" })).toThrow();
+  });
+
+  it("rejects non-integer retries", async () => {
+    const { billingConfigSchema } = await import("./index.js");
+    expect(() => billingConfigSchema.parse({ meterMaxRetries: "2.5" })).toThrow();
+  });
+});