backend-manager 5.9.5 → 5.9.7

package/test/functions/general/add-marketing-contact.js

@@ -1,335 +0,0 @@
-/**
- * Test: Add Marketing Contact
- * Tests the general:add-marketing-contact command for adding users to SendGrid/Beehiiv
- *
- * Set TEST_EXTENDED_MODE=true to run tests against real SendGrid/Beehiiv APIs
- * (requires SENDGRID_API_KEY and BEEHIIV_API_KEY env vars)
- */
-
-// Test email patterns - look like real emails but +bem suffix identifies them for cleanup.
-// Fixed `acme.com` test domain — deterministic across brands. Avoids cross-brand
-// state contamination in SendGrid/Beehiiv when the same test runs under different brands.
-const TEST_DOMAIN = 'acme.com';
-const TEST_EMAILS = {
-  valid: () => `sarah.martinez+bem@${TEST_DOMAIN}`,         // Should infer: Sarah Martinez
-  invalid: () => `nonexistent.user+bem@${TEST_DOMAIN}`,     // No such mailbox — mailbox verification should flag invalid
-};
-
-module.exports = {
-  description: 'Add marketing contact (SendGrid + Beehiiv)',
-  type: 'group',
-  tests: [
-    // Test 1: Admin can add valid email (with real provider calls if TEST_EXTENDED_MODE is set)
-    {
-      name: 'admin-valid-email-succeeds',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert, state }) {
-        const testEmail = TEST_EMAILS.valid();
-        state.testEmail = testEmail;
-
-        const response = await http.command('general:add-marketing-contact', {
-          email: testEmail,
-          source: 'bem-test',
-          // No firstName/lastName - should be inferred as "Rachel Greene"
-        });
-
-        assert.isSuccess(response, 'Add marketing contact should succeed for admin');
-        assert.hasProperty(response, 'data.success', 'Response should contain success');
-        assert.propertyEquals(response, 'data.success', true, 'success should be true');
-
-        // Admin gets detailed response
-        assert.hasProperty(response, 'data.providers', 'Admin response should contain providers');
-
-        // If TEST_EXTENDED_MODE is set, verify provider results
-        if (process.env.TEST_EXTENDED_MODE) {
-          const providers = response.data.providers || {};
-
-          if (process.env.SENDGRID_API_KEY) {
-            assert.hasProperty(response, 'data.providers.campaigns', 'Should have SendGrid result');
-            if (providers.campaigns?.success) {
-              state.sendgridAdded = true;
-            } else {
-              // Log error for debugging but don't fail - could be list matching issue
-              console.log('SendGrid result:', providers.campaigns);
-            }
-          }
-
-          if (process.env.BEEHIIV_API_KEY) {
-            assert.hasProperty(response, 'data.providers.newsletter', 'Should have Beehiiv result');
-            if (providers.newsletter?.success) {
-              state.beehiivAdded = true;
-            } else {
-              console.log('Beehiiv result:', providers.newsletter);
-            }
-          }
-        }
-      },
-
-      async cleanup({ state, http }) {
-        // Only cleanup if TEST_EXTENDED_MODE is set and contacts were added
-        if (!process.env.TEST_EXTENDED_MODE || !state.testEmail) {
-          return;
-        }
-
-        console.log(`Cleaning up test contact: ${state.testEmail}`);
-
-        const result = await http.command('general:remove-marketing-contact', {
-          email: state.testEmail,
-        });
-        console.log('Cleanup result:', result.data);
-      },
-    },
-
-    // Test 2: Invalid email format rejected
-    {
-      name: 'invalid-email-format-rejected',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('general:add-marketing-contact', {
-          email: 'not-a-valid-email',
-          source: 'bem-test',
-        });
-
-        assert.isError(response, 400, 'Invalid email format should return 400');
-      },
-    },
-
-    // Test 3: Missing email rejected
-    {
-      name: 'missing-email-rejected',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('general:add-marketing-contact', {
-          firstName: 'Test',
-          source: 'bem-test',
-        });
-
-        assert.isError(response, 400, 'Missing email should return 400');
-      },
-    },
-
-    // Test 4: Disposable email rejected
-    {
-      name: 'disposable-email-rejected',
-      auth: 'admin',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('general:add-marketing-contact', {
-          email: 'test@mailinator.com',
-          source: 'bem-test',
-        });
-
-        assert.isError(response, 400, 'Disposable email should return 400');
-      },
-    },
-
-    // Test 5: Name inferred from email (AI only — requires extended mode)
-    {
-      name: 'name-inferred-from-email',
-      skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE not set (AI inference requires OPENAI_API_KEY)' : false,
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert, state }) {
-        // Use valid email without providing name - should infer "Rachel Greene"
-        const testEmail = TEST_EMAILS.valid();
-        state.testEmail = testEmail;
-
-        const response = await http.command('general:add-marketing-contact', {
-          email: testEmail,
-          source: 'bem-test',
-          // No firstName/lastName - should be inferred
-        });
-
-        assert.isSuccess(response, 'Add marketing contact should succeed');
-
-        // Check name was inferred
-        assert.hasProperty(response, 'data.nameInferred', 'Should have nameInferred');
-        assert.ok(
-          response.data.nameInferred.firstName || response.data.nameInferred.lastName,
-          'Name should be inferred from email'
-        );
-        assert.hasProperty(response.data.nameInferred, 'method', 'Should include inference method');
-
-        // Track if providers were called
-        if (process.env.TEST_EXTENDED_MODE) {
-          state.sendgridAdded = response.data?.providers?.campaigns?.success;
-          state.beehiivAdded = response.data?.providers?.newsletter?.success;
-        }
-      },
-
-      async cleanup({ state, http }) {
-        if (!process.env.TEST_EXTENDED_MODE || !state.testEmail) {
-          return;
-        }
-
-        await http.command('general:remove-marketing-contact', { email: state.testEmail });
-      },
-    },
-
-    // Test 6: Admin can skip validation (use disposable domain but skip check)
-    {
-      name: 'admin-skip-validation',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert, state }) {
-        // Use disposable domain - normally blocked, but skipValidation bypasses
-        const testEmail = 'rachel.greene+bem@mailinator.com';
-        state.testEmail = testEmail;
-
-        const response = await http.command('general:add-marketing-contact', {
-          email: testEmail,
-          source: 'bem-test',
-          skipValidation: true,
-        });
-
-        // Should succeed because validation was skipped
-        assert.isSuccess(response, 'Add marketing contact with skipValidation should succeed');
-
-        if (process.env.TEST_EXTENDED_MODE) {
-          state.sendgridAdded = response.data?.providers?.campaigns?.success;
-          state.beehiivAdded = response.data?.providers?.newsletter?.success;
-        }
-      },
-
-      async cleanup({ state, http }) {
-        if (!process.env.TEST_EXTENDED_MODE || !state.testEmail) {
-          return;
-        }
-
-        await http.command('general:remove-marketing-contact', { email: state.testEmail });
-      },
-    },
-
-    // Test 7: Mailbox verification (only runs if TEST_EXTENDED_MODE and a mailbox API key are set)
-    {
-      name: 'mailbox-validation',
-      auth: 'admin',
-      timeout: 30000,
-      skip: !process.env.TEST_EXTENDED_MODE || !(process.env.NEVERBOUNCE_API_KEY || process.env.ZEROBOUNCE_API_KEY)
-        ? 'TEST_EXTENDED_MODE or mailbox API key not set'
-        : false,
-
-      async run({ http, assert, state, skip }) {
-        const testEmail = TEST_EMAILS.valid();
-        state.testEmail = testEmail;
-
-        const response = await http.command('general:add-marketing-contact', {
-          email: testEmail,
-          source: 'bem-test',
-        });
-
-        assert.isSuccess(response, 'Add marketing contact should succeed');
-
-        // Check that validation info is included
-        assert.hasProperty(response, 'data.validation', 'Response should contain validation');
-        assert.hasProperty(response, 'data.validation.checks', 'Validation should contain checks');
-
-        // Mailbox check should be in checks when key is set
-        assert.hasProperty(response, 'data.validation.checks.mailbox', 'Should have mailbox check');
-
-        const mbResult = response.data.validation.checks.mailbox;
-
-        // If out of credits, skip test - not a failure
-        if (mbResult.error?.includes('out of credits')) {
-          skip('Mailbox verification out of credits');
-        }
-
-        assert.hasProperty(mbResult, 'status', 'Mailbox check should return status');
-
-        state.sendgridAdded = response.data?.providers?.campaigns?.success;
-        state.beehiivAdded = response.data?.providers?.newsletter?.success;
-      },
-
-      async cleanup({ state, http }) {
-        if (!state.testEmail) {
-          return;
-        }
-
-        await http.command('general:remove-marketing-contact', { email: state.testEmail });
-      },
-    },
-
-    // Test 9: Mailbox verification rejects invalid email (only runs if TEST_EXTENDED_MODE and a mailbox API key are set)
-    {
-      name: 'mailbox-rejects-invalid',
-      auth: 'admin',
-      timeout: 30000,
-      skip: !process.env.TEST_EXTENDED_MODE || !(process.env.NEVERBOUNCE_API_KEY || process.env.ZEROBOUNCE_API_KEY)
-        ? 'TEST_EXTENDED_MODE or mailbox API key not set'
-        : false,
-
-      async run({ http, assert, skip }) {
-        // Use fake email that mailbox verification should flag as invalid
-        const testEmail = TEST_EMAILS.invalid();
-
-        const response = await http.command('general:add-marketing-contact', {
-          email: testEmail,
-          source: 'bem-test',
-        });
-
-        // Should still succeed (we fail open) but mailbox should report invalid
-        assert.isSuccess(response, 'Request should succeed even with invalid email');
-
-        const mbResult = response.data?.validation?.checks?.mailbox;
-
-        // If out of credits, skip test - not a failure
-        if (mbResult?.error?.includes('out of credits')) {
-          skip('Mailbox verification out of credits');
-        }
-
-        // Mailbox should return a status indicating the email is not valid
-        if (mbResult) {
-          assert.hasProperty(mbResult, 'status', 'Should have status');
-          // Status should NOT be 'valid' for this fake email
-          assert.notEqual(mbResult.status, 'valid', 'Fake email should not be marked valid');
-        }
-      },
-    },
-
-    // --- Auth rejection tests (at end per convention) ---
-    {
-      name: 'unauthenticated-requires-recaptcha',
-      auth: 'none',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        // Public request without reCAPTCHA should fail
-        const response = await http.command('general:add-marketing-contact', {
-          email: TEST_EMAILS.valid(),
-          source: 'bem-test',
-        });
-
-        // Should fail with 400 because no reCAPTCHA token
-        assert.isError(response, 400, 'Public request without reCAPTCHA should fail');
-      },
-    },
-
-    // --- Final cleanup test (runs last to clean up test contacts from providers) ---
-    {
-      name: 'cleanup-test-contacts',
-      auth: 'admin',
-      timeout: 30000,
-      skip: !process.env.TEST_EXTENDED_MODE ? 'TEST_EXTENDED_MODE not set' : false,
-
-      async run({ http, assert }) {
-        // Clean up the rachel.greene+bem test contact from marketing providers
-        const testEmail = TEST_EMAILS.valid();
-
-        const response = await http.command('general:remove-marketing-contact', {
-          email: testEmail,
-        });
-
-        assert.isSuccess(response, 'Remove marketing contact should succeed');
-      },
-    },
-  ],
-};

