backend-manager 5.9.7 → 5.9.9

package/test/routes/admin/email.js

@@ -0,0 +1,114 @@
+/**
+ * Test: POST /admin/email
+ * Route-level tests: auth, permissions, HTTP status codes, basic send/queue
+ *
+ * Library-level tests (validation, dedup, recipients, features) are in test/helpers/email.js
+ */
+module.exports = {
+  description: 'Admin send email (route)',
+  type: 'group',
+  skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE env var not set (skipping email tests)' : false,
+  tests: [
+    // --- Auth / Permissions ---
+
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('backend-manager/admin/email', {
+          subject: 'Test Email',
+          to: [{ email: `_test-receiver@${config.domain}` }],
+        });
+
+        assert.isError(response, 401, 'Send email should fail without authentication');
+      },
+    },
+
+    {
+      name: 'non-admin-rejected',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('backend-manager/admin/email', {
+          subject: 'Test Email',
+          to: [{ email: `_test-receiver@${config.domain}` }],
+        });
+
+        assert.isError(response, 403, 'Send email should fail for non-admin user');
+      },
+    },
+
+    // --- Basic Validation ---
+
+    {
+      name: 'missing-subject-rejected',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('backend-manager/admin/email', {
+          to: [{ email: `_test-receiver@${config.domain}` }],
+          copy: false,
+        });
+
+        assert.isError(response, 400, 'Missing subject should return 400');
+      },
+    },
+
+    // --- Happy Path ---
+
+    {
+      name: 'status-sent',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const response = await http.post('backend-manager/admin/email', {
+          subject: 'BEM Test Email - Status Sent',
+          to: [{ email: `_test-receiver@${config.domain}`, name: 'Test Receiver' }],
+          copy: false,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Status Sent',
+              body: 'This is a test email from BEM tests (status: sent).',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Admin should be able to send email');
+        assert.hasProperty(response, 'data.status', 'Response should have status');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
+      },
+    },
+
+    {
+      name: 'status-queued',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, config }) {
+        const sendAt = Math.floor(Date.now() / 1000) + (72 * 60 * 60);
+
+        const response = await http.post('backend-manager/admin/email', {
+          subject: 'BEM Test Email - Status Queued',
+          to: [{ email: `_test-receiver@${config.domain}`, name: 'Test Receiver' }],
+          copy: false,
+          sendAt: sendAt,
+          data: {
+            email: {
+              subject: 'BEM Test Email - Status Queued',
+              body: 'This is a test email scheduled for later (status: queued).',
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Admin should be able to queue email');
+        assert.hasProperty(response, 'data.status', 'Response should have status');
+        assert.equal(response.data.status, 'queued', 'Status should be queued when sendAt is beyond 71 hours');
+      },
+    },
+  ],
+};

package/test/routes/admin/firestore-query.js

@@ -0,0 +1,204 @@
+/**
+ * Test: POST /admin/firestore/query
+ * Tests the admin Firestore query endpoint
+ * Requires admin authentication
+ */
+const TEST_COLLECTION = '_test_query';
+
+module.exports = {
+  description: 'Admin Firestore query operation',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    // Test 1: Setup - write test documents
+    {
+      name: 'setup-test-documents',
+      async run({ http, assert, state }) {
+        state.testDocs = [
+          { name: 'doc1', category: 'alpha', value: 10 },
+          { name: 'doc2', category: 'alpha', value: 20 },
+          { name: 'doc3', category: 'beta', value: 30 },
+        ];
+
+        for (let i = 0; i < state.testDocs.length; i++) {
+          const doc = state.testDocs[i];
+          const response = await http.as('admin').post('backend-manager/admin/firestore', {
+            path: `${TEST_COLLECTION}/doc${i + 1}`,
+            document: doc,
+          });
+          assert.isSuccess(response, `Setup: Writing doc${i + 1} should succeed`);
+        }
+      },
+    },
+
+    // Test 2: Query all documents in collection
+    {
+      name: 'query-all-documents',
+      async run({ http, assert, state }) {
+        const queryResponse = await http.as('admin').post('backend-manager/admin/firestore/query', {
+          queries: [
+            { collection: TEST_COLLECTION },
+          ],
+        });
+
+        assert.isSuccess(queryResponse, 'Query should succeed');
+        assert.ok(
+          Array.isArray(queryResponse.data),
+          'Response should be an array'
+        );
+        assert.ok(
+          queryResponse.data.length >= 3,
+          `Should find at least 3 documents, found ${queryResponse.data.length}`
+        );
+      },
+    },
+
+    // Test 3: Query with where clause
+    {
+      name: 'query-with-where',
+      async run({ http, assert }) {
+        const queryResponse = await http.as('admin').post('backend-manager/admin/firestore/query', {
+          queries: [
+            {
+              collection: TEST_COLLECTION,
+              where: [
+                { field: 'category', operator: '==', value: 'alpha' },
+              ],
+            },
+          ],
+        });
+
+        assert.isSuccess(queryResponse, 'Query with where should succeed');
+        assert.ok(
+          Array.isArray(queryResponse.data),
+          'Response should be an array'
+        );
+        assert.equal(
+          queryResponse.data.length,
+          2,
+          'Should find exactly 2 alpha documents'
+        );
+
+        queryResponse.data.forEach(doc => {
+          assert.equal(doc.data.category, 'alpha', 'All results should be category alpha');
+        });
+      },
+    },
+
+    // Test 4: Query with limit
+    {
+      name: 'query-with-limit',
+      async run({ http, assert }) {
+        const queryResponse = await http.as('admin').post('backend-manager/admin/firestore/query', {
+          queries: [
+            {
+              collection: TEST_COLLECTION,
+              limit: 2,
+            },
+          ],
+        });
+
+        assert.isSuccess(queryResponse, 'Query with limit should succeed');
+        assert.ok(
+          queryResponse.data.length <= 2,
+          `Should return at most 2 documents, got ${queryResponse.data.length}`
+        );
+      },
+    },
+
+    // Test 5: Query with orderBy
+    {
+      name: 'query-with-orderBy',
+      async run({ http, assert }) {
+        const queryResponse = await http.as('admin').post('backend-manager/admin/firestore/query', {
+          queries: [
+            {
+              collection: TEST_COLLECTION,
+              orderBy: [
+                { field: 'value', order: 'desc' },
+              ],
+            },
+          ],
+        });
+
+        assert.isSuccess(queryResponse, 'Query with orderBy should succeed');
+        assert.ok(
+          Array.isArray(queryResponse.data) && queryResponse.data.length >= 2,
+          'Should have at least 2 results to verify order'
+        );
+
+        for (let i = 0; i < queryResponse.data.length - 1; i++) {
+          assert.ok(
+            queryResponse.data[i].data.value >= queryResponse.data[i + 1].data.value,
+            'Results should be in descending order by value'
+          );
+        }
+      },
+    },
+
+    // Test 6: Query with empty collection returns empty array
+    {
+      name: 'query-empty-collection',
+      async run({ http, assert }) {
+        const queryResponse = await http.as('admin').post('backend-manager/admin/firestore/query', {
+          queries: [
+            { collection: '_test_nonexistent_collection_12345' },
+          ],
+        });
+
+        assert.isSuccess(queryResponse, 'Query on empty collection should succeed');
+        assert.ok(
+          Array.isArray(queryResponse.data),
+          'Response should be an array'
+        );
+        assert.equal(
+          queryResponse.data.length,
+          0,
+          'Empty collection should return empty array'
+        );
+      },
+    },
+
+    // Test 7: Query with no collection specified returns empty
+    {
+      name: 'query-no-collection',
+      async run({ http, assert }) {
+        const queryResponse = await http.as('admin').post('backend-manager/admin/firestore/query', {
+          queries: [{}],
+        });
+
+        assert.isSuccess(queryResponse, 'Query with no collection should succeed (returns empty)');
+        assert.ok(
+          Array.isArray(queryResponse.data),
+          'Response should be an array'
+        );
+      },
+    },
+
+    // Test 8: Unauthenticated request fails
+    {
+      name: 'unauthenticated-rejected',
+      async run({ http, assert }) {
+        const queryResponse = await http.as('none').post('backend-manager/admin/firestore/query', {
+          queries: [{ collection: TEST_COLLECTION }],
+        });
+
+        assert.isError(queryResponse, 401, 'Query should fail without authentication');
+      },
+    },
+
+    // Test 9: Non-admin user fails
+    {
+      name: 'non-admin-rejected',
+      async run({ http, assert }) {
+        const queryResponse = await http.as('basic').post('backend-manager/admin/firestore/query', {
+          queries: [{ collection: TEST_COLLECTION }],
+        });
+
+        assert.isError(queryResponse, 403, 'Query should fail for non-admin user');
+      },
+    },
+
+  ],
+};

