Mail7: A Tester's Friend

Why Mail7 for Testing?

Getting Started

1. Account Setup

1. Sign up for a Mail7 account at portal.mail7.app
2. Generate your API key from the dashboard
3. Choose your preferred domain for test email addresses

2. Environment Setup

// Install Mail7 SDK
npm install @mail7/sdk

// Configure environment variables
MAIL7_API_KEY=your_api_key
MAIL7_DOMAIN=your_domain.mail7.io

Implementation Examples

1. Basic Email Testing

const Mail7 = require('@mail7/sdk');
const mail7 = new Mail7({
    apiKey: process.env.MAIL7_API_KEY,
    domain: process.env.MAIL7_DOMAIN
});

describe('User Registration Flow', () => {
    let testEmail;

    beforeEach(async () => {
        // Generate unique test email
        testEmail = await mail7.generateEmail();
    });

    it('should send welcome email after registration', async () => {
        // Register new user
        await registerUser(testEmail);

        // Wait for and verify welcome email
        const email = await mail7.waitForEmail({
            to: testEmail,
            subject: 'Welcome to Our App',
            timeout: 5000
        });

        expect(email).toBeDefined();
        expect(email.html).toContain('Welcome to Our App');
        expect(email.attachments).toHaveLength(1);
    });
});

2. Advanced Testing Patterns

class EmailTestHelper {
    constructor(config) {
        this.mail7 = new Mail7(config);
        this.emailPool = new Map();
    }

    async createTestEmail(prefix) {
        const email = await this.mail7.generateEmail({
            prefix: prefix || 'test',
            timestamp: true
        });
        this.emailPool.set(prefix, email);
        return email;
    }

    async verifyEmail(options) {
        const {
            to,
            subject,
            contentChecks = [],
            attachmentChecks = []
        } = options;

        const email = await this.mail7.waitForEmail({
            to,
            subject,
            timeout: 10000
        });

        // Verify email content
        for (const check of contentChecks) {
            if (check.type === 'html') {
                expect(email.html).toContain(check.content);
            } else if (check.type === 'text') {
                expect(email.text).toContain(check.content);
            }
        }

        // Verify attachments
        if (attachmentChecks.length > 0) {
            expect(email.attachments).toHaveLength(attachmentChecks.length);
            for (const [index, check] of attachmentChecks.entries()) {
                const attachment = email.attachments[index];
                expect(attachment.filename).toBe(check.filename);
                expect(attachment.contentType).toBe(check.contentType);
            }
        }

        return email;
    }

    async cleanup() {
        for (const [prefix, email] of this.emailPool) {
            await this.mail7.deleteEmails(email);
        }
        this.emailPool.clear();
    }
}

3. Webhook Integration

const express = require('express');
const app = express();

app.post('/mail7/webhook', async (req, res) => {
    const { email, timestamp, messageId } = req.body;

    // Process email event
    await processEmailEvent({
        email,
        timestamp,
        messageId
    });

    res.status(200).send('OK');
});

async function processEmailEvent(event) {
    // Example: Update test status based on email receipt
    await TestRunner.updateTestStatus({
        email: event.email,
        status: 'email_received',
        timestamp: event.timestamp
    });

    // Trigger next test step
    await TestRunner.proceedToNextStep(event.email);
}

Best Practices

1. Test Data Management

• Use unique email prefixes for different test scenarios
• Implement automatic cleanup of test emails
• Maintain isolation between test runs
• Use meaningful email prefixes for better debugging

2. Performance Optimization

• Implement email polling with exponential backoff
• Use webhook integration for real-time notifications
• Cache email addresses for reuse in related tests
• Batch email verifications when possible

3. Error Handling

• Implement proper timeout handling
• Add retry mechanisms for transient failures
• Log detailed error information for debugging
• Handle API rate limits gracefully

4. Security

• Secure API credentials using environment variables
• Implement IP whitelisting for webhook endpoints
• Rotate API keys regularly
• Validate webhook request signatures

Advanced Features

1. Custom Domain Integration

Use your own domain for testing by following these steps:

1. Add your domain in Mail7 dashboard
2. Configure DNS records as specified
3. Verify domain ownership
4. Update your test configuration to use the custom domain

2. Email Templates

Create and manage email templates for consistent testing:

const templateManager = new Mail7TemplateManager();

// Register templates
await templateManager.register('welcome', {
    subject: 'Welcome to {app_name}',
    body: `
        Dear {user_name},
        Welcome to {app_name}!
        ...
    `
});

// Use in tests
const email = await mail7.waitForEmail({
    to: testEmail,
    template: 'welcome',
    variables: {
        app_name: 'TestApp',
        user_name: 'John'
    }
});

3. Parallel Testing

Optimize test execution with parallel email verification:

class ParallelEmailVerifier {
    constructor(config) {
        this.mail7 = new Mail7(config);
        this.maxConcurrent = config.maxConcurrent || 5;
    }

    async verifyMultiple(verifications) {
        const queue = new PQueue({
            concurrency: this.maxConcurrent
        });

        return Promise.all(
            verifications.map(v =>
                queue.add(() => this.mail7.waitForEmail(v))
            )
        );
    }
}

Troubleshooting

Start Testing Now

Ready to revolutionize your email testing workflow? Get started with Mail7 today: