UOW & Repo template

BusinessTests.cs

[TestFixture]
public class BusinessTests
{
    private IRepository<Entity> repo;
    private ConcreteService service;

    [SetUp]
    public void SetUp()
    {
        repo = MockRepository.GenerateStub<IRepository<Entity>>();
        service = new ConcreteService(repo);
    }

    [Test]
    public void Service_DoSomething_DoesSomething()
    {
        var expectedName = "after";
        var entity = new Entity{Name="before"};
        var list = new List<Entity>{entity};
        repo.Stub(r => r.Query()).Return(list.AsQueryable());
        service.DoStuff();
        Assert.AreEqual(expectedName, entity.Name);
    }

}

EFClasses.cs

public class EFUnitOfWork : IUnitOfWork
{
	private readonly DbContext context;

	public EFUnitOfWork(DbContext context)
	{
		this.context = context;
	}

	internal DbSet<T> GetDbSet<T>()
		where T : class
	{
		return context.Set<T>();
	}

	public void Commit()
	{
		context.SaveChanges();
	}

	public void Dispose()
	{
		context.Dispose();
	}
}

public class EFRepository<T> : IRepository<T>
		where T : class
{
	private readonly DbSet<T> dbSet;

	public EFRepository(IUnitOfWork unitOfWork)
	{
		var efUnitOfWork = unitOfWork as EFUnitOfWork;
		if (efUnitOfWork == null) throw new Exception("Must be EFUnitOfWork"); // TODO: Typed exception
		dbSet = efUnitOfWork.GetDbSet<T>();
	}

	public void Add(T item)
	{
		dbSet.Add(item);
	}

	public void Remove(T item)
	{
		dbSet.Remove(item);
	}

	public IQueryable<T> Query()
	{
		return dbSet;
	}
}

IntegratedTests.cs

[TestFixture]
[Category("Integrated")]
public class IntegratedTest
{
	private EFUnitOfWork uow;
	private EFRepository<Entity> repo;

	[SetUp]
	public void SetUp()
	{
		Database.SetInitializer(new DropCreateDatabaseAlways<YourContext>());
		uow = new EFUnitOfWork(new YourContext());
		repo = new EFRepository<Entity>(uow);
	}

	[TearDown]
	public void TearDown()
	{
		uow.Dispose();
	}

	[Test]
	public void Repository_Add_AddsItem()
	{
		var expected = new Entity { Name = "Test" };
		repo.Add(expected);
		uow.Commit();
		var actual = repo.Query().FirstOrDefault(e => e.Name == "Test");
		Assert.IsNotNull(actual);
	}

	[Test]
	public void Repository_Remove_RemovesItem()
	{
		var expected = new Entity { Name = "Test" };
		repo.Add(expected);
		uow.Commit();
		repo.Remove(expected);
		uow.Commit();
		Assert.AreEqual(0, repo.Query().Count());
	}
}

Interfaces.cs

public interface IUnitOfWork : IDisposable
{
    void Commit();
}

public interface IRepository<T>
{
    void Add(T item);
    void Remove(T item);
    IQueryable<T> Query();
}

where T: class is missing at a few places, apart from that this could be the best and complete end to end piece of code I have seen so for.

Glad it was helpful. Fixed the errorsnow, thanks. :)