public void DelegatingMembers()
{
var emittableOperandProvider = MockRepository.GenerateStub <IEmittableOperandProvider>();
var mutableMethod = MutableMethodInfoObjectMother.Create();
var helper = new DecoratorTestHelper <IMethodBuilder> (_decorator, _innerMock);
helper.CheckDelegation(d => d.RegisterWith(emittableOperandProvider, mutableMethod));
}
public void DelegatingMembers()
{
var emittableOperandProvider = new Mock <IEmittableOperandProvider>().Object;
var mutableField = MutableFieldInfoObjectMother.Create();
var helper = new DecoratorTestHelper <IFieldBuilder> (_decorator, _innerMock);
helper.CheckDelegation(d => d.RegisterWith(emittableOperandProvider, mutableField));
}
public void DelegatingMembers()
{
var lambdaExpression = Expression.Lambda(Expression.Empty());
var ilGeneratorFactoryStub = new Mock <IILGeneratorFactory>();
var debugInfoGenerator = new Mock <DebugInfoGenerator>();
var helper = new DecoratorTestHelper <IMethodBaseBuilder> (_decorator.Object, _innerMock);
helper.CheckDelegation(d => d.SetBody(lambdaExpression, ilGeneratorFactoryStub.Object, debugInfoGenerator.Object));
}
public void DelegatingMembers()
{
var emittableOperandProvider = MockRepository.GenerateStub <IEmittableOperandProvider>();
var proxyType = MutableTypeObjectMother.Create();
var helper = new DecoratorTestHelper <ITypeBuilder> (_decorator, _innerMock);
helper.CheckDelegation(d => d.RegisterWith(emittableOperandProvider, proxyType));
helper.CheckDelegation(d => d.CreateType(), ReflectionObjectMother.GetSomeType());
}
public void DelegatingMembers()
{
var emittableOperandProvider = new Mock <IEmittableOperandProvider>();
var genericParameter = MutableGenericParameterObjectMother.Create();
var helper = new DecoratorTestHelper <IGenericTypeParameterBuilder> (_decorator, _innerMock);
helper.CheckDelegation(d => d.RegisterWith(emittableOperandProvider.Object, genericParameter));
helper.CheckDelegation(d => d.SetGenericParameterAttributes((GenericParameterAttributes)7));
}
public override void SetUp()
{
base.SetUp();
_innerFactoryMock = MockRepository.GenerateStrictMock <IRelationEndPointFactory>();
_listenerStub = MockRepository.GenerateStub <IVirtualEndPointStateUpdateListener>();
_decorator = new StateUpdateRaisingRelationEndPointFactoryDecorator(_innerFactoryMock, _listenerStub);
_decoratorTestHelper = new DecoratorTestHelper <IRelationEndPointFactory> (_decorator, _innerFactoryMock);
}
public override void SetUp()
{
base.SetUp();
_endPointID = RelationEndPointID.Create(DomainObjectIDs.Order1, typeof(Order), "OrderItems");
_listenerMock = MockRepository.GenerateStrictMock <IVirtualEndPointStateUpdateListener> ();
_innerEndPointMock = MockRepository.GenerateStrictMock <ICollectionEndPoint>();
_innerEndPointMock.Stub(stub => stub.HasChangedFast).Return(false);
_innerEndPointMock.Stub(stub => stub.ID).Return(_endPointID);
_decorator = new StateUpdateRaisingCollectionEndPointDecorator(_innerEndPointMock, _listenerMock);
_decoratorTestHelper = new DecoratorTestHelper <ICollectionEndPoint> (_decorator, _innerEndPointMock);
}
public void SetUp()
{
_helperForDecorator = CreateDecoratorTestHelper(
inner => inner.Get(),
(inner, s) => inner.Do(s));
_helperForNonDelegatingDecorator = CreateDecoratorTestHelper(inner => "Abc", (inner, s) => { });
_helperForFaultyDecorator = CreateDecoratorTestHelper(
inner =>
{
inner.Get();
return("faulty");
},
(inner, s) => inner.Do("faulty"));
}
private void CheckDelegation(Action <IDataManager> action)
{
var innerMock = MockRepository.GenerateStrictMock <IDataManager> ();
var delegatingDataManager = new DelegatingDataManager();
delegatingDataManager.InnerDataManager = innerMock;
var helper = new DecoratorTestHelper <IDataManager> (delegatingDataManager, innerMock);
helper.CheckDelegation(action);
delegatingDataManager.InnerDataManager = null;
Assert.That(
() => action(delegatingDataManager),
Throws.InvalidOperationException.With.Message.EqualTo("InnerDataManager property must be set before it can be used."));
}
public override void SetUp()
{
base.SetUp();
_mockRepository = new MockRepository();
_decoratedCommandMock = _mockRepository.StrictMock <IDataManagementCommand> ();
_modifiedEndPointID = RelationEndPointID.Create(DomainObjectIDs.Order1, typeof(Order), "OrderItems");
_stateUpdateListenerMock = _mockRepository.StrictMock <IVirtualEndPointStateUpdateListener> ();
_fakeChangeState = null;
_commandDecorator = new VirtualEndPointStateUpdatedRaisingCommandDecorator(
_decoratedCommandMock,
_modifiedEndPointID,
_stateUpdateListenerMock,
() => _fakeChangeState);
_decoratorTestHelper = new DecoratorTestHelper <IDataManagementCommand> (_commandDecorator, _decoratedCommandMock);
}
public void DelegatedMembers()
{
var testHelper = new DecoratorTestHelper <IQuery> (_queryAdapterBase, _queryMock);
var parameterCollection = new QueryParameterCollection {
{ "p1", 7 }
};
var eagerFetchQueries =
new EagerFetchQueryCollection {
{ GetEndPointDefinition(typeof(Order), "OrderTicket"), MockRepository.GenerateStub <IQuery>() }
};
testHelper.CheckDelegation(q => q.ID, "Some ID");
testHelper.CheckDelegation(q => q.Statement, "Some Statement");
testHelper.CheckDelegation(q => q.StorageProviderDefinition, TestDomainStorageProviderDefinition);
testHelper.CheckDelegation(q => q.CollectionType, typeof(OrderCollection));
testHelper.CheckDelegation(q => q.QueryType, QueryType.Collection);
testHelper.CheckDelegation(q => q.Parameters, parameterCollection);
testHelper.CheckDelegation(q => q.EagerFetchQueries, eagerFetchQueries);
}
public void DelegatingMembers()
{
var mappedType = MutableTypeObjectMother.Create();
var mappedGenericParameter = MutableGenericParameterObjectMother.Create();
var mappedField = MutableFieldInfoObjectMother.Create();
var mappedConstructor = MutableConstructorInfoObjectMother.Create();
var mappedMethod = MutableMethodInfoObjectMother.Create();
var emittableType = ReflectionObjectMother.GetSomeType();
var emittableGenericParameter = ReflectionObjectMother.GetSomeGenericParameter();
var emittableField = ReflectionObjectMother.GetSomeField();
var emittableConstructor = ReflectionObjectMother.GetSomeConstructor();
var emittableMethod = ReflectionObjectMother.GetSomeMethod();
var helper = new DecoratorTestHelper <IEmittableOperandProvider> (_decorator, _innerMock);
helper.CheckDelegation(d => d.AddMapping(mappedType, emittableType));
helper.CheckDelegation(d => d.AddMapping(mappedGenericParameter, emittableGenericParameter));
helper.CheckDelegation(d => d.AddMapping(mappedField, emittableField));
helper.CheckDelegation(d => d.AddMapping(mappedConstructor, emittableConstructor));
helper.CheckDelegation(d => d.AddMapping(mappedMethod, emittableMethod));
}
