public void Constructor_DisposablePart() { Type expectedType = typeof(TestPart); Lazy<Type> expectedLazyType = expectedType.AsLazy(); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ReflectionComposablePartDefinition definition = CreateReflectionPartDefinition( expectedLazyType, true, () => expectedImports, () => expectedExports, expectedMetadata, expectedOrigin); Assert.AreSame(expectedType, definition.GetPartType()); Assert.IsTrue(definition.Metadata.Keys.SequenceEqual(expectedMetadata.Keys)); Assert.IsTrue(definition.Metadata.Values.SequenceEqual(expectedMetadata.Values)); Assert.IsTrue(definition.ExportDefinitions.SequenceEqual(expectedExports.Cast<ExportDefinition>())); Assert.IsTrue(definition.ImportDefinitions.SequenceEqual(expectedImports.Cast<ImportDefinition>())); Assert.AreSame(expectedOrigin, ((ICompositionElement)definition).Origin); Assert.IsNotNull(((ICompositionElement)definition).DisplayName); Assert.IsTrue(definition.IsDisposalRequired); }
public void CreatePart() { Type expectedType = typeof(TestPart); Lazy <Type> expectedLazyType = expectedType.AsLazy(); IDictionary <string, object> expectedMetadata = new Dictionary <string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; IEnumerable <ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable <ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ReflectionComposablePartDefinition definition = CreateReflectionPartDefinition( expectedLazyType, false, () => expectedImports, () => expectedExports, expectedMetadata, expectedOrigin); var part = definition.CreatePart(); Assert.NotNull(part); Assert.False(part is IDisposable); }
public void CreatePart_DoesntLoadType() { Type expectedType = typeof(TestPart); Lazy <Type> expectedLazyType = new Lazy <Type>(() => { throw new NotImplementedException(); /*"Part should not be loaded" */ }); IDictionary <string, object> expectedMetadata = new Dictionary <string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; IEnumerable <ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable <ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ReflectionComposablePartDefinition definition = CreateReflectionPartDefinition( expectedLazyType, true, () => expectedImports, () => expectedExports, expectedMetadata, expectedOrigin); var part = definition.CreatePart(); Assert.NotNull(part); Assert.True(part is IDisposable); }
public void Constructor_DisposablePart() { Type expectedType = typeof(TestPart); Lazy <Type> expectedLazyType = expectedType.AsLazy(); IDictionary <string, object> expectedMetadata = new Dictionary <string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; IEnumerable <ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable <ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ReflectionComposablePartDefinition definition = CreateReflectionPartDefinition( expectedLazyType, true, () => expectedImports, () => expectedExports, expectedMetadata, expectedOrigin); Assert.Same(expectedType, definition.GetPartType()); Assert.True(definition.Metadata.Keys.SequenceEqual(expectedMetadata.Keys)); Assert.True(definition.Metadata.Values.SequenceEqual(expectedMetadata.Values)); Assert.True(definition.ExportDefinitions.SequenceEqual(expectedExports.Cast <ExportDefinition>())); Assert.True(definition.ImportDefinitions.SequenceEqual(expectedImports.Cast <ImportDefinition>())); Assert.Same(expectedOrigin, ((ICompositionElement)definition).Origin); Assert.NotNull(((ICompositionElement)definition).DisplayName); Assert.True(definition.IsDisposalRequired); }
public void SetUp() { origin = new MockOrigin(nowMs: 1000, handleRequest: (origin, requestOp) => { var nowMs = origin.NowMs; var thing = new Parent() { id = requestOp.IdAsInt ?? 0 }; thing.updatedAtMs = requestOp.TimeMs; return(Task.FromResult(new OpResponse( requestOp: requestOp, nowMs, connected: true, exists: true, result: thing, arrivedAtMs: nowMs ))); }); }
public void SetUp() { origin = new MockOrigin(nowMs: 1000, handleRequest: (origin, requestOp) => { var nowMs = origin.NowMs; var reqParent = (requestOp.Value as Parent) !; Parent parent; switch (requestOp.Verb) { case RequestVerb.Create: parent = new Parent() { id = 5, colour = reqParent.colour, updatedAtMs = nowMs }; break; case RequestVerb.Replace: parent = new Parent() { id = reqParent.id, colour = reqParent.colour, updatedAtMs = nowMs }; break; default: throw new NotImplementedException("Verb not implemented"); } return(Task.FromResult(new OpResponse( requestOp: requestOp, nowMs, connected: true, exists: true, result: parent, arrivedAtMs: nowMs ))); }); }
public void CreateExportDefinition_InvalidLazymemberInfo_ShouldThrowArtument() { EventInfo _event = typeof(TestPart).GetEvents().First(); LazyMemberInfo expectedLazyMember = new LazyMemberInfo(_event); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; string expectedContractName = "Foo"; ICompositionElement expectedOrigin = new MockOrigin(); ExceptionAssert.ThrowsArgument<ArgumentException>("exportingMember", () => { ReflectionModelServices.CreateExportDefinition(expectedLazyMember, expectedContractName, expectedMetadata.AsLazy(), expectedOrigin); }); }
public void CreatePartDefinition_NullMetadataAllowed() { Type expectedType = typeof(TestPart); Lazy<Type> expectedLazyType = expectedType.AsLazy(); IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false, new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports), new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports), null, expectedOrigin); Assert.IsNotNull(partDefinition); ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition; Assert.IsNotNull(definition); Assert.IsNotNull(definition.Metadata); Assert.AreEqual(0, definition.Metadata.Count); }
public void CreatePartDefinition_EvaluatedNullImportsAllowed() { Type expectedType = typeof(TestPart); Lazy<Type> expectedLazyType = expectedType.AsLazy(); IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); ICompositionElement expectedOrigin = new MockOrigin(); ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false, new Lazy<IEnumerable<ImportDefinition>>(() => null), new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports), expectedMetadata.AsLazy(), expectedOrigin); Assert.IsNotNull(partDefinition); ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition; Assert.IsNotNull(definition); Assert.IsNotNull(definition.ImportDefinitions); Assert.AreEqual(0, definition.ImportDefinitions.Count()); }
public void IsImportingParameter_OnParameterImport() { ParameterInfo parameter = typeof(TestPart).GetConstructor(new Type[] { typeof(int) }).GetParameters()[0]; Lazy<ParameterInfo> expectedLazyParameter = parameter.AsLazy(); string expectedContractName = "Foo"; string expectedRequiredTypeIdentity = "Bar"; KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) }; ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne; CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared; ICompositionElement expectedOrigin = new MockOrigin(); ImportDefinition importDefinition = ReflectionModelServices.CreateImportDefinition( expectedLazyParameter, expectedContractName, expectedRequiredTypeIdentity, expectedRequiredMetadata, expectedCardinality, expectedCreationPolicy, expectedOrigin); Assert.IsNotNull(importDefinition); Assert.IsTrue(ReflectionModelServices.IsImportingParameter(importDefinition)); }
public void IsImportingParameter_OnMemberImport() { PropertyInfo property = typeof(TestPart).GetProperties().First(); LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property); string expectedContractName = "Foo"; string expectedRequiredTypeIdentity = "Bar"; KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) }; ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne; CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared; bool expectedRecomposable = true; ICompositionElement expectedOrigin = new MockOrigin(); ImportDefinition importDefinition = ReflectionModelServices.CreateImportDefinition( expectedLazyMember, expectedContractName, expectedRequiredTypeIdentity, expectedRequiredMetadata, expectedCardinality, expectedRecomposable, expectedCreationPolicy, expectedOrigin); Assert.IsNotNull(importDefinition); Assert.IsFalse(ReflectionModelServices.IsImportingParameter(importDefinition)); }
public void CreateImportDefinition_Parameter() { ParameterInfo parameter = typeof(TestPart).GetConstructor(new Type[] { typeof(int) }).GetParameters()[0]; Lazy<ParameterInfo> expectedLazyParameter = parameter.AsLazy(); string expectedContractName = "Foo"; string expectedRequiredTypeIdentity = "Bar"; KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) }; ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne; CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared; ICompositionElement expectedOrigin = new MockOrigin(); ImportDefinition importDefinition = ReflectionModelServices.CreateImportDefinition( expectedLazyParameter, expectedContractName, expectedRequiredTypeIdentity, expectedRequiredMetadata, expectedCardinality, expectedCreationPolicy, expectedOrigin); Assert.IsNotNull(importDefinition); ReflectionParameterImportDefinition definition = importDefinition as ReflectionParameterImportDefinition; Assert.IsNotNull(definition); Assert.AreEqual(expectedLazyParameter, definition.ImportingLazyParameter); Assert.AreEqual(definition.ContractName, expectedContractName); Assert.AreEqual(definition.RequiredTypeIdentity, expectedRequiredTypeIdentity); Assert.IsTrue(definition.RequiredMetadata.SequenceEqual(expectedRequiredMetadata)); Assert.AreEqual(definition.Cardinality, expectedCardinality); Assert.AreEqual(definition.RequiredCreationPolicy, expectedCreationPolicy); Assert.IsFalse(definition.IsRecomposable); Assert.AreSame(expectedOrigin, ((ICompositionElement)definition).Origin); Assert.IsTrue(definition.IsPrerequisite); }
public void CreateImportDefinition_Parameter_NullAsParamater_ShouldThrowArgumentNull() { ParameterInfo parameter = typeof(TestPart).GetConstructor(new Type[] { typeof(int) }).GetParameters()[0]; Lazy<ParameterInfo> expectedLazyParameter = parameter.AsLazy(); string expectedContractName = "Foo"; string expectedRequiredTypeIdentity = "Bar"; KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) }; ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne; CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared; ICompositionElement expectedOrigin = new MockOrigin(); ExceptionAssert.ThrowsArgument<ArgumentNullException>("parameter", () => { ReflectionModelServices.CreateImportDefinition( null, expectedContractName, expectedRequiredTypeIdentity, expectedRequiredMetadata, expectedCardinality, expectedCreationPolicy, expectedOrigin); }); }
public void CreatePartDefinition_NullTypeNotAllowed() { Type expectedType = typeof(TestPart); Lazy<Type> expectedLazyType = expectedType.AsLazy(); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ExceptionAssert.ThrowsArgument<ArgumentNullException>("partType", () => { ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(null, false, new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports), new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports), expectedMetadata.AsLazy(), expectedOrigin); }); }
public void CreatePartDefinition_ImportsMustBeOfRightType() { Type expectedType = typeof(TestPart); Lazy<Type> expectedLazyType = expectedType.AsLazy(); IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); ICompositionElement expectedOrigin = new MockOrigin(); ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false, new Lazy<IEnumerable<ImportDefinition>>(() => CreateInvalidImports()), new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports), expectedMetadata.AsLazy(), expectedOrigin); Assert.IsNotNull(partDefinition); ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition; Assert.IsNotNull(definition); ExceptionAssert.Throws<InvalidOperationException>(() => { definition.ImportDefinitions.Count(); }); }
public void CreatePartDefinition_NullEvaluatedTypeNotAllowed() { Type expectedType = typeof(TestPart); Lazy<Type> expectedLazyType = expectedType.AsLazy(); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(new Lazy<Type>(() => null), false, new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports), new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports), expectedMetadata.AsLazy(), expectedOrigin); ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition; Assert.IsNotNull(definition); ExceptionAssert.Throws<InvalidOperationException>(() => { definition.GetPartType(); }); }
public void CreateExportDefinition_NullAsContractName_ThrowsNullArgument() { PropertyInfo property = typeof(TestPart).GetProperties().First(); LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; ICompositionElement expectedOrigin = new MockOrigin(); ExceptionAssert.ThrowsArgument<ArgumentNullException>("contractName", () => { ReflectionModelServices.CreateExportDefinition(expectedLazyMember, null, expectedMetadata.AsLazy(), expectedOrigin); }); }
public void CreateExportDefinition() { PropertyInfo property = typeof(TestPart).GetProperties().First(); LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; string expectedContractName = "Foo"; ICompositionElement expectedOrigin = new MockOrigin(); ExportDefinition exportDefinition = ReflectionModelServices.CreateExportDefinition(expectedLazyMember, expectedContractName, expectedMetadata.AsLazy(), expectedOrigin); Assert.IsNotNull(exportDefinition); ReflectionMemberExportDefinition definition = exportDefinition as ReflectionMemberExportDefinition; Assert.IsNotNull(definition); Assert.AreEqual(expectedContractName, definition.ContractName); Assert.IsTrue(definition.Metadata.Keys.SequenceEqual(expectedMetadata.Keys)); Assert.IsTrue(definition.Metadata.Values.SequenceEqual(expectedMetadata.Values)); Assert.AreEqual(expectedOrigin, ((ICompositionElement)definition).Origin); Assert.AreEqual(expectedLazyMember, definition.ExportingLazyMember); }
public void IsDisposalRequired_ForDisposable() { Type expectedType = typeof(TestPart); Lazy<Type> expectedLazyType = expectedType.AsLazy(); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, true, new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports), new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports), expectedMetadata.AsLazy(), expectedOrigin); Assert.IsNotNull(partDefinition); bool isDisposalRequired = ReflectionModelServices.IsDisposalRequired(partDefinition); Assert.IsTrue(isDisposalRequired); }
public void GetPartType() { Type expectedType = typeof(TestPart); Lazy<Type> expectedLazyType = expectedType.AsLazy(); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false, new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports), new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports), expectedMetadata.AsLazy(), expectedOrigin); Assert.IsNotNull(partDefinition); Lazy<Type> lazyPartType = ReflectionModelServices.GetPartType(partDefinition); Assert.AreEqual(expectedLazyType, lazyPartType); }
public void CreatePart_DoesntLoadType() { Type expectedType = typeof(TestPart); Lazy<Type> expectedLazyType = new Lazy<Type>(() => { Assert.Fail("Part should not be loaded"); return null; }); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ReflectionComposablePartDefinition definition = CreateReflectionPartDefinition( expectedLazyType, true, () => expectedImports, () => expectedExports, expectedMetadata, expectedOrigin); var part = definition.CreatePart(); Assert.IsNotNull(part); Assert.IsTrue(part is IDisposable); }
public void GetExportingMember() { PropertyInfo property = typeof(TestPart).GetProperties().First(); LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; string expectedContractName = "Foo"; ICompositionElement expectedOrigin = new MockOrigin(); ExportDefinition exportDefinition = ReflectionModelServices.CreateExportDefinition(expectedLazyMember, expectedContractName, expectedMetadata.AsLazy(), expectedOrigin); Assert.IsNotNull(exportDefinition); LazyMemberInfo lazyMember = ReflectionModelServices.GetExportingMember(exportDefinition); Assert.AreEqual(expectedLazyMember, lazyMember); }
public void CreatePart() { Type expectedType = typeof(TestPart); Lazy<Type> expectedLazyType = expectedType.AsLazy(); IDictionary<string, object> expectedMetadata = new Dictionary<string, object>(); expectedMetadata["Key1"] = 1; expectedMetadata["Key2"] = "Value2"; IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType); IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType); ICompositionElement expectedOrigin = new MockOrigin(); ReflectionComposablePartDefinition definition = CreateReflectionPartDefinition( expectedLazyType, false, () => expectedImports, () => expectedExports, expectedMetadata, expectedOrigin); var part = definition.CreatePart(); Assert.IsNotNull(part); Assert.IsFalse(part is IDisposable); }
public void CreateImportDefinition_Member_InvalidMember_ShouldThrowArgument() { MethodInfo method = typeof(TestPart).GetMethods().First(); LazyMemberInfo expectedLazyMember = new LazyMemberInfo(method); string expectedContractName = "Foo"; string expectedRequiredTypeIdentity = "Bar"; KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) }; ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne; CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared; bool expectedRecomposable = true; ICompositionElement expectedOrigin = new MockOrigin(); ExceptionAssert.ThrowsArgument<ArgumentException>("importingMember", () => { ReflectionModelServices.CreateImportDefinition( expectedLazyMember, expectedContractName, expectedRequiredTypeIdentity, expectedRequiredMetadata, expectedCardinality, expectedRecomposable, expectedCreationPolicy, expectedOrigin); }); }