摘要：中文文檔這個是對文檔的翻譯，都是我一個字一個字敲出來的。任何鉤子函數在執(zhí)行的時候都可以傳遞一個可選的描述信息，可以更容易地準確指出測試中的錯誤。不給測試用例傳遞一個回調函數，就是被等待實現的測試用例，但同樣會在報告中體現出來。

這個是對mocha文檔的翻譯，都是我一個字一個字敲出來的。水平有限，激情無限，歡迎大家批評指正。文檔我也放在了我的github上,后續(xù)，我會添加一些例子進去，歡迎大家關注和貢獻。

使用npm全局安裝：

$ npm install --global mocha

也可以作為項目的依賴進行安裝：

$ npm install --save-dev mocha

安裝Mocha >= v3.0.0，npm的版本應該>=v1.4.0。除此，確保使用Node.js的版本>=v0.10來運行Mocha

Mocha也可以使用Bower進行安裝(bower install mocha)，也可以從cdnjs上獲取。

$ npm install mocha
$ mkdir test
$ $EDITOR test/test.js # 或者使用你喜歡的編輯器

在編輯器中輸入：

var assert = require("assert")
describe("Array", function() {
    describe("#indexOf()", function() {
        it("should return -1 when the value is not present", function() {
            assert.equal(-1, [1, 2, 3].indexOf(4))
        })
    })
})

然后在終端中運行：

$ ./node_modules/mocha/bin/mocha

Array
    #indexOf()
      ? should return -1 when the value is not present


  1 passing (9ms)

在package.json中設置一個測試腳本：

"scripts":{
    "test": "mocha"
}

然后運行：

$ npm test

Mocha允許你使用任意你喜歡的斷言庫，在上面的例子中，我們使用了Node.js內置的assert模塊作為斷言。如果能夠拋出一個錯誤，它就能夠運行。這意味著你能使用下面的這些倉庫，比如：

should.js

expect.js

chai

better-assert

unexpected

使用mocha測試異步代碼是再簡單不過了。只需要在測試完成的時候調用一下回調函數即可。通過添加一個回調函數(通常命名為done)給it()方法，Mocha就會知道，它應該等這個函數被調用的時候才能完成測試。

describe("User", function() {
    describe("#save()", function() {
        it("should save without error", function() {
            var user = new User("Luna")
            user.save(function(err) {
                if(err) done(err);
                else done()
            })
        })
    })
})

也可以讓事情變得更簡單，因為done()函數接收一個err，所以，我們可以直接按照下面的使用：

describe("User", function() {
    describe("#save()", function() {
        it("should save without error", function(done) {
            var user = new User("Luna")
            user.save(done)
        })
    })
})

同時，除了使用done()回調函數，你也可以返回一個Promise。這種方式對于測試那些返回promies的方法是實用的。

beforeEach(function() {
  return db.clear()
    .then(function() {
      return db.save([tobi, loki, jane]);
    });
});

describe("#find()", function() {
  it("respond with matching records", function() {
    return db.find({ type: "User" }).should.eventually.have.length(3);
  });
});

后面的例子使用了Chai as Promised 進行promise斷言

在Mocha>=3.0.0版本中，返回一個promise的同時，調用了done函數。將會導致一個異常，下面是一個常見的錯誤：

const assert = require("assert")

it("should complete this test", function (done) {
    return new Promise(function (resolve) {
        assert.ok(true)
        resolve()
    })
    .then(done)
})

這個測試會失敗，錯誤信息為： Error: Resolution method is overspecified. Specify a callback *or* return a Promise; not both.
而比v3.0.0更老的版本中，調用done函數會被忽略。

如果你的js運行環(huán)境支持async/await，你也可以像下面這樣寫異步測試。

beforeEach(async function() {
  await db.clear();
  await db.save([tobi, loki, jane]);
});

describe("#find()", function() {
  it("responds with matching records", async function() {
    const users = await db.find({ type: "User" });
    users.should.have.length(3);
  });
});

當測試同步代碼的時候，可以省略參數中的回調函數，Mocha會自動的測試下面的代碼。