package/test/routes/admin/firestore.js

@@ -0,0 +1,127 @@
+/**
+ * Test: GET/POST /admin/firestore
+ * Tests the admin Firestore read/write endpoints
+ * Requires admin authentication
+ */
+const TEST_PATH = '_test/firestore-test-doc';
+
+module.exports = {
+  description: 'Admin Firestore read/write operations',
+  type: 'group',
+  tests: [
+    // Test 1: Setup - write a test document first
+    {
+      name: 'setup-test-document',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const testData = {
+          testField: 'read-test-value',
+          timestamp: new Date().toISOString(),
+          nested: {
+            field1: 'nested-value',
+            field2: 42,
+          },
+        };
+
+        const writeResponse = await http.post('backend-manager/admin/firestore', {
+          path: TEST_PATH,
+          document: testData,
+        });
+
+        assert.isSuccess(writeResponse, 'Setup: Firestore write should succeed');
+      },
+    },
+
+    // Test 2: Admin can read document
+    {
+      name: 'admin-read-succeeds',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const readResponse = await http.get('backend-manager/admin/firestore', {
+          path: TEST_PATH,
+        });
+
+        assert.isSuccess(readResponse, 'Firestore read should succeed with admin auth');
+        assert.hasProperty(readResponse, 'data.testField', 'Response should contain test data');
+        assert.equal(
+          readResponse.data.testField,
+          'read-test-value',
+          'Read data should match written data'
+        );
+        assert.hasProperty(readResponse, 'data.nested.field1', 'Response should contain nested data');
+        assert.equal(
+          readResponse.data.nested.field2,
+          42,
+          'Nested field should match written data'
+        );
+      },
+    },
+
+    // Test 3: Reading non-existent document returns empty/undefined/null
+    {
+      name: 'read-nonexistent-returns-empty',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const readResponse = await http.get('backend-manager/admin/firestore', {
+          path: '_test/nonexistent-document-12345',
+        });
+
+        assert.isSuccess(readResponse, 'Reading non-existent document should succeed');
+        const isEmpty = readResponse.data === undefined
+          || readResponse.data === null
+          || (typeof readResponse.data === 'object' && Object.keys(readResponse.data).length === 0);
+        assert.ok(isEmpty, 'Non-existent document should return undefined, null, or empty object');
+      },
+    },
+
+    // Test 4: Missing path returns 400 error
+    {
+      name: 'missing-path-rejected',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const readResponse = await http.get('backend-manager/admin/firestore', {});
+
+        assert.isError(readResponse, 400, 'Missing path should return 400');
+      },
+    },
+
+    // Test 5: Unauthenticated request fails
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const readResponse = await http.get('backend-manager/admin/firestore', {
+          path: TEST_PATH,
+        });
+
+        assert.isError(readResponse, 401, 'Firestore read should fail without authentication');
+      },
+    },
+
+    // Test 6: Non-admin user fails
+    {
+      name: 'non-admin-rejected',
+      auth: 'user',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const readResponse = await http.get('backend-manager/admin/firestore', {
+          path: TEST_PATH,
+        });
+
+        assert.isError(readResponse, 403, 'Firestore read should fail for non-admin user');
+      },
+    },
+
+  ],
+};

