Mocha: エラー：解決方法が指定されすぎています。

async関数（バベル）とdoneも破ります。

エラーが示すように、アリティが0より大きい関数（ doneコールバックを受け入れることを意味します）を提供することは想定されていません。そして、Promiseを返します。

これを修正する最も簡単な方法は、 returnを省略することですが、promiseを使用しているため、代わりにdoneコールバックを削除することをお勧めします。これにより、構成がはるかに単純になります。 ：

before(() => Promise.all([]).then(() => Model.insert(...)));

async （基本的にはpromise）とdoneの両方が壊れた例を次に示します。

it('fires change event when calling blah.doSomethingThatFiresChange', async function (done) {
  const blah = await getBlah()
  blah.on('change', () => done())
  blah.doSomethingThatFiresChange()
})

@eladoこれは興味深いユースケースですが、mochaの観点からは同じ状況です。つまり、 doneコールバックを受け取り、promiseを返す関数です。 私はそれを完全に約束ベースになるように書き直します：

it('fires change event when calling blah.doSomethingThatFiresChange', async function () {
  const blah = await getBlah()
  return new Promise(resolve => {
    blah.on('change', resolve)
    blah.doSomethingThatFiresChange()
  })
})

...しかし、あなたが得ているのは、この例では、モカが約束が解決され、コールバックが呼び出されるのを_両方_待つ方がよいということだと思いますか？

残念ながら、その特定のコンボはほとんどの場合テストのバグであるため、このエラーメッセージが最初に追加されました。

... .then（（）=> done（））を省略すると、テストがタイムアウトします。

いずれにせよ、これはバグのようです。

@ScottFreeCodeうーん、ええ、 doneコールバックとして提供された関数で「過剰指定」エラーが発行されたためと思われます： https ： ＃L357 -L373

...しかしもちろん、関数が戻ったらすぐにそのエラーで失敗する必要があると判断できます。

@ScottFreeCodeここでの修正は何ですか？

「約束が解決または拒否されるのを待ってから、「過剰指定」エラーで拒否する」と推測しますか？

同じテストでdoneとpromiseをエラーと見なす場合、 done受け取ったテスト関数がエラーを返すとすぐにエラーを検出しない理由はわかりません。 @papandreouが示唆したように、約束します。 場合によってはpromiseとdone一緒に許可するつもりがない限り、他のどのポイントがエラーをトリガーするかを理解しようとすることは私にはあまり意味がありません。

@ScottFreeCode私は同意します。 っていうことは

1. 問題を検出します。 インスタンス化Errorしかし呼び出すことはありませんdone()それで
2. Promiseが実行されるまで待ちます
3. Error拒否する

ボーナス質問：約束の履行の結果をどうするか？

ああ、私はそれを理解したと思います-エラーを検出した場合でも、テストを実行して、次のテスト中にコードが実行されないようにする必要があります。おそらく、テスト結果を報告することもできます。

テストは、約束を解決または拒否せずにdoneを呼び出すことになる可能性もありますか？ もしそうなら、それは私たちが処理しなければならないもう一つのエンドケースです。

私の傾向、再。 テストの結果をどうするかというと、タイムアウトした場合（ doneを呼び出すか、promiseを解決/拒否せずに）、promiseでdoneの使用を報告するだけです。 （組み合わせに関する混乱が、どちらにも到達せず、代わりにタイムアウトになった理由である可能性が非常に高いため）が、いずれかの方法で終了できた場合は、おそらく結果は有効（または少なくとも何らかの意味がある）であり、報告する必要がありますdone誤った使用の可能性と一緒に約束すること、そしてそれが少なくともある程度役立つことを期待するテスト結果の両方。

とにかく、それは私が現時点で思いつくことができる最高のものですが、この問題を掘り下げる時間を見つけることができれば、私はより多くの洞察を得るかもしれません。

そうですね、これは段階的に行うことができます。 1つ目は、Promiseが返され、 doneコールバックが与えられた場合に、Mochaが友好的に壊れることを確認することです。

（Bluebirdを使用して）次のようなことができるのは_考えられます_：

// to make this work, you need to omit `return`
it('should do something async for sure', function(done) {
  return somethingAsync()
    .then(makeAssertion)
    .asCallback(done);
});

しかし、それはあなたが_できる_ことです。 私はこれのユースケースをまだ決定していません。

私は自分自身を混乱させたと思います。 ここにバグがあるかどうかはまったくわかりません。

これは「貧弱なUI」タイプの問題です