describe("Array", function () {
    describe("#indexOf()", function () {
        it("should return -1 when the value is not present", function() {
          [1,2,3].indexOf(5).should.equal(-1);
          [1,2,3].indexOf(0).should.equal(-1);
        });
    })
})

向Mocha傳遞箭頭函數是不好的，由于this的詞法作用域的問題，箭頭函數是不能夠訪問mocha的上下文的。例如，由于箭頭函數本身的機制，下面的代碼會失敗。

describe("my suite", () => {
  it("my test", () => {
    // should set the timeout of this test to 1000 ms; instead will fail
    this.timeout(1000);
    assert.ok(true);
  });
});

如果你不需要使用mocha的上下文，可以使用箭頭函數。然而，如果你以后需要使用這個上下文的話，重構會變得十分困難。

鑒于默認使用BDD風格的接口，Mocha提供了一些鉤子函數:before(),after(),beforeEach()和afterEach()。這些鉤子函數可以用于設置測試的先決條件或者對測試進行清理。

describe("hooks", function() {
    before(function() {
        // 在這個區(qū)塊內的所有測試之前運行
    })
    after(function () {
        // 在這個區(qū)塊內的所有測試之后運行
    })
    beforeEach(function () {
        // 在這個區(qū)塊內的每個測試運行之前運行
    })
    afterEach(function () {
        // 在這個區(qū)塊內的每個測試之后運行
    })
})

測試可以出現在before,after或者和你的鉤子函數交替出現。鉤子函數會按照它們被定義的順序運行。一般就是，before()(只運行一次)->beforeEach()->afterEach()->after()(只運行一次)。

任何鉤子函數在執(zhí)行的時候都可以傳遞一個可選的描述信息，可以更容易地準確指出測試中的錯誤。如果鉤子函數使用了命名的回調函數，則其名字會被作為默認的描述信息。

beforeEach(function () {
    // beforeEach鉤子函數(沒有任何的描述信息)
})
beforeEach(function namedFn() {
    // beforeEach:namedFn會被當作描述信息
})
beforeEach("some description", function () {
    // beforeEach:some description(提供了描述信息)
})

所有的鉤子(before(),after(),beforeEach(),afterEach())可以是同步的也可以是異步的，其行為就像是普通的測試用例。例如，你希望在每個測試之前，向數據庫中填充一些內容。

describe("Connection", function() {
  var db = new Connection,
    tobi = new User("tobi"),
    loki = new User("loki"),
    jane = new User("jane");

  beforeEach(function(done) {
    db.clear(function(err) {
      if (err) return done(err);
      db.save([tobi, loki, jane], done);
    });
  });

  describe("#find()", function() {
    it("respond with matching records", function(done) {
      db.find({type: "User"}, function(err, res) {
        if (err) return done(err);
        res.should.have.length(3);
        done();
      });
    });
  });
});

你可以選擇幾個文件來添加根級別的鉤子。例如，添加beforeEach()在所有describe()塊外面(譯者注：可以理解為最頂級作用域中)，這會造成在每個測試用例之前調用這個鉤子函數。不僅僅它所在的這個文件(這是因為Mocha有一個暗藏的describe()，叫做"root-suite")。

beforeEach(function () {
    console.log("before every test in every file");
})

如果想在mocha命令運行之后，先做一些別的工作，再啟動測試，可以使用mocha --delay命令，此命令會在全局環(huán)境中生成一個run函數，延遲工作完成后調用run函數即可啟動測試。

setTimeout(function () {
    // do some setup
    
    describe("my suite", function () {
        // ...
    });
    
    run();
}, 5000)

不給測試用例傳遞一個回調函數，就是被等待實現的測試用例，但同樣會在報告中體現出來。

describe("Array", function() {
    describe("#indexOf", function () {
        // 等待測試
        it("should return -1 when the value is nor present");
    });
});

在用例測試集或者用例單元后面加上.only()方法，可以讓mocha只測試此用例集合或者用例單元。下面是一個僅執(zhí)行一個特殊的測試單元的例子：

