Mocha: 오류 : 해결 방법이 과도하게 지정되었습니다.

async 와 기능 (바벨) done 또한 휴식.

오류가 언급했듯이, arity가 0보다 큰 함수를 제공해서는 안되며 (즉, done 콜백을 수락 함을 의미) _and_ Promise를 반환합니다.

이 문제를 해결하는 가장 쉬운 방법은 return 를 생략하는 것입니다.하지만 promise를 사용하고 있기 때문에 대신 done 콜백을 제거하는 것이 좋습니다. :

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

다음은 async (본질적으로 프라 미스)와 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()
  })
})

...하지만 당신이 얻는 것은이 예제에서 mocha가 약속이 해결되고 콜백이 호출되기를 _both_ 기다리면 더 좋을 것 같습니다.

불행히도 특정 콤보는 테스트에서 가장 자주 발생하는 버그이므로이 오류 메시지가 처음에 추가되었습니다.

... .then (() => done ())을 생략하면 테스트 시간이 초과됩니다.

어쨌든 이것은 버그처럼 보입니다.

@ScottFreeCode 흠, 예, done 콜백으로 제공되는 함수에서 "과도하게 지정됨"오류가 발생했기 때문인 것 같습니다. https://github.com/mochajs/mocha/blob/4944e31ff60105815f4b314996a9861e73f6bfd2/lib/ runnable.js # L357 -L373

... 물론 우리는 함수가 반환 되 자마자 그 오류로 인해 실패해야한다는 것을 결정할 수 있습니다.

@ScottFreeCode 여기서 수정 사항은 무엇입니까?

"해결 또는 거부 약속을 기다린 다음 '과도하게 지정됨'오류로 거부"라고 추측 할 수 있습니다.

동일한 테스트에서 done 와 promise를 오류로 간주한다면 done 를받은 테스트 함수가 오류를 반환하자마자 오류를 감지하지 못할 이유가 없습니다. @papandreou가 제안 done 함께 허용하지 않는 한 어떤 다른 포인트가 오류를 유발해야하는지 알아내는 것은 나에게 의미가 없습니다.

@ScottFreeCode 동의합니다. 그래서 그것은

1. 문제 감지; Error 인스턴스화하지만 done() 를 호출하지 마십시오.
2. 약속이 이행 될 때까지 기다리십시오.
3. Error 거부

보너스 질문 : 약속 이행의 결과로 무엇을해야합니까?

아, 알 것 같습니다. 오류를 감지하더라도 다음 테스트에서 코드가 실행되지 않도록 테스트를 실행해야합니다. 그러면 테스트 결과를보고 할 수도 있습니다.

약속을 해결하거나 거부하지 않고 테스트에서 done 를 호출 할 수도 있습니까? 그렇다면 우리가 처리해야 할 또 다른 최종 사례입니다.

내 성향, re. 테스트 결과로해야 할 일은 시간이 초과 된 경우 ( done 호출하거나 약속을 해결 / 거부하지 않고) 시간이 초과되면 약속과 함께 done 사용을보고해야합니다. (조합에 대한 혼동이 둘 중 하나에 도달하지 못하고 대신 시간이 초과 된 이유 일 수 있기 때문에) 그러나 두 방법 중 하나를 사용하여 완료되면 아마도 결과가 유효하거나 (또는 ​​적어도 의미있는)보고해야합니다. done 의 잘못된 사용과 함께 약속하고 테스트 결과가 적어도 어느 정도 도움이되기를 바랍니다.

어쨌든 그것이 내가 지금 생각 해낼 수있는 최선의 방법이지만,이 문제를 파헤칠 시간을 찾을 수 있다면 더 많은 통찰력을 가질 수있을 것입니다.

음, 우리는 이것을 단계적으로 할 수 있습니다. 첫 번째는 Promise가 반환되고 done 콜백이 주어지면 Mocha가 친근한 방식으로 중단되는지 확인하는 것입니다.

다음과 같은 작업을 수행 할 수 있다는 것은 _ 생각할 수 있습니다 _ (블루 버드 사용) :

