backend-manager 5.9.4 → 5.9.6

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

@@ -1,207 +0,0 @@
-/**
- * Test: admin:firestore-query
- * Tests the admin Firestore query command
- * 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 }) {
-        // Write multiple test documents to query
-        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').command('admin:firestore-write', {
-            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').command('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').command('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'
-        );
-
-        // Verify all results have category alpha
-        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').command('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').command('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'
-        );
-
-        // Verify descending 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').command('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').command('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').command('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').command('admin:firestore-query', {
-          queries: [{ collection: TEST_COLLECTION }],
-        });
-
-        assert.isError(queryResponse, 403, 'Query should fail for non-admin user');
-      },
-    },
-
-  ],
-};

package/test/functions/admin/firestore-read.js

@@ -1,129 +0,0 @@
-/**
- * Test: admin:firestore-read
- * Tests the admin Firestore read command
- * Requires admin authentication
- */
-const TEST_PATH = '_test/firestore-read-test-doc';
-
-module.exports = {
-  description: 'Admin Firestore read operation',
-  type: 'group',
-  tests: [
-    // Test 1: Setup - write a test document first
-    {
-      name: 'setup-test-document',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        // Write a test document to read later
-        const testData = {
-          testField: 'read-test-value',
-          timestamp: new Date().toISOString(),
-          nested: {
-            field1: 'nested-value',
-            field2: 42,
-          },
-        };
-
-        const writeResponse = await http.command('admin:firestore-write', {
-          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.command('admin:firestore-read', {
-          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.command('admin:firestore-read', {
-          path: '_test/nonexistent-document-12345',
-        });
-
-        assert.isSuccess(readResponse, 'Reading non-existent document should succeed');
-        // Non-existent doc returns undefined from doc.data(), but response wrapper may convert to null or empty object
-        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.command('admin:firestore-read', {});
-
-        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.command('admin:firestore-read', {
-          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.command('admin:firestore-read', {
-          path: TEST_PATH,
-        });
-
-        assert.isError(readResponse, 403, 'Firestore read should fail for non-admin user');
-      },
-    },
-
-  ],
-};

package/test/functions/admin/firestore-write.js

@@ -1,105 +0,0 @@
-/**
- * Test: Admin Firestore Write
- * Tests the admin:firestore-write command
- * Requires admin authentication
- */
-const TEST_PATH = '_test/integration-test-doc';
-
-module.exports = {
-  description: 'Admin Firestore write operation',
-  type: 'group',
-  tests: [
-    // Test 1: Admin auth should succeed
-    {
-      name: 'admin-auth-succeeds',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const testData = {
-          testField: 'test-value',
-          timestamp: new Date().toISOString(),
-          nested: {
-            field1: 'value1',
-            field2: 123,
-          },
-        };
-
-        // Test writing to Firestore with admin auth
-        const writeResponse = await http.command('admin:firestore-write', {
-          path: TEST_PATH,
-          document: testData,
-          options: {
-            merge: true,
-            metadataTag: 'test:integration-test',
-          },
-        });
-
-        assert.isSuccess(writeResponse, 'Firestore write should succeed with admin auth');
-        assert.hasProperty(writeResponse, 'data.path', 'Response should contain path');
-        assert.equal(
-          writeResponse.data.path,
-          TEST_PATH,
-          'Response path should match request path'
-        );
-
-        // Test writing with dynamic path placeholder {pushId}
-        const pushIdPath = '_test/{pushId}';
-        const pushIdResponse = await http.command('admin:firestore-write', {
-          path: pushIdPath,
-          document: { test: 'pushId-test', type: 'dynamic-id-test' },
-        });
-
-        assert.isSuccess(pushIdResponse, 'Firestore write with {pushId} should succeed');
-        assert.hasProperty(pushIdResponse, 'data.path', 'Response should contain generated path');
-        assert.notEqual(
-          pushIdResponse.data.path,
-          pushIdPath,
-          'Path should have {pushId} replaced'
-        );
-        assert.ok(
-          !pushIdResponse.data.path.includes('{pushId}'),
-          'Path should not contain {pushId} placeholder'
-        );
-
-        return { success: true };
-      },
-    },
-
-    // Test 2: Unauthenticated should fail
-    {
-      name: 'unauthenticated-rejected',
-      auth: 'none',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const writeResponse = await http.command('admin:firestore-write', {
-          path: TEST_PATH,
-          document: { test: 'should-fail' },
-        });
-
-        assert.isError(writeResponse, 401, 'Firestore write should fail without authentication');
-
-        return { success: true };
-      },
-    },
-
-    // Test 3: Authenticated non-admin should fail
-    {
-      name: 'non-admin-rejected',
-      auth: 'user',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const writeResponse = await http.command('admin:firestore-write', {
-          path: TEST_PATH,
-          document: { test: 'should-fail' },
-        });
-
-        assert.isError(writeResponse, 403, 'Firestore write should fail for non-admin user');
-
-        return { success: true };
-      },
-    },
-  ],
-};

package/test/functions/admin/get-stats.js

@@ -1,115 +0,0 @@
-/**
- * Test: admin:get-stats
- * Tests the admin get stats command
- * Requires admin authentication
- */
-module.exports = {
-  description: 'Admin get stats operation',
-  type: 'group',
-  tests: [
-    // Test 1: Admin can get stats
-    {
-      name: 'admin-get-stats-succeeds',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        const response = await http.command('admin:get-stats', {});
-
-        assert.isSuccess(response, 'Get stats should succeed with admin auth');
-        assert.ok(
-          typeof response.data === 'object',
-          'Response data should be an object'
-        );
-      },
-    },
-
-    // Test 2: Stats contains users field
-    {
-      name: 'stats-contains-users',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        const response = await http.command('admin:get-stats', {});
-
-        assert.isSuccess(response, 'Get stats should succeed');
-        assert.hasProperty(response, 'data.users', 'Stats should contain users field');
-        assert.hasProperty(response, 'data.users.total', 'Users should have total field');
-        assert.ok(
-          typeof response.data.users.total === 'number',
-          'users.total should be a number'
-        );
-      },
-    },
-
-    // Test 3: Stats with update flag refreshes data
-    {
-      name: 'stats-with-update',
-      auth: 'admin',
-      timeout: 60000, // Longer timeout for update operation
-
-      async run({ http, assert }) {
-        const response = await http.command('admin:get-stats', {
-          update: { users: true },
-        });
-
-        assert.isSuccess(response, 'Get stats with update should succeed');
-        assert.hasProperty(response, 'data.users.total', 'Updated stats should have users.total');
-        assert.ok(
-          response.data.users.total >= 0,
-          'users.total should be a non-negative number'
-        );
-      },
-    },
-
-    // Test 4: Stats contains metadata
-    {
-      name: 'stats-has-metadata',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        // First do an update to ensure metadata is set
-        await http.command('admin:get-stats', {
-          update: { users: true },
-        });
-
-        // Then fetch stats
-        const response = await http.command('admin:get-stats', {});
-
-        assert.isSuccess(response, 'Get stats should succeed');
-        // Metadata may or may not exist on first run
-        if (response.data.metadata) {
-          assert.hasProperty(response, 'data.metadata.updated', 'Metadata should have updated timestamp');
-        }
-      },
-    },
-
-    // Test 5: Unauthenticated request fails
-    {
-      name: 'unauthenticated-rejected',
-      auth: 'none',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('admin:get-stats', {});
-
-        assert.isError(response, 401, 'Get stats should fail without authentication');
-      },
-    },
-
-    // Test 6: Non-admin user fails
-    {
-      name: 'non-admin-rejected',
-      auth: 'user',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('admin:get-stats', {});
-
-        assert.isError(response, 403, 'Get stats should fail for non-admin user');
-      },
-    },
-  ],
-};