describe("Array", function () {
    describe.only("#indexOf()", function () {
        // ....
    })
})

注意：在Array用例集下面嵌套的集合，只有#indexOf用例集合會被執(zhí)行。

下面的這個例子是僅僅執(zhí)行唯一一個測試單元。

describe("Array", function() {
    describe("#indexOf", function() {
        it.only("should return -1 unless preset", function () {
            // ...
        })
        it("should return the index when present", function () {
            // ...
        })
    })
})

在v3.0.0版本之前，.only()函數通過字符串匹配的方式去決定哪個測試應該被執(zhí)行。但是在v3.0.0版本及以后，.only()可以被定義多次來定義一系列的測試子集。

describe("Array", function () {
    describe("#indexOf", function () {
        it.only("should return -1 unless present", function () {
            // this test will be run
        })
        it.only("should return index when present", function () {
            // this test will also be run
        })
        it("should return -1 if called with a non-Array context", function () {
            // this test will not be run
        })
    })
})

你也可以選擇多個測試集合：

describe("Array", function () {
    describe.only("#indexOf()", function () {
        it("should return -1 unless present", function() {
          // this test will be run
        });
    
        it("should return the index when present", function() {
          // this test will also be run
        });
    });
    describe.only("#concat()", function () {
        it("should return a new Array", function () {
          // this test will also be run
        });
    });
    
    describe("#slice()", function () {
        it("should return a new Array", function () {
          // this test will not be run
        });
    });
})

上面兩種情況也可以結合在一起使用：

describe("Array", function () {
    describe.only("#indexOf()", function () {
        it.only("should return -1 unless present", function () {
            // this test will be run
        })
        it("should return the index when present", function () {
            // this test will not be run
        })
    })
})

注意：如果有鉤子函數，鉤子函數會被執(zhí)行。

除非你是真的需要它，否則不要提交only()到你的版本控制中。

和only()方法相反，.skip()方法可以用于跳過某些測試測試集合和測試用例。所有被跳過的用例都會被標記為pending用例，在報告中也會以pending用例顯示。下面是一個跳過整個測試集的例子。

describe("Array", function () {
    describe.skip("#indexOf", function () {
        // ...
    })
})

或者指定跳過某一個測試用例：

describe("Array", function () {
    describe("#indexOf()", function () {
        it.skip("should return -1 unless present", function () {
            // this test will not be run
        })
        
        it("should return the index when present", function () {
            // this test will be run
        })
    })
})

最佳實踐：使用.skip()方法來跳過某些不需要的測試用例而不是從代碼中注釋掉。

有些時候，測試用例需要某些特定的環(huán)境或者一些特殊的配置，但我們事先是無法確定的。這個時候，我們可以使用this.skip()［譯者注：這個時候就不能使用箭頭函數了］根據條件在運行的時候跳過某些測試用例。

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

這個測試在報告中會以pending狀態(tài)呈現。為了避免測試邏輯混亂，在調用skip函數之后，就不要再在用例函數或after鉤子中執(zhí)行更多的邏輯了。

下面的這個測試和上面的相比，因為沒有在else分支做任何事情，當if條件不滿足的時候，它仍然會在報告中顯示passing。

it("should only test in the correct environment", function () {
    if (/* check test environment */) {
        // make assertion
    } else {
        // do nothing
    }
})

最佳事件：千萬不要什么事情都不做，一個測試應該做個斷言判斷或者使用skip()

我們也可以在before鉤子函數中使用.skip()來跳過多個測試用例或者測試集合。

before(function () {
   if(/* check test environment */) {
       // setup mode
   } else {
       this.skip()
   }
})

Mocha v3.0.0之前，在異步的測試用例和鉤子函數中是不支持this.skip()的。

Mocha允許你為失敗的測試用例指定需要重復的次數。這個功能是為端對端測試所設計的，因為這些測試的數據不好模擬。Mocha不推薦在單元測試中使用這個功能。

這個功能會重新運行beforeEach/afterEach鉤子，但不會重新運行before/after鉤子。

下面是一個使用Selenium webdriver寫的一個重復執(zhí)行的測試用例。

