@camphoric/camphoric-event-import-tools 2.1.0 → 2.2.0

package/e2eAdmin.ts

@@ -0,0 +1,174 @@
+/**
+ * What an organizer does in the admin, for an event's e2e tests: invitations
+ * to register as a registration type, and the emails the server sent. It
+ * uses the admin API (as the admin client does), signed in as the admin the
+ * event was imported as, so tests don't drive the admin's own pages.
+ */
+
+import { randomBytes } from 'node:crypto';
+
+/** An invitation to register as one of the event's registration types. */
+export interface E2EInvitation {
+  id: number;
+  // The invitation's code and the address it's for (the registration form's
+  // `code` and `email`)
+  code: string;
+  email: string;
+  // The registration form with the invitation, as a path to open (the
+  // server's register_link, on whichever server the tests use)
+  registerUrl: string;
+}
+
+export interface InviteOptions {
+  // Who it's for (default: a new @example.com address, so it's unused)
+  email?: string;
+  name?: string;
+  // Also email it, as the admin's "Invite" does (default: no). The email is
+  // the registration type's invitation email, read back with emails().
+  send?: boolean;
+}
+
+/** An email the server sent (or queued), from its outbox. */
+export interface SentEmail {
+  id: number;
+  // confirmation, invitation, invoice, bulk, …
+  kind: string;
+  // queued, sending, sent, failed or cancelled; the throwaway server sends
+  // as it queues, so its email is sent (or failed, with lastError) at once
+  status: string;
+  to: string;
+  from: string;
+  replyTo: string;
+  subject: string;
+  text: string;
+  html: string;
+  lastError: string;
+  registration: number | null;
+  invitation: number | null;
+}
+
+export interface EmailsOptions {
+  // Only email to this address (any case)
+  to?: string;
+  // Only email of this kind, e.g. 'confirmation'
+  kind?: string;
+}
+
+interface Page<T> {
+  next: string | null;
+  results: T[];
+}
+
+interface EmailMessage {
+  id: number;
+  kind: string;
+  status: string;
+  to: string;
+  from_email: string;
+  reply_to: string;
+  subject: string;
+  text: string;
+  html: string;
+  last_error: string;
+  registration: number | null;
+  invitation: number | null;
+}
+
+// The address in "Name <address>", or the whole of a bare one
+const address = (recipient: string) => (/<([^>]*)>\s*$/.exec(recipient)?.[1] ?? recipient).trim().toLowerCase();
+
+export class CamphoricAdmin {
+  readonly url: string;
+  readonly eventId: number;
+  private readonly token: string;
+
+  constructor(url: string, token: string, eventId: number) {
+    this.url = url.replace(/\/$/, '');
+    this.token = token;
+    this.eventId = eventId;
+  }
+
+  /**
+   * Creates an invitation to register as the registration type with this
+   * `name` (its name in the event's data, not its label), as the admin's
+   * "Invite a special registration" does. Open its form with
+   * `page.goto(invitation.registerUrl)`.
+   */
+  async invite(registrationType: string, options: InviteOptions = {}): Promise<E2EInvitation> {
+    const types = await this.request<{ id: number, name: string }[]>(
+      'GET', `/api/registrationtypes/?event=${this.eventId}`);
+    const type = types.find(t => t.name === registrationType);
+    if (!type) {
+      const names = types.map(t => t.name).join(', ') || 'none';
+      throw new Error(`the event has no registration type named '${registrationType}' (it has: ${names})`);
+    }
+    const email = options.email ?? `e2e.invitee.${randomBytes(4).toString('hex')}@example.com`;
+    const invitation = await this.request<{ id: number, invitation_code: string, register_link: string }>(
+      'POST', '/api/invitations/', {
+        registration_type: type.id,
+        recipient_name: options.name ?? '',
+        recipient_email: email,
+      });
+    if (options.send) await this.request('POST', `/api/invitations/${invitation.id}/send`);
+    const link = new URL(invitation.register_link, this.url);
+    return {
+      id: invitation.id,
+      code: invitation.invitation_code,
+      email,
+      registerUrl: `${link.pathname}${link.search}`,
+    };
+  }
+
+  /**
+   * The emails the server sent about the event (its outbox), newest first,
+   * with what each said. Email is recorded as the request that sends it ends,
+   * so after a registration it's there when the page has moved on; to wait
+   * for one: `await expect.poll(async () => (await admin.emails({ to })).length).toBe(1)`.
+   */
+  async emails(options: EmailsOptions = {}): Promise<SentEmail[]> {
+    const query = new URLSearchParams({ event: String(this.eventId) });
+    if (options.to) query.set('q', address(options.to));
+    if (options.kind) query.set('kind', options.kind);
+    const listed: { id: number, to: string }[] = [];
+    let next: string | null = `/api/emailmessages/?${query}`;
+    while (next) {
+      const page: Page<{ id: number, to: string }> = await this.request('GET', next);
+      listed.push(...page.results);
+      // (Its path only: behind a proxy the server may name itself by another
+      // scheme or host, where the token wouldn't be sent)
+      next = page.next ? `${new URL(page.next).pathname}${new URL(page.next).search}` : null;
+    }
+    // (q matches part of the recipient or subject)
+    const wanted = options.to ? listed.filter(m => address(m.to) === address(options.to ?? '')) : listed;
+    const messages = await Promise.all(wanted.map(m => this.request<EmailMessage>('GET', `/api/emailmessages/${m.id}/`)));
+    return messages.map(m => ({
+      id: m.id,
+      kind: m.kind,
+      status: m.status,
+      to: m.to,
+      from: m.from_email,
+      replyTo: m.reply_to,
+      subject: m.subject,
+      text: m.text,
+      html: m.html,
+      lastError: m.last_error,
+      registration: m.registration,
+      invitation: m.invitation,
+    }));
+  }
+
+  private async request<T = unknown>(method: string, path: string, body?: unknown): Promise<T> {
+    const url = new URL(path, this.url);
+    const response = await fetch(url, {
+      method,
+      headers: {
+        'Authorization': `Token ${this.token}`,
+        ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+      },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    const text = await response.text();
+    if (!response.ok) throw new Error(`${method} ${url.pathname} answered ${response.status}: ${text}`);
+    return (text ? JSON.parse(text) : undefined) as T;
+  }
+}

package/e2eFakePayPal.py

@@ -0,0 +1,112 @@
+'''
+PayPal's Orders API, faked for an event's e2e tests (e2e-compose.yml runs it
+on the app image's Python, as the server's PAYPAL_BASE_URL). Only the Python
+standard library, so the image needs nothing more.
+
+It creates the orders the server asks for and keeps what each asked, for the
+tests to read (FakePayPal in e2ePayPal.ts):
+
+    GET /e2e/orders         every order created, oldest first
+    GET /e2e/orders/<id>    one, as {id, request_id, body}: body is the
+                            request the server sent, its amounts as sent
+
+No order is ever approved, so a capture is refused as PayPal refuses one the
+payer hasn't approved, and nothing is paid.
+'''
+
+import itertools
+import json
+import re
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+orders = {}  # id: {id, request_id, body}, in the order they were created
+by_request_id = {}  # PayPal-Request-Id: order id (a retried create returns the first)
+lock = threading.Lock()
+numbers = itertools.count(1)
+
+ORDER = re.compile(r'^/v2/checkout/orders/([A-Z0-9]+)$')
+CAPTURE = re.compile(r'^/v2/checkout/orders/([A-Z0-9]+)/capture$')
+RECORDED = re.compile(r'^/e2e/orders/([A-Z0-9]+)$')
+
+
+def order_response(order):
+    '''An order as PayPal returns it (Prefer: return=representation).'''
+    body = order['body']
+    return {
+        'id': order['id'],
+        'intent': body.get('intent'),
+        'status': 'CREATED',
+        'purchase_units': body.get('purchase_units', []),
+        'links': [],
+    }
+
+
+class Handler(BaseHTTPRequestHandler):
+    def send_json(self, status, data):
+        payload = json.dumps(data).encode()
+        self.send_response(status)
+        self.send_header('Content-Type', 'application/json')
+        self.send_header('Content-Length', str(len(payload)))
+        self.end_headers()
+        self.wfile.write(payload)
+
+    def not_found(self):
+        self.send_json(404, {'name': 'RESOURCE_NOT_FOUND', 'message': 'No such resource.'})
+
+    def read_json(self):
+        length = int(self.headers.get('Content-Length') or 0)
+        if not length:
+            return {}
+        return json.loads(self.rfile.read(length))
+
+    def do_GET(self):
+        if self.path == '/health':
+            return self.send_json(200, {'ok': True})
+        if self.path == '/e2e/orders':
+            with lock:
+                return self.send_json(200, list(orders.values()))
+        match = RECORDED.match(self.path) or ORDER.match(self.path)
+        if match:
+            with lock:
+                order = orders.get(match.group(1))
+            if order is None:
+                return self.not_found()
+            return self.send_json(200, order if self.path.startswith('/e2e/') else order_response(order))
+        return self.not_found()
+
+    def do_POST(self):
+        if self.path == '/v2/checkout/orders':
+            body = self.read_json()
+            request_id = self.headers.get('PayPal-Request-Id')
+            with lock:
+                if request_id and request_id in by_request_id:
+                    order = orders[by_request_id[request_id]]
+                else:
+                    order = {'id': f'E2EORDER{next(numbers):06d}', 'request_id': request_id, 'body': body}
+                    orders[order['id']] = order
+                    if request_id:
+                        by_request_id[request_id] = order['id']
+            return self.send_json(201, order_response(order))
+        match = CAPTURE.match(self.path)
+        if match:
+            with lock:
+                known = match.group(1) in orders
+            if not known:
+                return self.not_found()
+            return self.send_json(422, {
+                'name': 'UNPROCESSABLE_ENTITY',
+                'message': 'The requested action could not be performed.',
+                'details': [{
+                    'issue': 'ORDER_NOT_APPROVED',
+                    'description': 'The payer has not approved this order (a fake PayPal never does).',
+                }],
+            })
+        return self.not_found()
+
+    def log_message(self, format, *args):
+        print(f'fake PayPal: {format % args}', flush=True)
+
+
+if __name__ == '__main__':
+    ThreadingHTTPServer(('0.0.0.0', 8000), Handler).serve_forever()

package/e2eImport.ts

@@ -4,6 +4,7 @@
 
 import { getAuthToken } from './getAuthInfo.ts';
 import CamphoricEventCreator from './CamphoricEventCreator.ts';
+import { E2E_PAYPAL_CLIENT_ID } from './e2ePayPal.ts';
 import { Organizations, organizationLoader } from './organizations.ts';
 import type { ImportableEvent } from './types.ts';
 
@@ -22,12 +23,19 @@ export interface ImportForE2EOptions {
   // the page says registration is closed and shows no form). Its other dates
   // are unchanged.
   openRegistration?: boolean;
+  // Take payments online (default: no, unless the event's data does): PayPal
+  // is enabled with a client id only the fake PayPal accepts, so the payment
+  // step offers PayPal's buttons and adds the event's e-payment handling.
+  // Only for a throwaway server, whose PayPal is the fake (setUpEvent refuses
+  // it for an existing one).
+  onlinePayment?: boolean;
 }
 
 /** Imports the event (and creates its organization), returning its id. */
 export async function importForE2E(options: ImportForE2EOptions): Promise<number> {
   const {
     event, validate, url, username, password, withSampleRegistrations = false, openRegistration = true,
+    onlinePayment = false,
   } = options;
   // The fetcher logs in with these
   process.env.DJANGO_SUPERUSER_USERNAME = username;
@@ -41,7 +49,10 @@ export async function importForE2E(options: ImportForE2EOptions): Promise<number
     registration_start: new Date(Date.now() - day).toISOString(),
     registration_end: new Date(Date.now() + 365 * day).toISOString(),
   };
-  const data = openRegistration ? { ...event.data, event: { ...event.data.event, ...window } } : event.data;
+  const payPal = { paypal_enabled: true, paypal_client_id: E2E_PAYPAL_CLIENT_ID };
+  // Set again afterwards too, like the window
+  const changes = { ...(openRegistration ? window : {}), ...(onlinePayment ? payPal : {}) };
+  const data = { ...event.data, event: { ...event.data.event, ...changes } };
 
   const token = await getAuthToken(url);
   const organization = await organizationLoader(token, url)(event.organization);
@@ -55,7 +66,7 @@ export async function importForE2E(options: ImportForE2EOptions): Promise<number
   });
   await creator.create();
   const { id } = creator.savedEvent();
