Jest 测试框架 简单使用 测试ts 和异步方法

原文链接: Jest 测试框架 简单使用 测试ts 和异步方法

上一篇: Record 和 object 两种对象定义的区别的区别

下一篇: ts 使用infer 推断类型

https://github.com/facebook/jest

jest 入门

配置ts配置环境

npm i -D typescript jest ts-jest @types/jest

package.json中添加

  "scripts": {
    "test": "jest"
  },

为了能在ts中使用Promise

npm i @types/node -D

创建 jest.config.js：

module.exports = {
  // 测试文件名称后缀为tsx或ts时使用ts-jest
  transform: {
    '^.+\\.tsx?$': 'ts-jest',
  },

  // 具体配置项, 默认全局扫描 *.spec.js *.test.tsx?
  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$',
  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
}

一些断言

expect({a:1}).toBe({a:1})//判断两个对象是否相等
expect(1).not.toBe(2)//判断不等
expect(n).toBeNull(); //判断是否为null
expect(n).toBeUndefined(); //判断是否为undefined
expect(n).toBeDefined(); //判断结果与toBeUndefined相反
expect(n).toBeTruthy(); //判断结果为true
expect(n).toBeFalsy(); //判断结果为false
expect(value).toBeGreaterThan(3); //大于3
expect(value).toBeGreaterThanOrEqual(3.5); //大于等于3.5
expect(value).toBeLessThan(5); //小于5
expect(value).toBeLessThanOrEqual(4.5); //小于等于4.5
expect(value).toBeCloseTo(0.3); // 浮点数判断相等
expect('Christoph').toMatch(/stop/); //正则表达式判断
expect(['one','two']).toContain('one'); //不解释

function compileAndroidCode() {
  throw new ConfigError('you are using the wrong JDK');
}

test('compiling android goes as expected', () => {
  expect(compileAndroidCode).toThrow();
  expect(compileAndroidCode).toThrow(ConfigError); //判断抛出异常
}）

项目结构

测试函数 sum

function sum(a: number, b: number): number {
    return a + b;
}

export default sum

异步函数 getName

function getName(uid: string):Promise<string> {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(uid)
        }, 1000);
    })
}

export default getName

api.spec.ts

import getName from '../api'


describe("promise test", () => {
    it("ok", async () => {
        let name = await getName('ahao')
        expect(name).toBe(name);
    });

    it("err", async () => {
        let name = await getName('ahao')
        expect(name).toBe('');
    });
});

sum.spec.ts

import sum from '../sum'

test("adds 1 + 2 to equal 3", () => {
  expect(sum(1, 2)).toBe(3);
});

执行 npm test

使用async和await 在promise被reject后会报错, 但是使用then的形式可能会漏测, 因为测试分支并没有执行

此时使用 expect.assertions(1); 表示该测试用例必须有一次测试, 这样在reject后由于没有测试会报错

function fetchData1 () {
  return new Promise(function(resolve, reject) {
    setTimeout(reject('peanut butter'), 1000);
  });
}


test('the data is peanut butter', () => {
  // expect.assertions(1);
  return fetchData1().then(data => {
    expect(data).toBe('peanut butter11');
  }, (err) => {
    console.log(err)
  });
});

'

测试回调函数

function fetchData(call) {
  setTimeout(() => {
    call("peanut butter1");
  }, 1000);
}

test("the data is peanut butter", () => {
  function callback(data) {
    expect(data).toBe("peanut butter"); // 这里没有执行到
   
  }
  fetchData(callback);
});

这样做是不会报错的，因为没有执行到我们想要测试的语句中的时候 Jest 测试已经结束了。（一旦 fetchData 执行结束，此测试就在没有调用回调函数前结束，因为使用了 setTimeout，产生了异步）

而我们可以改成以下：
使用单个参数调用 done，而不是将测试放在一个空参数的函数中，Jest 会等 done 回调函数执行结束后，结束测试。

function fetchData(call) {
  setTimeout(() => {
    call("peanut butter1");
  }, 1000);
}

test("the data is peanut butter", done => {
  function callback(data) {
    expect(data).toBe("peanut butter");
    done();
  }
  fetchData(callback);
});

如果 done () 永远不会被调用，则说明这个测试将失败，这也正是我们所希望看到的。