describe("retries", function () {
    // 嘗試全部的失敗的測試4次，
    this.retries(4);

  beforeEach(function () {
    browser.get("http://www.yahoo.com");
  });

  it("should succeed on the 3rd try", function () {
    // Specify this test to only retry up to 2 times
    this.retries(2);
    expect($(".foo").isDisplayed()).to.eventually.be.true;
  });
})

Mocha可以使用Function.prototype.call和函數表達式來定義測試用例，其實就是動態(tài)生成一些測試用例，不需要使用什么特殊的語法。和你見過的其他框架可能有所不同，這個特性可以通過定義一些參數來實現測試用例所擁有的功能。

var assert = require("chai").assert;

function add() {
  return Array.prototype.slice.call(arguments).reduce(function(prev, curr) {
    return prev + curr;
  }, 0);
}

describe("add()", function() {
  var tests = [
    {args: [1, 2],       expected: 3},
    {args: [1, 2, 3],    expected: 6},
    {args: [1, 2, 3, 4], expected: 10}
  ];

  tests.forEach(function(test) {
    it("correctly adds " + test.args.length + " args", function() {
      var res = add.apply(null, test.args);
      assert.equal(res, test.expected);
    });
  });
});

上面的測試用例所產生的結果如下：

$ mocha

  add()
    ? correctly adds 2 args
    ? correctly adds 3 args
    ? correctly adds 4 args

很多的測試報告都會顯示測試所花費的時間，同樣也會對一些耗時的測試作出特殊的標記。

我們可以使用slow()方法來明確的表示出，超過多久的時間，這個測試就可以認為是slow的。

describe("something slow", function() {
  this.slow(10000);

  it("should take long enough for me to go make a sandwich", function() {
    // ...
  });
});

測試集合超時:

在測試集合上定義超時時間，會對這個測試集合中所有的測試用例和測試集合起作用。我們可以通過this.timeout(0)來關閉超時判斷的功能。而且在測試用例和測試集合上定義的超時時間會覆蓋外圍的測試集合的設置。

describe("a suite of tests", function() {
  this.timeout(500);

  it("should take less than 500ms", function(done){
    setTimeout(done, 300);
  });

  it("should take less than 500ms as well", function(done){
    setTimeout(done, 250);
  });
})

測試用例超時：

我們也可以給測試用例定義超時時間，或者通過this.timeout(0)來禁止超時時間的判斷。

it("should take less than 500ms", function(done){
  this.timeout(500);
  setTimeout(done, 300);
});

鉤子函數超時：

也可以給鉤子函數設定超時時間，同樣也可以使用this.timeout(0)來禁止掉超時時間的判斷。

describe("a suite of tests", function() {
  beforeEach(function(done) {
    this.timeout(3000); // A very long environment setup.
    setTimeout(done, 2500);
  });
});

在Mocha v3.0.0版本及以上，如果設定的超時時間比最大延遲時間的值大，那么也會被認為是禁止掉超時時間的判斷。

如果做斷言的時候拋出了AssertionErrors的異常，且錯誤對象中含有err.expected屬性和err.actual屬性，mocha會在報告中展示出期望值和實際值之間的差異。

格式：mocha [debug] [options] [files]

命令：
    init  : 生成一個在瀏覽器中運行的單元測試的模版

當我們運行如下命令的時候:mocha init .會在當前路徑中生成一個模版，文件如下：

mocha的命令的基本選項：

