Sprawdzanie określonego parametru za pomocą Moq

Question

public void SubmitMessagesToQueue_OneMessage_SubmitSuccessfully() 
{ 
    var messageServiceClientMock = new Mock<IMessageServiceClient>(); 
    var queueableMessage = CreateSingleQueueableMessage(); 
    var message = queueableMessage[0]; 
    var xml = QueueableMessageAsXml(queueableMessage); 
    messageServiceClientMock.Setup(proxy => proxy.SubmitMessage(xml)).Verifiable(); 
    //messageServiceClientMock.Setup(proxy => proxy.SubmitMessage(It.IsAny<XmlElement>())).Verifiable(); 

    var serviceProxyFactoryStub = new Mock<IMessageServiceClientFactory>(); 
    serviceProxyFactoryStub.Setup(proxyFactory => proxyFactory.CreateProxy()).Returns(essageServiceClientMock.Object); 
    var loggerStub = new Mock<ILogger>(); 

    var client = new MessageClient(serviceProxyFactoryStub.Object, loggerStub.Object); 
    client.SubmitMessagesToQueue(new List<IMessageRequestDTO> {message}); 

    //messageServiceClientMock.Verify(proxy => proxy.SubmitMessage(xml), Times.Once()); 
    messageServiceClientMock.Verify(); 
} 

Zaczynam używać Moq i nieco się z tym zmagam. Próbuję sprawdzić, czy messageServiceClient otrzymuje właściwy parametr, który jest XmlElement, ale nie mogę znaleźć żadnego sposobu, aby to działało. Działa tylko wtedy, gdy nie sprawdzam konkretnej wartości.

Wszelkie pomysły?

Częściowa odpowiedź: Znalazłem sposób na sprawdzenie, czy xml wysłany do proxy jest poprawny, ale nadal nie sądzę, że jest to właściwy sposób.

public void SubmitMessagesToQueue_OneMessage_SubmitSuccessfully() 
{ 
    var messageServiceClientMock = new Mock<IMessageServiceClient>(); 
    messageServiceClientMock.Setup(proxy => proxy.SubmitMessage(It.IsAny<XmlElement>())).Verifiable(); 
    var serviceProxyFactoryStub = new Mock<IMessageServiceClientFactory>(); 
    serviceProxyFactoryStub.Setup(proxyFactory => proxyFactory.CreateProxy()).Returns(messageServiceClientMock.Object); 
    var loggerStub = new Mock<ILogger>(); 

    var client = new MessageClient(serviceProxyFactoryStub.Object, loggerStub.Object); 
    var message = CreateMessage(); 
    client.SubmitMessagesToQueue(new List<IMessageRequestDTO> {message}); 

    messageServiceClientMock.Verify(proxy => proxy.SubmitMessage(It.Is<XmlElement>(xmlElement => XMLDeserializer<QueueableMessage>.Deserialize(xmlElement).Messages.Contains(message))), Times.Once()); 
} 

Nawiasem mówiąc, w jaki sposób mogę wyodrębnić wyrażenie z połączenia Verify?

Answer 1

Jeśli logika weryfikacji nie jest trywialna, pisanie dużej metody lambda (jak pokazuje Twój przykład) będzie kłopotliwe. Możesz umieścić wszystkie instrukcje testowe w osobnej metodzie, ale nie lubię tego robić, ponieważ zakłóca to przepływ odczytu kodu testowego.

Inną opcją jest użycie wywołania zwrotnego w wywołaniu Instalatora w celu zapisania wartości przekazanej do wyśmiewanej metody, a następnie napisanie standardowych metod Assert w celu sprawdzenia poprawności.Na przykład:

// Arrange 
MyObject saveObject; 
mock.Setup(c => c.Method(It.IsAny<int>(), It.IsAny<MyObject>())) 
     .Callback<int, MyObject>((i, obj) => saveObject = obj) 
     .Returns("xyzzy"); 

// Act 
// ... 

// Assert 
// Verify Method was called once only 
mock.Verify(c => c.Method(It.IsAny<int>(), It.IsAny<MyObject>()), Times.Once()); 
// Assert about saveObject 
Assert.That(saveObject.TheProperty, Is.EqualTo(2)); 

Answer 2

Sprawdzałem połączenia w ten sam sposób - uważam, że jest to właściwy sposób.

mockSomething.Verify(ms => ms.Method(
    It.IsAny<int>(), 
    It.Is<MyObject>(mo => mo.Id == 5 && mo.description = "test") 
), Times.Once()); 

Jeśli wyrażenie lambda staje się niewydolny, można utworzyć funkcję, która pobiera MyObject jako wejścia i wyjścia prawda/fałsz ...

mockSomething.Verify(ms => ms.Method(
    It.IsAny<int>(), 
    It.Is<MyObject>(mo => MyObjectFunc(mo)) 
), Times.Once()); 

private bool MyObjectFunc(MyObject myObject) 
{ 
    return myObject.Id == 5 && myObject.description == "test"; 
} 

również zdawać sobie sprawę z błędu z udawaną gdzie komunikat o błędzie stwierdza, że ​​metoda została wywołana wiele razy, gdy w ogóle nie była wywoływana. Być może naprawili go już teraz - ale jeśli widzisz tę wiadomość, możesz rozważyć weryfikację, czy została ona rzeczywiście wywołana.

EDYCJA: Oto przykład wywoływania sprawdzania wiele razy dla tych scenariuszy, w których chcesz sprawdzić, czy wywołujesz funkcję dla każdego obiektu na liście (na przykład).

foreach (var item in myList) 
    mockRepository.Verify(mr => mr.Update(
    It.Is<MyObject>(i => i.Id == item.Id && i.LastUpdated == item.LastUpdated), 
    Times.Once()); 

samo podejście do konfiguracji ...

foreach (var item in myList) { 
    var stuff = ... // some result specific to the item 
    this.mockRepository 
    .Setup(mr => mr.GetStuff(item.itemId)) 
    .Returns(stuff); 
} 

Więc za każdym razem GetStuff nazywa się w tym ItemID, powróci do tego elementu specyficzny materiał. Alternatywnie możesz użyć funkcji, która pobiera itemId jako dane wejściowe i zwraca rzeczy.

this.mockRepository 
    .Setup(mr => mr.GetStuff(It.IsAny<int>())) 
    .Returns((int id) => SomeFunctionThatReturnsStuff(id)); 

Jedna inna metoda Widziałam na blogu jakiś czas temu (? Phil Haack chyba) miał konfigurację powracającego z jakiegoś rozkolejkowania obiektu - za każdym razem funkcja została wywołana byłoby wyciągnąć element z kolejki.

Answer 3

Wierzę, że problem polega na tym, że Moq sprawdzi równość. A ponieważ XmlElement nie zastępuje Equals, jego implementacja sprawdzi równość referencyjną.

Nie można użyć niestandardowego obiektu, aby można było przesłonić równe wartości?

Answer 4

Prostszym sposobem byłoby zrobić:

ObjectA.Verify(
    a => a.Execute(
     It.Is<Params>(p => p.Id == 7) 
    ) 
);