Question

我使用Sinon和Mocha进行测试的代码如下。每当我运行这些测试时，我都会得到以下结果

  0 passing (747ms)
  8 pending
  1 failing

  1) Customer displays order Given that the order is empty "before each" hook for "will show no order items":
     Error: Timeout of 500ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves.

测试正在通过，直到我开始将promises合并到图片中并使测试更加真实，即设置为处理异步调用。

我做错了什么，如何让测试通过？

tests.js

'use strict';
require("babel-register");

var chai = require('chai');
var expect = chai.expect;
var sinon = require('sinon');
var orderSystemWith = require('../lib/orders');

chai.use(require("chai-as-promised"));


//describe is used to display features
//context is used to display scenarios
//it is used to describe tests within a feature/scenario
describe('Customer displays order', function () {
    beforeEach( () => {
        this.orderDAO = {
            byId: sinon.stub()
        };
        this.orderSystem = orderSystemWith(this.orderDAO);
    })
    context('Given that the order is empty', () => {
        var result;
        beforeEach( (done) => {
            this.orderId = 'some empty order id';
            this.orderDAO.byId
                .withArgs(this.orderId)
                .callsArgWithAsync(1, null, []);

            return this.orderSystem.display(this.orderId)
                .then(function (res){
                    result = res
                })   
        });

        it('will show no order items', () => {
            //expect(result).to.have.property('items').that.is.empty; 
            return expect(result).to.eventually.have.property('items').that.is.empty;   
        });
        it('will show 0 as the total prince', () => {
            expect(result).to.have.property('totalPrice').that.is.equal(0);
        });
        it('will only be possible to add a beverage', () => {
            expect(result).to.have.property('actions').that.is.deep.equal([{
                action:'append-beverage',
                target: this.orderId,
                parameters: {
                    beverageRef: null,
                    quantity: 0  
                } 
            }])
        });
    });

    context('Given that the order contains beverages', function(){

        it('will show one item per beverage');
        it('will show the sum of unit prices as total prince');
        it('will be possible to place the order');
        it('will be possible to add a beverage');
        it('will be possible to remove a beverage');
        it('will be possible to change the quantity of a beverage');
    });

    context('Given that the order has pending messages', function(){
        it('will show the pending messages');
        it('there will be no more pending messages');
    })

});

orders.js

var Q = require('q');
    module.exports = function () {
        return {
            display: (orderId) => {
                return Q.fulfill({
                    items: [],
                    totalPrice: 0,
                    actions: [
                    {
                        action: 'append-beverage',
                        target: orderId,
                        parameters: {
                            beverageRef: null,
                            quantity: 0 
                        }
                    }]    
                }); 
            }
        };
    };

Answer 1

您的承诺未得到解决。不推荐使用Q.fulfill。如果您希望返回已解决的承诺，请使用Q(value) 来自API reference：

问（值）

如果value是Q承诺，则返回承诺。

如果value是来自其他图书馆的承诺，则会被强制转换为Q.   承诺（如果可能）。

如果value不是承诺，则返回履行的承诺   值。

摩卡和诗乃测试承诺超时

1 个答案: