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); }