public void CacheMiss_UsesAssemblyContextFromPool()
{
var typeID = AssembledTypeIDObjectMother.Create();
var assemblyContext = CreateAssemblyContext();
bool isDequeued = false;
_assemblyContextPoolMock
.Expect(mock => mock.Dequeue())
.Return(assemblyContext)
.WhenCalled(mi => { isDequeued = true; });
_typeAssemblerMock
.Expect(
mock => mock.AssembleType(
// Use strongly typed Equals overload.
Arg <AssembledTypeID> .Matches(id => id.Equals(typeID)),
Arg.Is(assemblyContext.ParticipantState),
Arg.Is(assemblyContext.MutableTypeBatchCodeGenerator)))
.Return(new TypeAssemblyResult(_assembledType))
.WhenCalled(mi => Assert.That(isDequeued, Is.True));
_assemblyContextPoolMock
.Expect(mock => mock.Enqueue(assemblyContext))
.WhenCalled(mi => Assert.That(isDequeued, Is.True));
var result = _cache.GetOrCreateType(typeID);
_typeAssemblerMock.VerifyAllExpectations();
_assemblyContextPoolMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(_assembledType));
Assert.That(_assembledTypes[typeID].IsValueCreated, Is.True);
Assert.That(_assembledTypes[typeID].Value, Is.SameAs(_assembledType));
}
public void CacheMiss_AddsAdditionalTypesToCache_OverridesPreviouslyCachedValue()
{
var assemblyContext = CreateAssemblyContext();
var typeID = AssembledTypeIDObjectMother.Create();
var additionalTypeID = new object();
var additionalType = ReflectionObjectMother.GetSomeType();
_additionalTypes.Add(additionalTypeID, new Lazy <Type> (() => null, LazyThreadSafetyMode.None));
_assemblyContextPoolMock.Expect(mock => mock.Dequeue()).Return(assemblyContext);
_typeAssemblerMock
.Expect(mock => mock.AssembleType(new AssembledTypeID(), null, null))
.IgnoreArguments()
.Return(new TypeAssemblyResult(_assembledType, new Dictionary <object, Type> {
{ additionalTypeID, additionalType }
}));
_assemblyContextPoolMock
.Expect(mock => mock.Enqueue(assemblyContext))
.WhenCalled(mi => Assert.That(_additionalTypes[additionalTypeID].Value, Is.SameAs(additionalType)));
var result = _cache.GetOrCreateType(typeID);
_assemblyContextPoolMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(_assembledType));
}
public void CacheMiss_AddsAdditionalTypesToCache_OverridesPreviouslyCachedValue()
{
var assemblyContext = CreateAssemblyContext();
var typeID = AssembledTypeIDObjectMother.Create();
var additionalTypeID = new object();
var additionalType = ReflectionObjectMother.GetSomeType();
_additionalTypes.Add(additionalTypeID, new Lazy <Type> (() => null, LazyThreadSafetyMode.None));
_assemblyContextPoolMock.Setup(mock => mock.Dequeue()).Returns(assemblyContext).Verifiable();
_typeAssemblerMock
.Setup(mock => mock.AssembleType(It.IsAny <AssembledTypeID>(), It.IsAny <IParticipantState>(), It.IsAny <IMutableTypeBatchCodeGenerator>()))
.Returns(new TypeAssemblyResult(_assembledType, new Dictionary <object, Type> {
{ additionalTypeID, additionalType }
}))
.Verifiable();
_assemblyContextPoolMock
.Setup(mock => mock.Enqueue(assemblyContext))
.Callback((AssemblyContext _) => Assert.That(_additionalTypes[additionalTypeID].Value, Is.SameAs(additionalType)))
.Verifiable();
var result = _cache.GetOrCreateType(typeID);
_assemblyContextPoolMock.Verify();
Assert.That(result, Is.SameAs(_assembledType));
}
public void CacheMiss_AndExceptionDuringAssembleType_ReturnsAssemblyContextToPool()
{
var expectedException = new Exception();
var typeID = AssembledTypeIDObjectMother.Create();
var assemblyContext = CreateAssemblyContext();
var isDequeued = false;
_assemblyContextPoolMock
.Setup(mock => mock.Dequeue())
.Returns(assemblyContext)
.Callback(() => { isDequeued = true; })
.Verifiable();
_typeAssemblerMock
.Setup(mock => mock.AssembleType(It.IsAny <AssembledTypeID>(), It.IsAny <IParticipantState>(), It.IsAny <IMutableTypeBatchCodeGenerator>()))
.Callback(
(AssembledTypeID assembledTypeID, IParticipantState participantState, IMutableTypeBatchCodeGenerator mutableTypeBatchCodeGenerator) =>
Assert.That(isDequeued, Is.True))
.Throws(expectedException)
.Verifiable();
_assemblyContextPoolMock
.Setup(mock => mock.Enqueue(assemblyContext))
.Callback((AssemblyContext _) => Assert.That(isDequeued, Is.True))
.Verifiable();
Assert.That(() => _cache.GetOrCreateType(typeID), Throws.Exception.SameAs(expectedException));
_typeAssemblerMock.Verify();
_assemblyContextPoolMock.Verify();
}
public void CacheMiss_AndExceptionDuringAssembleType_ReturnsAssemblyContextToPool()
{
var expectedException = new Exception();
var typeID = AssembledTypeIDObjectMother.Create();
var assemblyContext = CreateAssemblyContext();
bool isDequeued = false;
_assemblyContextPoolMock
.Expect(mock => mock.Dequeue())
.Return(assemblyContext)
.WhenCalled(mi => { isDequeued = true; });
_typeAssemblerMock
.Expect(mock => mock.AssembleType(new AssembledTypeID(), null, null))
.IgnoreArguments()
.Throw(expectedException)
.WhenCalled(mi => Assert.That(isDequeued, Is.True));
_assemblyContextPoolMock
.Expect(mock => mock.Enqueue(assemblyContext))
.WhenCalled(mi => Assert.That(isDequeued, Is.True));
Assert.That(() => _cache.GetOrCreateType(typeID), Throws.Exception.SameAs(expectedException));
_typeAssemblerMock.VerifyAllExpectations();
_assemblyContextPoolMock.VerifyAllExpectations();
}
public void GetOrCreateConstructorCall_CacheMiss()
{
var typeID = AssembledTypeIDObjectMother.Create();
_typeCacheMock
.Setup(
mock => mock.GetOrCreateType(
// Use strongly typed Equals overload.
It.Is <AssembledTypeID> (id => id.Equals(typeID))))
.Returns(_assembledType)
.Verifiable();
_constructorDelegateFactoryMock
.Setup(mock => mock.CreateConstructorCall(typeID.RequestedType, _assembledType, _delegateType, _allowNonPublic))
.Returns(_generatedCtorCall)
.Verifiable();
var result = _constructorCallCache.GetOrCreateConstructorCall(typeID, _delegateType, _allowNonPublic);
Assert.That(result, Is.SameAs(_generatedCtorCall));
var key = new ConstructionKey(typeID, _delegateType, _allowNonPublic);
Assert.That(_constructorCalls[key], Is.SameAs(_generatedCtorCall));
}
public void GetPart_ParticipantDidNotContributeToTypeID()
{
var typeID = AssembledTypeIDObjectMother.Create(parts: new object[0]);
var result = _provider.GetPart(typeID, _participantWithoutIdentifierProvider.Object);
Assert.That(result, Is.Null);
}
public void GetPart_ParticipantContributedToTypeID()
{
var typeID = AssembledTypeIDObjectMother.Create(parts: new object[] { "abc", "def" });
var result = _provider.GetPart(typeID, _participantWithIdentifierProvider.Object);
Assert.That(result, Is.EqualTo("abc"));
}
public void AssembleType_RequestAssembledType()
{
var typeAssembler = CreateTypeAssembler();
var typeID = AssembledTypeIDObjectMother.Create(requestedType: _assembledType);
var codeGeneratorStub = MockRepository.GenerateStub <IMutableTypeBatchCodeGenerator>();
typeAssembler.AssembleType(typeID, _participantStateMock, codeGeneratorStub);
}
public void LoadTypes_DequeuesAllAssemblyContextDuringLoad()
{
var assembledType = typeof(AssembledType);
_typeAssemblerMock.Stub(stub => stub.IsAssembledType(assembledType)).Return(true);
var assembledTypeID = AssembledTypeIDObjectMother.Create();
_typeAssemblerMock.Stub(stub => stub.ExtractTypeID(assembledType)).Return(assembledTypeID);
var additionalGeneratedType = ReflectionObjectMother.GetSomeOtherType();
_typeAssemblerMock.Stub(stub => stub.IsAssembledType(additionalGeneratedType)).Return(false);
object additionalTypeID = new object();
_typeAssemblerMock.Stub(stub => stub.GetAdditionalTypeID(additionalGeneratedType)).Return(additionalTypeID);
var assemblyContexts = new[] { CreateAssemblyContext(), CreateAssemblyContext() };
bool isDequeued0 = false;
bool isDequeued1 = false;
_assemblyContextPoolMock
.Expect(mock => mock.DequeueAll())
.Return(assemblyContexts)
.WhenCalled(
mi =>
{
isDequeued0 = true;
isDequeued1 = true;
});
_assemblyContextPoolMock
.Expect(mock => mock.Enqueue(assemblyContexts[0]))
.WhenCalled(
mi =>
{
Assert.That(isDequeued0, Is.True);
isDequeued0 = false;
});
_assemblyContextPoolMock
.Expect(mock => mock.Enqueue(assemblyContexts[1]))
.WhenCalled(
mi =>
{
Assert.That(isDequeued0, Is.False);
Assert.That(isDequeued1, Is.True);
isDequeued1 = false;
Assert.That(_assembledTypes.ContainsKey(assembledTypeID), Is.True);
Assert.That(_additionalTypes.ContainsKey(additionalTypeID), Is.True);
});
_cache.LoadTypes(new[] { assembledType, additionalGeneratedType });
_assemblyContextPoolMock.VerifyAllExpectations();
}
public void SetUp()
{
_mutableTypeFactoryMock = new Mock <IMutableTypeFactory> (MockBehavior.Strict);
_complexSerializationEnablerMock = new Mock <IComplexSerializationEnabler> (MockBehavior.Strict);
_participantStateMock = new Mock <IParticipantState> (MockBehavior.Strict);
_requestedType = typeof(RequestedType);
_typeID = AssembledTypeIDObjectMother.Create(_requestedType);
_assembledType = typeof(AssembledType);
}
public void GetFlattenedExpressionForSerialization_ProviderReturnsNonFlatValue()
{
var requestedType = ReflectionObjectMother.GetSomeType();
var typeID = AssembledTypeIDObjectMother.Create(requestedType, new object[] { "abc" });
var nonFlatValueExpression = ExpressionTreeObjectMother.GetSomeExpression();
_identifierProviderMock.Stub(_ => _.GetFlatValueExpressionForSerialization("abc")).Return(nonFlatValueExpression);
_provider.GetAssembledTypeIDDataExpression(typeID);
}
public void GetOrCreateConstructorCall_CacheHit()
{
var typeID = AssembledTypeIDObjectMother.Create();
_constructorCalls.Add(new ConstructionKey(typeID, _delegateType, _allowNonPublic), _generatedCtorCall);
var result = _constructorCallCache.GetOrCreateConstructorCall(typeID, _delegateType, _allowNonPublic);
Assert.That(result, Is.SameAs(_generatedCtorCall));
}
public void GetTypeIDForRequestedType()
{
var fakeRequestedType = ReflectionObjectMother.GetSomeOtherType();
var fakeTypeID = AssembledTypeIDObjectMother.Create();
_typeAssemblerMock.Setup(mock => mock.ComputeTypeID(fakeRequestedType)).Returns(fakeTypeID).Verifiable();
var result = _service.GetTypeIDForRequestedType(fakeRequestedType);
_typeAssemblerMock.Verify();
Assert.That(result, Is.EqualTo(fakeTypeID));
}
public void SetUp()
{
_settings = PipelineSettings.New().Build();
_codeManagerMock = MockRepository.GenerateStrictMock <ICodeManager>();
_reflectionServiceMock = MockRepository.GenerateStrictMock <IReflectionService>();
_typeAssemblerMock = MockRepository.GenerateStrictMock <ITypeAssembler>();
_pipeline = new Pipeline(_settings, _codeManagerMock, _reflectionServiceMock, _typeAssemblerMock);
_requestedType = ReflectionObjectMother.GetSomeType();
_typeID = AssembledTypeIDObjectMother.Create();
}
public void SetUp()
{
_enabler = new ComplexSerializationEnabler();
_participantConfigurationID = "configID";
_assembledTypeIdentifierProviderStub = MockRepository.GenerateStub <IAssembledTypeIdentifierProvider>();
_typeID = AssembledTypeIDObjectMother.Create();
_assembledTypeIDData = ExpressionTreeObjectMother.GetSomeExpression();
_assembledTypeIdentifierProviderStub
.Stub(_ => _.GetAssembledTypeIDDataExpression(Arg <AssembledTypeID> .Matches(id => id.Equals(_typeID))))
.Return(_assembledTypeIDData);
}
public void AddTypeID_ProviderNotCalledForNull()
{
var proxyType = MutableTypeObjectMother.Create();
var typeID = AssembledTypeIDObjectMother.Create(parts: new object[] { null });
_provider.AddTypeID(proxyType, typeID);
_identifierProviderMock.AssertWasNotCalled(mock => mock.GetExpression(Arg <object> .Is.Anything));
var expectedIdPartExpression = Expression.Constant(null);
CheckTypeIDInitialization(proxyType, typeID.RequestedType, expectedIdPartExpression);
}
public void GetTypeIDForAssembledType()
{
var assembledType = ReflectionObjectMother.GetSomeType();
var fakeTypeID = AssembledTypeIDObjectMother.Create();
_typeAssemblerMock.Expect(mock => mock.ExtractTypeID(assembledType)).Return(fakeTypeID);
var result = _service.GetTypeIDForAssembledType(assembledType);
_typeAssemblerMock.VerifyAllExpectations();
Assert.That(result, Is.EqualTo(fakeTypeID));
}
public void GetFlattenedExpressionForSerialization_ProviderNotCalledForNull()
{
var requestedType = ReflectionObjectMother.GetSomeType();
var typeID = AssembledTypeIDObjectMother.Create(requestedType, new object[] { null });
var result = _provider.GetAssembledTypeIDDataExpression(typeID);
_identifierProviderMock.Verify(mock => mock.GetFlatValueExpressionForSerialization(It.IsAny <object>()), Times.Never());
var expectedIdPartExpression = Expression.Constant(null, typeof(IFlatValue));
CheckTypeIDDataExpression(result, requestedType, expectedIdPartExpression);
}
public void GetFlattenedExpressionForSerialization()
{
var requestedType = ReflectionObjectMother.GetSomeType();
var typeID = AssembledTypeIDObjectMother.Create(requestedType, new object[] { "abc" });
var idPartExpression = ExpressionTreeObjectMother.GetSomeExpression(typeof(IFlatValue));
_identifierProviderMock.Setup(_ => _.GetFlatValueExpressionForSerialization("abc")).Returns(idPartExpression);
var result = _provider.GetAssembledTypeIDDataExpression(typeID);
CheckTypeIDDataExpression(result, requestedType, idPartExpression);
}
public void GetAssembledType_AssembledTypeID()
{
var typeID = AssembledTypeIDObjectMother.Create();
var fakeAssembledType = ReflectionObjectMother.GetSomeOtherType();
_typeCacheMock.Setup(mock => mock.GetOrCreateType(It.Is <AssembledTypeID> (id => id.Equals(typeID)))).Returns(fakeAssembledType).Verifiable();
var result = _service.GetAssembledType(typeID);
_typeCacheMock.Verify();
Assert.That(result, Is.SameAs(fakeAssembledType));
}
public void CacheHit()
{
var typeID = AssembledTypeIDObjectMother.Create(_requestedType);
_assembledTypes.Add(typeID, new Lazy <Type> (() => _assembledType, LazyThreadSafetyMode.None));
var result = _cache.GetOrCreateType(typeID);
_typeAssemblerMock.VerifyAllExpectations();
_assemblyContextPoolMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(_assembledType));
}
public void GetAssembledType_AssembledTypeID()
{
var typeID = AssembledTypeIDObjectMother.Create();
var fakeAssembledType = ReflectionObjectMother.GetSomeOtherType();
_typeCacheMock.Expect(mock => mock.GetOrCreateType(Arg <AssembledTypeID> .Matches(id => id.Equals(typeID)))).Return(fakeAssembledType);
var result = _service.GetAssembledType(typeID);
_typeCacheMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeAssembledType));
}
public void AssembleType_RequestAssembledType()
{
var typeAssembler = CreateTypeAssembler();
var typeID = AssembledTypeIDObjectMother.Create(requestedType: _assembledType);
var codeGeneratorStub = new Mock <IMutableTypeBatchCodeGenerator>();
Assert.That(
() => typeAssembler.AssembleType(typeID, _participantStateMock.Object, codeGeneratorStub.Object),
Throws.ArgumentException
.With.Message.EqualTo(
"The provided requested type 'AssembledType' is already an assembled type."));
}
public void AddTypeID_ProviderNotCalledForNull()
{
var proxyType = MutableTypeObjectMother.Create();
var typeID = AssembledTypeIDObjectMother.Create(parts: new object[] { null });
_provider.AddTypeID(proxyType, typeID);
_identifierProviderMock.Verify(mock => mock.GetExpression(It.IsAny <object>()), Times.Never());
var expectedIdPartExpression = Expression.Constant(null);
CheckTypeIDInitialization(proxyType, typeID.RequestedType, expectedIdPartExpression);
}
public void SetUp()
{
_settings = PipelineSettings.New().Build();
_codeManagerMock = new Mock <ICodeManager> (MockBehavior.Strict);
_reflectionServiceMock = new Mock <IReflectionService> (MockBehavior.Strict);
_typeAssemblerMock = new Mock <ITypeAssembler> (MockBehavior.Strict);
_pipeline = new Pipeline(_settings, _codeManagerMock.Object, _reflectionServiceMock.Object, _typeAssemblerMock.Object);
_requestedType = ReflectionObjectMother.GetSomeType();
_typeID = AssembledTypeIDObjectMother.Create();
}
public void SetUp()
{
_enabler = new ComplexSerializationEnabler();
_participantConfigurationID = "configID";
_assembledTypeIdentifierProviderStub = new Mock <IAssembledTypeIdentifierProvider>();
_typeID = AssembledTypeIDObjectMother.Create();
_assembledTypeIDData = ExpressionTreeObjectMother.GetSomeExpression();
_assembledTypeIdentifierProviderStub
.Setup(_ => _.GetAssembledTypeIDDataExpression(It.Is <AssembledTypeID> (id => id.Equals(_typeID))))
.Returns(_assembledTypeIDData);
}
public void GetFlattenedExpressionForSerialization_ProviderReturnsNonFlatValue()
{
var requestedType = ReflectionObjectMother.GetSomeType();
var typeID = AssembledTypeIDObjectMother.Create(requestedType, new object[] { "abc" });
var nonFlatValueExpression = ExpressionTreeObjectMother.GetSomeExpression();
_identifierProviderMock.Setup(_ => _.GetFlatValueExpressionForSerialization("abc")).Returns(nonFlatValueExpression);
Assert.That(
() => _provider.GetAssembledTypeIDDataExpression(typeID),
Throws.InvalidOperationException
.With.Message.EqualTo(
"The expression returned from 'GetFlatValueExpressionForSerialization' must build an serializable instance of 'IFlatValue'."));
}
public void AddTypeID_ProviderReturnsNull_IsSubstitutedForConstantNullExpression()
{
var proxyType = MutableTypeObjectMother.Create();
var typeID = AssembledTypeIDObjectMother.Create(parts: new object[] { "abc" });
_identifierProviderMock.Setup(_ => _.GetExpression("abc")).Returns((Expression)null);
_provider.AddTypeID(proxyType, typeID);
var expectedIdPartExpression = Expression.Constant(null);
CheckTypeIDInitialization(proxyType, typeID.RequestedType, expectedIdPartExpression);
}
public void GetFlattenedExpressionForSerialization_ProviderReturnsNull_IsSubstitutedForConstantNullExpression()
{
var requestedType = ReflectionObjectMother.GetSomeType();
var typeID = AssembledTypeIDObjectMother.Create(requestedType, new object[] { "abc" });
_identifierProviderMock.Setup(_ => _.GetFlatValueExpressionForSerialization("abc")).Returns((Expression)null);
var result = _provider.GetAssembledTypeIDDataExpression(typeID);
var expectedIdPartExpression = Expression.Constant(null, typeof(IFlatValue));
CheckTypeIDDataExpression(result, requestedType, expectedIdPartExpression);
}
