如何为Jasmine或Mocha测试用例/套件按环境分类并批量执行？

Hey Stefan, great call looking to organize your tests by environment—this makes running targeted batches way easier than manually picking and choosing! Your current skip() approach works, but let's explore some more scalable, maintainable options tailored to Mocha's features:

1. Use Mocha's Built-in grep with Test Tags (My Top Pick) #

This is the simplest, most native way to group tests without modifying your test logic. Just add environment tags directly to your describe/it blocks:

// Example test file
describe('[local] User Authentication Tests', function() {
  it('should log in with local credentials', function() {
    // Test logic for localhost
  });
});

describe('[mock-stage] Payment Processing Tests', function() {
  it('should simulate a successful payment', function() {
    // Test logic for mock-stage environment
  });
});

describe('[prelive] End-to-End Checkout Tests', function() {
  it('should process a real test transaction', function() {
    // Test logic for prelive environment
  });
});

Then define npm scripts in your package.json to run only the tagged tests:

{
  "scripts": {
    "test:local": "mocha --grep \"\\[local\\]\"",
    "test:mock-stage": "mocha --grep \"\\[mock-stage\\]\"",
    "test:prelive": "mocha --grep \"\\[prelive\\]\"",
    "test:all": "mocha" // Run everything if needed
  }
}

Now you can run npm run test:local to execute only your localhost tests—no code changes required, and you can even combine tags (e.g., --grep "\[local\]\|\[mock-stage\]" to run two environments at once).

2. Refine Your Precondition Functions (For Granular Control) #

If you prefer keeping environment checks directly in your test code, let's clean up your current approach to be more flexible and robust:

First, centralize your environment configuration (using environment variables makes this dynamic):

// preconditions.js
const CURRENT_TEST_ENV = process.env.TEST_ENV || 'local'; // Fallback to local if not set

export function onlyEnv(targetEnv) {
  if (CURRENT_TEST_ENV !== targetEnv) {
    this.skip(); // Mocha handles skipping cleanly without manual parent pending flags
  }
}

// You can also make helper functions for common environments if you want:
export function onlyLocal() {
  this.onlyEnv('local');
}

export function onlyMockStage() {
  this.onlyEnv('mock-stage');
}

Then use these in your tests—either at the suite level (skip entire describe blocks) or individual test level:

import { onlyLocal, onlyMockStage } from './preconditions.js';

describe('Local Database Operations', function() {
  before(function() {
    this.onlyLocal(); // Skip entire suite if not in local env
  });

  it('should create a database record', function() {
    // Test logic
  });
});

it('should validate mock payment gateway', function() {
  this.onlyMockStage(); // Skip just this test if not in mock-stage
  // Test logic
});

Run tests by setting the environment variable first:

TEST_ENV=mock-stage mocha
# Or add to npm scripts:
"scripts": {
  "test:mock-stage": "TEST_ENV=mock-stage mocha"
}

3. Global Environment Filter with Mocha Root Hooks #

For teams that want a consistent, global rule for environment-specific tests, create a Mocha plugin to add custom describe.onlyEnv and it.onlyEnv methods:

// env-filter-plugin.js
module.exports = function(mocha) {
  const activeEnv = process.env.TEST_ENV || 'local';

  mocha.suite.on('pre-require', function(context) {
    // Add suite-level environment lock
    context.describe.onlyEnv = function(targetEnv, description, callback) {
      if (activeEnv === targetEnv) {
        return context.describe(description, callback);
      }
      return context.describe.skip(description, callback);
    };

    // Add test-level environment lock
    context.it.onlyEnv = function(targetEnv, description, callback) {
      if (activeEnv === targetEnv) {
        return context.it(description, callback);
      }
      return context.it.skip(description, callback);
    };
  });
};

Load the plugin when running Mocha, either via command line or mocha.config.js:

mocha --require ./env-filter-plugin.js

Then use it directly in your tests:

describe.onlyEnv('prelive', 'Prelive Order Fulfillment', function() {
  it.onlyEnv('prelive', 'should trigger warehouse notification', function() {
    // Test logic
  });
});

Which Option Should You Choose? #

• grep Tags: Best for quick setup, no test code changes, and flexible cross-environment runs.
• Refined Preconditions: Great if you want explicit environment checks directly in your test logic for clarity.
• Root Hook Plugin: Perfect for teams needing enforced global rules for environment-specific tests.

内容的提问来源于stack exchange，提问作者Stefan