返されたpromiseが解決/拒否されても、 doneが呼び出されるのを待つタイムアウトは、そのようなテストでdoneとpromiseを一緒に使用することを禁止するかどうかに関係なく、間違いなくバグです。場所。 これは、promiseとdone両方が同じテストで使用されたため、promiseまたはエラーの結果を使用する必要がありますが、一方が完了したときに一方が完了しなかったためにタイムアウトするだけではありません（それが現在行っていることです）：

it("should not time out", function(done) {
  return new Promise(function(resolve, reject) {
    setTimeout(resolve.bind(42), 50)
  })
})

1）タイムアウトしないでください：
エラー：2000msのタイムアウトを超えました。 このテストでdone（）コールバックが呼び出されていることを確認します。

とにかくPRを見ていきます...

興味のある方は＃2413をご覧ください。

@briansipple

バージョン3で複数の非同期beforeEachフックを使用すると、同じエラーが発生します。

  beforeEach((cb) => connection.db.collection('users').remove({}, cb));
  beforeEach((cb) => connection.db.collection('accounts').remove({}, cb));
  beforeEach((cb) => connection.db.collection('accounts').insertOne(account1, cb));

そのように非同期フックをまだ使用することはできませんか？

私は自分の問題を理解しました：各フック内のメソッドがpromise返し（そのような場合はpromiseを使用していなかったため、それを知りませんでした）、明らかにcb関数も渡しています。

これは良い考えではないと思います。 コールバックをリクエストした場合、彼らは彼らの意図を明確にしたと思います。 ここでのエラーはただの煩わしさです。 取り外してください。

これは実際には意図的な問題ではありません。 ＃1320の説明から：

コールバック関数が指定され、Promiseオブジェクトが
返されると、Runnableの解決条件はあいまいです。

あいまいではありません。コールバックが要求されました。 それはどのように曖昧ですか？

@RobertWHurstにあいまいさがないことに同意します。

それに加えて、この問題は「意見に基づく」ものである可能性があり、開発者は異なる見解を持っていると思います。 私はそれが壊滅的な変化をし、人々にそのように使わせることは非常に過激であると思います。

私たちは誰にも何もすることを_強制_しませんでした。 メジャーをリリースしましたが、これは定義上、重大な変更が加えられます。 私たちはsemverを壊しませんでした。

彼はあなたがセンバーを壊したという意味ではないと思います、彼はあなたがモカを壊したという意味だと思います。 この変更は開発者にとって物事を容易にするものではなく、意見を強制するものです。

beforeEach((cb) => connection.db.collection('users').remove({}, cb));
            ^^

^^それは曖昧ではありません。 著者が何を期待しているのかはかなり明確です。 作者は、コールバックを要求するために邪魔をしていません。

実際、ここで例外が発生する理由は、意見を強制することを最大限に回避するためです。 モカは、返された約束またはコールバックが信頼できるかどうかについて意見を持っていません。 結果があいまいになるため、両方を同時に使用することはできません。 テストフレームワークでのあいまいな結果は、エラーと見なす必要があります。 したがって、これを認識し、自分の意見に一致する選択と変更を行うのに役立つエラーメッセージが表示されます。

ドラマの量を減らすことは有益かもしれません。 「あなたはモカを壊した」は誰も助けていません。 semverのメジャーバージョンの増加は、コードの調整が必要になる可能性のある重大な変更として明示的に定義されています。 2.xにとどまり、テストを修正するための変更を加える時間を与えることができます。 これは進化であり、破損ではありません

@Munterコールバックのリクエストがどのように曖昧であるかについて、私はまだ暮れています。 コールバックを要求する場合は、それを使用する必要があります。 それ以外の場合は、プログラミングエラーです。 これは、テスト作成者による明示的なアクションです。

あなたがドラマを感じているなら、私は何も意味しません。 「あなたはモカを壊した」は双曲線を意味するものではありません。 これはモジュールの設計に反し、元のAPIコントラクトを破ると思います。

前に述べたように、babel async / awaitは新しいmocha @ 3ではうまく機能しません

it('should fill userName and password', async function (done) {
    const userNameField = global.driver.wait(until.elementLocated({css: '#username'}));
    userNameField.sendKeys('admin');

    const passNameField = global.driver.findElement({css: '#password'});
    passNameField.sendKeys('*******');

    const userNameVal = await userNameField.getAttribute('value');
    const passwordVal = await passNameField.getAttribute('value');

    try {
      assert.equal(userNameVal, 'admin');
      assert.equal(passwordVal, 'changeme');
    } catch (error) {
      done(error);
      return;
    }

    done();
  });

このコードはmocha @ 2でうまく機能しますが、 awaitではpromiseを返すため、 mocha @ 3では機能しません。

このPRはここに関連していると思います=> https://github.com/mochajs/mocha/pull/2413
このエラーのエッジケースに対処するためのより複雑な。

@artyomtrityakこれは、 doneが不要な良い例です。

中傷者は彼らの作品を言っています。 それでも、モカのメンテナは、この変更を元に戻すための議論に同意しません。 エラン・ハンマーは（言い換えれば）「メンテナーとして、あなたができる最も難しいことの1つは、仕事を自分の方向に動かしたい人を失望させることです」と述べました。

より多くのドキュメント（たとえば、このエラーのより多くの例とそれらを修正する方法）、より良いエラーメッセージなどの回避策を歓迎しますが、ドラマ、無礼、または不満には興味がありません。 これらの回避策のいずれかをMochaに提供すると、ネガティブをポジティブに変えるのに役立ちます。

この変更が気に入らず、単に建設的にできない場合は、OSSです。プロジェクトをフォークして、そこで変更を元に戻すことができます。

@boneskullは、promiseを返す非同期関数に変換されますmocha @ 2で完全に機能しますが、 mocha @ 3では機能しません。 そのため、私のチーム（〜20ppl）は最新のモカに移動できません。

現在、mocha 2.xは多くの柔軟性を提供しますが、この変更の技術的な理由はありますか？

@artyomtrityakこれは、完了が不要な場所の良い例です。

これがbabel async/await構文を使用し、 return new Promiseを使用しない場合の例を教えてください。

@artyomtrityak約束を完全に

it('should fill userName and password', async function () {
    const userNameField = global.driver.wait(until.elementLocated({css: '#username'}));
    userNameField.sendKeys('admin');

    const passNameField = global.driver.findElement({css: '#password'});
    passNameField.sendKeys('*******');

    const userNameVal = await userNameField.getAttribute('value');
    const passwordVal = await passNameField.getAttribute('value');

    assert.equal(userNameVal, 'admin');
    assert.equal(passwordVal, 'changeme');
  });

個人的に攻撃されていると感じた場合は、この会話にどれだけ感情的に投資しているかを再考する必要があると思います。 コメントはどれも個人的なものではありません。 特に、このプロジェクトの維持に時間を費やしてくださったことを考えると、皆さんは素晴らしいと確信しています。これは非常に高く評価され、非常に称賛に値します。

あなたのほとんど（現在アクティブなメンテナ）は、2014年半ば頃にモカに取り組み始めました。 モカは皆さんが貢献し始めた時点ですでに確立されています。 それは私の意見ですが、正当化されない限り、確立されたライブラリに重大な変更を加えるべきではないと考えているのは私だけではないと思います。 この変更の本来の正当性は想像できますが、次の点を指摘するとうまくいきません。 コールバックを要求することは、明確な意図を伝えます。 約束は要求されていないため明確ではなく、返されます。これは間接的かつ偶発的に発生する可能性があります（たとえば、サードパーティのライブラリから返されます）。 これらの違いのために、2つの降伏方法は等しくなく、したがって両方を使用しようとすることは実際には曖昧ではありません。 コールバックはテスト引数に書き込む必要があります。 約束ではそれを行うことはできないので、コールバックを要求することで、意図を明示的に伝えました。 あなたのコミュニティはこれらの懸念を提起しました、そしてあなたたちが失敗を認める代わりにあなたたちは倍増しています。 このエラーが一貫して機能することを確認するために、テストを強制的に非同期にすることを検討しているようです。 => https://github.com/mochajs/mocha/pull/2413を参照して

@tjの出発以来、

@RobertWHurstに完全に同意します。

doneを要求すると、返されたpromiseの動作が上書きされます。 不要なときにdoneを要求する可能性は低く、 async関数で発行されたイベントのシナリオは完璧な例です。

上記の私のコメントから：

it('fires change event when calling blah.doSomethingThatFiresChange', async function (done) {
  const blah = await getBlah()
  blah.on('change', () => done())
  blah.doSomethingThatFiresChange()
})

より多くの人々がES6 / 7 + async / awaitに移行するにつれて、これはMochaを使用する際の一般的な落とし穴になります。

この変更を再検討してください。

