C# 我如何断言一个方法只被调用一次？ [主题（类型（OncedayProcessor））] 处理两次时的公共类 { 私有静态ICANbeProcessedOnceday ProcessedOnceday； 私有建立上下文=（）=>{oncedayprocessor.Now=（）=>newdatetime（2011,1,1,0,0,0）；}； 私有，因为=（）=> { ProcessedOnceADay=MockRepository.GenerateMock（）； processedanceday.Process（）； processedanceday.Process（）； }; private It应该被调用（x=>x.Expect（p=>p.Process（））； private它应该只执行一次=（）=>ProcessedOnceday.AssertWasNotCalled（x=>x.Expect（p=>p.Process（））； }

编辑的解决方案：

[Subject(typeof(OnceADayProcessor))]
public class When_processing_process_twice
{
    private static ICanBeProcessedOnceADay ProcessedOnceADay;

    private Establish context = () => { OnceADayProcessor.Now = () => new DateTime(2011, 1, 1, 0, 0, 0, 0); };

    private Because of = () =>
                             {
                                 ProcessedOnceADay = MockRepository.GenerateMock<ICanBeProcessedOnceADay>();
                                 ProcessedOnceADay.Process();
                                 ProcessedOnceADay.Process();
                             };

    private It should_execute = () => ProcessedOnceADay.AssertWasCalled(x => x.Expect(p => p.Process()));
    private It should_execute_only_once = () => ProcessedOnceADay.AssertWasNotCalled(x => x.Expect(p => p.Process()));
}

[主题（类型（OncedayProcessor））]
在同一天处理两次时的公共课
{
静态ICANceday可以处理onceday；
建立上下文=（）=>
{
canbeprocessedonceday=A.Fake（）；
};
因为=（）=>
{
oncedayProcessor.Process（可以立即处理）；
oncedayProcessor.Process（可以立即处理）；
};
它应该只执行一次=（）=>
A.CallTo（（）=>canbeprocessedonceday.Process（））。必须已发生（重复。精确。一次）；
}

var mock=MockRepository.GenerateMock（）；
Expect（a=>a.Process（））.Repeat.Times（1）；
...
mock.verifyallexpections（）；

我将用

It

中的

stub.Process（），o=>o.Repeat.Once（）调用
stub.Expect（）
和
stub.verifyAllExpections（）
，来替换对
stub.Expect（）和
stub.verifyAllExpections（）
的调用。如果对存根有多个期望，那么可以将每个断言放在一个
It
中，让它们独立地失败（或成功）

存根的创建将进入
建立
（基本上，任何依赖项和被测系统的创建都是单元测试中“安排”阶段的一部分）

也考虑不要使用<代码> GeaTeMoCu但<代码> GuestAuthBu/COD>作为MOCKS，在调用其他方法时，可能会比使用<代码>期望指定的方法更容易导致脆性测试。像Fakeitesy这样的库通常提供更好、更易发现的API，更容易学习，并且会使您陷入“成功的陷阱”。
如果您想确保只调用一次方法，您需要一个严格的模拟：

var mock = MockRepository.GenerateMock<ICanBeProcessedOnceADay>();
mock.Expect(a => a.Process()).Repeat.Times(1);
...
mock.VerifyAllExpectations();

var mock=MockRepository.GenerateStrictMock（）；
Expect（a=>a.Process（））.Repeat.Once（）；
sut.过程（模拟）
mock.verifyallexpections（）；

如果您只使用GenerateMock，它将执行“至少”检查。这也适用于重复。时间（x）也是。
我不明白为什么我应该使用存根而不是模拟。我想我需要一个mock，因为我断言一个调用而没有状态。模拟会破坏测试，存根不会。就这么简单。这将只验证该方法是否至少被调用一次，而不是完全被调用一次。
var mock = MockRepository.GenerateMock<ICanBeProcessedOnceADay>();
mock.Expect(a => a.Process()).Repeat.Times(1);
...
mock.VerifyAllExpectations();

var mock = MockRepository.GenerateStrictMock<IShouldOnlyBeCalledOnce>();
mock.Expect(a => a.Process()).Repeat.Once();

sut.Process(mock)

mock.VerifyAllExpectations();