package/test/routes/admin/infer-contact.js

@@ -0,0 +1,218 @@
+/**
+ * Test: POST /admin/infer-contact
+ * Tests the admin infer-contact endpoint for inferring names from email addresses
+ *
+ * AI inference tests only run when TEST_EXTENDED_MODE is set (requires BACKEND_MANAGER_OPENAI_API_KEY)
+ */
+module.exports = {
+  description: 'Admin infer contact',
+  type: 'group',
+  tests: [
+    // ─── Auth rejection ───
+
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isError(response, 401, 'Should reject unauthenticated requests');
+      },
+    },
+
+    {
+      name: 'non-admin-rejected',
+      auth: 'user',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isError(response, 403, 'Should reject non-admin users');
+      },
+    },
+
+    // ─── Single email ───
+
+    {
+      name: 'single-email-returns-result',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isSuccess(response, 'Should succeed for admin');
+        assert.hasProperty(response, 'data.results', 'Should have results array');
+        assert.equal(response.data.results.length, 1, 'Should have 1 result');
+
+        const result = response.data.results[0];
+        assert.equal(result.email, 'john.smith@gmail.com', 'Should include email');
+        assert.hasProperty(result, 'firstName', 'Should have firstName field');
+        assert.hasProperty(result, 'lastName', 'Should have lastName field');
+        assert.hasProperty(result, 'method', 'Should include method');
+        assert.hasProperty(result, 'confidence', 'Should include confidence');
+        assert.equal(result.method, 'ai', 'Should use AI method');
+      },
+    },
+
+    // ─── Batch emails ───
+
+    {
+      name: 'batch-emails-returns-all-results',
+      auth: 'admin',
+      timeout: 60000,
+
+      async run({ http, assert }) {
+        const emails = [
+          'sarah.connor@skynet.io',
+          'bob-jones@hotmail.com',
+          'admin@acme.com',
+        ];
+
+        const response = await http.post('backend-manager/admin/infer-contact', { emails });
+
+        assert.isSuccess(response, 'Should succeed for batch');
+        assert.equal(response.data.results.length, 3, 'Should have 3 results');
+
+        // Verify each email is in results
+        for (let i = 0; i < emails.length; i++) {
+          assert.equal(response.data.results[i].email, emails[i], `Result ${i} should match input email`);
+        }
+      },
+    },
+
+    // ─── Name parsing (requires AI) ───
+
+    {
+      name: 'regex-parses-dot-separated-names',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        // Use a name unlikely to trigger the "fictional/brand" rejection in the AI prompt.
+        // The infer-contact prompt rejects placeholder + fictional names (e.g. alice.wonderland,
+        // john.doe). Use a generic-but-realistic name to exercise dot-separated parsing.
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'sarah.martinez@example.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+
+        assert.equal(result.firstName, 'Sarah', 'Should parse first name');
+        assert.equal(result.lastName, 'Martinez', 'Should parse last name');
+      },
+    },
+
+    {
+      name: 'infers-company-from-custom-domain',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'ceo@my-startup.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+        assert.ok(result.company, 'Should infer company from custom domain');
+      },
+    },
+
+    {
+      name: 'no-company-from-generic-domain',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          email: 'someone@gmail.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+        assert.equal(result.company, '', 'Should not infer company from gmail');
+      },
+    },
+
+    // ─── AI inference (requires TEST_EXTENDED_MODE) ───
+
+    {
+      name: 'ai-inference',
+      auth: 'admin',
+      timeout: 60000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping AI inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          emails: [
+            'john.smith@microsoft.com',
+            'xkcd42@gmail.com',
+            'bobs.burgers@example.com',
+          ],
+        });
+
+        assert.isSuccess(response, 'AI inference should succeed');
+
+        const results = response.data.results;
+        assert.equal(results.length, 3, 'Should have 3 results');
+
+        // Verify structure — AI may return empty names but shape must be correct
+        for (const r of results) {
+          assert.hasProperty(r, 'firstName', `${r.email}: should have firstName`);
+          assert.hasProperty(r, 'lastName', `${r.email}: should have lastName`);
+          assert.hasProperty(r, 'method', `${r.email}: should have method`);
+          assert.hasProperty(r, 'confidence', `${r.email}: should have confidence`);
+        }
+
+        // john.smith@microsoft.com — AI should parse this but may flake
+        const john = results.find(r => r.email === 'john.smith@microsoft.com');
+        assert.equal(john.method, 'ai', 'Should use AI method');
+        if (!john.firstName) {
+          console.warn('AI flake: john.smith@microsoft.com returned empty firstName (non-fatal)');
+        }
+      },
+    },
+
+    // ─── Edge cases ───
+
+    {
+      name: 'empty-emails-array-returns-empty',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/admin/infer-contact', {
+          emails: [],
+        });
+
+        assert.isSuccess(response);
+        assert.equal(response.data.results.length, 0, 'Empty input should return empty results');
+      },
+    },
+  ],
+};