backend-manager 5.9.4 → 5.9.6

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

@@ -1,134 +0,0 @@
-/**
- * Test: admin:database-read
- * Tests the admin Realtime Database read command
- * Requires admin authentication
- */
-const TEST_PATH = '_test/database-read-test';
-
-module.exports = {
-  description: 'Admin Realtime Database read operation',
-  type: 'group',
-  tests: [
-    // Test 1: Setup - write test data first
-    {
-      name: 'setup-test-data',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        // Write test data to read later
-        const testData = {
-          testField: 'database-read-test-value',
-          timestamp: new Date().toISOString(),
-          nested: {
-            field1: 'nested-value',
-            field2: 123,
-          },
-        };
-
-        const writeResponse = await http.command('admin:database-write', {
-          path: TEST_PATH,
-          document: testData,
-        });
-
-        assert.isSuccess(writeResponse, 'Setup: Database write should succeed');
-      },
-    },
-
-    // Test 2: Admin can read data
-    {
-      name: 'admin-read-succeeds',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const readResponse = await http.command('admin:database-read', {
-          path: TEST_PATH,
-        });
-
-        assert.isSuccess(readResponse, 'Database read should succeed with admin auth');
-        assert.hasProperty(readResponse, 'data.testField', 'Response should contain test data');
-        assert.equal(
-          readResponse.data.testField,
-          'database-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,
-          123,
-          'Nested field should match written data'
-        );
-      },
-    },
-
-    // Test 3: Reading non-existent path returns empty/null
-    {
-      name: 'read-nonexistent-returns-null',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const readResponse = await http.command('admin:database-read', {
-          path: '_test/nonexistent-path-12345',
-        });
-
-        assert.isSuccess(readResponse, 'Reading non-existent path should succeed');
-        // Realtime Database returns null for non-existent paths
-        // However, emulator may return empty object {} in some cases
-        const data = readResponse.data;
-        const isEmpty = data === null
-          || data === undefined
-          || (typeof data === 'object' && Object.keys(data).length === 0);
-        assert.ok(
-          isEmpty,
-          `Non-existent path should return null, undefined, or empty object, got: ${JSON.stringify(data)}`
-        );
-      },
-    },
-
-    // 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:database-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:database-read', {
-          path: TEST_PATH,
-        });
-
-        assert.isError(readResponse, 401, 'Database read should fail without authentication');
-      },
-    },
-
-    // Test 6: Non-admin user fails
-    {
-      name: 'non-admin-rejected',
-      auth: 'basic',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const readResponse = await http.command('admin:database-read', {
-          path: TEST_PATH,
-        });
-
-        assert.isError(readResponse, 403, 'Database read should fail for non-admin user');
-      },
-    },
-
-  ],
-};

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

