Test email in CI

// test/email.ts
const API = process.env.SANDBOX_API_URL!; // https://app.mailbench.dev
const KEY = process.env.SANDBOX_API_KEY!;
const INBOX = process.env.SANDBOX_INBOX_ID!;

/** Waits for an email sent to `to` and returns it, with its text, HTML and links. */
export async function waitForEmail(to: string, timeoutSeconds = 20) {
  const url = new URL(`/v1/inboxes/${INBOX}/messages/wait`, API);
  url.searchParams.set("to", to);
  url.searchParams.set("timeout", String(timeoutSeconds));

  const res = await fetch(url, { headers: { Authorization: `Bearer ${KEY}` } });
  const body = await res.json();
  if (!res.ok) {
    throw new Error(`No email for ${to}: ${body.error?.code} (${body.error?.message})`);
  }
  return body.data as {
    id: string;
    subject: string;
    from: string;
    text?: string;
    html?: string;
    links: string[];
  };
}

# tests/email_helpers.py
import os
import requests

API = os.environ["SANDBOX_API_URL"]  # https://app.mailbench.dev
KEY = os.environ["SANDBOX_API_KEY"]
INBOX = os.environ["SANDBOX_INBOX_ID"]


def wait_for_email(to: str, timeout: int = 20) -> dict:
    """Waits for an email sent to `to` and returns it, with its text, HTML and links."""
    res = requests.get(
        f"{API}/v1/inboxes/{INBOX}/messages/wait",
        params={"to": to, "timeout": timeout},
        headers={"Authorization": f"Bearer {KEY}"},
        timeout=timeout + 5,
    )
    body = res.json()
    if not res.ok:
        raise AssertionError(f"No email for {to}: {body['error']['code']} ({body['error']['message']})")
    return body["data"]

<?php
// tests/Support/WaitsForEmail.php
namespace Tests\Support;

use Illuminate\Support\Facades\Http;

trait WaitsForEmail
{
    /** Waits for an email sent to $to and returns it, with its text, HTML and links. */
    protected function waitForEmail(string $to, int $timeout = 20): array
    {
        $response = Http::withToken(env('SANDBOX_API_KEY'))
            ->timeout($timeout + 5)
            ->get(env('SANDBOX_API_URL') . '/v1/inboxes/' . env('SANDBOX_INBOX_ID') . '/messages/wait', [
                'to' => $to,
                'timeout' => $timeout,
            ]);

        $this->assertTrue(
            $response->successful(),
            "No email for {$to}: " . $response->json('error.code') . ' (' . $response->json('error.message') . ')'
        );

        return $response->json('data');
    }
}

import { test, expect } from "vitest";
import { waitForEmail } from "./email";

test("signing up sends a verification email", async () => {
  const address = `signup-${crypto.randomUUID()}@example.com`;

  await signUp({ email: address, password: "correct horse" }); // your code under test

  const message = await waitForEmail(address);
  expect(message.subject).toBe("Verify your email");

  const link = message.links.find((l) => l.includes("/verify/"));
  expect(link).toBeDefined();
  await visit(link!); // follow it, assert the account is now active
});

import uuid
from email_helpers import wait_for_email


def test_signing_up_sends_a_verification_email(client):
    address = f"signup-{uuid.uuid4()}@example.com"

    client.post("/signup", json={"email": address, "password": "correct horse"})  # your code under test

    message = wait_for_email(address)
    assert message["subject"] == "Verify your email"

    link = next(l for l in message["links"] if "/verify/" in l)
    assert client.get(link).status_code == 200

<?php
use Tests\Support\WaitsForEmail;
use Tests\TestCase;

class SignupEmailTest extends TestCase
{
    use WaitsForEmail;

    public function test_signing_up_sends_a_verification_email(): void
    {
        $address = 'signup-' . uniqid() . '@example.com';

        $this->post('/register', ['email' => $address, 'password' => 'correct horse']); // your code under test

        $message = $this->waitForEmail($address);
        $this->assertSame('Verify your email', $message['subject']);

        $link = collect($message['links'])->first(fn ($l) => str_contains($l, '/verify/'));
        $this->assertNotNull($link);
    }
}