您可以使用我的包mocha-assume以编程方式跳过测试，但只能从测试之外跳过。你可以这样使用它:

assuming(myAssumption).it("does someting nice", () => {});

Mocha-assume只会在myAssumption为真时运行你的测试，否则它会跳过它(使用它。skip)并传递一个好的消息。

下面是一个更详细的例子:

describe("My Unit", () => {
    /* ...Tests that verify someAssuption is always true... */

    describe("when [someAssumption] holds...", () => {
        let someAssumption;

        beforeAll(() => {
            someAssumption = /* ...calculate assumption... */
        });

        assuming(someAssumption).it("Does something cool", () => {
            /* ...test something cool... */
        });
    });
});

以这种方式使用它，可以避免级联故障。当某些假设不成立时，测试“do something cool”总是会失败——但这个假设已经在上面测试过了(在验证某些假设总是正确的测试中)。

因此，测试失败不会给您任何新信息。事实上，它甚至是一个假阳性:测试失败并不是因为“一些很酷的东西”没有工作，而是因为测试的先决条件没有得到满足。使用摩卡，假设你经常可以避免这种误报。

我不确定这是否可以称为“程序性跳过”，但是为了有选择性地跳过我们CI环境中的某些特定测试，我使用了Mocha的标记功能(https://github.com/mochajs/mocha/wiki/Tagging)。 在describe()或it()消息中，可以添加@no-ci这样的标记。要排除这些测试，可以在包中定义特定的“ci目标”。使用——grep和——invert参数，如下:

"scripts": {
  "test": "mocha",
  "test-ci" : "mocha --reporter mocha-junit-reporter --grep @no-ci --invert"
}

使用Mocha的skip()函数

它可以用来静态地禁用测试或整个套件，也可以在运行时动态地跳过它。

下面是一个运行时用法的例子:

it('should only test in the correct environment', function() {
  if (/* check test environment */) {
    // make assertions
  } else {
    this.skip();
  }
});

这取决于您希望如何以编程方式跳过测试。如果在运行任何测试代码之前可以确定跳过的条件，那么您可以直接调用它或它。根据需要，根据条件跳过。例如，如果环境变量ONE被设置为任何值，这将跳过一些测试:

var conditions = {
    "condition one": process.env["ONE"] !== undefined
    // There could be more conditions in this table...
};

describe("conditions that can be determined ahead of time", function () {
    function skip_if(condition, name, callback) {
        var fn = conditions[condition] ? it.skip: it;
        fn(name, callback);
    };

    skip_if("condition one", "test one", function () {
        throw new Error("skipped!");
    });

    // async.
    skip_if("condition one", "test one (async)", function (done) {
        throw new Error("skipped!");
    });

    skip_if("condition two", "test two", function () {
        console.log("test two!");
    });

});

如果您想要检查的条件只能在测试时确定，那就有点复杂了。如果你不想访问任何严格来说不是测试API的部分，那么你可以这样做:

describe("conditions that can be determined at test time", function () {
    var conditions = {};
    function skip_if(condition, name, callback) {
        if (callback.length) {
            it(name, function (done) {
                if (conditions[condition])
                    done();
                else
                    callback(done);
            });
        }
        else {
            it(name, function () {
                if (conditions[condition])
                    return;
                callback();
            });
        }
    };

    before(function () {
        conditions["condition one"] = true;
    });

    skip_if("condition one", "test one", function () {
        throw new Error("skipped!");
    });

    // async.
    skip_if("condition one", "test one (async)", function (done) {
        throw new Error("skipped!");
    });

    skip_if("condition two", "test two", function () {
        console.log("test two!");
    });

});

虽然我的第一个例子是将测试标记为正式跳过(又名“pending”)，但我刚才展示的方法只是避免执行实际的测试，但测试不会标记为正式跳过。他们将被标记为通过。如果你真的想跳过它们，我不知道有什么方法可以访问不是测试API的部分:

describe("conditions that can be determined at test time", function () {
    var condition_to_test = {}; // A map from condition names to tests.
    function skip_if(condition, name, callback) {
        var test = it(name, callback);
        if (!condition_to_test[condition])
            condition_to_test[condition] = [];
        condition_to_test[condition].push(test);
    };

    before(function () {
        condition_to_test["condition one"].forEach(function (test) {
            test.pending = true; // Skip the test by marking it pending!
        });
    });

    skip_if("condition one", "test one", function () {
        throw new Error("skipped!");
    });

    // async.
    skip_if("condition one", "test one (async)", function (done) {
        throw new Error("skipped!");
    });

    skip_if("condition two", "test two", function () {
        console.log("test two!");
    });

});

正如@danielstjules在这里回答的，有一种跳过测试的方法。@本主题的作者从github.com mochajs的讨论中复制了答案，但没有关于哪个版本的mocha可用的信息。

我正在使用咕哝摩卡测试模块集成摩卡测试功能在我的项目。跳转到最后一个(现在)版本- 0.12.7带来了mocha 2.4.5版本，实现了this.skip()。

在package。json中

  "devDependencies": {
    "grunt-mocha-test": "^0.12.7",
    ...

然后

npm install

这个钩子让我很开心:

describe('Feature', function() {

    before(function () {

        if (!Config.isFeaturePresent) {

            console.log('Feature not configured for that env, skipping...');
            this.skip();
        }
    });
...

    it('should return correct response on AB', function (done) {

        if (!Config.isABPresent) {

           return this.skip();
        }

        ...

这并不是真正使用摩卡的功能，而是调整它以获得我想要的行为。

我想在量角器摩卡测试中跳过所有后续的“it’s”，但有一个“it’s”失败了。这是因为一旦旅程测试的一个步骤失败，几乎可以肯定其他步骤也会失败，并且可能需要很长时间，如果他们使用浏览器等待元素出现在页面上等，可能会占用构建服务器。

当只是运行标准摩卡测试(不是量角器)时，这可以通过全局beforeEach和afterEach钩子来实现，在测试的父(描述)上附加一个' skipfollow '标志，如下所示:

    beforeEach(function() {
      if(this.currentTest.parent.skipSubsequent) {
            this.skip();
      }
    }); 


    afterEach(function() {
      if (this.currentTest.state === 'failed') {
        this.currentTest.parent.skipSubsequent = 'true'
      }
    })

当尝试使用量角器和摩卡时，“this”的范围发生了变化，上面的代码不起作用。你最终会得到一个错误消息，比如'error calling done()'，量角器会停止。

相反，我最终得到了下面的代码。不是最漂亮的，但它最终用this.skip()替换了其余测试函数的实现。如果/当摩卡的内部结构在后续版本中发生变化时，这可能会停止工作。

这是通过调试和检查摩卡内部的一些试验和错误发现的……不过，当测试失败时，有助于更快地完成浏览器测试套件。

beforeEach(function() {

    var parentSpec = this.currentTest.parent;

    if (!parentSpec.testcount) {
        parentSpec.testCount = parentSpec.tests.length;
        parentSpec.currentTestIndex = 0;
    } else {
        parentSpec.currentTestIndex = parentSpec.currentTestIndex + 1;
    }

    if (parentSpec.skipSubsequent) {

        parentSpec.skipSubsequent = false;
        var length = parentSpec.tests.length;
        var currentIndex = parentSpec.currentTestIndex;

        for (var i = currentIndex + 1; i < length; i++) {
            parentSpec.tests[i].fn = function() {
                this.skip();
            };
        }
    }
});


afterEach(function() {
    if (this.currentTest.state === 'failed') {
        this.currentTest.parent.skipSubsequent = 'true'
    }
});