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

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.0.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",

package/types.ts

@@ -25,6 +25,7 @@ export interface LodgingNode {
   visible?: boolean;
   name?: string;
   notes?: string;
+  availability?: 'auto' | 'full' | 'open';
   id?: number;
 }
 
@@ -42,6 +43,11 @@ export interface ImportData {
     registration_end?: string;
     confirmation_email_subject?: string;
     confirmation_email_template?: string;
+    confirmation_email_reply_to?: string;
+    invoice_email_subject?: string;
+    invoice_email_template?: string;
+    invoice_email_from?: string;
+    invoice_email_reply_to?: string;
     [field: string]: unknown;
   };
   lodgings?: Lodgings;
@@ -51,6 +57,18 @@ export interface ImportData {
     name: string,
     invitation_email_subject: string,
     invitation_email_template: string,
+    invitation_email_from?: string,
+    invitation_email_reply_to?: string,
+    [field: string]: unknown,
+  }[];
+  // Group emails, matched to the saved ones by name
+  email_templates?: { name: string, [field: string]: unknown }[];
+  // Matched to the saved ones by code, ignoring case
+  promo_codes?: {
+    code: string,
+    expiration_date?: string,
+    // registration type names
+    excluded_registration_types?: string[],
     [field: string]: unknown,
   }[];
 }
@@ -60,6 +78,9 @@ export interface ImportResults {
   event?: Saved;
   lodging?: Lodgings;
   reports?: Saved[];
+  registration_types?: Saved[];
+  email_templates?: Saved[];
+  promo_codes?: Saved[];
 }
 
 /** What has been saved by the time an event's overrides and sample registrations run. */