Have the DynamicReturnValue expectations to be turned on?

Below is an example case where having the expectations turned on within the context of DynamicReturnValue delegate calls would be very beneficial, for constructing stubs.

In this example Entity and EntityColl classes are to be mocked because they are from a third party assembly requiring a server enviroment etc.
EntityColl class is a dictionary collection with its own add and get methods.

I have added inline comments within the code below that explains how having the expectations turned off inside DynamicReturnValue methods causing problems. I think the code is explanatory enough, if needed I can give more explanation.

The mocked objects are avaliable in the DynamicReturnValue context, but its mocked methods/properties aren't. Why not have the mocked methods
avaliable also?

using System.Collections.Generic;
using NUnit.Framework;
using TypeMock;
namespace UnitTesting
{

class Entity
{
string _name;
public string Name { get { return _name;}}
int _id;
public int Id { get { return _id;}}
public Entity(string name, int id)
{
_name = name;
_id = id;
}
}

class EntityColl
{
// this class holds a dictionary of Entities
private EntityColl()
{

}

public Entity Add(string name, int id)
{
// supposed to create an Entity object and adds it to the internal dictionary
return null; // just get it to compile, implementation here is not important
}
public Entity GetById(int id)
{
// supposed to find in the dictionary the Entity object that has this id and return it
return null; // just get it to compile, implementation here is not important
}

public Entity this[string index]
{
get
{
return null; // just get it to compile, implementation here is not important
}
}
}
[TestFixture]
public class TestClass
{
class EntityCollStub
{
private Dictionary<string, Entity> _entities;
private MockObject _entityCollMock;
public EntityCollStub()
{
_entities = new Dictionary<string, Entity>();
_entityCollMock = MockManager.MockObject(typeof (EntityColl));
_entityCollMock.ExpectGetIndexAlways(new DynamicReturnValue(IndexerGetValue));
_entityCollMock.AlwaysReturn("Add", new DynamicReturnValue(AddReturnValue));
_entityCollMock.AlwaysReturn("GetById", new DynamicReturnValue(GetByIdReturnValue));
}
public EntityColl Stubbed
{
get { return (EntityColl)_entityCollMock.MockedInstance; }
}

object IndexerGetValue(object[] parameters, object context)
{
return _entities[parameters[0].ToString()];
}
object GetByIdReturnValue(object[] parameters, object context)
{
int id = (int)parameters[0];
// this never finds the entity within the dictionary
// because the entities inside the dictionary are mocked objects
// and within this DynamicReturnValue context the expectations
// are turned off and they all return null or empty,
// as a result the method always returns nulls... incorrectly.
foreach (Entity entity in _entities.Values)
{
if (entity.Id == id)
{
return entity;
}
}
return null;
}
object AddReturnValue(object[] parameters, object context)
{
MockObject entityMock = MockManager.MockObject(typeof(Entity));
entityMock.ExpectGetAlways("Name", parameters[0].ToString());
entityMock.ExpectGetAlways("Id", parameters[1]);
Entity mocked = (Entity)entityMock.MockedInstance;
// fails in the following line, because mocked.Name returns null!
_entities.Add(mocked.Name, mocked);
return mocked;
}
public void AddEntityHelper(Entity entity)
{
_entities.Add(entity.Name, entity);
}
}
[Test]
public void TestFails()
{
EntityCollStub entityCollStub = new EntityCollStub();
EntityColl entityColl = entityCollStub.Stubbed;

// fails in EntityCollStub.AddReturnValue() method because the mock object's expectations that is
// created within the AddReturnValue is not executed.
Entity entity = entityColl.Add("first entity", 1);

}
[Test]
public void TestFails2()
{
MockObject entityMock1 = MockManager.MockObject(typeof (Entity));
entityMock1.ExpectGetAlways("Name", "some entity");
entityMock1.ExpectGetAlways("Id", 1);

EntityCollStub entityCollStub = new EntityCollStub();
// this time use the helper Add method to add the mocked
// entity to the stub
entityCollStub.AddEntityHelper((Entity)entityMock1.MockedInstance);
EntityColl entityColl = entityCollStub.Stubbed;
// this also fails, because inside EntityCollStub.GetByIdReturnValue
// the mocked entity that was added above has all the expectations turned off
// they all return null or empty
Assert.AreEqual("some entity", entityColl.GetById(1));


}
[SetUp]
public void Setup()
{
MockManager.Init();
}
}
}