Question

测试与此问题相关，这是我几天前提出的（＆已解决）。我当前的测试是：

// Helpers
function getObjectStructure(runners) {
    const backStake = runners.back.stake || expect.any(Number).toBeGreaterThan(0)
    const layStake = runners.lay.stake || expect.any(Number).toBeGreaterThan(0)

    return {
        netProfits: {
            back: expect.any(Number).toBeGreaterThan(0),
            lay: expect.any(Number).toBeGreaterThan(0)
        },
        grossProfits: {
            back: (runners.back.price - 1) * backStake,
            lay: layStake
        },
        stakes: {
            back: backStake,
            lay: layStake
        }
    }
}

// Mock
const funcB = jest.fn(pairs => {
    return pairs[0]
})

// Test
test('Should call `funcB` with correct object structure', () => {
    const params = JSON.parse(fs.readFileSync(paramsPath, 'utf8'))
    const { arb } = params
    const result = funcA(75)
    
    expect(result).toBeInstanceOf(Object)
    expect(funcB).toHaveBeenCalledWith(
        Array(3910).fill(
            expect.objectContaining(
                getObjectStructure(arb.runners)
            )
        )
    )
})

arb.runners的对象结构是这样的：

{
    "back": {
        "stake": 123,
        "price": 1.23
    },
    "lay": {
        "stake": 456,
        "price": 4.56
    }
}

围绕此函数有许多不同的测试，主要取决于传递给funcA的参数。在此示例中，它是75。取决于此参数，传递给funcB的数组长度不同。但是，现在还取决于runners （back和/或lay）是否具有它们的现有stake属性。我在每个测试中都有一个beforeAll，该操作会操纵我保存参数的文件中的arb。因此，这就是跑步者每次输入都不相同的原因。我要实现的目标概述是：

测量传递到funcB的数组的长度正确
测量数组中的对象的结构正确：

2.1如果跑步者有stake，那很好，测试很简单

2.2如果没有stake与跑步者在一起，我需要进行测试； netProfits，grossProfits和stakes属性均具有正数数字

2.2 是我一直在努力的那个。如果我尝试以下尝试，则测试将失败并显示以下错误：

TypeError：Expect.any（...）。toBeGreaterThan不是函数

Answer 1

与previous question一样，问题在于expect.any(Number).toBeGreaterThan(0)是不正确的，因为expect.any(...)不是断言并且没有匹配方法。 expect.any(...)的结果只是Jest相等匹配器识别的特殊值。不能在(runners.back.price - 1) * backStake之类的表达式中使用它。

如果要使用自定义行为扩展相等匹配器，则custom matcher就是这种情况。由于间谍匹配器始终使用内置的相等匹配器，因此需要使用自定义匹配器显式声明间谍参数。

否则，应手动声明其他限制。应该是：

function getObjectStructure() {
    return {
        netProfits: {
            back: expect.any(Number),
            lay: expect.any(Number)
        },
        grossProfits: {
            back: expect.any(Number),
            lay: expect.any(Number)
        },
        stakes: {
            back: expect.any(Number),
            lay: expect.any(Number)
        }
    }
}

和

expect(result).toBeInstanceOf(Object)
expect(funcB).toHaveBeenCalledTimes(1);
expect(funcB).toHaveBeenCalledWith(
    Array(3910).fill(
        expect.objectContaining(
            getObjectStructure()
        )
    )
)

const funcBArg = funcB.mock.calls[0][0];

const nonPositiveNetProfitsBack = funcBArg
    .map(({ netProfits: { back } }, i) => [i, back])
    .filter(([, val] => !(val > 0))
    .map(([i, val] => `${netProfits:back:${i}:${val}`);
expect(nonPositiveNetProfitsBack).toEqual([]);

const nonPositiveNetProfitsLay = ...

要检测到!(val > 0)时需要NaN的地方。如果没有自定义匹配器，则断言失败将不会导致有意义的消息，但是索引和nonPositiveNetProfitsBack临时变量名可以提供足够的反馈来发现问题。可以重新映射数组以包含有意义的值（例如字符串），并减少错误占用的空间。

期望传递正数参数-开玩笑

1 个答案: