Javascript 用笑话模仿函数对象_Javascript_Unit Testing_Jestjs

Javascript 用笑话模仿函数对象

javascript unit-testing jestjs

Javascript 用笑话模仿函数对象,javascript,unit-testing,jestjs,Javascript,Unit Testing,Jestjs,我当前有一个用于与我的API进行交互的对象API.js： export var Auth = (function () { var Login = async function(username, password) { //Async login code for interacting with the API }; return { Login: Login } }); import * as API from './api

我当前有一个用于与我的API进行交互的对象

API.js

：

export var Auth = (function () {
    var Login = async function(username, password) {
        //Async login code for interacting with the API
    };
    return {
        Login: Login
    }
});

import * as API from './api';

export var LoginRequestHandler = function() {
   //processess user input, then calls:
   try {
       await API.Auth().Login(username, password);
   } catch(e) {
       throw new Error(e);
}

export var Auth = (function () {
    var Login = async function(username, password) {
        return Promise.resolve(true);
    };
    return {
        Login: Login
    }
});

这个对象被导入另一个文件，

login.js

：

export var Auth = (function () {
    var Login = async function(username, password) {
        //Async login code for interacting with the API
    };
    return {
        Login: Login
    }
});

import * as API from './api';

export var LoginRequestHandler = function() {
   //processess user input, then calls:
   try {
       await API.Auth().Login(username, password);
   } catch(e) {
       throw new Error(e);
}

export var Auth = (function () {
    var Login = async function(username, password) {
        return Promise.resolve(true);
    };
    return {
        Login: Login
    }
});

这是我的玩笑测试：

import * as API from '../api';
import * as User from '../user';

jest.mock('../api');

const spy = jest.spyOn(API.Auth(), 'Login');
    User.LoginRequestHandler().then(() => {
        expect(spy).toHaveBeenLastCalledWith('theUsername', 'thePassword');
    }).catch(error => console.log(error));

这是我的模拟文件，

模拟/api.js

：

export var Auth = (function () {
    var Login = async function(username, password) {
        //Async login code for interacting with the API
    };
    return {
        Login: Login
    }
});

import * as API from './api';

export var LoginRequestHandler = function() {
   //processess user input, then calls:
   try {
       await API.Auth().Login(username, password);
   } catch(e) {
       throw new Error(e);
}

export var Auth = (function () {
    var Login = async function(username, password) {
        return Promise.resolve(true);
    };
    return {
        Login: Login
    }
});

我通过

document.getElementId（）

在

LoginRequestHandler

中检索用户名

和密码
在LoginRequestHandler
中添加console.log（username）
，表明它正在被调用，并且能够获得正确的值。此外，在API.Auth（）.Login
中添加console.log（username）
也表明它也获得了正确的值。但是，当我查看我的测试日志时，我看到：模拟函数的调用次数：0
，测试结果出错
我假设我试图监视错误的函数，是否还有其他方法可以解决此问题？
每次调用API.Auth（）
，它都会返回一个新对象，该对象具有登录方法。因此，在测试用例中由LoginRequestHandler
函数和jest.spyOn（API.Auth（），'Login'）
语句创建的对象是不同的。间谍只是被添加到后面的一个。未监视LoginRequestHandler
函数中的Login
方法
因此，这里我将使用jest.mock（）
来模拟api.js
模块，而不将模拟对象放入\uuuuumocks\uuu
目录。例如
api.js
：
export var Auth = (function () {
    var Login = async function(username, password) {
        //Async login code for interacting with the API
    };
    return {
        Login: Login
    }
});

import * as API from './api';

export var LoginRequestHandler = function() {
   //processess user input, then calls:
   try {
       await API.Auth().Login(username, password);
   } catch(e) {
       throw new Error(e);
}

export var Auth = (function () {
    var Login = async function(username, password) {
        return Promise.resolve(true);
    };
    return {
        Login: Login
    }
});

export var Auth=function（）{
var Login=异步函数（用户名、密码）{}；
返回{
登录：登录，
};
};

user.js
：
export var Auth = (function () {
    var Login = async function(username, password) {
        //Async login code for interacting with the API
    };
    return {
        Login: Login
    }
});

import * as API from './api';

export var LoginRequestHandler = function() {
   //processess user input, then calls:
   try {
       await API.Auth().Login(username, password);
   } catch(e) {
       throw new Error(e);
}

export var Auth = (function () {
    var Login = async function(username, password) {
        return Promise.resolve(true);
    };
    return {
        Login: Login
    }
});

将*作为API从“/API”导入；
导出变量LoginRequestHandler=异步函数（）{
const username='theUsername'；
const password='thePassword'；
试一试{
等待API.Auth（）.Login（用户名、密码）；
}捕获（e）{
抛出新错误（e）；
}
};

user.test.js
：
export var Auth = (function () {
    var Login = async function(username, password) {
        //Async login code for interacting with the API
    };
    return {
        Login: Login
    }
});

import * as API from './api';

export var LoginRequestHandler = function() {
   //processess user input, then calls:
   try {
       await API.Auth().Login(username, password);
   } catch(e) {
       throw new Error(e);
}

export var Auth = (function () {
    var Login = async function(username, password) {
        return Promise.resolve(true);
    };
    return {
        Login: Login
    }
});

将*作为API从“/API”导入；
从“./User”以用户身份导入*；
jest.mock（'./api'，（）=>{
const auth={Login:jest.fn（）}；
返回{
Auth:jest.fn（（）=>Auth），
};
});
描述（'61643983'，（）=>{
之后（（）=>{
开玩笑。clearAllMocks（）；
});
它（'应该登录'，（）=>{
期望.断言（2）；
返回User.LoginRequestHandler（）。然后（（）=>{
expect（API.Auth）.toBeCalledTimes（1）；
期望（API.Auth（）.Login）.tohavenbelst调用时使用（'theUsername'，'thePassword'）；
});
});
它（'应该抛出错误'，（）=>{
期望.断言（4）；
const mError=新错误（“未找到用户”）；
API.Auth（）.Login.mockRejectedValueOnce（mError）；
返回User.LoginRequestHandler（）.catch（（e）=>{
expect（API.Auth.toBeCalled（）；
期望（API.Auth（）.Login）.tohavenbelst调用时使用（'theUsername'，'thePassword'）；
期望（e）.安装（错误）；
expect（e.message）.toMatch（/user not found/）；
});
});
});

100%覆盖率的单元测试结果：
PASS stackoverflow/61643983/user.test.js（11.507s）
61643983
✓ 应登录（5ms）
✓ 应抛出错误（3ms）
----------|---------|----------|---------|---------|-------------------
文件|%Stmts |%Branch |%Funcs |%Line |未覆盖行|s
----------|---------|----------|---------|---------|-------------------
所有文件| 100 | 100 | 100 | 100 |
user.js | 100 | 100 | 100 | 100 |
----------|---------|----------|---------|---------|-------------------
测试套件：1个通过，共1个
测试：2次通过，共2次
快照：共0个
时间：13.023s

源代码：
每次调用API.Auth（）
，它都会返回一个新对象，该对象具有登录方法。因此，在测试用例中由LoginRequestHandler
函数和jest.spyOn（API.Auth（），'Login'）
语句创建的对象是不同的。间谍只是被添加到后面的一个。未监视LoginRequestHandler
函数中的Login
方法
因此，这里我将使用jest.mock（）
来模拟api.js
模块，而不将模拟对象放入\uuuuumocks\uuu
目录。例如
api.js
：
export var Auth = (function () {
    var Login = async function(username, password) {
        //Async login code for interacting with the API
    };
    return {
        Login: Login
    }
});

import * as API from './api';

export var LoginRequestHandler = function() {
   //processess user input, then calls:
   try {
       await API.Auth().Login(username, password);
   } catch(e) {
       throw new Error(e);
}

export var Auth = (function () {
    var Login = async function(username, password) {
        return Promise.resolve(true);
    };
    return {
        Login: Login
    }
});

export var Auth=function（）{
var Login=异步函数（用户名、密码）{}；
返回{
登录：登录，
};
};

user.js
：
export var Auth = (function () {
    var Login = async function(username, password) {
        //Async login code for interacting with the API
    };
    return {
        Login: Login
    }
});

import * as API from './api';

export var LoginRequestHandler = function() {
   //processess user input, then calls:
   try {
       await API.Auth().Login(username, password);
   } catch(e) {
       throw new Error(e);
}

export var Auth = (function () {
    var Login = async function(username, password) {
        return Promise.resolve(true);
    };
    return {
        Login: Login
    }
});

将*作为API从“/API”导入；
导出变量LoginRequestHandler=异步函数（）{
const username='theUsername'；
const password='thePassword'；
试一试{
等待API.Auth（）.Login（用户名、密码）；
}捕获（e）{
抛出新错误（e）；
}
};

user.test.js
：
export var Auth = (function () {
    var Login = async function(username, password) {
        //Async login code for interacting with the API
    };
    return {
        Login: Login
    }
});

import * as API from './api';

export var LoginRequestHandler = function() {
   //processess user input, then calls:
   try {
       await API.Auth().Login(username, password);
   } catch(e) {
       throw new Error(e);
}

export var Auth = (function () {
    var Login = async function(username, password) {
        return Promise.resolve(true);
    };
    return {
        Login: Login
    }
});

将*作为API从“/API”导入；
从“./User”以用户身份导入*；
jest.mock（'./api'，（）=>{
const auth={Login:jest.fn（）}；
返回{
Auth:jest.fn（（）=>Auth），
};
});
描述（'61643983'，（）=>{
之后（（）=>{
开玩笑。clearAllMocks（）；
});
它（'应该登录'，（）=>{
期望.断言（2）；
返回User.LoginRequestHandler（）。然后（（）=>{
expect（API.Auth）.toBeCalledTimes（1）；
期望（API.Auth（）.Login）.tohavenbelst调用时使用（'theUsername'，'thePassword'）；
});
});
它（'应该抛出错误'，（）=>{
期望.断言（4）；
const mError=新错误（“未找到用户”）；
API.Auth（）.Login.mockRejectedValueOnce（mError）；
返回User.LoginRequestHandler（）.catch（（e）=>{
expect（API.Auth.toBeCalled（）；
期望（API.Auth（）.Login）.tohavenbelst调用时使用（'theUsername'，'thePassword'）；
期望（e）.安装（错误）；
expect（e.message）.toMatch（/user not found/）；
});
});
});

100%覆盖率的单元测试结果：
PASS stackoverflow/61643983/user.test.js（11.507s）
61643983
✓