backend-manager 5.9.7 → 5.9.9

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

@@ -0,0 +1,208 @@
+const { TEST_DATA } = require('../../../src/test/test-accounts.js');
+
+/**
+ * Test: admin:send-notification
+ * Tests the admin send notification (FCM) command
+ * Requires admin authentication
+ *
+ * To test with a real FCM token, set the TEST_FCM_TOKEN environment variable:
+ *   TEST_FCM_TOKEN=your-fcm-token npx bm test admin/send-notification
+ *
+ * You can get your FCM token from browser dev tools (Application > Service Workers)
+ * or from console.log in your app's notification subscription code.
+ */
+module.exports = {
+  description: 'Admin send notification (FCM)',
+  type: 'group',
+  tests: [
+    // Test 1: Admin can call send-notification with no subscribers
+    // (In emulator, notifications collection is likely empty)
+    {
+      name: 'admin-succeeds-empty-collection',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:send-notification', {
+          notification: {
+            title: 'BEM Test Notification',
+            body: 'Testing from BEM test suite',
+            clickAction: 'https://example.com/test',
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification should succeed for admin');
+        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
+        assert.hasProperty(response, 'data.deleted', 'Response should have deleted count');
+      },
+    },
+
+    // Test 4: Notification with owner filter
+    {
+      name: 'with-owner-filter',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:send-notification', {
+          notification: {
+            title: 'Filtered Notification',
+            body: 'Testing owner filter',
+          },
+          filters: {
+            owner: TEST_DATA.filterUid,
+            limit: 10,
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification with filters should succeed');
+        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
+      },
+    },
+
+    // Test 5: Notification with tags filter
+    {
+      name: 'with-tags-filter',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:send-notification', {
+          notification: {
+            title: 'Tagged Notification',
+            body: 'Testing tags filter',
+          },
+          filters: {
+            tags: ['test-tag', 'another-tag'],
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification with tags filter should succeed');
+      },
+    },
+
+    // Test 6: Notification with limit filter
+    {
+      name: 'with-limit-filter',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:send-notification', {
+          notification: {
+            title: 'Limited Notification',
+            body: 'Testing limit filter',
+          },
+          filters: {
+            limit: 5,
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification with limit should succeed');
+        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
+      },
+    },
+
+    // Test 7: Default notification values applied
+    {
+      name: 'default-values-applied',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        // Send with minimal payload to test defaults
+        const response = await http.command('admin:send-notification', {
+          notification: {},
+          filters: {
+            limit: 1,
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification with defaults should succeed');
+      },
+    },
+
+    // Test 8: Send to real FCM token (requires TEST_FCM_TOKEN env var)
+    // Skip if no token configured
+    {
+      name: 'send-to-real-token',
+      auth: 'admin',
+      timeout: 30000,
+      skip: !process.env.TEST_FCM_TOKEN ? 'TEST_FCM_TOKEN env var not set' : false,
+
+      async run({ http, assert, config }) {
+        const response = await http.command('admin:send-notification', {
+          notification: {
+            title: 'BEM Test Notification',
+            body: `Test sent at ${new Date().toISOString()}`,
+            clickAction: `https://${config.domain}/?test-notification=true`,
+          },
+          filters: {
+            token: process.env.TEST_FCM_TOKEN,
+          },
+        });
+
+        assert.isSuccess(response, 'Send notification to real token should succeed');
+        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
+      },
+    },
+
+    // Test 9: Send to fake token (API succeeds, FCM fails silently)
+    {
+      name: 'fake-token-api-succeeds',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:send-notification', {
+          notification: {
+            title: 'Fake Token Test',
+            body: 'Testing with invalid token',
+          },
+          filters: {
+            token: 'fake-invalid-token-for-testing',
+          },
+        });
+
+        // The API should succeed even if FCM fails
+        // (FCM errors are logged but don't fail the request)
+        assert.isSuccess(response, 'Send notification to fake token should succeed API-wise');
+      },
+    },
+
+    // --- Auth rejection tests (at end per convention) ---
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:send-notification', {
+          notification: {
+            title: 'Test Notification',
+            body: 'This is a test',
+          },
+        });
+
+        assert.isError(response, 401, 'Send notification should fail without authentication');
+      },
+    },
+
+    {
+      name: 'non-admin-rejected',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:send-notification', {
+          notification: {
+            title: 'Test Notification',
+            body: 'This is a test',
+          },
+        });
+
+        assert.isError(response, 403, 'Send notification should fail for non-admin user');
+      },
+    },
+  ],
+};

package/test/functions/admin/write-repo-content.js