@RobertWHurst doneコールバックを定義することは明示的な意図であるとあなたは主張します。 returnステートメントは明示的な意図ではありませんか？ どちらもコードで定義されています。 コードの一部が意図的であり、別の部分が意図的ではないとどのように判断できますか？ () => fooより前の世界を想像すると、returnステートメントは常に明示的でした。 あなたが今腕を組んでいる唯一の理由は、あなたが暗黙のreturnステートメントを使い始めたからです。私が考えることができるのは美的理由だけです。

Mochaの使用法の多くは、通常doneコールバックを含む可能性が高い例をコピーして貼り付ける初心者によるものであるとすると、この新しいユーザーが明示的にpromiseを返したが、タイムアウトが発生した場合をどのように処理しますか？ これは、気が狂っている変更が元に戻された場合の結果です。

現在の動作は、予期しないタイムアウトよりも、何が問題であるかについてはるかに明確です。

@Munter画像にasync関数がある場合、 awaitを使用するかどうかに関係なく、自動的に作成されて返されるため、返されるpromiseスコアは明示性スケールで低くなると思います。

it('should work with a async function that could have been sync', async function () {
  assert.ok(true);
});

it('should work with a legitimately async function', async function () {
  assert.equal(await getBlah(), 'blah');
});

it('should work with a fully spelled-out Promise-based test', function () {
  return getBlah().then(function (blah) {
    assert.equal(blah, 'blah');
  });
});

そして、物議を醸すものがあります：

it('should foo', async function (done) {
  assert.equal('foo', 'foo');
  done();
});

また、その小さなasyncが誤って侵入するのも簡単なので、 @ eladoが指摘しているように、（少なくとも）最初の例を新しい種類の

ここで少し話し合った後=> https://github.com/mochajs/mocha/pull/1320、私は問題の代替ソリューションのアイデアを思いつきました。 ここにあなたのレビューの喜びのためのPRを追加しました=> https://github.com/mochajs/mocha/pull/2454

：ビール：

完了したコールバックを定義することは明示的な意図であるとあなたは主張します。 returnステートメントは明示的な意図ではありませんか？

@Muntercoffeescriptとes6の矢印関数式が_implicitly_を返すことを忘れないでください。そうすれば、次のようなことができます。

it 'should foo', (done) -> request('/foo').end (err, res, body) -> done()

あなたは安全だと思います。 しかし、この問題は、その素敵なワンライナーを次のようなものに変換する必要があることを意味します

it 'should foo', (done) ->
  request('/foo').end (err, res, body) -> done()
  return

これはまさに、それぞれとmecanoの全体的なコードベースに関する問題

it 'should foo', (done) ->
  obj =
    run: ->
      done()
      @
    then: -> "what the hell, i'm not a promise"
  obj.run()

これはcoffeescriptに完全に固有ではありませんが、暗黙の値を返すと最悪になります。 Mochaは有効なpromiseインスタンスを検出する必要があります。 また、オプションでこの機能を無効にすることもできます。

やあみんな、
次のコードでこの問題に遭遇しました。

describe('Page', ->
  describe('/GET home', ->
    it('it SHOULD return the homepage', (done) ->
      chai.request(app).get('/').end((err, res) ->
        res.should.have.status(200)
        res.text.should.be.a('string')
        done()
      )
    )
  )
)

promiseチェーンを尊重し、コールバックdone()を省略することで、これを解決しました。

describe('Page', ->
  describe('/GET home', ->
    it('it SHOULD return the homepage', ->
      chai.request(app).get('/').then((res) ->
        res.should.have.status(200)
        res.text.should.be.a('string')
      )
    )
  )
)

これが、同様のエラーに遭遇した他の人に役立つことを願っています：smile：

PS ：heart：Mocha btw：+1：

編集@Munterのコメントに基づいてcatch()を削除します。

@karlbatemanありがとう。 ただし、最後の.catchは必要ありません。 拒否された約束は、モカによってエラーとしてカウントされます

@Munterなるほど、ありがとう：smiley：

もう少し考えてみると、約束とコールバックの両方を待つという振る舞いが本当に好きです。 それを実装することで何か進歩はありましたか？

@ light24bulbsフィードバックをありがとう！ いいえ、それは私が反応を見るためにそこに投げ込んだ単なるアイデアなので、誰もそれに取り組み始めませんでした。 私はちょうど今、アイデアについて追加のフィードバックがあったかどうか、それが機能しない場合などがあるかどうかを確認していました。

babelを使用する場合の回避策はありますか？

babelを使用する場合の回避策はありますか？

私は2回ラップします：

it("should work", done => {
  (async () => {
    await something;
    done();
  })();
});

@SaschaNazありがとう、これはv3.2.0で動作します:)

