Jasmine异步调用两次测试停止问题解析

目前golang学习网上已经有很多关于文章的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《Jasmine 异步函数调用两次测试停止问题解析》，也希望能帮助到大家，如果阅读完后真的对你学习文章有帮助，欢迎动动手指，评论留言并分享~

本文旨在解决 Jasmine 测试中异步 mock 函数在同一测试函数中被多次调用后，后续断言失败的问题。通过分析问题代码，定位到原因是应用代码中缺少 async/await 关键字，导致测试未正确等待异步操作完成。文章提供修复后的代码示例，并强调了在测试异步代码时正确使用 async/await 的重要性。

在 Jasmine 测试框架中，处理异步代码的测试需要特别注意。如果异步操作没有正确地被等待，测试结果可能会出现不一致，甚至导致测试提前结束。本文将探讨一个常见的问题：当在同一个测试函数中多次调用异步 mock 函数时，Jasmine 测试可能会停止，导致后续的断言失败。

问题描述

在测试中，我们经常会使用 jasmine.createSpy 创建 mock 函数，并使用 and.returnValues 或 and.resolveValues 定义其返回值。当被 mock 的函数是异步的，并且在同一个测试函数中被多次调用时，可能会遇到以下问题：

1. expect(mockFunction).toHaveBeenCalledTimes(n) 断言能够通过，表明 mock 函数被调用了正确的次数。
2. 但是，后续的断言（例如 expect(someVariable).toBe(expectedValue)）却失败，即使在控制台中打印出的值是正确的。
3. 甚至会出现 mock 函数的调用次数断言失败，提示调用次数为 0。

原因分析

这个问题通常是由于应用代码中缺少 async/await 关键字导致的。在 JavaScript 中，async 函数返回一个 Promise 对象。如果调用 async 函数时没有使用 await 关键字，函数会立即返回，而不会等待 Promise 对象 resolve。这会导致测试代码在异步操作完成之前就执行后续的断言，从而导致断言失败。

具体到本文提到的问题，getDialogAnswer 函数是一个返回 Promise 对象的异步函数。在应用代码中，如果调用 getDialogAnswer 时没有使用 await 关键字，函数会立即返回，而不会等待对话框关闭并返回结果。这会导致后续的代码在对话框关闭之前就执行，从而导致测试失败。

解决方案

解决这个问题的关键是在应用代码中正确使用 async/await 关键字。确保在调用任何返回 Promise 对象的异步函数时，都使用 await 关键字等待其 resolve。

以下是修改后的代码示例：

原始代码 (maincode.js):

function main_obj() {
    this.objmethod1 = function () {
        const async_objmethod = async function(){
            let deleteProject = getDialogAnswer();
            deleteProject = getDialogAnswer();
            this.objmethod2();
            this.objmethod3();
            this.objmethod4();
            unsaved_changes = true;
            method5(this.name);
        }
        async_objmethod.bind(this)();
    };
    this.objmethod2 = function () {};
    this.objmethod3 = function () {};
    this.objmethod4 = function () {};
}

修改后的代码 (maincode.js):

function main_obj() {
    this.objmethod1 = async function () {
        const async_objmethod = async function(){
            let deleteProject = await getDialogAnswer();
            deleteProject = await getDialogAnswer();
            this.objmethod2();
            this.objmethod3();
            this.objmethod4();
            unsaved_changes = true;
            method5(this.name);
        }
        await async_objmethod.bind(this)();
    };
    this.objmethod2 = function () {};
    this.objmethod3 = function () {};
    this.objmethod4 = function () {};
}

关键修改：

1. 在 this.objmethod1 函数的定义中添加了 async 关键字，使其成为一个异步函数。
2. 在 async_objmethod.bind(this)() 调用之前添加了 await 关键字，确保等待异步操作完成。
3. 在 let deleteProject = getDialogAnswer() 调用之前添加了 await 关键字，确保等待异步操作完成。

测试代码 (test_spec.js):

const getDialogAnswer = jasmine.createSpy('Mock_getDialogAnswer').and.resolveValues(
    'yes',
    'yes',
);
const method5 = jasmine.createSpy('Mock_method5')
let unsaved_changes;

// var for main_inst instance set in 'before-funcs'
let main_inst
beforeEach(function() {
    main_inst = new main_obj();
    unsaved_changes = null
    spyOn(main_inst, 'objmethod2')
    spyOn(main_inst, 'objmethod3')
    spyOn(main_inst, 'objmethod4')
});

describe("Test makemain_inst.js", () => {
    describe("Test new jquery ui dialog functions", () => {
        describe("test dialog uses", () => {
            describe("test this.objmethod1()", () => {
                describe("test yes no", () => {
                    it("should delete on yes + yes", async () => {
                        // ------------ setup -------------
                        // --------   Call ----------------
                        const x = await main_inst.objmethod1()
                        // ------------- verify ------------
                        expect(getDialogAnswer).toHaveBeenCalledTimes(2)

                        expect(main_inst.objmethod2).toHaveBeenCalledTimes(1)
                        expect(main_inst.objmethod3).toHaveBeenCalledTimes(1)
                        expect(main_inst.objmethod4).toHaveBeenCalledTimes(1)
                        expect(method5).toHaveBeenCalledTimes(1)
                        expect(unsaved_changes).toBe(true);
                    });
                });
            });
        });
    });
});

注意：

• 在 mock 异步函数时，使用 and.resolveValues 或 and.resolveTo 来返回 resolved Promise 对象。
• 在测试异步函数时，确保测试函数本身也是 async 的，并且在调用被测试函数时使用 await 关键字。

总结

在 Jasmine 测试中，正确处理异步代码至关重要。当遇到异步 mock 函数调用多次后测试停止的问题时，首先要检查应用代码中是否缺少 async/await 关键字。确保在调用任何返回 Promise 对象的异步函数时，都使用 await 关键字等待其 resolve。同时，在测试异步函数时，也要确保测试函数本身也是 async 的，并且在调用被测试函数时使用 await 关键字。通过这些措施，可以有效地解决异步测试中的问题，确保测试结果的准确性和可靠性。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Jasmine异步调用两次测试停止问题解析》文章吧，也可关注golang学习网公众号了解相关技术文章。