Library to enable mocking of Entity Framework. Keeps an in-memory store of data.
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
MockEF.Moq
MockEF.Rhino
MockEF.Tests
MockEF
.gitattributes
.gitignore
MockEF.sln
README.md

README.md

Rhino.MockEF

Library to enable mocking of Entity Framework. Keeps an in-memory store of data.

The library is designed to make testing with Entity Framework easier, by using an abstraction of your DbContext to enable in-memory use of your entity stores.

syntactically the library uses the TestBuilder pattern to set up your context, you must call the .Setup(..) method for each table/entity you will be using in your test. You can also provide optional seed data on setup if you require.

  var context = new ContextBuilder<IMyContext>()
      .Setup(x => x.Authors, new List<Author> { new Author { Id = 1, Name = "bob" }})
      .Setup(x => x.Books)
  .GetContext();

Becuase Rhino.MockEF just provides a mock of the context, you can also perform actions in your test later down the line. Such as adding more data, inspecting the Entity to Assert - or stubbing more specialist methods you have going on in your context interface.

  //adding
  context.MyEntity.Add(obj);
  
  //checking
  Assert.AreEqual(1, context.MyEntity.Count());
  
  //stubbing
  context.Stub(s => s.MyWeirdAndWonderfulThing(Arg<object>.Is.Anything)).Returns(null);

The library is dependant on Rhino.Mocks currently, and the returned context provided is built via Rhino's .GenerateMock()

View The MockEF.Tests project for example tests.

###Setup

All you need in order to start working with Rhino.MockEF is to implement a way of providing/injecting your mocked version of the context to your code. A great way to do this is to use a factory. Consider the following:

public interface IFactory
{
  IMyContext Create();
}

public class Factory : IFactory
{
  public IMyFactory Create()
  {
    return new MyContext();
  }
}

//class that needs to use the context
public class Example
{
  private IFactory _factory;
  public Example(IFactory factory)
  {
    _factory = factory;
  }
  
  public bool MethodThatUsesContext()
  {
    //Important. Your context interface MUST implement IDisposable. 
    //Firstly because this won't work otherwise, Secondonly because - you should anyway.
    using (var context = _factory.Create())
    {
      //Use context here.
    }
    return true;
  }
}

//When testing you can then stub your factory to return the context you have set up, like so:
var factory = MockRepository.GenerateMock<IFactory>();
factory.Stub(x => x.Create()).Return(context); //context built using Rhino.MockEF.
//then
var result = new Example(factory).MethodThatUsesContext();
Assert.IsTrue(result);


//When running the code not in test, in you DI registrations you can use something like:
container.Register<IFactory, Factory>();

voilà!