backend-manager 5.0.39 → 5.0.41

package/.codeclimate.yml

@@ -0,0 +1,32 @@
+version: "2"         # required to adjust maintainability checks
+checks:
+#   argument-count:
+#     config:
+#       threshold: 4
+#   complex-logic:
+#     config:
+#       threshold: 4
+#   file-lines:
+#     config:
+#       threshold: 250
+#   method-complexity:
+#     config:
+#       threshold: 5
+#   method-count:
+#     config:
+#       threshold: 20
+  method-lines:
+    config:
+      threshold: 200
+  # nested-control-flow:
+  #   config:
+  #     threshold: 4
+  # return-statements:
+  #   config:
+  #     threshold: 4
+  # similar-code:
+  #   config:
+  #     threshold: # language-specific defaults. an override will affect all languages.
+  identical-code:
+    config:
+      threshold: 10

package/CHANGELOG.md

@@ -14,6 +14,31 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - `Fixed` for any bug fixes.
 - `Security` in case of vulnerabilities.
 
+# [5.0.39] - 2025-01-12
+### Added
+- New test infrastructure with Firebase emulator support for reliable, isolated testing.
+- Test runner with emulator auto-detection and startup.
+- Test types: standalone, suite (sequential with shared state), group (independent).
+- Built-in test accounts with SSOT configuration (basic, admin, premium-active, etc.).
+- Firestore security rules testing support.
+- HTTP client with auth helpers (`http.as('admin').command()`).
+- Rich assertion library (`isSuccess`, `isError`, `hasProperty`, etc.).
+- New `bm emulators` command for standalone emulator management.
+- Enhanced `bm test` with path filtering and parallel test support.
+
+### Changed
+- Reorganized test files to `test/functions/` with `admin/`, `user/`, `general/` categories.
+- Standardized auth test naming to `unauthenticated-rejected`.
+- Auth rejection tests moved to end of test files (before cleanup).
+
+### Fixed
+- Changed unauthenticated API error from 500 to 401 with proper "Authentication required" message.
+
+### Removed
+- Removed legacy test files (moved to `test/_legacy/`).
+- Removed deprecated CLI files and templates.
+- Consolidated test account creation from API endpoint to test runner.
+
 # [5.0.31] - 2025-01-17
 ### Changed
 - Refactored CLI to modular command architecture with individual command classes and test files for better maintainability.

package/CLAUDE.md

@@ -71,7 +71,7 @@ src/
     routes/                           # Built-in routes
     schemas/                          # Built-in schemas
   cli/
-    cli-refactored.js                 # CLI entry point
+    index.js                          # CLI entry point
     commands/                         # CLI commands
 templates/
   backend-manager-config.json         # Config template
@@ -521,13 +521,14 @@ assert.fail(message)                           // Explicit fail
 | Batch utilities | `src/manager/helpers/utilities.js` |
 | Main API handler | `src/manager/functions/core/actions/api.js` |
 | Config template | `templates/backend-manager-config.json` |
-| CLI entry | `src/cli/cli-refactored.js` |
+| CLI entry | `src/cli/index.js` |
 
 ## Environment Detection
 
 ```javascript
 assistant.isDevelopment()  // true when ENVIRONMENT !== 'production' or in emulator
 assistant.isProduction()   // true when ENVIRONMENT === 'production'
+assistant.isTesting()      // true when running tests (via npx bm test)
 ```
 
 ## Response Headers

package/README.md

@@ -447,6 +447,7 @@ assistant.debug('Debug message');
 // Environment
 assistant.isDevelopment(); // true in emulator
 assistant.isProduction();  // true in production
+assistant.isTesting();     // true when running tests
 
 // File uploads
 const { fields, files } = await assistant.parseMultipartFormData();

package/REFACTOR-BEM-API.md

@@ -65,8 +65,12 @@ I would like each new route to have a great name clearly indicating its purpose,
 
 Since we can build this new API system however we want, i also expect you to rewrite and refactor the BEM api endppints to be kickass, modern, and well designed.
 
+Also, certain VERBS should be removed from the actual file/function names since they are implied by the HTTP method. For example, instead of having a generate-uuid.js file, we could just have uuid.js since the POST method implies that we are generating/creating a new one, or insetad of add-marketing-contact we could just have marketing-contact.js since the POST method implies adding a new one and GET would imply fetching them.
 
+Next, some fucntions have a lot crammed isnide them that could use some separation. For example, in add-marketing-contact.js we have code for handling multiple email providers (SendGrid, Beehiiv) all jammed into a single file. I think we should refactor this to have a separate file for each provider in subfolder that handles the specifics of that provider, and then the main route file just calls those provider-specific files as needed. This will make it much easier to maintain and extend in the future as we add more providers.
 
-
-
+Also, sometimes there are two endpoints that should be combined,for example
+* /Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/functions/core/actions/api/general/add-marketing-contact.js
+* /Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/functions/core/actions/api/general/remove-marketing-contact.js
+These could be combined into a single marketing-contact.js file that handles both adding and removing based on the HTTP method (POST for add, DELETE for remove). This will make the API more RESTful and easier to understand.
 

package/TODO.md

@@ -26,3 +26,152 @@ BEM
 
 ADD HEALTHCHECK TO BEM!!!
   ✗ https://api.clockii.com/backend-manager?command=healthcheck → fetch failed
+
+TODO
+
+# TEST REWRRK
+btw... the account.json needs to be removed. remove it from BEM and the consumong project. when we make our test system, we DO NOT NEED TO STORE THE ACCOUBT IN A JSON file. we just need a source of truth in BEM for what uid/emails to look for
+
+need a "projectScripts" that creates the npm start, npm test, etc scripts in the consuming project.
+
+during test run, we need to check that the test accounts exist. we also need to ALWAYS reset them at the begining of the run to ensure they are in the proper format, specifically by resetting their usage, roles, amd subscriptipn
+
+needa new account type that we can change the subscription level of to test the sub events? maybe _test-upgrade that starts free and we test how it progresses from free to paid to canceled?
+
+# Use gitignore from backend-manager-tempalte
+
+# CLEAN
+having different ID and UID is messy and annoying, just make it the same
+  admin: {
+    id: 'admin',
+    uid: '_test-admin',
+    email: '_test.admin@{domain}',
+
+should be "admin" for ALL
+
+
+# TODO
+Update deps
+Remove unused deps like
+  * node-fetch
+
+# MOVE LEGACY BEM INDIVIDUAL FUNCTIONS TO AN _OLD FOLDER
+/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/functions/core/actions/create-post-handler.js
+/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/functions/core/actions/generate-uuid.js
+/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/functions/core/actions/sign-up-handler.js
+/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/functions/test
+/Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/src/manager/functions/core/admin
+
+# Things to deprecate
+* api manager
+
+# Email
+Move the sendEmail function to HERE instead of calling ITW
+
+# BEM TESTS
+# User Auth rules
+* User can only access their own user doc
+  * fails when trying to access another user's doc
+  * succeeds when accessing their own,
+  * fails when NOT authed
+  * fails when trying to perform an admin action (can create/use the test:admin http event to test this)
+  * fails when a user tries to write to a restricted field/key like roles, subscription, usage, etc (SEE RULES)
+  * Any other rules: /Users/ian/Developer/Repositories/ITW-Creative-Works/backend-manager/templates/firestore.rules
+* User can delete their own user doc (can use _test-delete via user:delete http event)
+  * fails when trying to delete another user's doc
+  * succeeds when deleting their own,
+  * fails when NOT authed
+
+# Signup Flow
+* Create a referrer user and a referred user then use user:signup http event on the referred user to test that
+  * the referral code works and the bonus is applied to the referrer
+  * something is added to the account to denote it received the signup event??? not sure
+  * context data is added to the referred user's account
+  * a second signup event
+
+# Test
+* test:authenticate http event
+  * success when valid uid
+  * fail when invalid uid
+  * fail when no uid
+* test admin
+  * all admin functions fail when not authed as admin
+  * test each admin function
+
+# Usage
+* Using an account with a specific plan, test that the usage limits are enforced
+  * success if user has access to the plan
+  * success if the user is within the usage limits
+  * fail if the user exceeds the usage limits
+  * fail if the user is on a plan that does not allow usage (free plan)
+  * successful usage should increment the usage count
+
+# Events
+* trigger cron daily
+  * it should reset temp usage for all users
+  * reset userdocs to current usage = 0
+
+# Payment
+* test subscription upgrade flow via http event
+  * start with free plan
+  * upgrade to paid plan
+  * verify plan is updated
+  * verify usage limits are updated
+  * downgrade back to free plan
+  * verify plan is updated
+  * verify usage limits are updated
+
+# BEM API
+# Admin
+* All functions need to fail when not authed as admin
+* then test each one
+
+# Advanced
+* test sub accounts
+
+# payment system
+* dont store a "resolved" status, but make a universal library that frontend and backend use to determine whther a user has access to a plan currently
+
+# New bem api and test to make
+# test:usage
+* the fnction itself just utilizes the usage API to increment an arbitrary usage item
+
+the test should check the usage storage and ensure that it was incremented successfully
+
+# test for bm_cronDaily
+then, we need to test the bm_cronDaily function to ensure that it does its things like clearing the usage storage properly
+
+# test for schema
+* a comprehesive schema with fields that test EVERY possible field type including required, default, min, max, "value" etc (both static and FUNCTIONS)
+* test multiple plan levels including unathenticated, basic, & premium
+
+# quetsion
+* how does usage get reset? does it reset daily? or monthly?
+* how do we set usage limits?
+  * per plan? or when users prmeium is updated do we set it inside their doc?
+  * if we store it per plan, where should we store the plan data? firestore or in code?
+  * if its firestore we will use lots of reads, if we store in code we have to push new code to update plan limits (not a huge issue)
+
+
+change name from routes/content/post to maye routes/blog/post??? whatfdo you think??
+
+
+# MIGRATIONS
+## user
+affiliate: {
+  referrer: affiliateCode,
+},
+-->
+attribution.affiliate.code
+
+
+
+
+## OLD TESTS
+    "_test": "npm run prepare && ./node_modules/mocha/bin/mocha test/ --recursive --timeout=10000",
+    "test": "./node_modules/mocha/bin/mocha test/ --recursive --timeout=10000",
+    "test:cli": "./node_modules/mocha/bin/mocha test/cli-commands.test.js --timeout=10000",
+    "test:usage": "./node_modules/mocha/bin/mocha test/usage.js --timeout=10000",
+    "test:payment-resolver": "./node_modules/mocha/bin/mocha test/payment-resolver/index.js --timeout=10000",
+    "test:user": "./node_modules/mocha/bin/mocha test/user.js --timeout=10000",
+    "test:ai": "./node_modules/mocha/bin/mocha test/ai/index.js --timeout=10000",

package/bin/bem

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-let Main = new (require('../src/cli/cli-refactored.js'))(process.argv);
+let Main = new (require('../src/cli/index.js'))(process.argv);
 (async function() {
   'use strict';
   await Main.process(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "5.0.39",
+  "version": "5.0.41",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -44,6 +44,7 @@
   },
   "dependencies": {
     "@firebase/rules-unit-testing": "^5.0.0",
+    "@google-cloud/pubsub": "^5.2.2",
     "@google-cloud/storage": "^7.16.0",
     "@octokit/rest": "^19.0.13",
     "@sendgrid/mail": "^7.7.0",

package/src/cli/commands/base-command.js

@@ -42,11 +42,12 @@ class BaseCommand {
       .filter(([_, port]) => port)
       .map(([name, port]) => ({ name, port }));
 
+    // Collect ALL processes on each blocked port
     const blockedPorts = [];
     for (const { name, port } of portsToCheck) {
-      const processInfo = this.getProcessOnPort(port);
-      if (processInfo) {
-        blockedPorts.push({ name, port, ...processInfo });
+      const processes = this.getProcessesOnPort(port);
+      if (processes) {
+        blockedPorts.push({ name, port, processes });
       }
     }
 
@@ -55,9 +56,11 @@ class BaseCommand {
     }
 
     this.log(chalk.yellow('\n  The following ports are in use:'));
-    for (const { name, port, pid, processName, command } of blockedPorts) {
-      const cmdInfo = command ? ` ${command}` : '';
-      this.log(chalk.gray(`    - ${name} emulator (port ${port}) - PID ${pid} (${processName})${cmdInfo}`));
+    for (const { name, port, processes } of blockedPorts) {
+      for (const { pid, processName, command } of processes) {
+        const cmdInfo = command ? ` ${command}` : '';
+        this.log(chalk.gray(`    - ${name} emulator (port ${port}) - PID ${pid} (${processName})${cmdInfo}`));
+      }
     }
 
     const { shouldKill } = await inquirer.prompt([{
@@ -72,13 +75,19 @@ class BaseCommand {
       return false;
     }
 
-    for (const { name, port, pid } of blockedPorts) {
-      try {
-        process.kill(pid, 'SIGTERM');
-        this.log(chalk.green(`    ✓ Killed process ${pid} on port ${port} (${name})`));
-      } catch (error) {
-        this.logError(`    ✗ Failed to kill process ${pid}: ${error.message}`);
-        return false;
+    // Kill ALL processes on each blocked port
+    for (const { name, port, processes } of blockedPorts) {
+      for (const { pid } of processes) {
+        try {
+          process.kill(pid, 'SIGKILL');
+          this.log(chalk.green(`    ✓ Killed process ${pid} on port ${port} (${name})`));
+        } catch (error) {
+          // ESRCH means process already dead - that's fine
+          if (error.code !== 'ESRCH') {
+            this.logError(`    ✗ Failed to kill process ${pid}: ${error.message}`);
+            return false;
+          }
+        }
       }
     }
 
@@ -88,39 +97,57 @@ class BaseCommand {
   }
 
   /**
-   * Get info about a process using a specific port
+   * Get info about ALL processes using a specific port
    * @param {number} port - Port number to check
-   * @returns {object|null} - Process info if port is in use, null otherwise
+   * @returns {object[]|null} - Array of process info if port is in use, null otherwise
    */
-  getProcessOnPort(port) {
+  getProcessesOnPort(port) {
     try {
       const result = execSync(`lsof -ti:${port} 2>/dev/null`, { encoding: 'utf8' });
-      const pid = parseInt(result.trim().split('\n')[0], 10);
-      if (isNaN(pid)) {
+      const pids = result.trim().split('\n')
+        .map(line => parseInt(line.trim(), 10))
+        .filter(pid => !isNaN(pid));
+
+      if (pids.length === 0) {
         return null;
       }
 
-      // Get more info about the process
-      let processName = 'unknown';
-      let command = '';
-      try {
-        const psResult = execSync(`ps -p ${pid} -o comm=,args= 2>/dev/null`, { encoding: 'utf8' });
-        const parts = psResult.trim().split(/\s+/);
-        processName = parts[0] || 'unknown';
-        command = parts.slice(1).join(' ').substring(0, 100);
-        if (command.length === 100) {
-          command += '...';
+      // Get unique PIDs (lsof can return duplicates for multiple connections)
+      const uniquePids = [...new Set(pids)];
+
+      const processes = uniquePids.map(pid => {
+        let processName = 'unknown';
+        let command = '';
+        try {
+          const psResult = execSync(`ps -p ${pid} -o comm=,args= 2>/dev/null`, { encoding: 'utf8' });
+          const parts = psResult.trim().split(/\s+/);
+          processName = parts[0] || 'unknown';
+          command = parts.slice(1).join(' ').substring(0, 100);
+          if (command.length === 100) {
+            command += '...';
+          }
+        } catch (e) {
+          // Ignore - just use defaults
         }
-      } catch (e) {
-        // Ignore - just use defaults
-      }
+        return { pid, processName, command };
+      });
 
-      return { pid, processName, command };
+      return processes.length > 0 ? processes : null;
     } catch (error) {
       return null;
     }
   }
 
+  /**
+   * Get info about a process using a specific port (returns first process only for backwards compatibility)
+   * @param {number} port - Port number to check
+   * @returns {object|null} - Process info if port is in use, null otherwise
+   */
+  getProcessOnPort(port) {
+    const processes = this.getProcessesOnPort(port);
+    return processes ? processes[0] : null;
+  }
+
   /**
    * Check if a port is in use
    * @param {number} port - Port number to check

package/src/cli/commands/emulators.js

@@ -9,39 +9,60 @@ const { DEFAULT_EMULATOR_PORTS } = require('./setup-tests/emulators-config');
 
 class EmulatorsCommand extends BaseCommand {
   async execute() {
-    const projectDir = this.main.firebaseProjectPath;
-
-    // Load emulator ports from firebase.json
-    const emulatorPorts = this.loadEmulatorPorts(projectDir);
-
-    // Check for port conflicts before starting emulators
-    const canProceed = await this.checkAndKillBlockingProcesses(emulatorPorts);
-    if (!canProceed) {
-      return;
-    }
-
     this.log(chalk.cyan('\n  Starting Firebase emulators (keep-alive mode)...\n'));
     this.log(chalk.gray('  Emulators will stay running until you press Ctrl+C\n'));
 
+    // Warn if TEST_EXTENDED_MODE is enabled
+    if (process.env.TEST_EXTENDED_MODE) {
+      this.log(chalk.yellow.bold('\n  ⚠️⚠️⚠️  WARNING: TEST_EXTENDED_MODE IS TRUE  ⚠️⚠️⚠️'));
+      this.log(chalk.yellow('  External API calls (emails, SendGrid, etc.) are ENABLED!'));
+      this.log(chalk.yellow('  This will send real emails and make real API calls.\n'));
+    }
+
     // Start BEM watcher in background
     const watcher = new WatchCommand(this.main);
     watcher.startBackground();
 
-    // Start emulators with a long-running command to keep them alive
-    // BEM_TESTING=true is passed so Functions skip external API calls (emails, SendGrid)
-    const emulatorsCommand = `BEM_TESTING=true firebase emulators:exec --only functions,firestore,auth,database --ui 'echo ""; echo "Emulators ready. Press Ctrl+C to shut down..."; sleep 86400'`;
+    // Run emulators with keep-alive command (use single quotes since runWithEmulators wraps in double quotes)
+    const keepAliveCommand = "echo ''; echo 'Emulators ready. Press Ctrl+C to shut down...'; sleep 86400";
 
     try {
-      await powertools.execute(emulatorsCommand, {
-        log: true,
-        cwd: projectDir,
-      });
+      await this.runWithEmulators(keepAliveCommand);
     } catch (error) {
       // User pressed Ctrl+C - this is expected
       this.log(chalk.gray('\n  Emulators stopped.\n'));
     }
   }
 
+  /**
+   * Run a command with Firebase emulators
+   * @param {string} command - The command to execute inside emulators:exec
+   * @returns {Promise<void>}
+   */
+  async runWithEmulators(command) {
+    const projectDir = this.main.firebaseProjectPath;
+
+    // Load emulator ports from firebase.json
+    const emulatorPorts = this.loadEmulatorPorts(projectDir);
+
+    // Check for port conflicts before starting emulators
+    const canProceed = await this.checkAndKillBlockingProcesses(emulatorPorts);
+    if (!canProceed) {
+      throw new Error('Port conflicts could not be resolved');
+    }
+
+    // BEM_TESTING=true is passed so Functions skip external API calls (emails, SendGrid)
+    // hosting is included so localhost:5002 rewrites work (e.g., /backend-manager -> bm_api)
+    // pubsub is included so scheduled functions (bm_cronDaily) can be triggered in tests
+    // Use double quotes for command wrapper since the command may contain single quotes (JSON strings)
+    const emulatorsCommand = `BEM_TESTING=true firebase emulators:exec --only functions,firestore,auth,database,hosting,pubsub --ui "${command}"`;
+
+    await powertools.execute(emulatorsCommand, {
+      log: true,
+      cwd: projectDir,
+    });
+  }
+
   /**
    * Load emulator ports from firebase.json or use defaults
    */

package/src/cli/commands/setup-tests/emulators-config.js

@@ -10,6 +10,7 @@ const DEFAULT_EMULATOR_PORTS = {
   database: 9000,
   hosting: 5002,
   storage: 9199,
+  pubsub: 8085,
   ui: 4000,
 };
 
@@ -20,6 +21,7 @@ const REQUIRED_EMULATORS = {
   database: { port: DEFAULT_EMULATOR_PORTS.database },
   hosting: { port: DEFAULT_EMULATOR_PORTS.hosting },
   storage: { port: DEFAULT_EMULATOR_PORTS.storage },
+  pubsub: { port: DEFAULT_EMULATOR_PORTS.pubsub },
   ui: { enabled: true },
 };
 

package/src/cli/commands/setup-tests/hosting-rewrites.js

@@ -1,5 +1,6 @@
 const BaseTest = require('./base-test');
 const jetpack = require('fs-jetpack');
+const _ = require('lodash');
 
 class HostingRewritesTest extends BaseTest {
   getName() {

package/src/cli/commands/test.js

@@ -5,6 +5,7 @@ const jetpack = require('fs-jetpack');
 const JSON5 = require('json5');
 const powertools = require('node-powertools');
 const { DEFAULT_EMULATOR_PORTS } = require('./setup-tests/emulators-config');
+const EmulatorsCommand = require('./emulators');
 
 class TestCommand extends BaseCommand {
   async execute() {
@@ -28,12 +29,14 @@ class TestCommand extends BaseCommand {
     }
 
     // Build unified test config object
+    // Use hosting URL for all API requests (rewrites to bm_api function)
     const testConfig = {
       ...projectConfig,
-      functionsUrl: `http://127.0.0.1:${emulatorPorts.functions}/${projectConfig.projectId}/us-central1`,
+      hostingUrl: `http://127.0.0.1:${emulatorPorts.hosting}`,
       projectDir,
       testPaths,
       emulatorPorts,
+      includeLegacy: argv.legacy || false, // Include legacy tests from test/functions/
     };
 
     // Build the test command
@@ -47,7 +50,7 @@ class TestCommand extends BaseCommand {
       await this.runTestsDirectly(testCommand, functionsDir, emulatorPorts);
     } else {
       this.log(chalk.cyan('Starting emulators and running tests...'));
-      await this.runEmulatorTests(testCommand, projectDir, emulatorPorts);
+      await this.runEmulatorTests(testCommand);
     }
   }
 
@@ -103,6 +106,7 @@ class TestCommand extends BaseCommand {
     const projectId = config.firebaseConfig?.projectId;
     const backendManagerKey = argv.key || process.env.BACKEND_MANAGER_KEY;
     const appId = config.brand?.id;
+    const brandName = config.brand?.name;
     const githubRepoWebsite = config.github?.repo_website;
 
     // Extract domain from brand.contact.email (e.g., 'support@example.com' -> 'example.com')
@@ -131,7 +135,7 @@ class TestCommand extends BaseCommand {
       return null;
     }
 
-    return { appId, projectId, backendManagerKey, domain, githubRepoWebsite };
+    return { appId, projectId, backendManagerKey, domain, brandName, githubRepoWebsite };
   }
 
   /**
@@ -140,9 +144,9 @@ class TestCommand extends BaseCommand {
   buildTestCommand(testConfig) {
     const testScriptPath = path.join(__dirname, '..', '..', 'test', 'run-tests.js');
 
-    // Pass entire config as JSON, plus emulator hosts
+    // Pass entire config as base64-encoded JSON to avoid shell escaping issues
     const testEnv = {
-      BEM_TEST_CONFIG: JSON.stringify(testConfig),
+      BEM_TEST_CONFIG: Buffer.from(JSON.stringify(testConfig)).toString('base64'),
       FIRESTORE_EMULATOR_HOST: `127.0.0.1:${testConfig.emulatorPorts.firestore}`,
       FIREBASE_AUTH_EMULATOR_HOST: `127.0.0.1:${testConfig.emulatorPorts.auth}`,
     };
@@ -167,7 +171,7 @@ class TestCommand extends BaseCommand {
    * Run tests directly (emulators already running)
    */
   async runTestsDirectly(testCommand, functionsDir, emulatorPorts) {
-    this.log(chalk.gray(`  Functions: http://127.0.0.1:${emulatorPorts.functions}`));
+    this.log(chalk.gray(`  Hosting: http://127.0.0.1:${emulatorPorts.hosting}`));
     this.log(chalk.gray(`  Firestore: 127.0.0.1:${emulatorPorts.firestore}`));
     this.log(chalk.gray(`  Auth: 127.0.0.1:${emulatorPorts.auth}`));
     this.log(chalk.gray(`  UI: http://127.0.0.1:${emulatorPorts.ui}\n`));
@@ -185,23 +189,14 @@ class TestCommand extends BaseCommand {
   /**
    * Run tests with Firebase emulators (starts emulators, runs tests, shuts down)
    */
-  async runEmulatorTests(testCommand, projectDir, emulatorPorts) {
-    // Check for port conflicts before starting emulators
-    const canProceed = await this.checkAndKillBlockingProcesses(emulatorPorts);
-    if (!canProceed) {
-      return;
-    }
-
+  async runEmulatorTests(testCommand) {
     this.log(chalk.gray('  Starting Firebase emulators...\n'));
 
-    // BEM_TESTING=true is passed to the emulator so Functions can skip external API calls (emails, SendGrid)
-    const emulatorsCommand = `BEM_TESTING=true firebase emulators:exec --only functions,firestore,auth,database --ui '${testCommand}'`;
+    // Use EmulatorsCommand to run tests with emulators
+    const emulatorsCmd = new EmulatorsCommand(this.main);
 
     try {
-      await powertools.execute(emulatorsCommand, {
-        log: true,
-        cwd: projectDir,
-      });
+      await emulatorsCmd.runWithEmulators(testCommand);
     } catch (error) {
       // Only exit with error if it wasn't a user-initiated exit
       if (error.code !== 0) {