6か月後、この問題はまだすべての最新のjsテストにブレーキをかけています...
恥

@benfavreボランティアが子供と遊ぶのではなく、自由な時間に指定していないソリューションを実装する責任を負うように、最も確実に

@Muntermochajsの新規ユーザーとして直面した特定の問題を特定するのに役立つことを嬉しく思います。
@SaschaNazは、2回ラッピングするソリューションは

=> promiseを排他的に使用すると、正常に機能しました。

次回は、無料で侮辱されないように、モロンのように「+1」するだけでいいと思います。
私のメッセージには侮辱的なものは何もありませんでした。さらに私の発言は真実のままです。

ほとんどの人は別のフレームワークを選択するでしょう...今のところ、それはasync / awaitで単純に壊れており、メインサイトのどこにも明確な表示がなく、CLIに明確なエラーメッセージがありません。

明けましておめでとうございます。子供たちと遊んで楽しんでください。

チル...

ディスカッションは、 doneコールバックと返されたPromise両方に「注意を払う」ことに発展しました： https ：

閉鎖。 ＃2509を参照

一部の体がまだ苦労している場合...

babelを使用する場合の回避策はありますか？

＃2509で述べたように、promiseの組み込みハンドラーを使用すると、次のようにwrapping twice hackを使用する必要はありません。

it("should work", done => {
  (async () => {
    await something;
    done();
  })();
});

その代わりに、私たちはこれで簡単に行くことができます：

it("should work", async () => {
  await something;
});

詳細については、この投稿を確認してください

@ lo-tp
1.）このコードはbabelでコンパイルすると機能しますか？

it("should work", async () => {
  await something;
});

@SerkanSipahi

• はい、今async/await構文を使用するには、babelの助けが必要です。

何かが足りないかどうかはわかりません...しかし、Promisesでreturnステートメントを使用せず、done（）に依存することで、この問題を解決しました。

これが私のために働いている例です

  describe('STRIPE CHARGES: Get Charges', () => {
    it('should list customer charges', async () => {
      const charges = await Stripe.getChargesList(customerObj);
      charges.data[0].should.have.property('id');
      charges.data[0].amount.should.have.property('id');
    });
  });

私はchai.assertでmocha4を使用しています。

最初は、done（）コールバックをそのように使用しようとしました。

it('should throw an error', async function(done) {
  try {
    result = await something('value that causes something() to throw an Error');
    done('failed');
  } catch (e) {
    done();
  }
});

それは失敗しました

Error: Resolution method is overspecified. Specify a callback *or* return a Promise; not both."

そのエラーが私をここ、このページに導いたのです。 このかなり長いスレッドをくぐり抜けて（そして私はすべての論争を完全に理解していなかったことを認めます）、それらはPromisedベースであるため、非同期呼び出しでdone（）を使用するべきではないことを理解していますか？

もしそうなら、something（）を待つための呼び出しがエラーをスローしたときに次のテストに合格するにはどうすればよいですか？これは私が起こると予想されることですか？

it('should throw an error', async function() {
  try {
    result = await something('value that causes something() to throw an Error');
  } catch (e) {
    // how to indicate that this should happen, if I can't call done() to tell mocha?
  }
});

誰かが私がこの特定のケースを理解するのを手伝ってくれませんか？ アサーションライブラリを使用する必要がありますか、それとも上記のコードに追加する必要があるものがありますか？

どうもありがとう。

低レベルでエラーが発生しやすいソリューション：

it('should throw an error', async function() {
  try {
    result = await something('value that causes something() to throw an Error');
    throw new Error('Promise unexpectedly fulfilled');
  } catch (e) {
    // Optionally assert something about e...
  }
});

私は曜日を問わずアサーションライブラリを使用します。

const expect = require('unexpected');
it('should throw an error', async function () {
    await expect(something(), 'to be rejected with', 'the error message');
});

またはchai + chai-as-promised：

const chai = require('chai');
chai.use(require('chai-as-promised'));
const expect = chai.expect;

it('should throw an error', async function () {
    await expect(something()).to.be.rejectedWith('argh');
});

こんにちはみんな、これはasyncawaitでうまく機能します（ 'done（）'を省略してください）

describe('New order from landing', function() {
    describe('check new client function', function () {
        it("must check db and return that random client is new", async function () {
            var result = await handler.checkClient(reqNewClient.body)
                expect(result).to.have.property('newclient').equal(true)
            })
    })
})

結果：

着陸からの新規注文
新しいクライアント機能を確認してください
√dbをチェックし、ランダムクライアントが新しいことを返す必要があります
1パス（9ミリ秒）

@kolykhalovありがとうそれは私のために働いた

私の場合、非同期ブロックをtry / catchでラップしました

it('It should activate a user.', async() => {
        return new Promise((resolve, reject) => {
            try {
                // Get the last activation token from the DB
                let sql = 'select * from activation_tokens order by created_at desc limit 1';
                let res = await DB.query(sql);
                let {token} = res[0];

                server
                    .post('/auth/activate')
                    .send({token})
                    .set('Content-Type', 'application/x-www-form-urlencoded')
                    .expect('Content-Type', /json/)
                    .expect(200)
                    .end((err, res) => {
                        res.body.data.should.contain.keys('message');
                        res.body.data.message.should.equal("Activated");
                        resolve();
                    });
            } catch (e) {
                console.error(e);
            }
        });
    });

脆弱性を回避するためにアップグレードされました。 今、私は99のテストを書き直さなければなりません。 FML

したがって、問題が何であるかを明確にするために、 doneとasyncを使用する必要はないと言う人もいますが、ここでは両方を使用する例を示します。

it('should error on fn', async function(done) {
  try {
    await fn();
  } catch (e) {
    // assert some things here
    done()
  }
});

doneを使用しないと、エラーがスローされない場合にテストに合格します。 expect(await fn).to.throw('blah')ようなものを使用することを提案する人もいますが、ワンライナーに収まるよりも多くのプロパティをチェックする必要がある場合があります。

このエラーが発生しましたが、誤って約束を返していました（スーパーテスト）

it('Should do something', (done) => {
       return supertest(server)
           .get(`/api/endpoint`)
           .set('somekey', 'somevalue')
           .expect(200)
           .then(() => { done(); })
           .catch(done);
});

'return'句を削除すると、問題が解決しました

これに夢中になった他の人のために...

これは機能します：

it("should work", async () => {
  await something;
});

これはしません：

it("should work", async (done) => {
  await something;
});

パラメータとしてdoneを削除する必要があります。

@tamoyal 、ええ投稿したように。

async / awaitを使用すると、暗黙のPromiseが返されます。 doneコールバックの使用は
ここに示すように、 CPSベースの非同期。 モカは両方をサポートしています...しかし同時にではありません。
これは文書化されており、Mocha-3.0リリース以降の標準的な動作です。

このエラーが発生しましたが、誤って約束を返していました（スーパーテスト）

it('should do something', (done) => {
       return supertest(server)
           .get(`/api/endpoint`)
           .set('somekey', 'somevalue')
           .expect(200)
           .then(() => { done(); })
           .catch(done);
});

'return'句を削除すると、問題が解決しました

@victorsferreira 、これが解決策だったはずです...

it('should do something', () => {
  return supertest(server)
    .get(`/api/endpoint`)
    .set('somekey', 'somevalue')
    .expect(200);
});

@tamoyalうん、それが私をつまずかせたものだった。 私が作成した関数のパラメーターを調べ、それを使用して決定を下すために、サードパーティのライブラリを使用することは非常に直感的ではありません。

@mienaikoe 、この正確なシナリオは明示的に文書化されています、あなたは知っています...

@plroebuck 2つのこと：

1）何かを文書化することと、関数のパラメーターをイントロスペクトするnpmの数少ないライブラリーの1つであることには違いがあります。 私が最初に友達に会ったときにすべての友達の身元調査を行ったことを記録することはできましたが、それでも奇妙で、理由がなく、明示的に理由を伝えない限り、人々はそれについて不平を言うでしょう。

2）ドキュメントに欠陥があります：

Mocha v3.0.0以降では、Promiseを返し、done（）を呼び出します...

これは、doneを呼び出すことではなく、使用するかどうかに関係なく、_パラメーターとしてdoneを指定することです。

@mienaikoe

1. Mochaは、 itの2番目のパラメーターをチェックして、関数が存在するかどうかを確認し、存在する場合は、そのアリティをチェックして、ユーザーがコールバックを追加したかどうかを判断します。 これはイントロスペクションとしてはほとんど適格ではなく、JavaScriptで一般的に使用されます。
2. あいまいすぎると思われる場合は、PRを送信してドキュメントを修正してください。

パラメータとして行われた削除は私のために働いた！

前：

AFTER（動作します！）

@QauseenMZ 、「前」と「後」のコードに違いはありません。

あなたはまたあなたの約束を返していません。 こんな感じじゃないですか？

  it('should receive successful RPC response', async () => {
    return await getResponse(unitData)
      .then((res) => {
        expect(res).to.have.status(200);
      });
  });

