backend-manager 5.9.4 → 5.9.6

package/test/routes/admin/email.js

@@ -1,114 +0,0 @@
-/**
- * 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

@@ -1,204 +0,0 @@
-/**
- * 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

@@ -1,127 +0,0 @@
-/**
- * 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

@@ -1,218 +0,0 @@
-/**
- * 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');
-      },
-    },
-  ],
-};