backend-manager 5.0.89 → 5.0.92

package/test/helpers/email.js

@@ -0,0 +1,381 @@
+/**
+ * Test: Email library (libraries/email.js)
+ * Library-level tests: validation edge cases, recipient formats, deduplication, features
+ *
+ * These tests exercise the email library through the admin/email route to get a real
+ * SendGrid integration. Route-level tests (auth, permissions) are in test/routes/admin/email.js.
+ */
+module.exports = {
+  description: 'Email library',
+  type: 'group',
+  skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE env var not set (skipping email tests)' : false,
+  tests: [
+    // --- Validation / Rejection ---
+
+    {
+      name: 'empty-to-array-rejected',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Empty To',
+          to: [],
+          copy: false,
+        });
+
+        assert.isError(response, 400, 'Empty to array should return 400');
+      },
+    },
+
+    {
+      name: 'object-recipient-without-email-rejected',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Bad Object',
+          to: [{ name: 'No Email' }],
+          copy: false,
+        });
+
+        assert.isError(response, 400, 'Object without email should return 400');
+      },
+    },
+
+    {
+      name: 'missing-template-and-html-rejected',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - No Template',
+          to: [{ email: `_test-receiver@${config.domain}` }],
+          template: '',
+          copy: false,
+        });
+
+        assert.isError(response, 400, 'Missing template and html should return 400');
+      },
+    },
+
+    {
+      name: 'nonexistent-uid-rejected',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Bad UID',
+          to: 'uid:nonexistent_uid_12345',
+          copy: false,
+        });
+
+        assert.isError(response, 400, 'Nonexistent UID should return 400');
+      },
+    },
+
+    // --- Subject Fallback ---
+
+    {
+      name: 'subject-from-data-fallback',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          to: [{ email: `_test-receiver@${config.domain}` }],
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Fallback Subject',
+              body: 'Testing subject fallback from data.email.subject.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should use subject from data.email.subject');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+      },
+    },
+
+    // --- Recipient Formats ---
+
+    {
+      name: 'string-email-recipient',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - String Email',
+          to: `_test-receiver@${config.domain}`,
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - String Email',
+              body: 'Testing string email format.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email to string address');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+      },
+    },
+
+    {
+      name: 'uid-recipient',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, accounts }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - UID Recipient',
+          to: `uid:${accounts.admin.uid}`,
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - UID Recipient',
+              body: 'Testing UID resolution.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email to UID');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+      },
+    },
+
+    {
+      name: 'mixed-recipients',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, accounts, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Mixed Recipients',
+          to: [
+            `_test-receiver@${config.domain}`,
+            { email: `_test-receiver-2@${config.domain}`, name: 'Receiver 2' },
+            `uid:${accounts.admin.uid}`,
+          ],
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Mixed Recipients',
+              body: 'Testing mixed recipient formats.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email to mixed recipients');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+      },
+    },
+
+    {
+      name: 'object-recipient-with-name',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Object Recipient',
+          to: { email: `_test-receiver@${config.domain}`, name: 'Named Recipient' },
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Object Recipient',
+              body: 'Testing single object recipient with name.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email to object recipient');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+      },
+    },
+
+    {
+      name: 'cc-bcc-recipients-accepted',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - CC/BCC',
+          to: `_test-receiver@${config.domain}`,
+          cc: `_test-cc@${config.domain}`,
+          bcc: { email: `_test-bcc@${config.domain}`, name: 'BCC Receiver' },
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - CC/BCC',
+              body: 'Testing cc and bcc recipients.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email with cc and bcc');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+      },
+    },
+
+    // --- Deduplication ---
+
+    {
+      name: 'dedup-same-email-in-to',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const email = `_test-dedup@${config.domain}`;
+
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Dedup To',
+          to: [email, email],
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Dedup To',
+              body: 'Testing deduplication of same email in to.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send despite duplicate to');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+        assert.equal(response.data.options.to.length, 1, 'Duplicate should be removed from to');
+      },
+    },
+
+    {
+      name: 'dedup-to-removes-from-cc',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const email = `_test-dedup-cc@${config.domain}`;
+
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Dedup CC',
+          to: email,
+          cc: email,
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Dedup CC',
+              body: 'Testing cross-list dedup (to removes from cc).',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send despite duplicate in cc');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+        assert.equal(response.data.options.cc.length, 0, 'Email in to should be removed from cc');
+      },
+    },
+
+    {
+      name: 'dedup-case-insensitive',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - Case Dedup',
+          to: [`_TEST-DEDUP@${config.domain}`, `_test-dedup@${config.domain}`],
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Case Dedup',
+              body: 'Testing case-insensitive deduplication.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send despite case-different duplicates');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+        assert.equal(response.data.options.to.length, 1, 'Case-insensitive duplicate should be removed');
+      },
+    },
+
+    // --- Features ---
+
+    {
+      name: 'copy-false-no-carbon-copies',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - No Copy',
+          to: `_test-receiver@${config.domain}`,
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - No Copy',
+              body: 'Testing that copy:false produces no cc/bcc.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email without carbon copies');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+        assert.equal(response.data.options.cc.length, 0, 'cc should be empty with copy:false');
+        assert.equal(response.data.options.bcc.length, 0, 'bcc should be empty with copy:false');
+      },
+    },
+
+    {
+      name: 'html-override-replaces-template',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - HTML Override',
+          to: `_test-receiver@${config.domain}`,
+          html: '<p>This is raw HTML content.</p>',
+          copy: false,
+        });
+
+        assert.isSuccess(response, 'Should send email with HTML override');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+        assert.ok(response.data.options.content, 'Should have content array for HTML override');
+        assert.equal(response.data.options.templateId, undefined, 'templateId should be removed for HTML override');
+      },
+    },
+
+    {
+      name: 'sendat-iso-string-accepted',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        // Use a time 1 hour from now (well within the 71h limit)
+        const sendAtDate = new Date(Date.now() + (60 * 60 * 1000)).toISOString();
+
+        const response = await http.post('admin/email', {
+          subject: 'BEM Test Email - ISO SendAt',
+          to: `_test-receiver@${config.domain}`,
+          sendAt: sendAtDate,
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - ISO SendAt',
+              body: 'Testing ISO string sendAt.',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Should send email with ISO sendAt');
+        assert.equal(response.data.status, 'sent', 'Status should be sent (within 71h)');
+        assert.isType(response.data.options.sendAt, 'number', 'sendAt should be normalized to unix timestamp');
+      },
+    },
+  ],
+};