package/test/functions/general/fetch-post.js

@@ -1,54 +0,0 @@
-/**
- * Test: general:fetch-post
- * Tests the general fetch post command
- * Fetches blog post content from GitHub
- * Requires GitHub API key and repo_website config
- */
-module.exports = {
-  description: 'General fetch post from GitHub',
-  type: 'group',
-  tests: [
-    // Test 1: Missing URL returns 400 error
-    {
-      name: 'missing-url-rejected',
-      auth: 'none',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('general:fetch-post', {});
-
-        assert.isError(response, 400, 'Missing URL should return 400');
-      },
-    },
-
-    // Test 2: Non-existent post returns 404
-    {
-      name: 'nonexistent-post-returns-404',
-      auth: 'none',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        const response = await http.command('general:fetch-post', {
-          url: 'https://example.com/blog/this-post-definitely-does-not-exist-12345',
-        });
-
-        assert.isError(response, 404, 'Non-existent post should return 404');
-      },
-    },
-
-    // Test 3: Authenticated user fetching non-existent post returns 404
-    {
-      name: 'authenticated-nonexistent-returns-404',
-      auth: 'basic',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        const response = await http.command('general:fetch-post', {
-          url: 'https://example.com/blog/nonexistent-test-post-12345',
-        });
-
-        assert.isError(response, 404, 'Non-existent post should return 404');
-      },
-    },
-  ],
-};

package/test/functions/general/generate-uuid.js

@@ -1,114 +0,0 @@
-/**
- * Test: UUID Generation (Legacy Command)
- * Tests the legacy command-style API for backwards compatibility
- */
-module.exports = {
-  description: 'UUID generation (legacy)',
-  type: 'group',
-  tests: [
-    {
-      name: 'v4-random-uuid',
-      auth: 'none',
-      timeout: 10000,
-
-      async run({ http, assert }) {
-        const response = await http.command('general:generate-uuid', {
-          version: '4',
-        });
-
-        assert.isSuccess(response, 'UUID v4 generation should succeed');
-        assert.hasProperty(response, 'data.uuid', 'Response should contain uuid');
-        assert.match(
-          response.data.uuid,
-          /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-          'UUID v4 should have correct format'
-        );
-
-        return { success: true };
-      },
-    },
-
-    {
-      name: 'v5-namespaced-uuid',
-      auth: 'none',
-      timeout: 10000,
-
-      async run({ http, assert }) {
-        const response = await http.command('general:generate-uuid', {
-          version: '5',
-          name: 'test-name-for-uuid',
-        });
-
-        assert.isSuccess(response, 'UUID v5 generation should succeed');
-        assert.hasProperty(response, 'data.uuid', 'Response should contain uuid');
-        assert.match(
-          response.data.uuid,
-          /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-          'UUID v5 should have correct format'
-        );
-
-        return { success: true };
-      },
-    },
-
-    {
-      name: 'v5-deterministic',
-      auth: 'none',
-      timeout: 10000,
-
-      async run({ http, assert }) {
-        const response1 = await http.command('general:generate-uuid', {
-          version: '5',
-          name: 'test-name-for-uuid',
-        });
-
-        const response2 = await http.command('general:generate-uuid', {
-          version: '5',
-          name: 'test-name-for-uuid',
-        });
-
-        assert.isSuccess(response1, 'First UUID v5 generation should succeed');
-        assert.isSuccess(response2, 'Second UUID v5 generation should succeed');
-        assert.equal(
-          response1.data.uuid,
-          response2.data.uuid,
-          'UUID v5 should be deterministic - same input should produce same output'
-        );
-
-        return { success: true };
-      },
-    },
-
-    {
-      name: 'v5-requires-name',
-      auth: 'none',
-      timeout: 10000,
-
-      async run({ http, assert }) {
-        const response = await http.command('general:generate-uuid', {
-          version: '5',
-        });
-
-        assert.isError(response, 400, 'UUID v5 without name should return 400');
-
-        return { success: true };
-      },
-    },
-
-    {
-      name: 'invalid-version-rejected',
-      auth: 'none',
-      timeout: 10000,
-
-      async run({ http, assert }) {
-        const response = await http.command('general:generate-uuid', {
-          version: '99',
-        });
-
-        assert.isError(response, 400, 'Invalid version should return 400');
-
-        return { success: true };
-      },
-    },
-  ],
-};

