Difficult.
I think you have two options.
If you can change the return type of Headers
from IEntityRepository<T>
to IQueryable<T>
, you can return a queryable List<T>
for Headers
:
IList<T> list = new List<Header> { /* Some Header object */ }
IQueryable<T> queryableList = list.AsQueryable();
_repository.Stub(x => x.Headers).Return(queryableList);
If you can't change the return type, you need to create a test fake (a new class) that derives from IEntityRepository<T>
, and wraps a queryable List<T>
. You will need to implement all the methods that IEntityRepository<T>
and its interfaces define, but just call the relevant function on the queryable List<T>
. Then you add a relevant Header
to the underlying queryable List<T>
as above and return a new instance of this object to stub Headers
.
IQueryable<Header>
Wrapper would look something like this:
public class HeadersWrapper : IQueryable<Header>
{
private readonly IQueryable<Header> _queryableSource;
public HeadersWrapper(IEnumerable<Header> source)
{
_queryableSource = source.AsQueryable();
}
public IEnumerator<Header> GetEnumerator()
{
return _queryableSource.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public Expression Expression
{
get { return _queryableSource.Expression; }
}
public Type ElementType
{
get { return _queryableSource.ElementType; }
}
public IQueryProvider Provider
{
get { return _queryableSource.Provider; }
}
}
And you'd use it something like this:
var headers = new List<Header>
{
new Header { Id = "foo" }
};
var wrapper = new HeadersWrapper(headers);
repo.Stub(x => x.Headers).Return(wrapper);
And of course, you can exchange IQueryable<Header>
for IEntityRepository<Header>
if you want to.