package/test/helpers/infer-contact.js

@@ -0,0 +1,299 @@
+/**
+ * Test: libraries/infer-contact.js
+ * Unit tests for contact inference from email addresses
+ *
+ * Tests capitalize, inferContactFromEmail (regex), and inferContact (AI fallback).
+ * AI tests only run when TEST_EXTENDED_MODE is set.
+ */
+const { inferContact, inferContactFromEmail, capitalize } = require('../../src/manager/libraries/infer-contact.js');
+
+module.exports = {
+  description: 'Infer contact from email',
+  type: 'group',
+
+  tests: [
+    // ─── capitalize ───
+
+    {
+      name: 'capitalize-single-word',
+      async run({ assert }) {
+        assert.equal(capitalize('john'), 'John', 'Should capitalize first letter');
+      },
+    },
+
+    {
+      name: 'capitalize-multiple-words',
+      async run({ assert }) {
+        assert.equal(capitalize('john doe'), 'John Doe', 'Should capitalize each word');
+      },
+    },
+
+    {
+      name: 'capitalize-all-uppercase',
+      async run({ assert }) {
+        assert.equal(capitalize('JOHN'), 'John', 'Should lowercase after first letter');
+      },
+    },
+
+    {
+      name: 'capitalize-mixed-case',
+      async run({ assert }) {
+        assert.equal(capitalize('jOHN dOE'), 'John Doe', 'Should normalize mixed case');
+      },
+    },
+
+    {
+      name: 'capitalize-empty-string',
+      async run({ assert }) {
+        assert.equal(capitalize(''), '', 'Empty string should return empty');
+      },
+    },
+
+    {
+      name: 'capitalize-null',
+      async run({ assert }) {
+        assert.equal(capitalize(null), '', 'Null should return empty');
+      },
+    },
+
+    {
+      name: 'capitalize-undefined',
+      async run({ assert }) {
+        assert.equal(capitalize(undefined), '', 'Undefined should return empty');
+      },
+    },
+
+    // ─── inferContactFromEmail: name parsing ───
+
+    {
+      name: 'regex-first-dot-last',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john.doe@gmail.com');
+
+        assert.equal(result.firstName, 'John', 'First name from local part before dot');
+        assert.equal(result.lastName, 'Doe', 'Last name from local part after dot');
+        assert.equal(result.method, 'regex', 'Method should be regex');
+        assert.equal(result.confidence, 0.5, 'Two-part name should have 0.5 confidence');
+      },
+    },
+
+    {
+      name: 'regex-first-underscore-last',
+      async run({ assert }) {
+        const result = inferContactFromEmail('jane_smith@yahoo.com');
+
+        assert.equal(result.firstName, 'Jane', 'First name from local part before underscore');
+        assert.equal(result.lastName, 'Smith', 'Last name from local part after underscore');
+      },
+    },
+
+    {
+      name: 'regex-first-hyphen-last',
+      async run({ assert }) {
+        const result = inferContactFromEmail('bob-jones@hotmail.com');
+
+        assert.equal(result.firstName, 'Bob', 'First name from local part before hyphen');
+        assert.equal(result.lastName, 'Jones', 'Last name from local part after hyphen');
+      },
+    },
+
+    {
+      name: 'regex-three-part-name',
+      async run({ assert }) {
+        const result = inferContactFromEmail('mary.jane.watson@example.com');
+
+        assert.equal(result.firstName, 'Mary', 'First name is first part');
+        assert.equal(result.lastName, 'Jane Watson', 'Last name joins remaining parts');
+      },
+    },
+
+    {
+      name: 'regex-single-word-local-part',
+      async run({ assert }) {
+        const result = inferContactFromEmail('admin@example.com');
+
+        assert.equal(result.firstName, 'Admin', 'Single word becomes first name');
+        assert.equal(result.lastName, '', 'No last name for single word');
+        assert.equal(result.confidence, 0.25, 'Single-part name should have 0.25 confidence');
+      },
+    },
+
+    {
+      name: 'regex-strips-trailing-numbers',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john.doe42@gmail.com');
+
+        assert.equal(result.firstName, 'John', 'Trailing numbers stripped before parsing');
+        assert.equal(result.lastName, 'Doe', 'Name parsed correctly after stripping');
+      },
+    },
+
+    {
+      name: 'regex-only-numbers-after-name',
+      async run({ assert }) {
+        const result = inferContactFromEmail('user123@gmail.com');
+
+        assert.equal(result.firstName, 'User', 'Numbers stripped, name capitalized');
+        assert.equal(result.lastName, '', 'No last name');
+      },
+    },
+
+    // ─── inferContactFromEmail: company inference ───
+
+    {
+      name: 'regex-company-from-custom-domain',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@acme.com');
+
+        assert.equal(result.company, 'Acme', 'Company from custom domain');
+      },
+    },
+
+    {
+      name: 'regex-company-from-hyphenated-domain',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@my-company.com');
+
+        assert.equal(result.company, 'My Company', 'Hyphens replaced with spaces');
+      },
+    },
+
+    {
+      name: 'regex-company-from-underscored-domain',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@my_company.com');
+
+        assert.equal(result.company, 'My Company', 'Underscores replaced with spaces');
+      },
+    },
+
+    {
+      name: 'regex-no-company-from-gmail',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@gmail.com');
+
+        assert.equal(result.company, '', 'Gmail is generic, no company');
+      },
+    },
+
+    {
+      name: 'regex-no-company-from-yahoo',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@yahoo.com');
+
+        assert.equal(result.company, '', 'Yahoo is generic, no company');
+      },
+    },
+
+    {
+      name: 'regex-no-company-from-outlook',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@outlook.com');
+
+        assert.equal(result.company, '', 'Outlook is generic, no company');
+      },
+    },
+
+    {
+      name: 'regex-no-company-from-protonmail',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@protonmail.com');
+
+        assert.equal(result.company, '', 'Protonmail is generic, no company');
+      },
+    },
+
+    {
+      name: 'regex-no-company-from-icloud',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@icloud.com');
+
+        assert.equal(result.company, '', 'iCloud is generic, no company');
+      },
+    },
+
+    {
+      name: 'regex-generic-domain-case-insensitive',
+      async run({ assert }) {
+        const result = inferContactFromEmail('john@GMAIL.COM');
+
+        assert.equal(result.company, '', 'Generic domain check should be case-insensitive');
+      },
+    },
+
+    // ─── inferContactFromEmail: combined name + company ───
+
+    {
+      name: 'regex-full-result-custom-domain',
+      async run({ assert }) {
+        const result = inferContactFromEmail('sarah.connor@skynet.io');
+
+        assert.equal(result.firstName, 'Sarah', 'First name parsed');
+        assert.equal(result.lastName, 'Connor', 'Last name parsed');
+        assert.equal(result.company, 'Skynet', 'Company from domain');
+        assert.equal(result.method, 'regex', 'Method is regex');
+        assert.equal(result.confidence, 0.5, 'Confidence 0.5 for two-part name');
+      },
+    },
+
+    {
+      name: 'regex-single-name-custom-domain',
+      async run({ assert }) {
+        const result = inferContactFromEmail('info@acme.com');
+
+        assert.equal(result.firstName, 'Info', 'Single word capitalized');
+        assert.equal(result.lastName, '', 'No last name');
+        assert.equal(result.company, 'Acme', 'Company inferred');
+        assert.equal(result.confidence, 0.25, 'Lower confidence for single name');
+      },
+    },
+
+    // ─── inferContact: regex fallback (no OPENAI_API_KEY) ───
+
+    {
+      name: 'infer-contact-regex-fallback',
+      async run({ assert }) {
+        // Temporarily clear OPENAI_API_KEY to force regex path
+        const originalKey = process.env.OPENAI_API_KEY;
+        delete process.env.OPENAI_API_KEY;
+
+        try {
+          const result = await inferContact('alice.wonderland@example.com');
+
+          assert.equal(result.firstName, 'Alice', 'Regex fallback first name');
+          assert.equal(result.lastName, 'Wonderland', 'Regex fallback last name');
+          assert.equal(result.company, 'Example', 'Regex fallback company');
+          assert.equal(result.method, 'regex', 'Should use regex when no API key');
+        } finally {
+          // Restore
+          if (originalKey) {
+            process.env.OPENAI_API_KEY = originalKey;
+          }
+        }
+      },
+    },
+
+    // ─── inferContact: AI path (requires TEST_EXTENDED_MODE) ───
+
+    {
+      name: 'infer-contact-ai',
+      skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE not set (skipping AI inference test)' : false,
+      timeout: 30000,
+
+      async run({ assert, Manager }) {
+        // This test requires a real OPENAI_API_KEY and running Manager
+        if (!process.env.OPENAI_API_KEY) {
+          return assert.fail('OPENAI_API_KEY not set');
+        }
+
+        const assistant = Manager.Assistant();
+        const result = await inferContact('john.smith@microsoft.com', assistant);
+
+        assert.ok(result, 'Should return a result');
+        assert.ok(result.firstName, 'Should infer a first name');
+        assert.equal(result.method, 'ai', 'Should use AI method');
+        assert.ok(typeof result.confidence === 'number', 'Confidence should be a number');
+      },
+    },
+  ],
+};