// 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을 봐야합니다.

뿡 빵뀨

버전 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를 깨지 않았습니다.

나는 그가 당신이 semver를 깨뜨렸다는 의미가 아니라 당신이 Mocha를 깨뜨렸다는 것을 의미한다고 생각합니다. 이 변경은 개발자에게 일을 더 쉽게 만들지 않고 의견을 강요합니다.

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

^^ 모호하지 않습니다. 저자가 기대하는 바는 매우 분명합니다. 작성자가 콜백을 요청했습니다.

실제로 여기에서 예외를 얻는 이유는 의견을 강요하는 것을 최대한 회피하기 때문입니다. Mocha는 반환 된 promise 또는 콜백이 신뢰할 수 있는지에 대한 의견이 없습니다. 모호한 결과로 이어지기 때문에 동시에 둘 다 가질 수는 없습니다. 테스트 프레임 워크의 모호한 결과는 오류로 간주되어야합니다. 따라서 오류 메시지는이를 인식하고 귀하의 의견에 맞게 선택하고 변경하는 데 도움이됩니다.

드라마의 양을 줄이는 것이 도움이 될 수 있습니다. "당신은 모카를 깼습니다"는 누구에게도 도움이되지 않습니다. 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 가 불필요한 좋은 예입니다.

비방하는 사람들은 그들의 말을했습니다. 그러나 Mocha의 메인테이너들은이 변경 사항을 되 돌리는 주장에 동의하지 않습니다. Eran Hammer는 "관리자로서 할 수있는 가장 어려운 일 중 하나는 작업을 자신의 방향으로 옮기고 자하는 사람들을 실망시키는 것"이라고 말했습니다.

더 많은 문서 (예 :이 오류에 대한 더 많은 예제 및 수정 방법), 더 나은 오류 메시지 등의 해결 방법을 환영하지만 드라마, 무례 함 또는 불평에는 관심이 없습니다. 이러한 해결 방법 중 하나를 Mocha에 제공하면 부정적인 것을 긍정적으로 바꾸는 데 도움이됩니다.

이 변경 사항이 마음에 들지 않고 단순히 건설적 일 수 없다면 OSS입니다. 프로젝트를 분기하고 변경 사항을 되돌릴 수 있습니다.

@boneskull은 promise를 반환하는 비동기 함수로 변환합니다. 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 년 중반에 Mocha 작업을 시작했습니다. 모카는 여러분이 기여하기 시작한 시점에 이미 설립되었습니다. 제 의견 일 뿐이지 만 정당화되지 않는 한 기존 라이브러리를 변경해서는 안된다고 생각하는 것이 저 혼자라고 생각하지 않습니다. 이 변경에 대한 원래의 정당성을 상상할 수 있지만 다음을 지적하면 잘 맞지 않습니다. 콜백을 요청하는 것은 명확한 의도를 전달합니다. Promise는 요청되지 않았기 때문에 명확하지 않으며 반환되며 간접적 및 우발적으로 발생할 수 있습니다 (예 : 타사 라이브러리에서 반환 됨). 이러한 차이로 인해 양보의 두 가지 방법이 동일하지 않으므로 두 가지를 모두 사용하려는 시도는 실제로 모호하지 않습니다. 콜백은 테스트 인수에 작성되어야합니다. 약속으로는 그렇게 할 수 없으므로 콜백을 요청함으로써 의도를 명시 적으로 전달한 것입니다. 귀하의 커뮤니티는 이러한 우려를 제기했으며 실수를 인정하는 대신 두 배로 줄어들고 있습니다. 이 오류가 일관되게 작동하는지 확인하기 위해 테스트를 비 동기화하는 것을 고려하고있는 것 같습니다. => 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 우연히 잠입하기 쉽기 때문에

여기에서 약간의 대화 => https://github.com/mochajs/mocha/pull/1320 후에 문제에 대한 대체 솔루션에 대한 아이디어가 생겼습니다. 여기에 리뷰의 즐거움을 위해 PR을 추가했습니다 => https://github.com/mochajs/mocha/pull/2454