@@ -0,0 +1,223 @@
+/**
+ * Test: admin:write-repo-content
+ * Tests the admin write repo content command
+ * Writes arbitrary content to a GitHub repository
+ * Requires admin/blogger role, GitHub API key, and repo_website config
+ *
+ * IMPORTANT: These tests require GH_TOKEN and github.repo_website to be configured.
+ * If GitHub is not configured, the tests will fail.
+ *
+ * This is a suite because we need to clean up created files and cancel workflows after tests.
+ */
+const { Octokit } = require('@octokit/rest');
+
+// Test file paths that will be created and need cleanup
+const TEST_FILES = [
+  '_test/bem-write-test.txt',
+  '_test/type-test.txt',
+];
+
+module.exports = {
+  description: 'Admin write content to GitHub repo',
+  type: 'suite',
+  timeout: 120000,
+  skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE env var not set (skipping GitHub write tests)' : false,
+
+  tests: [
+    // Test 1: Missing path returns 400 error
+    {
+      name: 'missing-path-rejected',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:write-repo-content', {
+          content: 'Test content',
+        });
+
+        assert.isError(response, 400, 'Missing path should return 400');
+      },
+    },
+
+    // Test 4: Missing content returns 400 error
+    {
+      name: 'missing-content-rejected',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:write-repo-content', {
+          path: '_test/bem-test-file.txt',
+        });
+
+        assert.isError(response, 400, 'Missing content should return 400');
+      },
+    },
+
+    // Test 5: Admin can write content
+    {
+      name: 'admin-can-write-content',
+      auth: 'admin',
+      timeout: 60000,
+
+      async run({ http, assert, state }) {
+        const uniqueContent = `BEM Test - ${new Date().toISOString()}`;
+        const response = await http.command('admin:write-repo-content', {
+          path: '_test/bem-write-test.txt',
+          content: uniqueContent,
+        });
+
+        assert.isSuccess(response, 'Admin should be able to write content');
+        assert.hasProperty(response, 'data.path', 'Response should contain path');
+        assert.equal(response.data.path, '_test/bem-write-test.txt', 'Path should match');
+
+        // Store for cleanup
+        state.filesCreated = state.filesCreated || [];
+        state.filesCreated.push('_test/bem-write-test.txt');
+      },
+    },
+
+    // Test 6: Content type defaults to text
+    {
+      name: 'content-type-default',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert, state }) {
+        const response = await http.command('admin:write-repo-content', {
+          path: '_test/type-test.txt',
+          content: 'Test content with default type',
+        });
+
+        assert.isSuccess(response, 'Write with default type should succeed');
+        assert.hasProperty(response, 'data.type', 'Response should contain type');
+        assert.equal(response.data.type, 'text', 'Default type should be text');
+
+        // Store for cleanup
+        state.filesCreated = state.filesCreated || [];
+        state.filesCreated.push('_test/type-test.txt');
+      },
+    },
+
+    // Test 7: Non-existent repo returns 404
+    {
+      name: 'nonexistent-repo-returns-404',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:write-repo-content', {
+          path: '_test/custom-repo-test.txt',
+          content: 'Test content',
+          githubUser: 'nonexistent-user-12345',
+          githubRepo: 'nonexistent-repo-12345',
+        });
+
+        assert.isError(response, 404, 'Non-existent repo should return 404');
+      },
+    },
+
+    // --- Auth rejection tests (at end per convention) ---
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:write-repo-content', {
+          path: '_test/bem-test-file.txt',
+          content: 'Test content',
+        });
+
+        assert.isError(response, 401, 'Write repo content should fail without authentication');
+      },
+    },
+
+    {
+      name: 'non-admin-rejected',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.command('admin:write-repo-content', {
+          path: '_test/bem-test-file.txt',
+          content: 'Test content',
+        });
+
+        assert.isError(response, 403, 'Write repo content should fail for non-admin user');
+      },
+    },
+
+    // Cleanup - delete test files and cancel workflows
+    {
+      name: 'cleanup',
+      auth: 'admin',
+      timeout: 60000,
+
+      async run({ state, config }) {
+        if (!process.env.GH_TOKEN || !config.github?.repo_website) {
+          return;
+        }
+
+        const octokit = new Octokit({ auth: process.env.GH_TOKEN });
+
+        // Parse owner/repo from githubRepoWebsite (e.g., 'https://github.com/owner/repo')
+        const repoMatch = config.github?.repo_website.match(/github\.com\/([^/]+)\/([^/]+)/);
+        if (!repoMatch) {
+          return;
+        }
+        const owner = repoMatch[1];
+        const repo = repoMatch[2];
+
+        // Delete test files
+        const filesToDelete = state.filesCreated || TEST_FILES;
+        for (const filePath of filesToDelete) {
+          try {
+            const { data: fileData } = await octokit.rest.repos.getContent({
+              owner,
+              repo,
+              path: filePath,
+            });
+
+            await octokit.rest.repos.deleteFile({
+              owner,
+              repo,
+              path: filePath,
+              message: `🧹 BEM test cleanup: ${filePath}`,
+              sha: fileData.sha,
+            });
+          } catch (e) {
+            // File might not exist, ignore
+          }
+        }
+
+        // Cancel running workflows triggered by our test commits
+        try {
+          const { data: runs } = await octokit.rest.actions.listWorkflowRunsForRepo({
+            owner,
+            repo,
+            status: 'in_progress',
+            per_page: 10,
+          });
+
+          for (const run of runs.workflow_runs) {
+            if (run.head_commit?.message?.includes('admin:write-repo-content')
+                || run.head_commit?.message?.includes('BEM test cleanup')) {
+              try {
+                await octokit.rest.actions.cancelWorkflowRun({
+                  owner,
+                  repo,
+                  run_id: run.id,
+                });
+              } catch (e) {
+                // May already be completed, ignore
+              }
+            }
+          }
+        } catch (e) {
+          // Workflow cancellation failed, not critical
+        }
+      },
+    },
+  ],
+};