backend-manager 5.9.7 → 5.9.9

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

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

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

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

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

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