PS。 Nodeコールバック引数の順序が崩れています... error _ always_が最初になります。

@plroebuck言及してくれてありがとう！ 編集しました。

getResponse関数がコールバックを返しているため、promiseを処理していません。 それは私がそれを機能させる唯一の方法でした。 getResponse関数は次のとおりです。

ここで、エラーは、コールバックgetResponse関数が返されているという理由だけで2番目のパラメーターです。 それについてのあなたの考えを教えてください。 ありがとう！

いくつかの部分はちょっと非論理的に見えます。 わかりやすくするために、どのrequestパッケージを使用していますか？
optionsオブジェクト（ unitDataという名前）を返す必要があるのはなぜですか？

• objどこから来たのですか？
• res.statusCode === 200 res.body.errorがあるのはなぜですか？

PS。 コードの画像ではなく、コード自体を貼り付けてください...

これに夢中になった他の人のために...

これは機能します：

it("should work", async () => {
  await something;
});

これはしません：

it("should work", async (done) => {
  await something;
});

パラメータとしてdoneを削除する必要があります。

@tamoyalあなたは私の命を救った<3

これが壊れて、同じエラーが発生します。

it('Location Querying Works', async () => {
    await WeatherComponent.pullLocationData();
    Vue.nextTick(()=>{
      expect(WeatherComponent.$el.textContent).contain("Spain")
    })
  })

、あなたにこの問題への迅速な解決を与える約束であなたの全体のテストをラップし、使用するには、 resolveあなたは同じようにdone 。

これを回します：

it.only("Works with the database", async (done) => {
    let browser = await puppeteer.launch();
    let query = db.collection('lists').where('ownerId', '==', 'UJIXXwynaCj8oeuWfYa8');
    let ct = 0;
    query.onSnapshot(async querySnapshot => {
        if (ct === 0) {
            await addAPurpose(browser, session, sessionSig); // A function with a bunch of Puppeteer code.
            ct++
        } else {
            expect(querySnapshot.size).to.equal(1);
            expect(querySnapshot.docs[0].get().title).to.equal("Understand Mocha");
            done();
        }
        console.log(`Received query snapshot of size ${querySnapshot.size}`);
    }, err => {
        console.log(`Encountered error: ${err}`);
    });
});

これに：

it.only("Works with the database", async () => {
    const onSnap = new Promise(async (res, rej) => {
        let browser = await puppeteer.launch();
        let query = db.collection('lists').where('ownerId', '==', 'UJIo1gGMueoubgfWfYa8');
        let ct = 0;
        let unsubscribe = query.onSnapshot(async querySnapshot => {
            if (ct === 0) {
                await addAPurpose(browser, session, sessionSig);
                ct++
            } else {
                expect(querySnapshot.size).to.equal(1);
                expect(querySnapshot.docs[0].data().title).to.equal("Evolution");
                // done(); 
                unsubscribe();
                res();
            }
            console.log(`Received query snapshot of size ${querySnapshot.size}`);
        }, err => {
            console.log(`Encountered error: ${err}`);
            rej()
        });
    });
    return onSnap;
});

そしてそれはあなたが望むように機能します。

doneを削除する必要があることに驚いた。テストは、完了するまで実行されたからだ。 doneをasyncで使用してはならないことをより明確にするために、doneが渡された場合、非同期関数は_すぐに_失敗する必要があります。 Mochaは次の方法でテストを開始する必要があります。

1. 関数が非同期であるかどうかを確認し、
2. done引数を検出しています。

両方が存在する場合は、 doneが呼び出されるまでテストを実行してから、ブルーボールを実行するのではなく、スローする必要があります。 次に、エラーは、コードを別のpromiseでラップし、 doneと同じようにresolveを使用することを示唆しているはずです。

function.prototype.name === "AsyncFunction"使用できることは知っています。 それからそれは

if (function.prototype.name === "AsyncFunction && arg1.name === "done") {
  throw new Error("Can't use done with an async function")
}

これを実装します。

私はこれに関してほぼSOLでした。 非同期コードを実行する必要があり、コードの実行が（これまでに）終了しないことが予想されるため、doneを使用する必要があります。 厄介なハックアラウンドは、非同期テストコードを自己呼び出し非同期関数でラップし、 it関数を同期関数として残すこと

解決：

it("It shouldn't be like this", function (done) {
    ( async function(){
        var life = require('InfiniteLife');
        var asyncRes = await life.someCoolstuff();
        assert(asyncRes);
        setTimeout( function(){
            done();
        },letsCallItQuitsNow);
    })();
});

