Migration from Moq to FakeItEasy

Using

Moq:

using Moq; 

FakeItEasy:

using FakeItEasy;

Declaration of the new vairiable which will hold Mock

Moq:

private Mock<IClassName> _mockClassName = null!; 

FakeItEasy:

private IClassName _mockClassName = null!;

Initiation of the new Mock

Moq:

_mockClassName = new Mock<ClassName>();

FakeItEasy:

_mockClassName = A.Fake<ClassName>();

Injecting Mock into tested class

Moq:

_systemUnderTest = new SystemUnderTest(_mockClassName.Object);

FakeItEasy:

_systemUnderTest = new SystemUnderTest(_mockClassName);

Setting up behaviour of the property

Moq:

_mockClassName.SetupGet(x => x.PropertyName).Returns(propertyValue);

FakeItEasy:

A.CallTo(() => _mockClassName.PropertyName).Returns(propertyValue);

Setting up behaviour of the method

Moq:

_mockClassName.Setup(x => x.MethodName()).Returns(response);

FakeItEasy:

A.CallTo(() => _mockClassName.MethodName()).Returns(response);

Moq:

_mockClassName.Setup(x => x.MethodName(It.IsAny<int>(), It.IsAny<string>())).Returns(response);

FakeItEasy:

A.CallTo(() => _mockClassName.MethodName(A<int>._, A<string>._)).Returns(response);

A<int>._ is a shorthand declaration of A<int>.Ignored. It is equivalent of It.IsAny<int>() in Moq.

Veryfing if method run once

Moq:

_mockClassName.Verify(x => x.MethodName(), Times.Once);

FakeItEasy:

A.CallTo(() => _mockClassName.MethodName()).MustHaveHappenedOnceExactly();

Moq:

_mockClassName.Verify(x => x.MethodName(A<int>._, A<string>._), Times.Once);

FakeItEasy:

A.CallTo(() => _mockClassName.MethodName(A<int>._, A<string>._)).MustHaveHappenedOnceExactly();

Moq:

_mockClassName.Verify(mock => mock.MethodName(It.Is<int>(body =>
    body.PropertyValueOne == valueOne &&
    body.PropertyValueTwo == valueTwo
)));

FakeItEasy:

A.CallTo(() => _mockClassName.MethodName(A<int>.That.Matches(body =>
        body.PropertyValueOne == valueOne &&
        body.PropertyValueTwo == valueTwo
    )));

Moq default behaviour when we do not specify return for a method is to return null. FakeItEasy, on other hand, is returning empty object instead - that is why sometime I have to add specific stup for a method which runs inside of my tested class.

Moq:

// Nothing specified here for return from _mockClassName.GetById(1)

FakeItEasy:

A.CallTo(() => _mockClassName.GetById(1)).Returns(null as ReturnType);

Moq:

_mockClassName.Verify(x => x.GetById(1), Times.Exactly(3));

FakeItEasy:

A.CallTo(() => _mockClassName.GetById(1)).MustHaveHappened(3, Times.Exactly);

Setting up on Invoke

Moq:

_mockClassName.Setup(x => x(It.IsAny<int>()));

FakeItEasy:

A.CallTo(() => _mockClassName.Invoke(A<int>._));

Sequential returns

Moq:

_mockClassName.SetupSequence(x =>
        x.MethodName(It.IsAny<string>(), It.IsAny<Func<Task<string>>>(), It.IsAny<TimeSpan?>()))
    .ReturnsAsync(returnValueOne)
    .ReturnsAsync(returnValueTwo)
    .ReturnsAsync(returnValueThree);

FakeItEasy:

A.CallTo(() => _mockClassName
    .MethodName(A<string>._, A<Func<Task<string>>>._, A<TimeSpan?>._))
        .Returns(returnValueOne).Once()
        .Then
        .Returns(returnValueTwo).Once()
        .Then
        .Returns(returnValueThree);