我应该在单元测试中模拟每一个依赖项吗？

问：

经过大量阅读，我发现人们建议在单元测试中模拟方法中的每个依赖项。

我应该在单元测试时模拟所有依赖项吗？

我应该什么时候嘲笑？

但是，我有一个创建对象列表（依赖项）的方法，并使用这些对象的方法更改列表。在实际场景中，该方法是将客户端发送的数据有效负载转换为这些对象。 下面是 Typescript 中的代码实现，但它只是给你一个想法。

import {expect} from 'chai';

import 'mocha';

class Bar {
    private val: number;

    constructor(val: number) {
        this.val = val;
    }

    isValid(): boolean {
        return this.val !== 2;
    }

    canMergeWith(bar: Bar): boolean {
        return this.val === bar.val;
    }
}

class BarBuilder {
    constructor() {
    }

    createBars(payload: number[]): Bar[] {
        const bars: Bar[] = [];
        payload.forEach(p => {
            bars.push(new Bar(p));
        });

        const filtered = this.filterBars(bars);
        const merged = this.mergeBars(filtered);
        return merged;
    }

    private filterBars(bars: Bar[]): Bar[] {
        return bars.filter(b => b.isValid());
    }

    private mergeBars(bars: Bar[]): Bar[] {
        const merged: Bar[] = [];
        bars.forEach((bar, i) => {
            if (i > 0) {
                const before = bars[i - 1];
                if (!bar.canMergeWith(before)) {
                    merged.push(bar);
                }
            } else {
                merged.push(bar);
            }
        });
        return merged;
    }
}

describe('BarBuilder', () => {
    it('Should convert payload into valid bars', () => {
        const payload = [1, 2, 3, 4, 4, 5, 5];
        const barBuilder = new BarBuilder();
        const bars = barBuilder.createBars(payload);
        expect(bars).to.deep.equal([{val: 1}, {val: 3}, {val: 4}, {val: 5}]);
    });
});

目前，测试正在通过。但这违反了我应该嘲笑类中每个依赖项的规则。

我的问题是我应该做以下哪一项：

1. 我真的应该为了遵守该规则而嘲笑 Bar 类吗？

如果是这样，我发现这样做还有另一个困难。如果我模拟类 Bar，我如何制作模拟方法并根据它们的输入返回 true 或 false？这难道不等同于重写类本身吗？canMergeWithisValid

2. 我应该重构我的代码吗？

我也在想，问题可能出在我的代码不可测试上。之前，方法和属于.为了便于阅读，我把它们移到了 Bar 中。但现在，单元测试不再是竞争对手了。canMergeWithisValidBarBuilderBarBuilder

3. 尽管测试违反了单元测试规则，但仍保持原样。