-  if (openRegistration) await creator.fetch('PATCH', `/api/events/${id}/`, window);
+  if (Object.keys(changes).length) await creator.fetch('PATCH', `/api/events/${id}/`, changes);
 
   return id;
 }

package/e2ePayPal.ts

@@ -0,0 +1,129 @@
+/**
+ * PayPal, faked for an event's e2e tests. The throwaway server's PayPal API is
+ * e2eFakePayPal.py, and the browser's PayPal script is FAKE_PAYPAL_SDK (the
+ * `test` fixture serves it in place of PayPal's), so the payment step's
+ * PayPal buttons work without a PayPal account and nothing is paid.
+ */
+
+/** What the server asked PayPal for, as e2eFakePayPal.py recorded it. */
+export interface PayPalOrder {
+  // PayPal's order id, as the browser was given it
+  id: string;
+  // The order's amount as the server sent it, e.g. '102.50' (a string, so
+  // its decimal places can be checked), and its currency
+  amount: string;
+  currency: string;
+  // The whole request the server sent to create the order
+  body: Record<string, unknown>;
+}
+
+interface RecordedOrder {
+  id: string;
+  body: { purchase_units?: { amount?: { value?: string, currency_code?: string } }[] };
+}
+
+// The client id an event is imported with for online payment (e2eImport.ts):
+// only the fakes accept it
+export const E2E_PAYPAL_CLIENT_ID = 'camphoric-e2e-fake-paypal';
+
+// PayPal's script, wherever the client loads it from
+export const PAYPAL_SDK_URL = /^https:\/\/www\.(sandbox\.)?paypal\.com\/sdk\/js(\?|$)/;
+
+/** The fake PayPal API's record of the orders the server created. */
+export class FakePayPal {
+  readonly url: string;
+
+  constructor(url: string) {
+    this.url = url.replace(/\/$/, '');
+  }
+
+  /** Every order the server created, oldest first. */
+  async orders(): Promise<PayPalOrder[]> {
+    const recorded = await this.get('/e2e/orders') as RecordedOrder[];
+    return recorded.map(order);
+  }
+
+  /** The order with this id, as the server asked for it. */
+  async order(id: string): Promise<PayPalOrder> {
+    return order(await this.get(`/e2e/orders/${encodeURIComponent(id)}`) as RecordedOrder);
+  }
+
+  private async get(path: string): Promise<unknown> {
+    const response = await fetch(`${this.url}${path}`);
+    if (!response.ok) {
+      throw new Error(`the fake PayPal answered ${response.status} to ${path}: ${await response.text()}`);
+    }
+    return response.json();
+  }
+}
+
+function order(recorded: RecordedOrder): PayPalOrder {
+  const amount = recorded.body.purchase_units?.[0]?.amount;
+  return {
+    id: recorded.id,
+    amount: amount?.value ?? '',
+    currency: amount?.currency_code ?? '',
+    body: recorded.body as Record<string, unknown>,
+  };
+}
+
+/**
+ * PayPal's browser script, faked: `paypal.Buttons()` draws a "PayPal" and a
+ * "Debit or Credit Card" button, as the client's PayPal library expects. A
+ * click does what PayPal's does up to its popup: onClick, then createOrder
+ * (which asks the server for the order). The popup then stays "open": the
+ * payer never approves or cancels, so nothing is captured.
+ */
+export const FAKE_PAYPAL_SDK = `(() => {
+  const buttons = [['paypal', 'PayPal'], ['card', 'Debit or Credit Card']];
+  window.paypal = {
+    version: 'camphoric-e2e-fake',
+    FUNDING: { PAYPAL: 'paypal', CARD: 'card' },
+    Buttons(props) {
+      let container = null;
+      const elements = [];
+      // Disabled (as the client does while it's busy) by the buttons' own
+      // attribute, so a test's click waits until they're enabled
+      const setDisabled = (disabled) => {
+        for (const button of elements) button.disabled = disabled;
+        return Promise.resolve();
+      };
+      const actions = { enable: () => setDisabled(false), disable: () => setDisabled(true) };
+      const pay = async (fundingSource) => {
+        const data = { fundingSource };
+        const clickActions = { resolve: () => Promise.resolve(), reject: () => Promise.resolve() };
+        if (props.onClick && (await props.onClick(data, clickActions)) === false) return;
+        try {
+          await props.createOrder(data, {});
+        } catch (error) {
+          if (props.onError) props.onError(error);
+        }
+      };
+      return {
+        isEligible: () => true,
+        render(target) {
+          container = typeof target === 'string' ? document.querySelector(target) : target;
+          const box = document.createElement('div');
+          box.setAttribute('data-camphoric-e2e-paypal', '');
+          for (const [fundingSource, label] of buttons) {
+            const button = document.createElement('button');
+            button.type = 'button';
+            button.textContent = label;
+            button.addEventListener('click', () => { pay(fundingSource); });
+            elements.push(button);
+            box.appendChild(button);
+          }
+          container.appendChild(box);
+          if (props.onInit) props.onInit({}, actions);
+          return Promise.resolve();
+        },
+        updateProps: () => Promise.resolve(),
+        close() {
+          if (container) container.replaceChildren();
+          return Promise.resolve();
+        },
+      };
+    },
+  };
+})();
+`;

package/e2eRegistrationForm.ts

@@ -83,6 +83,56 @@ export class FormSection {
   message(text: string | RegExp): Locator {
     return this.root.getByText(text);
   }
+
+  /**
+   * A list question (an array of objects in the event's schema, such as a
+   * camper's parking passes), by its title: its items, and adding and
+   * removing them. A camper's list is the camper's: `camper(n).list(title)`
+   * (on the whole form, every camper's list has that title).
+   */
+  list(title: string): ListQuestion {
+    // The list's own title (its heading, a child of the list's box), not
+    // that of a list inside one of its items
+    const heading = this.page.locator(':scope > h3').filter({ hasText: new RegExp(`^${escapeRegExp(title)}$`) });
+    return new ListQuestion(this.page, this.root.locator('.rjsf-field-array').filter({ has: heading }));
+  }
+}
+
+/** A list question's items, each with questions of its own (FormSection.list). */
+export class ListQuestion {
+  readonly page: Page;
+  readonly root: Locator;
+
+  constructor(page: Page, root: Locator) {
+    this.page = page;
+    this.root = root;
+  }
+
+  /** Its items, in order: count them with `expect(list.items()).toHaveCount(n)`. */
+  items(): Locator {
+    return this.root.locator(':scope > .rjsf-array-item-list > .rjsf-array-item');
+  }
+
+  /** The nth item's questions (from 1). */
+  item(n: number): FormSection {
+    return new FormSection(this.page, this.items().nth(n - 1));
+  }
+
+  /** Adds an item (its "Add …" button), returning its questions. */
+  async add(): Promise<FormSection> {
+    const count = await this.items().count();
+    await this.root.locator(':scope > * > .rjsf-array-item-add').click();
+    await expect(this.items()).toHaveCount(count + 1);
+    return this.item(count + 1);
+  }
+
+  /** Removes the nth item (from 1), with its × button. */
+  async remove(n: number): Promise<void> {
+    const count = await this.items().count();
+    await this.items().nth(n - 1).locator(':scope > .rjsf-array-item-toolbar')
+      .getByRole('button', { name: 'Remove', exact: true }).click();
+    await expect(this.items()).toHaveCount(count - 1);
+  }
 }
 
 /** One camper's questions, under its "1st Camper", "2nd Camper", … heading. */
