如何使用列表存储模拟对象

Question

I am a new guy in this Moq community.

I am wondering is there any way to put an Inheritance object of A (Mock) to a list of Mock interface A?

For example, assume we have

Class ClientA :IMyClient{...}   //has override virtual codes
Class ClientB :IMyClient{...}

and

 List<Mock<IMyClient>> mockClients = new List<Mock<IMyClient>>();

Is there anyway that I can do something like this:

var mockClientA = new Mock<ClientA>();
mockClients.Add(mockClientA);

I might not be on the right track. Need some help. Thanks.

=================================

Setup

   // setup everyone to Free
    actualManager.Status = Status.Free;
    foreach (var mock in mockClients) {
        mock.Object.Status = Status.Free;
        actualManager.AddClient(mock.Object);
    }

Test

    Assert.AreEqual(Status.Free, actualManager.Status); // pass
    var firstClient = mockClients.First();
    IMyClient actualFirstClient  = SetClientToTriggerOutsideCallbacks(firstClient);
    firstClient.Status = Status.Busy;

    // busy, since the first client is busy now.
    Assert.AreEqual(Status.Busy, actualManager.Status);  //pass
    SessionSwitchEventArgs e = new SessionSwitchEventArgs(SessionSwitchReason.SessionLock);
    actualManager.SystemEvents_SessionSwitch(null, e);
    Assert.AreEqual(Status.Away, actualManager.Status);   //not pass

I was trying to check influence of status changes on different clients, so I was trying to use a list to store all the clients. The problem is: actualManager.SystemEvents_SessionSwitch(null, e); doesn't work correctly if the first client is not in type of ClientA.

Answer 1

First of all - why do we need mocks and stubs ? Because our SUT (System Under Test, the object which you are testing) often has some dependencies. We cannot use real dependencies which we have in production code, because we will not be able to tell the reason why test is passing or failing. It might be error in SUT or in dependency. So we should provide something instead of real dependency which will be reliable . Ie it should not produce any unexpected errors no matter how you change implementation of real dependencies. That's why we use stubs and mocks.

But what's the difference between them? Stubs are used in tests which do state verification . Ie when you after exercising SUT verify state of SUT and (sometime) stub. Stub can be very simple. You can just implement dependency interface and use auto-properties without any logic inside. It's enough for you to setup some value, SUT will read/write something into stub. At the end you will check state. You will not check what operations were performed.

Behavior verification is very different. It focuses on interaction between SUT and dependencies. We setup some expectations for mock object. It's not same as setting up some properties with fake data. With mock you setup the fact that property or method should be called, and correct parameters should be passed. With stub you don't check whether it was called. You just make call possible and check state at the end.

So.. what you are doing here is state verification with mocks. Which is not how mocks supposed to be used. Ie you setup status of clients and then check state of manager. Instead of using Moq following simple implementation completely satisfies your needs:

public class ClientStub : IMyClient
{
    public Status Status { get; set; }
    // some other members here
}

You can set status. Manager can read it. You can check manager's state. If you are going to use mocks, you should use behavior verification (otherwise it's just overkill). It's hard to tell what is the purpose of your manager class and how it checks status of clients. If you'll add this information I'll add some behavior verification test for your manager.

And regarding your question about putting mocks of different types into list - you cannot do that (well, only if you have list of objects). And it makes no sense. If some SUT expects list of dependencies, then you should put mock objects (accessible via Object property of mock) into that list. That's the difference between Moq and RhinoMocks.

Answer 2

Thank you, @SergeyBerezovskiy. I was not even in a right direction. Thank you for the ref link. I rewrote the example of the link in C# version and tested. I think it help me understand Mock a lot. Please let me know if I made anything bad in here. Thanks.

WareHouse.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Test {
    public class WareHouse {
    private Dictionary<string, int> wareHouseRepo = new Dictionary<string, int>();

    public void Add(string location, int number) {
    //null add
    if (wareHouseRepo.ContainsKey(location)) {
    int inventory_Old = wareHouseRepo[location];
        wareHouseRepo[location] = inventory_Old + number;
    } else {
         wareHouseRepo.Add(location, number);
    }
}


public virtual bool FillIt(string location, int number) {
    if (wareHouseRepo.ContainsKey(location)) {
        int inventory = wareHouseRepo[location];
        if(inventory >= number){
            wareHouseRepo[location] = inventory - number;
            return true;
        }else{
            return false;
        }
    } else {
        return false;
    }
}
}    

public int GetInventory(string location) {
    if (wareHouseRepo.ContainsKey(location)) {
        return wareHouseRepo[location];              
    } else {
        return 0;
    }
    }
}

Order.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

    namespace Test {
        class Order {
            private string location = "";
            private int orderNum = 0;

            private bool filled = true;

            public Order(string loc, int num) {
                this.location = loc;
                this.orderNum = num;
            }

            public void Fill(WareHouse wh){
                if (wh.FillIt(location, orderNum)) {
                    filled = true;
                } else {
                    filled = false;
                }
            }

            public bool isFilled() {
                return filled;
            }

        }
    }

TestWareHouse.cs

using Moq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Test {

    [TestFixture]
    class TestWareHouse {

        private WareHouse warehouse = new WareHouse();
        private static String TALISKER = "Talisker";
        private static String HIGHLAND_PARK = "Highland Park";

        [SetUp]
        public void SetUp() {
            //reset
            warehouse = new WareHouse();
            warehouse.Add(TALISKER, 50);
            warehouse.Add(HIGHLAND_PARK, 25);
        }

        //regular testing
        [Test]
        public void testOrderIsFilledIfEnoughInWarehouse() {
            Order order = new Order(TALISKER, 50);
            order.Fill(warehouse);
            Assert.True(order.isFilled());
            Assert.AreEqual(0, warehouse.GetInventory(TALISKER));
        }

         [Test]
        public void testOrderDoesNotRemoveIfNotEnough() {
            Order order = new Order(TALISKER, 51);
            order.Fill(warehouse);
            Assert.False(order.isFilled());
            Assert.AreEqual(50, warehouse.GetInventory(TALISKER));
        }


        //Now I am trying to do the things with Mock
        [Test]
        public void testOrderIsFilledIfEnoughInWarehouseMock() {
            Order order = new Order(TALISKER, 50);
            //-- Creating a fake ICustomerRepository object
            var warehouseMock = new Mock<WareHouse>();
            //warehouseMock

            warehouseMock
            .Setup(m => m.FillIt(TALISKER, 50))
            .Returns(true);

            order.Fill(warehouseMock.Object);


            //-- Assert ----------------------
            Assert.IsTrue(order.isFilled());


            warehouseMock.Verify(x => x.FillIt(It.IsAny<string>(), It.IsAny<int>()), Times.Exactly(1));
            }

        [Test]
        public void testFillingDoesNotRemoveIfNotEnoughInStock() {
            Order order = new Order(TALISKER, 51);
            //-- Creating a fake ICustomerRepository object
            var warehouseMock = new Mock<WareHouse>();

             warehouseMock
            .Setup(m => m.FillIt(It.IsAny<string>(), It.IsAny<int>()))
            .Returns(false);

             order.Fill(warehouseMock.Object);


            //-- Assert ----------------------
            Assert.IsFalse(order.isFilled());

            warehouseMock.Verify(x => x.FillIt(It.IsAny<string>(), It.IsAny<int>()), Times.Exactly(1));

        }

      }
}