:맥주:

done 콜백을 정의하는 것이 명시적인 의도라고 주장합니다. return 문이 명시적인 의도가 아닙니까?

@Munter coffeescript와 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()
      )
    )
  )
)

약속 체인을 존중하고 콜백 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')
      )
    )
  )
)

나는 이것이 비슷한 오류가 발생하는 다른 사람들에게 도움이되기를 바랍니다.

PS : 하트 : 모카 btw : +1 :

편집 @Munter 의 의견에 따라 catch() 제거.

@karlbateman 감사합니다. 그래도 마지막 .catch 는 필요하지 않습니다. 거부 된 약속은 Mocha에 의해 오류로 간주됩니다.

@Munter , 감사합니다 : 스마일 :

조금 더 생각 해보니 프라 미스와 콜백을 기다리는 동작이 정말 마음에 듭니다. 이를 구현하는 데 진전이 있었습니까?

@ light24bulbs 피드백 주셔서 감사합니다! 아니, 아파 익 내가 반응을보기 위해 거기에 던진 아이디어이기 때문에 아무도 그것에 대해 작업을 시작하지 않았습니다. 방금 아이디어에 대한 추가 피드백이 있는지, 작동하지 않는 경우가 있는지 확인하고있었습니다.

바벨을 사용할 때 이에 대한 해결 방법이 있습니까?

바벨을 사용할 때 이에 대한 해결 방법이 있습니까?

두 번 포장합니다.

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

@SaschaNaz 감사합니다, 이것은 v3.2.0에서 작동합니다 :)

6 개월 후, 이것은 여전히 ​​모든 최신 js 테스트를 제동하는 문제입니다.
부끄러움

@benfavre 자원 봉사자들이 아이들과 놀기보다 자유 시간에 지정하지 않은 솔루션을 구현할 책임을지게 할 가장 확실한 동기를 부여하는 격려의 말에 감사드립니다.

@Munter mochajs 의 새로운 사용자로서 직면 한 특정 문제를 식별하는 데 도움을 줄 수있어 걱정할
@SaschaNaz 는 두 번 포장하는 솔루션을 제안했지만 도움이되지 않았습니다.

=> 약속 만 사용하면 제대로 작동했습니다.

다음 번에는 바보처럼 "+1"만하면 될 것 같아 공짜로 모욕을 당하지 않도록.
내 메시지에는 모욕적 인 내용이 없었으며 더 나아가 내 진술은 사실로 남아 있습니다.

대부분의 사람들은 다른 프레임 워크를 선택할 것입니다. 현재로서는 async / await로 단순하게 깨졌고, 메인 사이트에 명확한 표시가없고 cli에 명확한 오류 메시지가 없습니다.

새해 복 많이 받으시고 아이들과 즐거운 시간을 보내십시오.

냉기...

토론은 done 콜백과 반환 된 Promise 모두에 "주의를 기울이는"것으로 발전했습니다. : https://github.com/mochajs/mocha/issues/2509

폐쇄. # 2509 참조

아직 몸이 힘들다면 ...

바벨을 사용할 때 이에 대한 해결 방법이 있습니까?

이제 # 2509에서 언급 한 약속 처리기가 내장되어 있으므로 다음과 같이 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;
});

안녕하세요.

• 예, 지금 async/await 구문을 사용하려면 babel의 도움이 필요합니다.

내가 뭔가를 놓치고 있는지 확실하지 않지만 약속과 함께 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와 함께 mocha 4를 사용하고 있습니다.

처음에는 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."

그 오류가 나를이 페이지로 이끌었습니다. 이 다소 긴 스레드를 통과하면서 (그리고 모든 분쟁을 완전히 이해하지 못했다는 것을 인정합니다) 약속 기반이기 때문에 비동기 호출과 함께 done ()을 사용해서는 안된다는 것을 이해해야합니까?

그렇다면 await 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 회 통과 (9ms)

@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);
});

'반품'절을 제거하면 문제가 해결되었습니다.

이것에 열광한 다른 사람에게는 ...