@@ -154,6 +204,18 @@ export class RegistrationForm extends FormSection {
     return this.camper(count + 1);
   }
 
+  /**
+   * Removes the nth camper (from 1), with the Remove button by its heading;
+   * the campers after it move up (the 3rd becomes the 2nd).
+   */
+  async removeCamper(n: number): Promise<void> {
+    const count = await this.page.locator('.camphoric-camper').count();
+    // (The heading's row, not the Remove buttons of the camper's lists)
+    await this.camper(n).root.locator(':scope > .mantine-Group-root')
+      .getByRole('button', { name: 'Remove', exact: true }).click();
+    await expect(this.page.locator('.camphoric-camper')).toHaveCount(count - 1);
+  }
+
   /** Waits until the price ticker shows this total (in dollars). */
   async expectTotal(amount: number): Promise<void> {
     await expect(this.page.getByText(/^Total: /)).toHaveText(`Total: ${money(amount)}`);
@@ -187,4 +249,50 @@ export class RegistrationForm extends FormSection {
   async payByCheck(): Promise<void> {
     await this.page.getByRole('button', { name: /by check$/ }).click();
   }
+
+  /**
+   * On the payment step: what the chosen payment option costs, in dollars,
+   * as it shows it: by check (the default), or online, which adds the
+   * event's e-payment handling (shown only when the event takes payments
+   * online: import it with `onlinePayment`).
+   */
+  async paymentTotal(how: 'check' | 'online' = 'check'): Promise<number> {
+    const due = this.page.getByRole('table', { name: 'Amount due now' });
+    const row = due.getByRole('row').filter({ hasText: how === 'check' ? /^By check/ : /^Online/ });
+    const amount = row.getByRole('cell').last();
+    await expect(amount).toBeVisible();
+    return Number(((await amount.textContent()) ?? '').replace(/[^0-9.-]/g, ''));
+  }
+
+  /**
+   * On the payment step of an event imported with `onlinePayment`: presses
+   * a PayPal button ('PayPal', or 'Card' for "Debit or Credit Card"), which
+   * completes the registration and has the server create its PayPal order,
+   * and returns the order's id. The fake PayPal's window then stays open: the
+   * payer never approves, so nothing is paid. Read what the order asked for
+   * with the `payPal` fixture's `order(id)`.
+   */
+  async startOnlinePayment(button: 'PayPal' | 'Card' = 'PayPal'): Promise<string> {
+    const name = button === 'Card' ? 'Debit or Credit Card' : 'PayPal';
+    const created = this.page.waitForResponse((response) => {
+      const request = response.request();
+      // (With an invitation, the form posts with its code in the query)
+      if (request.method() !== 'POST' || new URL(response.url()).pathname !== `/api/events/${this.eventId}/register`) {
+        return false;
+      }
+      try {
+        return (request.postDataJSON() as { step?: string } | null)?.step === 'paypal-order';
+      } catch {
+        return false;
+      }
+    });
+    await this.page.locator('[data-camphoric-e2e-paypal]')
+      .getByRole('button', { name, exact: true }).click();
+    const response = await created;
+    const body = await response.json() as { orderID?: string, detail?: string };
+    if (!response.ok() || !body.orderID) {
+      throw new Error(`the server didn't create a PayPal order (${response.status()}): ${body.detail ?? JSON.stringify(body)}`);
+    }
+    return body.orderID;
+  }
 }

package/e2eServer.ts

@@ -18,6 +18,9 @@ export interface CamphoricServer {
   // the admin to import as
   username: string;
   password: string;
+  // A throwaway server's fake PayPal API (e2eFakePayPal.py), which its
+  // PAYPAL_BASE_URL names, when it was asked for (none for an existing server)
+  payPalUrl?: string;
   // Removes a throwaway server and its data (a no-op for an existing one)
   stop: () => Promise<void>;
 }
@@ -27,6 +30,9 @@ export interface CamphoricServerOptions {
   // tag, else ghcr.io/camphoric/camphoric:<CAMPHORIC_IMAGE_TAG or latest>,
   // pulled fresh each run)
   image?: string;
+  // Also start the fake PayPal API (default: no), for online payment. It's
+  // mounted from this package, so Docker must see its files.
+  fakePayPal?: boolean;
 }
 
 // This package's e2e-compose.yml, from its source or its build in dist/
@@ -69,6 +75,9 @@ export async function camphoricServer(options: CamphoricServerOptions = {}): Pro
   }
 
   const port = await freePort();
+  let payPalPort = await freePort();
+  while (payPalPort === port) payPalPort = await freePort();
+  const fakePayPal = options.fakePayPal ?? false;
   const username = 'e2e-admin';
   const password = randomBytes(12).toString('hex');
   const project = `camphoric-e2e-${randomBytes(4).toString('hex')}`;
@@ -78,6 +87,9 @@ export async function camphoricServer(options: CamphoricServerOptions = {}): Pro
     CAMPHORIC_E2E_IMAGE: local ?? `ghcr.io/camphoric/camphoric:${process.env.CAMPHORIC_IMAGE_TAG ?? 'latest'}`,
     CAMPHORIC_E2E_PULL_POLICY: local ? 'missing' : 'always',
     CAMPHORIC_E2E_PORT: String(port),
+    CAMPHORIC_E2E_PAYPAL_PORT: String(payPalPort),
+    // (for every compose command, so `down` removes the fake PayPal too)
+    COMPOSE_PROFILES: fakePayPal ? 'paypal' : '',
     CAMPHORIC_E2E_USERNAME: username,
     CAMPHORIC_E2E_PASSWORD: password,
   };
@@ -110,5 +122,11 @@ export async function camphoricServer(options: CamphoricServerOptions = {}): Pro
     process.off('SIGTERM', interrupted);
   }
 
-  return { url: `http://localhost:${port}`, username, password, stop };
+  return {
+    url: `http://localhost:${port}`,
+    username,
+    password,
+    payPalUrl: fakePayPal ? `http://127.0.0.1:${payPalPort}` : undefined,
+    stop,
+  };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camphoric/camphoric-event-import-tools",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Camphoric REST client, login, the event importer (creator and organization loader), e2e scaffolding for an event's registration form, and the runner that posts generated registrations to an event.",
   "license": "MIT",
   "repository": {
@@ -22,7 +22,10 @@
     "types.ts",
     "utils.ts",
     "e2e.ts",
+    "e2eAdmin.ts",
+    "e2eFakePayPal.py",
     "e2eImport.ts",
+    "e2ePayPal.ts",
     "e2eRegistrationForm.ts",
     "e2eServer.ts",
     "e2e-compose.yml",