package/test/functions/test/authenticate.js

@@ -1,64 +0,0 @@
-/**
- * Test: test:authenticate
- * Tests different authentication methods
- */
-module.exports = {
-  description: 'Authentication methods',
-  type: 'group',
-  tests: [
-    // Test 1: Unauthenticated request
-    {
-      name: 'no-auth',
-      auth: 'none',
-      async run({ http, assert }) {
-        const response = await http.command('test:authenticate', {});
-
-        assert.isSuccess(response, 'Should succeed without auth');
-        assert.equal(response.data.user.authenticated, false, 'User should not be authenticated');
-      },
-    },
-
-    // Test 2: Private key authentication
-    {
-      name: 'private-key',
-      auth: 'basic',
-      async run({ http, assert, accounts }) {
-        const response = await http.command('test:authenticate', {});
-
-        assert.isSuccess(response, 'Should succeed with privateKey');
-        assert.equal(response.data.user.authenticated, true, 'User should be authenticated');
-        assert.equal(response.data.user.auth.uid, accounts.basic.uid, 'UID should match');
-      },
-    },
-
-    // Test 3: Invalid private key
-    {
-      name: 'invalid-private-key',
-      auth: 'none',
-      async run({ http, assert }) {
-        const response = await http.post('/bm_api', {
-          command: 'test:authenticate',
-          payload: {},
-        }, {
-          headers: { 'Authorization': 'Bearer invalid-key-12345' },
-        });
-
-        assert.isSuccess(response, 'Should succeed but not authenticate');
-        assert.equal(response.data.user.authenticated, false, 'Invalid key should not authenticate');
-      },
-    },
-
-    // Test 4: Admin (backendManagerKey) authentication
-    {
-      name: 'backend-manager-key',
-      auth: 'admin',
-      async run({ http, assert }) {
-        const response = await http.command('test:authenticate', {});
-
-        assert.isSuccess(response, 'Should succeed with backendManagerKey');
-        assert.equal(response.data.user.authenticated, true, 'User should be authenticated');
-        assert.equal(response.data.user.roles?.admin, true, 'Should have admin role');
-      },
-    },
-  ],
-};