이것은 작동합니다 :

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

이것은하지 않습니다 :

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

done 를 매개 변수로 제거해야합니다.

@tamoyal , 예 -elado가 2016 년 8 월 3 일에

async / await를 사용하면 암시 적 Promise 반환합니다. done 콜백 사용은
여기에 표시된대로 CPS 기반 비동기. Mocha는 둘 다 지원하지만 동시에는 아닙니다.
이것은 문서화 되어 있으며 Mocha-3.0 릴리스 이후 표준 동작이었습니다.

이 오류가 발생했지만 실수로 약속을 반환했습니다 (슈퍼 테스트).

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

'반품'절을 제거하면 문제가 해결되었습니다.

@victorsferreira , 이것이 해결책이었을 것 같습니다 ...

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

@tamoyal 네 그게 나를 넘어

@mienaikoe ,이 정확한 시나리오는 명시 적으로 문서화 되어 있습니다.

@plroebuck 두 가지 :

1) 무언가를 문서화하는 것과 함수의 매개 변수를 조사하는 npm의 몇 안되는 라이브러리 중 하나가되는 것에는 차이가 있습니다. 친구들을 처음 만났을 때 모든 친구들의 배경 조사를 받는다는 것을 문서화 할 수 있지만, 여전히 이상하고 사람들은 내가 이유가없고 명시 적으로 이유를 말하지 않는 한 불평 할 것입니다.

2) 문서에 결함이 있습니다.

Mocha v3.0.0 이상에서 Promise를 반환하고 done ()을 호출합니다.

done을 호출하는 것이 아니라 사용 여부에 관계없이 _ done 를 매개 변수로 지정 _하는 것입니다.

뿡 빵뀨

1. Mocha는 it 의 두 번째 매개 변수를 확인하여 함수가 존재하는지 확인하고 (있는 경우) 사용자가 콜백을 추가했는지 여부를 확인합니다. 이것은 인트로 스펙 션으로 거의 적합하지 않으며 JavaScript에서 일반적으로 사용됩니다.
2. 문서가 너무 모호하다고 생각되면 PR을 보내 문서를 수정하십시오.

param으로 제거하면 나를 위해 일했습니다!

전에:

후 (작동!)

@QauseenMZ , "이전"과 "이후"코드간에 차이가 없습니다.

당신은 또한 당신의 약속을 돌려주지 않습니다. 다음과 비슷하지 않습니까?

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

추신. 노드 콜백 인수 순서가 잘못되었습니다 ... error _always_가 먼저 진행됩니다.

@plroebuck 언급

getResponse 함수가 콜백을 반환하기 때문에 약속을 처리하지 않습니다. 그것이 내가 작동하게 한 유일한 방법이었습니다. getResponse 함수는 다음과 같습니다.

여기서 오류는 콜백 getResponse 함수가 반환하기 때문에 두 번째 매개 변수입니다. 그것에 대한 당신의 생각을 알려주십시오. 감사!

일부 부분은 비논리적으로 보입니다. 명확성을 위해 어떤 request 패키지를 사용하고 있습니까?
options 객체 ( unitData 라는 이름)를 반환해야하는 이유는 무엇입니까?

• obj 출처는 어디입니까?
• 왜 것 res.body.error A를 res.statusCode === 200 ?

추신. 코드 이미지가 아닌 코드 자체를 붙여 넣으세요.

이것에 열광한 다른 사람에게는 ...

이것은 작동합니다 :

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 를 제거해야하는 필요성에 놀랐습니다. 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 func는 동기화 함수로 남겨 두었습니다.

해결책:

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();
        });
    });

헉헉

테스트에서 done 도 async 도 필요하지 않습니다. Chai 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");
    });
});

뿡 빵뀨

게시 된 솔루션은 시간이 너무 오래 걸리는 경우 테스트 시간을 초과하는 것입니다. Mocha 에는 이미이 기능이 내장되어 있습니다.

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를 사용하십시오.
비동기를 사용하고 완전히 완료되었는지 확인하십시오.

  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
        }   
    })

})
`