Typescript 是什么导致Jest在此代码中显示75%的分支覆盖率？

我有一个文件，

parsePredicate.ts

，我相信它没有分支。然而，Jest报道说它只有75%的分支机构覆盖率。分支机构在哪里

parsePredicate.ts

：

import parseIdentifier from "../parseIdentifier/parseIdentifier";
import parseOperator from "../parseOperator/parseOperator";
import { parseExpression } from "../parseExpression/parseExpression";

const parsePredicate = (str: string)=>{
    let {identifier: left, rest:identRest} = parseIdentifier(str);
    let {operator, rest:opRest} = parseOperator(identRest);
    let {expression: right, rest:exprRest} = parseExpression(opRest);
    return { left: left, operator: operator, right: right, rest: exprRest };
}
export default parsePredicate;

import parsePredicate from "./parsePredicate";
import parseIdentifier from "../parseIdentifier/parseIdentifier";
import parseOperator from "../parseOperator/parseOperator";
import { parseExpression } from "../parseExpression/parseExpression";

jest.mock("../parseIdentifier/parseIdentifier");
jest.mock("../parseOperator/parseOperator");
jest.mock("../parseExpression/parseExpression");

test("Parsing a predicate with number returns proper values", ()=>{
    // @ts-ignore
    parseIdentifier.mockReturnValueOnce({identifier: "x", rest:" = 1"});
    // @ts-ignore
    parseOperator.mockReturnValueOnce({operator: "=", rest:" 1"});
    // @ts-ignore
    parseExpression.mockReturnValueOnce({expression: "1", rest:""});
    expect(parsePredicate("x = 1")).toStrictEqual({left:"x", operator:"=", right:"1", rest:""});
});
test("Parsing a predicate with math returns proper values", ()=>{
    // @ts-ignore
    parseIdentifier.mockReturnValueOnce({identifier: "x", rest:" = 1 + 1"});
    // @ts-ignore
    parseOperator.mockReturnValueOnce({operator: "=", rest:" 1 + 1"});
    // @ts-ignore
    parseExpression.mockReturnValueOnce({expression: "1 + 1", rest:""});
    expect(parsePredicate("x = 1 + 1")).toStrictEqual({left:"x", operator:"=", right:"1 + 1", rest:""});
});
test("Parsing a predicate with string returns proper values", ()=>{
    // @ts-ignore
    parseIdentifier.mockReturnValueOnce({identifier: "x", rest:" = 'Hello World'"});
    // @ts-ignore
    parseOperator.mockReturnValueOnce({operator: "=", rest:" 'Hello World'"});
    // @ts-ignore
    parseExpression.mockReturnValueOnce({expression: "'Hello World'", rest:""});
    expect(parsePredicate("x = 'Hello World'")).toStrictEqual({left:"x", operator:"=", right:"'Hello World'", rest:""});
});
test("Parsing a predicate with identifier returns proper values", ()=>{
    // @ts-ignore
    parseIdentifier.mockReturnValueOnce({identifier: "x", rest:" = ident"});
    // @ts-ignore
    parseOperator.mockReturnValueOnce({operator: "=", rest:" ident"});
    // @ts-ignore
    parseExpression.mockReturnValueOnce({expression: "ident", rest:""});
    expect(parsePredicate("x = ident")).toStrictEqual({left:"x", operator:"=", right:"ident", rest:""});
});

parsePredicate.test.ts

：

import parseIdentifier from "../parseIdentifier/parseIdentifier";
import parseOperator from "../parseOperator/parseOperator";
import { parseExpression } from "../parseExpression/parseExpression";

const parsePredicate = (str: string)=>{
    let {identifier: left, rest:identRest} = parseIdentifier(str);
    let {operator, rest:opRest} = parseOperator(identRest);
    let {expression: right, rest:exprRest} = parseExpression(opRest);
    return { left: left, operator: operator, right: right, rest: exprRest };
}
export default parsePredicate;

import parsePredicate from "./parsePredicate";
import parseIdentifier from "../parseIdentifier/parseIdentifier";
import parseOperator from "../parseOperator/parseOperator";
import { parseExpression } from "../parseExpression/parseExpression";

jest.mock("../parseIdentifier/parseIdentifier");
jest.mock("../parseOperator/parseOperator");
jest.mock("../parseExpression/parseExpression");

test("Parsing a predicate with number returns proper values", ()=>{
    // @ts-ignore
    parseIdentifier.mockReturnValueOnce({identifier: "x", rest:" = 1"});
    // @ts-ignore
    parseOperator.mockReturnValueOnce({operator: "=", rest:" 1"});
    // @ts-ignore
    parseExpression.mockReturnValueOnce({expression: "1", rest:""});
    expect(parsePredicate("x = 1")).toStrictEqual({left:"x", operator:"=", right:"1", rest:""});
});
test("Parsing a predicate with math returns proper values", ()=>{
    // @ts-ignore
    parseIdentifier.mockReturnValueOnce({identifier: "x", rest:" = 1 + 1"});
    // @ts-ignore
    parseOperator.mockReturnValueOnce({operator: "=", rest:" 1 + 1"});
    // @ts-ignore
    parseExpression.mockReturnValueOnce({expression: "1 + 1", rest:""});
    expect(parsePredicate("x = 1 + 1")).toStrictEqual({left:"x", operator:"=", right:"1 + 1", rest:""});
});
test("Parsing a predicate with string returns proper values", ()=>{
    // @ts-ignore
    parseIdentifier.mockReturnValueOnce({identifier: "x", rest:" = 'Hello World'"});
    // @ts-ignore
    parseOperator.mockReturnValueOnce({operator: "=", rest:" 'Hello World'"});
    // @ts-ignore
    parseExpression.mockReturnValueOnce({expression: "'Hello World'", rest:""});
    expect(parsePredicate("x = 'Hello World'")).toStrictEqual({left:"x", operator:"=", right:"'Hello World'", rest:""});
});
test("Parsing a predicate with identifier returns proper values", ()=>{
    // @ts-ignore
    parseIdentifier.mockReturnValueOnce({identifier: "x", rest:" = ident"});
    // @ts-ignore
    parseOperator.mockReturnValueOnce({operator: "=", rest:" ident"});
    // @ts-ignore
    parseExpression.mockReturnValueOnce({expression: "ident", rest:""});
    expect(parsePredicate("x = ident")).toStrictEqual({left:"x", operator:"=", right:"ident", rest:""});
});

当我运行

jest--coverage

时，我得到了我的

parsePredicate.ts

文件的以下输出：

---------------------|---------|----------|---------|---------|-------------------
File                 | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
---------------------|---------|----------|---------|---------|-------------------
parsePredicate       |     100 |       75 |     100 |     100 |                   
  parsePredicate.ts  |     100 |       75 |     100 |     100 | 11   

正如你所看到的，它说第11行没有被覆盖。但是，第11行只是一个导出语句：

导出默认语法谓词；

lcov报告如下所示： 请注意，如果我按n或j，没有任何变化

我一直在研究这个问题，似乎它可能与Babel生成的esmodule glue代码有关，但是我不确定如何解决这个问题

---

如果您需要更多信息，请留下评论。任何帮助都将不胜感激。

经过相当长的时间断断续续地试图解决这个问题，我得出了以下答案

基本上，在我的

jest.config.js

中，我使用的是

v8

覆盖率提供程序

//指示应使用哪个提供程序为覆盖范围插入代码
覆盖率提供程序：“v8”，

我使用节点版本12.16.1，所以这个提供程序不是很好，并且有很多问题

更改为

babel

提供程序修复了我遇到的所有问题，并为该代码提供了100%的分支覆盖率

//指示应使用哪个提供程序为覆盖范围插入代码
保险范围提供者：“巴贝尔”，