Options:

    -h, --help                  輸出幫助信息
    -V, --version               輸出mocha的版本號
    -A, --async-only            強制所有的測試用例必須使用callback或者返回一個promise的格式來確定異步的正確性
    -c, --colors                在報告中顯示顏色
    -C, --no-colors             在報告中禁止顯示顏色
    -g, --growl                 在桌面上顯示測試報告的結果
    -O, --reporter-options   設置報告的基本選項
    -R, --reporter        指定測試報告的格式
    -S, --sort                  對測試文件進行排序
    -b, --bail                  在第一個測試沒有通過的時候就停止執(zhí)行后面所有的測試
    -d, --debug                 啟用node的debugger功能
    -g, --grep         用于搜索測試用例的名稱，然后只執(zhí)行匹配的測試用例
    -f, --fgrep         只執(zhí)行測試用例的名稱中含有string的測試用例
    -gc, --expose-gc            展示垃圾回收的log內容
    -i, --invert                只運行不符合條件的測試用例，必須和--grep或--fgrep之一同時運行
    -r, --require         require指定模塊
    -s, --slow              指定slow的時間，單位是ms，默認是75ms
    -t, --timeout           指定超時時間，單位是ms，默認是200ms
    -u, --ui              指定user-interface (bdd|tdd|exports)中的一種
    -w, --watch                 用來監(jiān)視指定的測試腳本。只要測試腳本有變化，就會自動運行Mocha
    --check-leaks               檢測全局變量造成的內存泄漏問題
    --full-trace                展示完整的錯誤棧信息
    --compilers :,...  使用給定的模塊來編譯文件
    --debug-brk                 啟用nodejs的debug模式
    --es_staging                啟用全部staged特性
    --harmony<_classes,_generators,...>     all node --harmony* flags are available
    --preserve-symlinks                     告知模塊加載器在解析和緩存模塊的時候，保留模塊本身的軟鏈接信息
    --icu-data-dir                          include ICU data
    --inline-diffs              用內聯的方式展示actual/expected之間的不同
    --inspect                   激活chrome瀏覽器的控制臺
    --interfaces                展示所有可用的接口
    --no-deprecation            不展示warning信息
    --no-exit                   require a clean shutdown of the event loop: mocha will not call process.exit
    --no-timeouts               禁用超時功能
    --opts                定義option文件路徑 
    --perf-basic-prof           啟用linux的分析功能
    --prof                      打印出統(tǒng)計分析信息
    --recursive                 包含子目錄中的測試用例
    --reporters                 展示所有可以使用的測試報告的名稱
    --retries            設置對于失敗的測試用例的嘗試的次數
    --throw-deprecation         無論任何時候使用過時的函數都拋出一個異常
    --trace                     追蹤函數的調用過程
    --trace-deprecation         展示追蹤錯誤棧
    --use_strict                強制使用嚴格模式
    --watch-extensions ,... --watch監(jiān)控的擴展 
    --delay                     異步測試用例的延遲時間

如果你在js文件中使用了es6的模塊，你可以npm install --save-dev babel-register，然后使用--require選項 mocha --require babel-register。如果你指定了文件的后綴名，--compilers選項也是必需的。

如果你只對第一個異常感興趣，可以使用這個選項。

啟用nodejs的debug功能。這個選項會用node debug 的模式運行你的腳本，所以會在debugger語句處暫停執(zhí)行。這個選項和mocha debug以及mocha --debug是不同的；mocha debug將會喚起nodejs默認的debug客戶端，mocha --debug也可以使用不同的接口，比如－－Blink的控制臺工具。

names是一個逗號分隔的列表，例如，假設你的app需要使用全局變量app和YUI，這個時候你就可以使用--global app, YUI了。names也可以是一個通配符。比如，--global "*bar"將會匹配foobar，barbar等。參數傳入 * 的話，會忽略所有全局變量。

默認情況下，mocha并不會去檢查應用暴露出來的全局變量，加上這個配置后就會去檢查，此時某全局變量如果沒有用上面的--GLOBALS去配置為可接受，mocha就會報錯。

這個命令可以引入一些測試運行時候所必需的依賴。比如should.js，通過這個選項你不需要在每個文件使用require("should")來添加should.js了。也可以用--require ./test/helper.js這樣的命令去引入指定的本地模塊。
但是，如果要引用模塊導出的對象，還是需要require，var should = require("should")這樣搞。

用來指定測試所使用的接口，默認是"bdd"。

這個命令用于指定報告的格式。默認是spec。這個選項也可以用于指定使用第三方的報告樣式。例如，在npm install mocha-lcov-reporter后，就可以使用--reporter mocha-lcov-reporter來指定報告格式。