@@ -1,159 +0,0 @@
-/**
- * Test: admin:database-write
- * Tests the admin Realtime Database write command
- * Requires admin authentication
- * Note: There's a bug in the API - line 19 checks `if (payload.user.roles.admin)` but should be `if (!payload.user.roles.admin)`
- */
-const TEST_PATH = '_test/database-write-test';
-
-module.exports = {
-  description: 'Admin Realtime Database write operation',
-  type: 'group',
-  tests: [
-    // Test 1: Admin can write data
-    {
-      name: 'admin-write-succeeds',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const testData = {
-          testField: 'database-write-test-value',
-          timestamp: new Date().toISOString(),
-          nested: {
-            field1: 'nested-value',
-            field2: 456,
-          },
-        };
-
-        const writeResponse = await http.command('admin:database-write', {
-          path: TEST_PATH,
-          document: testData,
-        });
-
-        assert.isSuccess(writeResponse, 'Database write should succeed with admin auth');
-        assert.hasProperty(writeResponse, 'data.testField', 'Response should contain written data');
-        assert.equal(
-          writeResponse.data.testField,
-          'database-write-test-value',
-          'Response data should match input'
-        );
-      },
-    },
-
-    // Test 2: Verify written data can be read back
-    {
-      name: 'verify-write-persisted',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const readResponse = await http.command('admin:database-read', {
-          path: TEST_PATH,
-        });
-
-        assert.isSuccess(readResponse, 'Reading written data should succeed');
-        assert.equal(
-          readResponse.data.testField,
-          'database-write-test-value',
-          'Persisted data should match written data'
-        );
-        assert.equal(
-          readResponse.data.nested.field2,
-          456,
-          'Nested data should be persisted'
-        );
-      },
-    },
-
-    // Test 3: Can overwrite existing data
-    {
-      name: 'overwrite-succeeds',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const newData = {
-          testField: 'updated-value',
-          newField: 'this-is-new',
-        };
-
-        const writeResponse = await http.command('admin:database-write', {
-          path: TEST_PATH,
-          document: newData,
-        });
-
-        assert.isSuccess(writeResponse, 'Overwrite should succeed');
-        assert.equal(
-          writeResponse.data.testField,
-          'updated-value',
-          'Response should have updated value'
-        );
-
-        // Verify the data was actually overwritten (not merged)
-        const readResponse = await http.command('admin:database-read', {
-          path: TEST_PATH,
-        });
-
-        assert.isSuccess(readResponse, 'Reading overwritten data should succeed');
-        assert.equal(
-          readResponse.data.testField,
-          'updated-value',
-          'Data should be updated'
-        );
-        assert.ok(
-          !readResponse.data.nested,
-          'Previous nested data should be gone (set replaces, not merges)'
-        );
-      },
-    },
-
-    // Test 4: Missing path returns 400 error
-    {
-      name: 'missing-path-rejected',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const writeResponse = await http.command('admin:database-write', {
-          document: { test: 'data' },
-        });
-
-        assert.isError(writeResponse, 400, 'Missing path should return 400');
-      },
-    },
-
-    // Test 5: Unauthenticated request fails
-    {
-      name: 'unauthenticated-rejected',
-      auth: 'none',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const writeResponse = await http.command('admin:database-write', {
-          path: TEST_PATH,
-          document: { test: 'should-fail' },
-        });
-
-        assert.isError(writeResponse, 401, 'Database write should fail without authentication');
-      },
-    },
-
-    // Test 6: Non-admin user fails
-    {
-      name: 'non-admin-rejected',
-      auth: 'basic',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const writeResponse = await http.command('admin:database-write', {
-          path: TEST_PATH,
-          document: { test: 'should-fail' },
-        });
-
-        assert.isError(writeResponse, 403, 'Database write should fail for non-admin user');
-      },
-    },
-
-  ],
-};

package/test/functions/admin/edit-post.js