package/test/functions/user/create-custom-token.js

@@ -1,73 +0,0 @@
-/**
- * Test: user:create-custom-token
- * Tests the user create custom token command
- * Requires user authentication (uses Api.resolveUser with adminRequired: true which means user must be authenticated)
- */
-module.exports = {
-  description: 'User create custom token',
-  type: 'group',
-  tests: [
-    // Test 1: Authenticated user can create custom token
-    {
-      name: 'authenticated-user-succeeds',
-      auth: 'basic',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('user:create-custom-token', {});
-
-        assert.isSuccess(response, 'Create custom token should succeed for authenticated user');
-        assert.hasProperty(response, 'data.token', 'Response should contain token');
-        assert.ok(
-          typeof response.data.token === 'string' && response.data.token.length > 0,
-          'Token should be a non-empty string'
-        );
-      },
-    },
-
-    // Test 2: Token has valid JWT format
-    {
-      name: 'token-is-valid-jwt',
-      auth: 'basic',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('user:create-custom-token', {});
-
-        assert.isSuccess(response, 'Create custom token should succeed');
-
-        // JWT tokens have 3 parts separated by dots
-        const parts = response.data.token.split('.');
-        assert.equal(parts.length, 3, 'Token should be a valid JWT with 3 parts');
-      },
-    },
-
-    // Test 3: Premium user can create custom token
-    // Note: Admin via backendManagerKey can't create tokens without a UID since it's not a real user
-    {
-      name: 'premium-user-succeeds',
-      auth: 'premium-active',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('user:create-custom-token', {});
-
-        assert.isSuccess(response, 'Create custom token should succeed for premium user');
-        assert.hasProperty(response, 'data.token', 'Response should contain token');
-      },
-    },
-
-    // Test 4: Unauthenticated request fails
-    {
-      name: 'unauthenticated-rejected',
-      auth: 'none',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.command('user:create-custom-token', {});
-
-        assert.isError(response, 401, 'Create custom token should fail without authentication');
-      },
-    },
-  ],
-};