用來指定用例超時時間。單位是ms，默認是2s?？梢灾苯邮褂脦挝坏臅r間來覆蓋掉默認的單位。例如：--timeout 2s和--timeout 2000是一樣的。

用來指定慢用例判定時間，默認是75ms。

參數用于搜索測試用例的名稱（即it塊的第一個參數），然后只執(zhí)行匹配的測試用例。

describe("api", function() {
  describe("GET /api/users", function() {
    it("respond with an array of users", function() {
      // ...
    });
  });
});

describe("app", function() {
  describe("GET /users", function() {
    it("respond with an array of users", function() {
      // ...
    });
  });
});

當我們使用--grep api或者--grep app只能運行其中一個對應的測試。

mocha的測繪接口類型指的是集中測試用例組織模式的選擇。Mocha提供了BDD,TDD,Exports,QUnit和Require-style幾種接口。

BDD測試提供了describe()，context()，it()，specify()，before()，after()，beforeEach()和afterEach()這幾種函數。

context()是describe()的別名，二者的用法是一樣的。最大的作用就是讓測試的可讀性更好，組織的更好。相似地，specify()是it()的別名。

上面的所有測試都是用BDD風格的接口寫的。

describe("Array", function() {
    before(function() {
      // ...
    });

    describe("#indexOf()", function() {
      context("when not present", function() {
        it("should not throw an error", function() {
          (function() {
            [1,2,3].indexOf(4);
          }).should.not.throw();
        });
        it("should return -1", function() {
          [1,2,3].indexOf(4).should.equal(-1);
        });
      });
      context("when present", function() {
        it("should return the index where the element first appears in the array", function() {
          [1,2,3].indexOf(3).should.equal(2);
        });
      });
    });
  });

TDD風格的測試提供了suite(), test(), suiteSetup(), suiteTeardown(), setup(), 和 teardown()這幾個函數:

suite("Array", function() {
  setup(function() {
    // ...
  });

  suite("#indexOf()", function() {
    test("should return -1 when not present", function() {
      assert.equal(-1, [1,2,3].indexOf(4));
    });
  });
});

Exports 的寫法有的類似于Mocha的前身expresso，鍵 before, after, beforeEach, 和afterEach都具有特殊的含義。對象值對應的是測試集合，函數值對應的是測試用例。

module.exports = {
  before: function() {
    // ...
  },

  "Array": {
    "#indexOf()": {
      "should return -1 when not present": function() {
        [1,2,3].indexOf(4).should.equal(-1);
      }
    }
  }
};

QUNIT風格的測試像TDD接口一樣支持suite和test函數，同時又像BDD一樣支持before(), after(), beforeEach(), 和 afterEach()等鉤子函數。

function ok(expr, msg) {
  if (!expr) throw new Error(msg);
}

suite("Array");

test("#length", function() {
  var arr = [1,2,3];
  ok(arr.length == 3);
});

test("#indexOf()", function() {
  var arr = [1,2,3];
  ok(arr.indexOf(1) == 0);
  ok(arr.indexOf(2) == 1);
  ok(arr.indexOf(3) == 2);
});

suite("String");

test("#length", function() {
  ok("foo".length == 3);
});

require可以使用require方法引入describe函數，同時，你可以為其設置一個別名。如果你不想再測試中出現全局變量，這個方法也是十分實用的。

注意：這種風格的測試不能通過node命令來直接運行，因為，這里的require()方法node是不能夠解析的，我們必須通過mocha來運行測試。

var testCase = require("mocha").describe;
var pre = require("mocha").before;
var assertions = require("mocha").it;
var assert = require("chai").assert;

testCase("Array", function() {
  pre(function() {
    // ...
  });

  testCase("#indexOf()", function() {
    assertions("should return -1 when not present", function() {
      assert.equal([1,2,3].indexOf(4), -1);
    });
  });
});

Mocha報告會自適應終端窗口，如果終端類型非TTY類型，會禁用ANSI-escape顏色。

這是默認的測試報告，輸出的格式是一個嵌套的分級視圖。

dot matrix視圖報告使用一系列的字符來表示報告的結果，失敗的測試使用紅色的!來表示，pending測試使用藍色的,來表示。慢的測試用黃色的.來表示。這個終端輸出的內容最少。

"nyan"報告就是你所期望的那樣（謎一樣的解釋）：

The TAP reporter emits lines for a Test-Anything-Protocol consumer.

landing strip飛機降落的跑道，測試報告就是像一架飛機軌道一樣的視圖。

"list"報告就是簡單的輸出一個列表來顯示每個測試用例是否通過或失敗，對于失敗的測試用例，會在下面輸出詳細的信息。

"progress"報告就是一個包含進度條的視圖。

json視圖會輸出一個json對象作為結果

輸出的也是一個json，不同測試用例以換行符進行分割。

這個報告只顯示測試的整體情況，但是仍然會輸出錯誤和失敗的情況。和--watch選項結合使用最好。

生成一個只包含html的body內容的測試報告。

例如，假設你有下面的javascript代碼：

describe("Array", function() {
  describe("#indexOf()", function() {
    it("should return -1 when the value is not present", function() {
      [1,2,3].indexOf(5).should.equal(-1);
      [1,2,3].indexOf(0).should.equal(-1);
    });
  });
});

通過mocha --reporter doc array會生成如下的報告：

  
Array
  

    

      
#indexOf()
      

      
should return -1 when the value is not present
      
[1,2,3].indexOf(5).should.equal(-1);
[1,2,3].indexOf(0).should.equal(-1);
      
    
  

"markdown"格式的報告會給你的測試用例生成一個markdown內容。如果你想使用github wiki或者生成一個github能夠渲染的markdown文件，這種格式十分有用。這有一個例子test output

只有在瀏覽器中使用Mocha的時候才能生成這種報告。

"XUnit"類型的報告也是可以使用的。默認情況下，只會在console控制臺中輸出。為了將報告寫入一個文件中，使用--reporter-options output=filename.xml

Mocha也可以使用第三方報告生成器，具體的件文檔

Mocha可以在瀏覽器中使用。每次Mocha發(fā)版，都會生成一個新的./mocha.js和./mocha.css文件，以便在瀏覽器中使用。

下面的方法只能在瀏覽器中使用。

mocha.allowUncaught()：未捕獲的錯誤不會被拋出。

下面是一個典型的例子。在加載測試腳本之前，使用mocha.setup("bdd")函數把測試模式設置為BDD接口，測試腳本加載完之后用mocha.run()函數來運行測試。

瀏覽器中可以通過在url后邊加?grep=api參數，來使用grep命令。

可以通過mocha.setup()方法來設置配置:

// Use "tdd" interface.  This is a shortcut to setting the interface;
// any other options must be passed via an object.
mocha.setup("tdd");

// This is equivalent to the above.
mocha.setup({
  ui: "tdd"
});

// Use "tdd" interface, ignore leaks, and force all tests to be asynchronous
mocha.setup({
  ui: "tdd",
  ignoreLeaks: true,
  asyncOnly: true
});

下面的選項只能在瀏覽器中使用。

noHighlighting：如果為true，在輸出結果中語法不會高亮。

在服務端運行的時候，mocha會去加載test目錄下的mocha.opts文件，來讀取mocha配置項。這個配置文件中的每一行代表一項配置。如果運行mocha命令的時候，帶上的配置參數與這個配置文件中的配置沖突的話，以命令中的為準。

假設你有如下的mocha.opt文件：

-- require should
-- reporter dot
-- ui bdd

上面的配置就會讓mocha 引入一下should模塊、報告樣式設置為dot，并且使用bdd的測試接口。在這個基礎上，運行mocha的時候也可以添加一些額外的參數，比如添加--Growl選項同時更改報告樣式為list風格：

$ mocha --reporter list --growl

默認情況下，Mocha會搜索./test/*.js和./test/*.coffee，所以，你可以把你的測試放在test/文件夾下面。

Express

Connect

SuperAgent

WebSocket.io

Mocha

$ cd /path/to/mocha
$ npm install
$ npm test