Javascript 改进用于阵列比较的Jasmine测试输出

我要替换此测试代码：

expect(events.length).toEqual(2);

expect(events[0].item).toEqual("A");
expect(events[0].newIndex).toEqual(0);
expect(events[0].type).toEqual(CollectionChangeType.Insert);

expect(events[1].item).toEqual("D");
expect(events[1].oldIndex).toEqual(2);
expect(events[1].type).toEqual(CollectionChangeType.Remove);

…用较短的形式（实际上在我的情况下更彻底）

但是，在出现错误的情况下，输出太难读取

预期[{type:0，item:'A'，itemId:'A'，newIndex:0，oldIndex:-1}，{type:2，item:'D'，itemId:'D'，newIndex:-1，oldIndex:3}]等于[{type:0，itemId:'A'，newIndex:0，oldIndex:-1}，{type:2，itemId:'D'，newIndex:-1，oldIndex:2}]

有没有办法定制这个输出？例如，我很乐意：

Array items differ at indices:

[1] expected { type: 2, item: 'D', itemId: 'D', newIndex: -1, oldIndex: 3 }
    but saw  { type: 2, item: 'D', itemId: 'D', newIndex: -1, oldIndex: 2 }

---

我是否可以修改数组比较时的逻辑来执行此操作？

您可以创建自己的jasmine matcher，其中包含更详细的消息

我在jasmine 1.3中做了一个简单的版本，可以让你开始

describe("example", function ()
{
    beforeEach(function ()
    {
        this.addMatchers({

            arrayComparison: function (expected)
            {
                var actual = this.actual;
                this.message = function() { return "Array items differ at indices:\n\n[1] expected " + expected + "\n but saw " + actual; }
                return this.actual == expected;
            }
        });
    });
    it("should compare arrays", function ()
        {
            var array1 = { type: 2, item: 'D', itemId: 'D', newIndex: -1, oldIndex: 3 };
            var array2 = { type: 2, item: 'D', itemId: 'D', newIndex: -1, oldIndex: 2 };
            expect(array1).arrayComparison(array2);
        });
});

---

编写自定义格式化程序以获得漂亮的输出是不方便的，因为它迫使您为涉及自定义对象的每个测试编写自定义格式化程序。例如，您必须复制

[{key:new MyObject（）}]

和

[new MyObject（）]

的自定义格式逻辑。如果有一种方法可以指定

MyObject

是如何序列化的，那就方便多了

这可以通过

jasmineToString

方法完成。如果函数中存在此函数，则Jasmine将打印其返回值，而不是递归处理对象。这适用于所有版本的Jasmine（1.3、2.0、2.1、2.3）

以下是一个示例（故意失败的测试）：

函数MyObject（id）{
this.id=id；
this.junk='bla'；//我不想看到这个。
}
它（'应该很漂亮'，函数（）{
MyObject.prototype.jasmineToString=函数（）{
返回'MyObject（'+this.id+'）；
};
expect（[new MyObject（123）]）。toBe（new MyObject（'different'））；
//“预期[MyObject（123）]为MyObject（不同）。”
});
它（'应该很难看'，函数（）{
MyObject.prototype.jasmineToString=未定义；
expect（[new MyObject（123）]）。toBe（new MyObject（'different'））；
//“预期[MyObject（{id:123，junk:'bla'}）]为…”
});
谢谢，这看起来是一个很有前途的方法。我们将进一步调查。
describe("example", function ()
{
    beforeEach(function ()
    {
        this.addMatchers({

            arrayComparison: function (expected)
            {
                var actual = this.actual;
                this.message = function() { return "Array items differ at indices:\n\n[1] expected " + expected + "\n but saw " + actual; }
                return this.actual == expected;
            }
        });
    });
    it("should compare arrays", function ()
        {
            var array1 = { type: 2, item: 'D', itemId: 'D', newIndex: -1, oldIndex: 3 };
            var array2 = { type: 2, item: 'D', itemId: 'D', newIndex: -1, oldIndex: 2 };
            expect(array1).arrayComparison(array2);
        });
});