package/test/functions/admin/send-email.js

@@ -1,119 +0,0 @@
-/**
- * Test: admin:send-email
- * Tests the admin send email command
- * Requires admin authentication and SendGrid API key configured
- *
- * To test with SendGrid, set SENDGRID_API_KEY environment variable.
- * Tests will be skipped if SendGrid is not configured.
- *
- * Possible status values:
- * - 'sent': Email sent via SendGrid
- * - 'queued': Scheduled beyond 71 hours, saved to queue for later
- */
-module.exports = {
-  description: 'Admin send email',
-  type: 'group',
-  skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE env var not set (skipping email tests)' : false,
-  tests: [
-    // Test 1: Missing subject returns 400 error
-    {
-      name: 'missing-subject-rejected',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert, config }) {
-        const response = await http.command('admin:send-email', {
-          to: [{ email: `_test-receiver@${config.domain}` }],
-          copy: false,
-        });
-
-        assert.isError(response, 400, 'Missing subject should return 400');
-      },
-    },
-
-    // Test 4: Status 'sent' - Email sent successfully via SendGrid
-    {
-      name: 'status-sent',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert, config }) {
-        const response = await http.command('admin:send-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');
-      },
-    },
-
-    // Test 5: Status 'queued' - Email scheduled beyond 71 hours
-    {
-      name: 'status-queued',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert, config }) {
-        // Schedule email for 72+ hours from now (beyond SendGrid's 71-hour limit)
-        const sendAt = Math.floor(Date.now() / 1000) + (72 * 60 * 60);
-
-        const response = await http.command('admin:send-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');
-      },
-    },
-
-    // --- Auth rejection tests (at end per convention) ---
-    {
-      name: 'unauthenticated-rejected',
-      auth: 'none',
-      timeout: 15000,
-
-      async run({ http, assert, config }) {
-        const response = await http.command('admin:send-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.command('admin:send-email', {
-          subject: 'Test Email',
-          to: [{ email: `_test-receiver@${config.domain}` }],
-        });
-
-        assert.isError(response, 403, 'Send email should fail for non-admin user');
-      },
-    },
-  ],
-};