Wie auf null zurück, wenn der Zugriff auf eine moq Objekt?

Es klingt wie Sie versuchen, um zwei tests mit einem test-Methode - vielleicht wäre es besser, teilen sich die tests in zwei?

Möchten Sie auch, dass zur Initialisierung eines neuen Objekts wird die Methode übergeben null. Um dies zu testen, schlage ich vor, erstellen ein factory-Objekt verantwortlich für die Erstellung von Instanzen von MyClass. Der neue code würde wie folgt Aussehen:

interface IMyClassFactory
{
    IMyClass CreateMyClass();
}

bool Method(IMyClass myObj, IMyClassFactory myClassFactory)
{
    if (myObj != null)
    {
        return true;
    }

    myObj = myClassFactory.CreateMyClass();
    return myObj.SomeFunctionReturningBool();
}

Dann würden die tests Aussehen:

[Test]
public void Method_ShouldReturnTrueIfNotPassedNull()
{
    Assert.That(target.Method(new MyClass()), Is.True);
}

[Test]
public void Method_ShouldCreateObjectAndReturnResultOfSomeFunctionIfPassedNull()
{
    //Arrange
    bool expectedResult = false;

    var mockMyClass = new Mock<IMyClass>();
    mockMyClass.Setup(x => x.SomeFunctionReturningBool()).Returns(expectedResult);

    var mockMyFactory = new Mock<IMyClassFactory>();
    mockMyFactory.Setup(x => x.CreateMyClass()).Returns(mockMyClass.Object);

    //Act
    var result = target.Method(null, mockMyFactory.Object);

    //Assert
    mockMyClass.Verify(x => x.SomeFunctionReturningBool(), Times.Once());
    mockMyFactory.Verify(x => x.CreateMyClass(), Times.Once());
    Assert.That(result, Is.EqualTo(expectedResult));
}

Hier die Fabrik-Muster wurde verwendet, um in ein Objekt, die Objekte erstellen, die von IMyClass geben, und dann die Fabrik selbst wurde verspottet.

Wenn Sie nicht wollen, ändern Sie Ihre Methode, die Signatur zu erzeugen, dann die Fabrik im Konstruktor der Klasse, und machen es zugänglich über eine öffentliche Eigenschaft der Klasse. Es kann dann überschrieben werden, die Prüfung durch die mock-factory. Dies wird als dependency injection.

Derzeit Ihr SUT ist eng gekoppelt mit MyClass Umsetzung. Sie können keine mock-Objekte, die instanziiert sind mit new Schlüsselwort in Ihrem SUT. So können Sie nicht testen Sie Ihr SUT in isolation, und Ihr test nicht unit test mehr. Bei der Umsetzung von MyClass.SomeFunctionReturningBool ändern wird (es wird zurück true statt false), tests bereitgestellt wird scheitern. Dies sollte nicht passieren. So delegieren Sie die Erstellung, um einige Abhängigkeit (Fabrik) und injizieren, diese Abhängigkeit zu Ihr SUT:

[Test]
public void ShouldReturnTrueWhenMyClassIsNotNull()
{
    Mock<IMyClassFactory> factory = new Mock<IMyClassFactory>();
    Mock<IMyClass> myClass = new Mock<IMyClass>();
    var foo = new Foo(factory.Object);
    Assert.True(foo.Method(myClass.Object));
}

[Test]
public void ShouldCreateNewMyClassAndReturnSomeFunctionValue()
{
    bool expected = true;
    Mock<IMyClass> myClass = new Mock<IMyClass>();
    myClass.Setup(mc => mc.SomeFunctionReturningBool()).Returns(expected);
    Mock<IMyClassFactory> factory = new Mock<IMyClassFactory>();
    factory.Setup(f => f.CreateMyClass()).Returns(myClass.Object);

    var foo = new Foo(factory.Object);

    Assert.That(foo.Method(null), Is.EqualTo(expected));
    factory.VerifyAll();
    myClass.VerifyAll();
}

BTW Zuweisung einen neuen Wert Methode parameter hat keine Auswirkung auf die Referenz, die Sie an Methode übergeben.

Umsetzung:

public class Foo
{
    private IMyClassFactory _factory;

    public Foo(IMyClassFactory factory)
    {
        _factory = factory;
    }

    public bool Method(IMyClass myObj)
    {
        if (myObj != null)
            return true;       

        return _factory.CreateMyClass().SomeFunctionReturningBool();
    }
}

Moq - null Zurück - Dieses Beispiel soll zeigen, wie null zurück, mit Moq. Während Sie die Codezeile benötigt wird, ist die auskommentierte Zeile unten, eine voll funktionsfähige Beispiel.

//_mockShopService.Setup(x => x.GetProduct(It.IsAny<string>())).Returns(() => null);

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;

public class Product
{
    public string Id { get; set; }
    public string Name { get; set; }
}

public interface IShopService
{
    Product GetProduct(string productId);
}

public class ShopService : IShopService
{
    public Product GetProduct(string productId)
    {
        if (string.IsNullOrWhiteSpace(productId))
        {
            return new Product();
        }

        return new Product { Id = "8160807887984", Name = "How to return null in Moq" };
    }
}

public class Shop
{
    private static IShopService _shopService;

    public Shop(IShopService shopService)
    {
        _shopService = shopService;
    }

    public Product GetProduct(string productId)
    {
        Product product = _shopService.GetProduct(productId);

        return product;
    }
}

[TestClass]
public class ShopTests
{
    Mock<IShopService> _mockShopService;

    [TestInitialize]
    public void Setup()
    {
        _mockShopService = new Mock<IShopService>();
    }

    [TestMethod]
    public void ShopService_GetProduct_Returns_null()
    {
        //Arrange
        Shop shop = new Shop(_mockShopService.Object);

        //This is how we return null --- all other code above is to bring this line of code home
        _mockShopService.Setup(x => x.GetProduct(It.IsAny<string>())).Returns(() => null);

        //Act
        var actual = shop.GetProduct(It.IsAny<string>());

        //Assert

        Assert.IsNull(actual);
    }
}