@@ -1,366 +0,0 @@
-/**
- * Test: admin:edit-post
- * Tests the admin edit post command
- * Edits blog post content in a GitHub repository
- * Requires admin/blogger role, GitHub API key, and repo_website config
- *
- * This is a suite because we need to:
- * 1. Create a test post file via Octokit
- * 2. Wait for GitHub to index it (for code search)
- * 3. Edit it via the API
- * 4. Clean up the test file
- */
-const { Octokit } = require('@octokit/rest');
-
-// Test post configuration
-const TEST_POST_SLUG = 'bem-test-post';
-const TEST_POST_ID = Date.now();
-
-// Generate frontmatter for the test post
-function generatePostContent(body) {
-  const frontmatter = `layout: blueprint/blog/post
-
-meta:
-  title: BEM Test Post
-  description: This is a test post created by BEM test suite.
-  og:image: ''
-
-post:
-  title: BEM Test Post
-  id: ${TEST_POST_ID}
-  description: This is a test post created by BEM test suite.
-  author: guest
-  tags: []
-  categories: []`;
-
-  return `---\n${frontmatter}\n---\n\n${body}`;
-}
-
-module.exports = {
-  description: 'Admin edit post on GitHub',
-  type: 'suite',
-  timeout: 300000, // 5 minutes total for the suite
-  skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE env var not set (skipping GitHub edit tests)' : false,
-
-  tests: [
-    // Test 1: Missing URL returns 400 error
-    {
-      name: 'missing-url-rejected',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('admin:edit-post', {
-          body: 'Test content',
-        });
-
-        assert.isError(response, 400, 'Missing URL should return 400');
-      },
-    },
-
-    // Test 4: Missing body returns 400 error
-    {
-      name: 'missing-body-rejected',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('admin:edit-post', {
-          url: 'https://example.com/blog/test-post',
-        });
-
-        assert.isError(response, 400, 'Missing body should return 400');
-      },
-    },
-
-    // Test 5: Non-existent post returns 404
-    {
-      name: 'nonexistent-post-returns-404',
-      auth: 'admin',
-      timeout: 60000,
-
-      async run({ http, assert, config }) {
-        const response = await http.command('admin:edit-post', {
-          url: `https://${config.domain}/blog/nonexistent-test-post-12345`,
-          body: 'This is test content from BEM test suite.',
-        });
-
-        assert.isError(response, 404, 'Non-existent post should return 404');
-      },
-    },
-
-    // Test 6: Non-existent repo returns 404
-    {
-      name: 'nonexistent-repo-returns-404',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        const response = await http.command('admin:edit-post', {
-          url: 'https://example.com/blog/test-post',
-          body: 'Test content',
-          githubUser: 'nonexistent-user-12345',
-          githubRepo: 'nonexistent-repo-12345',
-        });
-
-        assert.isError(response, 404, 'Non-existent repo should return 404');
-      },
-    },
-
-    // Test 7: Create a test post via Octokit
-    {
-      name: 'create-test-post',
-      auth: 'admin',
-      timeout: 60000,
-      skip: !process.env.GH_TOKEN ? 'GH_TOKEN env var not set' : false,
-
-      async run({ assert, state, config }) {
-        if (!config.github?.repo_website) {
-          assert.fail('githubRepoWebsite not configured');
-          return;
-        }
-
-        const octokit = new Octokit({ auth: process.env.GH_TOKEN });
-
-        // Parse owner/repo from githubRepoWebsite
-        const repoMatch = config.github?.repo_website.match(/github\.com\/([^/]+)\/([^/]+)/);
-        if (!repoMatch) {
-          assert.fail('Could not parse githubRepoWebsite');
-          return;
-        }
-
-        state.owner = repoMatch[1];
-        state.repo = repoMatch[2];
-
-        // Build the post path (matches the structure expected by fetch-post)
-        const date = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
-        const year = date.split('-')[0];
-        state.postPath = `src/_posts/${year}/guest/${date}-${TEST_POST_SLUG}.md`;
-        state.postSlug = TEST_POST_SLUG;
-
-        // Create the post content
-        const originalBody = 'This is the original content of the test post.\n\nIt will be edited by the BEM test suite.';
-        state.originalBody = originalBody;
-        const content = generatePostContent(originalBody);
-
-        // Check if the file already exists (from a previous failed run)
-        let existingSha;
-        try {
-          const existing = await octokit.rest.repos.getContent({
-            owner: state.owner,
-            repo: state.repo,
-            path: state.postPath,
-          });
-          existingSha = existing.data.sha;
-        } catch (e) {
-          // File doesn't exist, that's fine
-        }
-
-        // Create or update the file via Octokit
-        const createResult = await octokit.rest.repos.createOrUpdateFileContents({
-          owner: state.owner,
-          repo: state.repo,
-          path: state.postPath,
-          message: `🧪 BEM test: create test post for edit-post test`,
-          content: Buffer.from(content).toString('base64'),
-          sha: existingSha, // Include SHA if file exists
-        }).catch(e => e);
-
-        if (createResult instanceof Error) {
-          assert.fail(`Failed to create test post: ${createResult.message}`);
-          return;
-        }
-
-        assert.ok(createResult.data.content.sha, 'Post should be created with a SHA');
-        state.postSha = createResult.data.content.sha;
-      },
-    },
-
-    // Test 8: Verify the file exists via GitHub API (not code search)
-    {
-      name: 'verify-file-exists',
-      auth: 'admin',
-      timeout: 30000,
-      skip: !process.env.GH_TOKEN ? 'GH_TOKEN env var not set' : false,
-
-      async run({ assert, state, config }) {
-        if (!state.postPath) {
-          return; // Previous test didn't run
-        }
-
-        state.postUrl = `https://${config.domain}/blog/${state.postSlug}`;
-
-        const octokit = new Octokit({ auth: process.env.GH_TOKEN });
-
-        // Verify the file exists via direct API (not code search)
-        const { data: fileData } = await octokit.rest.repos.getContent({
-          owner: state.owner,
-          repo: state.repo,
-          path: state.postPath,
-        });
-
-        assert.ok(fileData.sha, 'File should exist in GitHub repo');
-        state.currentSha = fileData.sha;
-      },
-    },
-
-    // Test 9: Edit the test post via admin:edit-post
-    // NOTE: This may fail if GitHub's code search hasn't indexed the file yet
-    // The edit-post API uses fetch-post which relies on code search
-    {
-      name: 'edit-test-post',
-      auth: 'admin',
-      timeout: 60000,
-      skip: !process.env.GH_TOKEN ? 'GH_TOKEN env var not set' : false,
-
-      async run({ http, assert, state }) {
-        if (!state.postUrl) {
-          return; // Previous tests didn't run
-        }
-
-        const newBody = 'This content was EDITED by the BEM test suite.\n\nThe edit was successful!';
-        state.editedBody = newBody;
-
-        const response = await http.command('admin:edit-post', {
-          url: state.postUrl,
-          body: newBody,
-        });
-
-        // If fetch-post can't find the file (not indexed yet), it returns 404
-        // This is a known limitation - the file exists but code search hasn't indexed it
-        if (response.status === 404 && response.error?.includes('not found')) {
-          state.editSkipped = true;
-          assert.ok(true, 'Edit skipped - GitHub code search has not indexed the file yet (this is expected for new files)');
-          return;
-        }
-
-        assert.isSuccess(response, 'Edit post should succeed');
-        assert.hasProperty(response, 'data.url', 'Response should have url');
-      },
-    },
-
-    // Test 10: Verify the edit was applied (using Octokit directly)
-    {
-      name: 'verify-edit',
-      auth: 'admin',
-      timeout: 30000,
-      skip: !process.env.GH_TOKEN ? 'GH_TOKEN env var not set' : false,
-
-      async run({ assert, state }) {
-        if (!state.postPath || state.editSkipped) {
-          assert.ok(true, 'Skipping verify - edit was not performed');
-          return;
-        }
-
-        const octokit = new Octokit({ auth: process.env.GH_TOKEN });
-
-        // Fetch the file directly from GitHub
-        const { data: fileData } = await octokit.rest.repos.getContent({
-          owner: state.owner,
-          repo: state.repo,
-          path: state.postPath,
-        });
-
-        // Decode the content
-        const content = Buffer.from(fileData.content, 'base64').toString();
-
-        assert.ok(
-          content.includes('EDITED by the BEM test suite'),
-          'Post content should contain the edited text'
-        );
-      },
-    },
-
-    // --- Auth rejection tests (at end per convention) ---
-    {
-      name: 'unauthenticated-rejected',
-      auth: 'none',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('admin:edit-post', {
-          url: 'https://example.com/blog/test-post',
-          body: 'Test content',
-        });
-
-        assert.isError(response, 401, 'Edit post should fail without authentication');
-      },
-    },
-
-    {
-      name: 'non-admin-rejected',
-      auth: 'basic',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('admin:edit-post', {
-          url: 'https://example.com/blog/test-post',
-          body: 'Test content',
-        });
-
-        assert.isError(response, 403, 'Edit post should fail for non-admin user');
-      },
-    },
-
-    // Cleanup - delete test post and cancel workflows
-    {
-      name: 'cleanup',
-      auth: 'admin',
-      timeout: 60000,
-
-      async run({ state }) {
-        if (!process.env.GH_TOKEN || !state.postPath) {
-          return;
-        }
-
-        const octokit = new Octokit({ auth: process.env.GH_TOKEN });
-
-        // Get the current SHA (may have changed after edit)
-        try {
-          const { data: fileData } = await octokit.rest.repos.getContent({
-            owner: state.owner,
-            repo: state.repo,
-            path: state.postPath,
-          });
-
-          // Delete the test post
-          await octokit.rest.repos.deleteFile({
-            owner: state.owner,
-            repo: state.repo,
-            path: state.postPath,
-            message: `🧹 BEM test cleanup: delete test post`,
-            sha: fileData.sha,
-          });
-        } catch (e) {
-          // File might not exist, ignore
-        }
-
-        // Cancel any running workflows triggered by our test commits
-        try {
-          const { data: runs } = await octokit.rest.actions.listWorkflowRunsForRepo({
-            owner: state.owner,
-            repo: state.repo,
-            status: 'in_progress',
-            per_page: 10,
-          });
-
-          for (const run of runs.workflow_runs) {
-            if (run.head_commit?.message?.includes('BEM test')) {
-              try {
-                await octokit.rest.actions.cancelWorkflowRun({
-                  owner: state.owner,
-                  repo: state.repo,
-                  run_id: run.id,
-                });
-              } catch (e) {
-                // May already be completed, ignore
-              }
-            }
-          }
-        } catch (e) {
-          // Workflow cancellation failed, not critical
-        }
-      },
-    },
-  ],
-};