backend-manager 5.0.147 → 5.0.149

package/test/helpers/email-validation.js

@@ -0,0 +1,420 @@
+/**
+ * Test: Email validation library (libraries/email/validation.js)
+ * Unit tests for format, local part, disposable domain, and ZeroBounce checks
+ *
+ * Format, local part, and disposable tests always run (free, regex-based).
+ * Mailbox verification tests require TEST_EXTENDED_MODE + ZEROBOUNCE_API_KEY.
+ */
+const { validate, DEFAULT_CHECKS, ALL_CHECKS } = require('../../src/manager/libraries/email/validation.js');
+
+module.exports = {
+  description: 'Email validation',
+  type: 'group',
+  tests: [
+    // --- Format checks ---
+
+    {
+      name: 'format-valid-email-passes',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('rachel.greene@gmail.com');
+
+        assert.equal(result.valid, true, 'Valid email should pass');
+        assert.propertyEquals(result, 'checks.format.valid', true, 'Format check should pass');
+      },
+    },
+
+    {
+      name: 'format-no-at-sign-fails',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('not-a-valid-email');
+
+        assert.equal(result.valid, false, 'Missing @ should fail');
+        assert.propertyEquals(result, 'checks.format.valid', false, 'Format check should fail');
+      },
+    },
+
+    {
+      name: 'format-no-domain-fails',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('user@');
+
+        assert.equal(result.valid, false, 'Missing domain should fail');
+        assert.propertyEquals(result, 'checks.format.valid', false, 'Format check should fail');
+      },
+    },
+
+    {
+      name: 'format-empty-string-fails',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('');
+
+        assert.equal(result.valid, false, 'Empty string should fail');
+        assert.propertyEquals(result, 'checks.format.valid', false, 'Format check should fail');
+      },
+    },
+
+    {
+      name: 'format-spaces-fails',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('user name@gmail.com');
+
+        assert.equal(result.valid, false, 'Spaces should fail');
+        assert.propertyEquals(result, 'checks.format.valid', false, 'Format check should fail');
+      },
+    },
+
+    // --- Local part checks ---
+
+    {
+      name: 'localpart-test-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('test@gmail.com');
+
+        assert.equal(result.valid, false, '"test" local part should be blocked');
+        assert.propertyEquals(result, 'checks.localPart.blocked', true, 'Should be flagged as blocked');
+        assert.propertyEquals(result, 'checks.localPart.localPart', 'test', 'Should include the local part');
+      },
+    },
+
+    {
+      name: 'localpart-noreply-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('noreply@company.com');
+
+        assert.equal(result.valid, false, '"noreply" local part should be blocked');
+        assert.propertyEquals(result, 'checks.localPart.blocked', true, 'Should be flagged as blocked');
+      },
+    },
+
+    {
+      name: 'localpart-admin-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('admin@company.com');
+
+        assert.equal(result.valid, false, '"admin" local part should be blocked');
+        assert.propertyEquals(result, 'checks.localPart.blocked', true, 'Should be flagged as blocked');
+      },
+    },
+
+    {
+      name: 'localpart-all-numeric-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('123456@gmail.com');
+
+        assert.equal(result.valid, false, 'All-numeric local part should be blocked');
+        assert.propertyEquals(result, 'checks.localPart.blocked', true, 'Should be flagged as blocked');
+        assert.propertyEquals(result, 'checks.localPart.reason', 'Matches junk pattern', 'Should match junk pattern');
+      },
+    },
+
+    {
+      name: 'localpart-repeating-chars-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('aaaa@gmail.com');
+
+        assert.equal(result.valid, false, 'Repeating chars should be blocked');
+        assert.propertyEquals(result, 'checks.localPart.blocked', true, 'Should be flagged as blocked');
+      },
+    },
+
+    {
+      name: 'localpart-keyboard-walk-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('asdf@gmail.com');
+
+        assert.equal(result.valid, false, 'Keyboard walk should be blocked');
+        assert.propertyEquals(result, 'checks.localPart.blocked', true, 'Should be flagged as blocked');
+      },
+    },
+
+    {
+      name: 'localpart-test-prefix-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('test.user@gmail.com');
+
+        assert.equal(result.valid, false, '"test." prefix should be blocked');
+        assert.propertyEquals(result, 'checks.localPart.blocked', true, 'Should be flagged as blocked');
+      },
+    },
+
+    {
+      name: 'localpart-letter-plus-numbers-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('a123@gmail.com');
+
+        assert.equal(result.valid, false, 'Single letter + numbers should be blocked');
+        assert.propertyEquals(result, 'checks.localPart.blocked', true, 'Should be flagged as blocked');
+      },
+    },
+
+    {
+      name: 'localpart-plus-suffix-stripped-before-check',
+      timeout: 5000,
+
+      async run({ assert }) {
+        // "test+something" → strips to "test" → blocked
+        const result = await validate('test+newsletter@gmail.com');
+
+        assert.equal(result.valid, false, '"test+suffix" should still be blocked (strips +suffix first)');
+        assert.propertyEquals(result, 'checks.localPart.blocked', true, 'Should be blocked after stripping suffix');
+      },
+    },
+
+    {
+      name: 'localpart-bem-suffix-allowed-on-real-names',
+      timeout: 5000,
+
+      async run({ assert }) {
+        // "rachel.greene+bem" → strips to "rachel.greene" → allowed
+        const result = await validate('rachel.greene+bem@gmail.com');
+
+        assert.equal(result.valid, true, 'Real name with +bem suffix should pass');
+        assert.propertyEquals(result, 'checks.localPart.valid', true, 'Local part check should pass');
+      },
+    },
+
+    {
+      name: 'localpart-real-name-passes',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('john.smith@company.com');
+
+        assert.equal(result.valid, true, 'Real name should pass');
+        assert.propertyEquals(result, 'checks.localPart.valid', true, 'Local part check should pass');
+      },
+    },
+
+    {
+      name: 'localpart-single-real-name-passes',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('rachel@company.com');
+
+        assert.equal(result.valid, true, 'Single real name should pass');
+        assert.propertyEquals(result, 'checks.localPart.valid', true, 'Local part check should pass');
+      },
+    },
+
+    // --- Disposable domain checks ---
+
+    {
+      name: 'disposable-mailinator-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('rachel.greene@mailinator.com');
+
+        assert.equal(result.valid, false, 'Mailinator should be invalid');
+        assert.propertyEquals(result, 'checks.disposable.blocked', true, 'Should be flagged as blocked');
+        assert.propertyEquals(result, 'checks.disposable.domain', 'mailinator.com', 'Should include blocked domain');
+      },
+    },
+
+    {
+      name: 'disposable-guerrillamail-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('rachel.greene@guerrillamail.com');
+
+        assert.equal(result.valid, false, 'GuerrillaMail should be invalid');
+        assert.propertyEquals(result, 'checks.disposable.blocked', true, 'Should be flagged as blocked');
+      },
+    },
+
+    {
+      name: 'disposable-tempmail-blocked',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('rachel.greene@temp-mail.org');
+
+        assert.equal(result.valid, false, 'temp-mail.org should be invalid');
+        assert.propertyEquals(result, 'checks.disposable.blocked', true, 'Should be flagged as blocked');
+      },
+    },
+
+    {
+      name: 'valid-gmail-passes-disposable',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('rachel.greene@gmail.com');
+
+        assert.equal(result.valid, true, 'Gmail should be valid');
+        assert.propertyEquals(result, 'checks.disposable.valid', true, 'Should pass disposable check');
+        assert.propertyEquals(result, 'checks.disposable.blocked', false, 'Should not be blocked');
+      },
+    },
+
+    {
+      name: 'valid-custom-domain-passes',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('ian@somiibo.com');
+
+        assert.equal(result.valid, true, 'Custom domain should be valid');
+        assert.propertyEquals(result, 'checks.disposable.valid', true, 'Should pass disposable check');
+      },
+    },
+
+    // --- Selective checks ---
+
+    {
+      name: 'checks-format-only',
+      timeout: 5000,
+
+      async run({ assert }) {
+        // "test@gmail.com" normally blocked by localPart, but only running format
+        const result = await validate('test@gmail.com', { checks: ['format'] });
+
+        assert.equal(result.valid, true, 'Should pass with only format check');
+        assert.propertyEquals(result, 'checks.format.valid', true, 'Format should pass');
+        assert.equal(result.checks.localPart, undefined, 'localPart should not run');
+        assert.equal(result.checks.disposable, undefined, 'disposable should not run');
+      },
+    },
+
+    {
+      name: 'checks-format-and-disposable-skips-localpart',
+      timeout: 5000,
+
+      async run({ assert }) {
+        // "test@gmail.com" would be blocked by localPart, but we only run format + disposable
+        const result = await validate('test@gmail.com', { checks: ['format', 'disposable'] });
+
+        assert.equal(result.valid, true, 'Should pass without localPart check');
+        assert.propertyEquals(result, 'checks.format.valid', true, 'Format should pass');
+        assert.propertyEquals(result, 'checks.disposable.blocked', false, 'Disposable should pass');
+        assert.equal(result.checks.localPart, undefined, 'localPart should not run');
+      },
+    },
+
+    {
+      name: 'checks-format-and-disposable-still-blocks-disposable',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('rachel.greene@mailinator.com', { checks: ['format', 'disposable'] });
+
+        assert.equal(result.valid, false, 'Disposable should still fail');
+        assert.propertyEquals(result, 'checks.disposable.blocked', true, 'Should be blocked');
+      },
+    },
+
+    {
+      name: 'checks-default-matches-expected',
+      timeout: 5000,
+
+      async run({ assert }) {
+        assert.deepEqual(DEFAULT_CHECKS, ['format', 'disposable', 'localPart'], 'DEFAULT_CHECKS should be format + disposable + localPart');
+        assert.deepEqual(ALL_CHECKS, ['format', 'disposable', 'localPart', 'mailbox'], 'ALL_CHECKS should include mailbox');
+      },
+    },
+
+    // --- Mailbox verification behavior ---
+
+    {
+      name: 'mailbox-not-in-default-checks',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const result = await validate('rachel.greene@gmail.com');
+
+        assert.equal(result.valid, true, 'Should be valid');
+        assert.equal(result.checks.mailbox, undefined, 'Mailbox should not run with default checks');
+      },
+    },
+
+    {
+      name: 'mailbox-skipped-without-api-key',
+      timeout: 5000,
+
+      async run({ assert }) {
+        const originalKey = process.env.ZEROBOUNCE_API_KEY;
+        delete process.env.ZEROBOUNCE_API_KEY;
+
+        try {
+          const result = await validate('rachel.greene@gmail.com', { checks: ALL_CHECKS });
+
+          assert.equal(result.valid, true, 'Should still be valid');
+          assert.hasProperty(result, 'checks.mailbox', 'Should have mailbox check');
+          assert.propertyEquals(result, 'checks.mailbox.skipped', true, 'Should be marked as skipped');
+        } finally {
+          if (originalKey) {
+            process.env.ZEROBOUNCE_API_KEY = originalKey;
+          }
+        }
+      },
+    },
+
+    // --- Mailbox verification API checks (require TEST_EXTENDED_MODE + ZEROBOUNCE_API_KEY) ---
+
+    {
+      name: 'mailbox-valid-email-passes',
+      timeout: 15000,
+      skip: !process.env.TEST_EXTENDED_MODE || !process.env.ZEROBOUNCE_API_KEY
+        ? 'TEST_EXTENDED_MODE or ZEROBOUNCE_API_KEY not set'
+        : false,
+
+      async run({ assert, skip }) {
+        const result = await validate('disposable@gmail.com', { checks: ALL_CHECKS });
+
+        if (result.checks.mailbox?.error?.includes('out of credits')) {
+          skip('Mailbox verification out of credits');
+        }
+
+        assert.hasProperty(result, 'checks.mailbox', 'Should have mailbox check');
+        assert.hasProperty(result, 'checks.mailbox.status', 'Should have status');
+      },
+    },
+
+    {
+      name: 'mailbox-fake-domain-fails',
+      timeout: 15000,
+      skip: !process.env.TEST_EXTENDED_MODE || !process.env.ZEROBOUNCE_API_KEY
+        ? 'TEST_EXTENDED_MODE or ZEROBOUNCE_API_KEY not set'
+        : false,
+
+      async run({ assert, skip }) {
+        const result = await validate('rachel.greene@thisfakedomain99999.com', { checks: ALL_CHECKS });
+
+        if (result.checks.mailbox?.error?.includes('out of credits')) {
+          skip('Mailbox verification out of credits');
+        }
+
+        assert.hasProperty(result, 'checks.mailbox.status', 'Should have status');
+        assert.notEqual(result.checks.mailbox.status, 'valid', 'Fake domain should not be valid');
+      },
+    },
+  ],
+};

package/test/helpers/email.js

@@ -76,7 +76,7 @@ module.exports = {
       async run({ http, assert }) {
         const response = await http.post('admin/email', {
           subject: 'BEM Test Email - Bad UID',
-          to: 'uid:nonexistent_uid_12345',
+          to: 'nonexistent_uid_12345',
           copy: false,
         });
 
@@ -141,7 +141,7 @@ module.exports = {
       async run({ http, assert, accounts }) {
         const response = await http.post('admin/email', {
           subject: 'BEM Test Email - UID Recipient',
-          to: `uid:${accounts.admin.uid}`,
+          to: accounts.admin.uid,
           copy: false,
           data: {
             email: {
@@ -167,7 +167,7 @@ module.exports = {
           to: [
             `_test-receiver@${config.domain}`,
             { email: `_test-receiver-2@${config.domain}`, name: 'Receiver 2' },
-            `uid:${accounts.admin.uid}`,
+            accounts.admin.uid,
           ],
           copy: false,
           data: {
@@ -378,18 +378,131 @@ module.exports = {
         assert.isSuccess(response, 'Should send email');
         assert.equal(response.data.status, 'sent', 'Status should be sent');
 
-        const appImages = response.data.options.dynamicTemplateData.app.images;
+        const brandImages = response.data.options.dynamicTemplateData.brand.images;
 
         // Any image that was an SVG should now be a PNG (-x.svg → -1024.png)
-        for (const [key, value] of Object.entries(appImages)) {
+        for (const [key, value] of Object.entries(brandImages)) {
           assert.ok(
             !String(value || '').endsWith('.svg'),
-            `app.images.${key} should not be an SVG (got: ${value})`,
+            `brand.images.${key} should not be an SVG (got: ${value})`,
           );
         }
       },
     },
 
+    // --- Sender Resolution ---
+
+    {
+      name: 'sender-orders-resolves-from-and-asm',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Sender Orders',
+          to: `_test-receiver@${config.domain}`,
+          sender: 'orders',
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Sender Orders',
+              body: 'Testing sender resolution for orders.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email with orders sender');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+        assert.ok(response.data.options.from.email.startsWith('orders@'), 'From email should start with orders@');
+        assert.ok(response.data.options.from.name.includes('Orders'), 'From name should include Orders');
+        assert.ok(response.data.options.asm, 'Should have ASM group');
+        assert.ok(response.data.options.replyTo.startsWith('orders@'), 'replyTo should match from address');
+      },
+    },
+
+    {
+      name: 'sender-security-resolves-from-asm-and-unsubscribe',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Sender Security',
+          to: `_test-receiver@${config.domain}`,
+          sender: 'security',
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Sender Security',
+              body: 'Testing that security sender resolves correctly.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email with security sender');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+        assert.ok(response.data.options.from.email.startsWith('security@'), 'From email should start with security@');
+        assert.ok(response.data.options.asm, 'Should have ASM group');
+        assert.ok(response.data.options.headers['List-Unsubscribe'], 'Should have List-Unsubscribe header');
+        assert.ok(response.data.options.dynamicTemplateData.email.unsubscribeUrl, 'Should have unsubscribeUrl');
+      },
+    },
+
+    {
+      name: 'sender-explicit-from-overrides-sender',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const customFrom = { email: `custom@${config.domain}`, name: 'Custom Sender' };
+
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - From Override',
+          to: `_test-receiver@${config.domain}`,
+          sender: 'orders',
+          from: customFrom,
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - From Override',
+              body: 'Testing that explicit from overrides sender.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email with explicit from');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+        assert.equal(response.data.options.from.email, customFrom.email, 'Explicit from should override sender');
+        assert.equal(response.data.options.from.name, customFrom.name, 'Explicit from name should override sender');
+      },
+    },
+
+    {
+      name: 'sender-unknown-falls-back-to-defaults',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Unknown Sender',
+          to: `_test-receiver@${config.domain}`,
+          sender: 'nonexistent',
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Unknown Sender',
+              body: 'Testing that unknown sender falls back to brand defaults.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email with default from');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+        assert.ok(response.data.options.from.email, 'Should have a from email (brand default)');
+        assert.ok(response.data.options.asm, 'Should have default ASM group');
+      },
+    },
+
     {
       name: 'sendat-iso-string-accepted',
       auth: 'admin',

package/test/helpers/marketing-lifecycle.js

@@ -0,0 +1,121 @@
+/**
+ * Test: Marketing lifecycle (add → sync → remove)
+ * End-to-end suite testing the full marketing contact flow via routes
+ *
+ * Requires TEST_EXTENDED_MODE=true and SENDGRID_API_KEY / BEEHIIV_API_KEY env vars.
+ * These tests hit real external APIs.
+ */
+module.exports = {
+  description: 'Marketing lifecycle (add → sync → remove)',
+  type: 'suite',
+  timeout: 60000,
+  skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE not set' : false,
+
+  tests: [
+    // Step 0: Pre-clean test contacts from providers (in case a previous run left them)
+    {
+      name: 'pre-clean-test-contacts',
+      auth: 'admin',
+
+      async run({ http, config, state }) {
+        const testEmail = `lifecycle.test+bem@${config.domain}`;
+        state.testEmail = testEmail;
+
+        // Delete from all providers — handles "not found" gracefully
+        await http.delete('marketing/contact', { email: testEmail }).catch(() => {});
+      },
+    },
+
+    // Step 1: Add a contact via POST /marketing/contact
+    {
+      name: 'add-contact',
+      auth: 'admin',
+
+      async run({ http, assert, state }) {
+        const response = await http.post('marketing/contact', {
+          email: state.testEmail,
+          firstName: 'Lifecycle',
+          lastName: 'Test',
+          source: 'bem-test-lifecycle',
+        });
+
+        assert.isSuccess(response, 'Add contact should succeed');
+        assert.propertyEquals(response, 'data.success', true, 'success should be true');
+
+        if (process.env.SENDGRID_API_KEY) {
+          assert.hasProperty(response, 'data.providers.sendgrid', 'Should have SendGrid result');
+          assert.propertyEquals(response, 'data.providers.sendgrid.success', true, 'SendGrid add should succeed');
+        }
+
+        if (process.env.BEEHIIV_API_KEY) {
+          assert.hasProperty(response, 'data.providers.beehiiv', 'Should have Beehiiv result');
+          assert.propertyEquals(response, 'data.providers.beehiiv.success', true, 'Beehiiv add should succeed');
+        }
+      },
+    },
+
+    // Step 2: Sync by UID via PUT /marketing/contact
+    // Tests the full sync pipeline: UID resolution → buildFields → upsert with custom fields
+    {
+      name: 'sync-contact-by-uid',
+      auth: 'admin',
+
+      async run({ http, assert, accounts }) {
+        // Sync the admin test account — exercises UID→doc resolution + buildFields
+        const response = await http.put('marketing/contact', {
+          uid: accounts.admin.uid,
+        });
+
+        assert.isSuccess(response, 'Sync contact should succeed');
+        assert.propertyEquals(response, 'data.success', true, 'success should be true');
+
+        if (process.env.SENDGRID_API_KEY) {
+          assert.hasProperty(response, 'data.providers.sendgrid', 'Should have SendGrid result');
+          assert.propertyEquals(response, 'data.providers.sendgrid.success', true, 'SendGrid sync should succeed');
+        }
+
+        if (process.env.BEEHIIV_API_KEY) {
+          assert.hasProperty(response, 'data.providers.beehiiv', 'Should have Beehiiv result');
+          assert.propertyEquals(response, 'data.providers.beehiiv.success', true, 'Beehiiv sync should succeed');
+        }
+      },
+    },
+
+    // Step 3: Remove the contact via DELETE /marketing/contact
+    {
+      name: 'remove-contact',
+      auth: 'admin',
+
+      async run({ http, assert, state }) {
+        const response = await http.delete('marketing/contact', {
+          email: state.testEmail,
+        });
+
+        assert.isSuccess(response, 'Remove contact should succeed');
+        assert.propertyEquals(response, 'data.success', true, 'success should be true');
+
+        if (process.env.SENDGRID_API_KEY) {
+          assert.hasProperty(response, 'data.providers.sendgrid', 'Should have SendGrid result');
+          assert.propertyEquals(response, 'data.providers.sendgrid.success', true, 'SendGrid remove should succeed');
+        }
+
+        if (process.env.BEEHIIV_API_KEY) {
+          assert.hasProperty(response, 'data.providers.beehiiv', 'Should have Beehiiv result');
+          assert.propertyEquals(response, 'data.providers.beehiiv.success', true, 'Beehiiv remove should succeed');
+        }
+      },
+    },
+
+    // Step 4: Clean up the admin test contact that sync added
+    {
+      name: 'cleanup-synced-admin-contact',
+      auth: 'admin',
+
+      async run({ http, accounts }) {
+        await http.delete('marketing/contact', {
+          email: accounts.admin.email,
+        }).catch(() => {});
+      },
+    },
+  ],
+};