CODEWITHSUNDEEP
c#mockingnunitrhino-mocks
Peter Agambar
Peter Agambar

Reputation: 41

Rhino Mocks - Use Expect.Call for a method with two signatures

How can I mock a method with two signatures?

sudo code:

public Class ClassA{
  //... do stuff
}

public Class ClassB{
  //... do stuff
}

public Class BigClass
{
  public BigClass(){}

  public ClassB MapMe(ClassA a)
  {
     //... do stuff
     return new ClassB();
  }

  public ClassA MapMe(ClassB a)  
  {
     //... do stuff    
     return new ClassA();
  }
}

public Class ClassToTest
{
  public void DoSomething()
  {
     var ResultA = BigClass.MapMe(new ClassA());

     //... do some more stuff

     ResultA = BigClass.MapMe(new ClassB());
  }
}

Apologies for the poor code example, doing this on IPad, but hopefully gives you the idea.

Upvotes: 1

Views: 6568

Answers (1)

sll
sll

Reputation: 62564

Just use Argument Constraints

Argument constraints also define the method's signature by specifying the arguments types. That's why they can't be omitted. 

mock.Expect(x => x.MapMe(Arg<ClassB>.Is.Anything).Return(resultB);
mock.Expect(x => x.MapMe(Arg<ClassA>.Is.Anything).Return(resultA);

EDIT:

I believe an other issue you faced - you've mocked BigClass without backing interface so obviously RhinoMocks does not allow setting expectations on such a mock. So just abstract a BigClass by interface and mock based on it:

public interface IMapper
{
    ClassB MapMe(ClassA entity);
    ClassA MapMe(ClassB entity);
}

public class BigClass : IMapper


[Test]
public void MapperTest()
{
    // !!! Below I've used WhenCalled() to show you that correct  
    // expectation is called based on argument type, just see in debugger
    IMapper mapperMock = MockRepository.GenerateMock<IMapper>();
    mapperMock.Expect(x => x.MapMe(Arg<ClassA>.Is.Anything))
              .WhenCalled((mi) =>
                        {
                            Debug.WriteLine("MapMe - ClassA parameter");
                        })
              .Return(null /*TODO: return correct instance*/);
    mapperMock.Expect(x => x.MapMe(Arg<ClassB>.Is.Anything))
              .WhenCalled((mi) =>
                        {
                            Debug.WriteLine("MapMe - ClassB parameter");
                        })
              .Return(null /*TODO: return correct instance*/);

    var resultB = mapperMock.MapMe(new ClassA());
    var resultA = mapperMock.MapMe(new ClassB());

   // TODO: Asserts
}

Upvotes: 7

Related Questions