ブレークが完了した非同期関数の例。

it('If the credentials exists in the system it should return the token generated against it.', async (done) => {
        let aObj = await admin.createAdmin();
        chai.request(server)
        .post("/authenticate")
        .set("Content-Type", "application/x-www-form-urlencoded")
        .send({username: aObj.login,password:aObj.password})
        .end((err, res) => {
            res.should.have.status(200);
            res.body.should.be.a("string");
            done();
        });
    });

成功事例

it('If the credentials exists in the system it should return the token generated against it.', async () => {
        let adminObj = await admin.createAdmin();
        chai.request(server)
        .post("/auth/login")
        .set("Content-Type", "application/x-www-form-urlencoded")
        .send({username: adminObj.login,password:adminObj.password})
        .end((err, res) => {
            res.should.have.status(200);
            res.body.should.be.a("string");
            // done();
        });
    });

@ Haisum92

テストではdoneもasyncも必要ありません。 チャイhttpは約束を返します。 Promiseを返すと、Mochaのテストは非同期コードで機能します。

it('If the credentials exists in the system it should return the token generated against it.', () => {
  let adminObj = await admin.createAdmin();
  return chai.request(server)
    .post("/auth/login")
    .set("Content-Type", "application/x-www-form-urlencoded")
    .send({username: adminObj.login,password:adminObj.password})
    .end((err, res) => {
      res.should.have.status(200);
      res.body.should.be.a("string");
    });
});

@NateZimmer

投稿された解決策は、時間がかかりすぎる場合にテストをタイムアウトすることです。 モカにはすでにこの機能が組み込まれています。

it("It should be liek this", async function () {
  this.timeout(letsCallItQuitsNow);

  var life = require('InfiniteLife');
  var asyncRes = await life.someCoolstuff();
  assert(asyncRes);
});

あなたの例も、タイムアウトを超えてもテストに失敗しないようですので、その正確さに応じて注意してください

`express / jsとfirebaseクラウド関数を使用して、APIエラー応答を確認し、トークンを取得して再試行します。 expressを使用する場合は、.sendではなく.jsonを返すようにしてください。また、mochaでロガーのバグが機能するため、プレーンなconsole.logを使用してください。
必ずasyncを使用し、完全に実行してください。

  process.env.NODE_ENV='TESTING';
  const { FIREBASE_UID } = require('dotenv').config()?.parsed;
  const { red, green, white } = require('chalk');
  const chai = require('chai');
  const chaiHttp = require('chai-http');
  const server = require('../lib/api').API;
  const should = chai.should();
  const expect = chai.expect;
  chai.use(chaiHttp);
  const test = chai.request(server).keepOpen();

  const shouldPrint = (details, status) => {
      return white(`details: ${details}, status: ${status}`);
  };

describe('Authorization Middleware Error Check for bad token', () => {

    it(shouldPrint('Bad Request', red(400)), async () => {
        try {
            const res = await test.get('/').send()
            res.should.have.status(400);
            res.should.have.json
            const { details, status } = JSON.parse(res.text)
            expect(details).to.equal('Bad request')
            expect(status).to.equal(400)
        } catch (error) { 
            throw error 
        }
    })


    it(shouldPrint('Unauthorized', red(401)), async () => {
        try {
            const res = await test.get('/').set('Authorization', 'Bearer bad123token').send()
            res.should.exist
            res.should.have.status(401);
            res.should.have.json
            const { details, status } = JSON.parse(res.text)
            expect(details).to.equal('Unauthorized')
            expect(status).to.equal(401) 
        } catch (error) {
            throw error
        }
    })

}）

 describe('Get token and ping', () => {
    let adminToken

    it(shouldPrint( 'Create custom jwt for testing', green(200)), async () => {
        try {
            const res = await test.get(`/createToken/${FIREBASE_UID}`).send()
            res.should.exist
            res.should.have.status(200);
            res.should.have.json
            adminToken = (JSON.parse(res.text)).token
        } catch (error) {
            throw error
        }
    })

    it(shouldPrint('PING', green(200)), async () => {
        try {
            const res = await test.get('/')
                .set('x-tenorders-testing', 'true')
                .set('Authorization', `Bearer ${adminToken}`).send()

            res.should.exist
            res.should.have.status(200);
            res.should.have.json
            const { details, status } = JSON.parse(res.text)
            expect(details).to.equal('PING')
            expect(status).to.equal(200)
        } catch (error) {
            throw error
        }   
    })

}）
`