C＃模拟对象并期望其构造函数使用Rhino Mocks返回模拟对象

Question

I have an object which I initialize inside using block to dispose few things. Then later inside using block I am calling some method of that object.

public void MyMethod()
{
 using(var obj = new Someclass())
 {
   // I want to mock this method call
   var result = obj.SomeMethod();
 }
}   

As I am writing unit test case for this, I have to mock the object and expect my own result by calling SomeMethod.

I understand that If you want to mock any object then that object should be passed as a dependency and then we can expect our own result there but here in this case, if I pass the object as a dependency then I will not be able to use using block. For eg-

public void MyMethod(SomeClass object)
{
 // Here can I do something like this ?
 // If this works then I can easily send the mocked object
 using(var obj = object)
 {
   // I want to mock this method call
   var result = obj.SomeMethod();
 }     
}

So my question is that

1. Is there a way that I pass the mock object as a dependency and also use the object initialization but I should expect from my object that If your constructor is called anywhere in the code then please ignore that
2. Shall I stop thinking of using Using block and call the dispose method manually

Thanks in advance

Answer 1

When adding the depency as parameter to your method, the client of that method isn´t only resposible for creating that depenency, but also for disposing it. Thus there´s no need to have the using in your method. However you´ll need it at the client-side:

using(var mock = Mock<MyClass>()) // don´t know the exact Rhino-syntax to get a mock
{
    MyMethod(mock);
}

Now your method becomes something like this:

void MyMethod(MyClass m)
{
    m.SomeMethod();  // notice that there´s no using
}

However when having a mock you surely won´t need to dipsoe it at all, at it is a leightweight instance whithout any unmanaged resources.

EDIT: If you are sure that MyMethod is the only place that uses the dependency, you can surely dispose it within that method as well:

void MyMethod(MyClass m)
{
    using(m) { m.SomeMethod(); }
}

However thais may lead to confusion to clients of MyMethod , as the dependecy will be disposed after calling this method:

var m = Mock<MyClass>();
MyMethod(m);
m.DoSomething();  // will lead to ObjectDisposedException

Answer 2

There is a way to do this. You want to pass dependency, but only for creation of the object. This way you can mock Dispose assuring you never dispose the object in tests. I don't have knowledge of rhino mock library, but you should get the idea.

You need SomeClassFactory which will be dependency and will return an instance of SomeClass . This way you can mock SomeClass 's Dispose method and ignore disposing the object.

//Arrange
var someClassFactoryMock = MockRepository.GenerateMock<ISomeClassFactory>();
var someClassMock = MockRepository.GenerateMock<ISomeClass>();
someClassMock.Stub(s => s.Dispose()); // Ignore Dispose
someClassFactoryMock.Stub(s => s.Get()).Return(someClassMock); // Return mock
var fooClass = new Foo();
fooClass.SomeClassFactory = someClassFactoryMock;

// Act
fooClass.SomeMethod();

// Assert
someClassMock.Expect(s => s.SomeMethod()).Repeat.Times(1); // Assert that it was called once.

SomeClassFactory is just a very simple factory

public class SomeClassFactory : ISomeClassFactory
{
    public ISomeClass Get() => new SomeClass();
}

And put it all together:

public class Foo
{
    public ISomeClassFactory SomeClassFactory { get; set; }
    public void MyMethod()
    {
        using(ISomeClass obj = SomeClassFactory.Get())
        {
          // When testing, obj will be a mock with Dispose method mocked to not do anything. This way it will not be disposed.
           var result = obj.SomeMethod();
        }
    }
}

Please note this is only pseudo code. If you want any errors, please let me know.