public void GetDescriptor_CycleMetadataCompleted_MethodsReturnExpected() { ExportDescriptorPromise promise = null; IDictionary <string, object> metadata = null; promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), depdendencies => { ExportDescriptor cycleDescriptor = promise.GetDescriptor(); metadata = cycleDescriptor.Metadata; return(ExportDescriptor.Create(Activator, new Dictionary <string, object> { { "key", "value" } })); }); // Invoke the GetDescriptor method to start the test. Assert.NotNull(promise.GetDescriptor()); // Make sure all the IDictionary methods complete successfully. Assert.Equal("value", metadata["key"]); Assert.True(metadata.Contains(new KeyValuePair <string, object>("key", "value"))); Assert.True(metadata.ContainsKey("key")); Assert.False(metadata.IsReadOnly); metadata["key"] = "value2"; Assert.True(metadata.TryGetValue("key", out object value)); Assert.Equal("value2", value); metadata.Add("key2", "value"); Assert.Equal(2, metadata.Count); metadata.Remove("key2"); Assert.Equal(1, metadata.Count); metadata.Add(new KeyValuePair <string, object>("key2", "value")); Assert.Equal(2, metadata.Count); metadata.Remove(new KeyValuePair <string, object>("key2", "value")); Assert.Equal(1, metadata.Count); Assert.Equal(1, metadata.Keys.Count); Assert.Equal(1, metadata.Values.Count); var array = new KeyValuePair <string, object> [2]; metadata.CopyTo(array, 1); Assert.Equal(new KeyValuePair <string, object>[] { default(KeyValuePair <string, object>), new KeyValuePair <string, object>("key", "value2") }, array); IEnumerator enumerator = metadata.GetEnumerator(); Assert.True(enumerator.MoveNext()); Assert.Equal(new KeyValuePair <string, object>("key", "value2"), enumerator.Current); enumerator = ((IEnumerable)metadata).GetEnumerator(); Assert.True(enumerator.MoveNext()); Assert.Equal(new KeyValuePair <string, object>("key", "value2"), enumerator.Current); metadata.Clear(); Assert.Equal(0, metadata.Count); }
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors(CompositionContract contract, DependencyAccessor descriptorAccessor) { var target = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), dependencies => { return(ExportDescriptor.Create(Activator, new Dictionary <string, object>())); }); return(new ExportDescriptorPromise[] { target, target }); }
public void ToString_Invoke_ReturnsExpected() { var promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), depdendencies => { return(ExportDescriptor.Create(Activator, new Dictionary <string, object>())); }); Assert.Equal("Int32 supplied by Origin", promise.ToString()); }
public void Dependencies_GetWhenReturnsNull_ThrowsArgumentNullException() { var descriptor = ExportDescriptor.Create(Activator, new Dictionary <string, object>()); var promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => null, depdendencies => { return(ExportDescriptor.Create(Activator, new Dictionary <string, object>())); }); AssertExtensions.Throws <ArgumentNullException>("source", () => promise.Dependencies); }
public void GetDescriptor_GetWhenReturnsNull_ThrowsArgumentNullException() { var descriptor = ExportDescriptor.Create(Activator, new Dictionary <string, object>()); var promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), depdendencies => { return(null); }); AssertExtensions.Throws <ArgumentNullException>("descriptor", () => promise.GetDescriptor()); }
public void GetDescriptor_GetWhenNull_ThrowsNullReferenceException() { var descriptor = ExportDescriptor.Create(Activator, new Dictionary <string, object>()); var promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, null, dependencies => { return(ExportDescriptor.Create(Activator, new Dictionary <string, object>())); }); Assert.Throws <NullReferenceException>(() => promise.GetDescriptor()); }
public void Satisfied_NullContract_ThrowsArgumentNullException() { var descriptor = ExportDescriptor.Create(Activator, new Dictionary <string, object>()); var target = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), dependencies => { return(ExportDescriptor.Create(Activator, new Dictionary <string, object>())); }); AssertExtensions.Throws <ArgumentNullException>("contract", () => CompositionDependency.Satisfied(null, target, false, new object())); }
public void GetDescriptor_GetWhenReturnsNull_ThrowsInternalErrorException() { var descriptor = ExportDescriptor.Create(Activator, new Dictionary <string, object>()); var promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), depdendencies => { return(null); }); Exception ex = Assert.ThrowsAny <Exception>(() => promise.GetDescriptor()); Assert.Equal("Microsoft.Internal.Assumes+InternalErrorException", ex.GetType().ToString()); }
private ExportDescriptorPromise ExportHttpRequestMessagePart(CompositionContract contract, DependencyAccessor descriptorAccessor) { Contract.Requires(contract != null); Contract.Requires(descriptorAccessor != null); Contract.Ensures(Contract.Result <ExportDescriptorPromise>() != null); const bool shared = true; Func <IEnumerable <CompositionDependency>, ExportDescriptor> factory = dependencies => ExportDescriptor.Create((context, operation) => LogicalHttpRequestMessage.Current, NoMetadata); var promise = new ExportDescriptorPromise(contract, "WebApi", shared, NoDependencies, factory); return(promise); }
public static IEnumerable <object[]> Oversupplied_TestData() { yield return(new object[] { Enumerable.Empty <ExportDescriptorPromise>() }); yield return(new object[] { new ExportDescriptorPromise[] { null } }); var descriptor = ExportDescriptor.Create(Activator, new Dictionary <string, object>()); var target = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", false, () => Enumerable.Empty <CompositionDependency>(), dependencies => { return(ExportDescriptor.Create(Activator, new Dictionary <string, object>())); }); yield return(new object[] { new ExportDescriptorPromise[] { target } }); }
public void GetDescriptor_CycleMetadataBroken_HasExpectedProperties() { ExportDescriptorPromise promise = null; ExportDescriptor cycleDescriptor = null; promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), depdendencies => { cycleDescriptor = promise.GetDescriptor(); return(ExportDescriptor.Create(Activator, new Dictionary <string, object> { { "key", "value" } })); }); ExportDescriptor descriptor = promise.GetDescriptor(); Assert.Same(descriptor.Activator, cycleDescriptor.Activator); Assert.Same(descriptor.Metadata, cycleDescriptor.Metadata); }
public void GetDescriptor_CycleActivatorNotCompleted_ThrowsNotImplementedException() { ExportDescriptorPromise promise = null; promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), depdendencies => { ExportDescriptor cycleDescriptor = promise.GetDescriptor(); CompositeActivator activator = cycleDescriptor.Activator; Assert.Throws <NotImplementedException>(() => activator(null, null)); return(ExportDescriptor.Create(Activator, new Dictionary <string, object> { { "key", "value" } })); }); // Invoke the GetDescriptor method to start the test. Assert.NotNull(promise.GetDescriptor()); }
public void Satisfied_Invoke_ReturnsExpected() { var contract = new CompositionContract(typeof(int)); var descriptor = ExportDescriptor.Create(Activator, new Dictionary <string, object>()); var target = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", false, () => Enumerable.Empty <CompositionDependency>(), dependencies => { return(ExportDescriptor.Create(Activator, new Dictionary <string, object>())); }); CompositionDependency dependency = CompositionDependency.Satisfied(contract, target, true, "Site"); Assert.Same(contract, dependency.Contract); Assert.Equal("Site", dependency.Site); Assert.Same(target, dependency.Target); Assert.True(dependency.IsPrerequisite); Assert.Equal("'Site' on contract 'Int32' supplied by Origin", dependency.ToString()); }
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors( CompositionContract contract, DependencyAccessor descriptorAccessor) { var result = new List <ExportDescriptorPromise>(); foreach (var service in ServicesByType[contract.ContractType]) { Log.Debug($"Providing {service.ImplementationType.FullName} as {contract.ContractType.FullName}."); var promise = new ExportDescriptorPromise(contract, nameof(CustomExportProvider), true, () => GetDependencies(service, contract, descriptorAccessor), dependencies => ExportDescriptor.Create( activator: (context, o) => ServiceProvider.GetRequiredService(contract.ContractType), metadata: NoMetadata)); result.Add(promise); } return(result); }
public override IEnumerable <ExportDescriptorPromise> GetExportDescriptors( CompositionContract contract, DependencyAccessor descriptorAccessor) { var result = new List <ExportDescriptorPromise>(); foreach (var service in services.Where(s => s.ServiceType == contract.ContractType)) { var servicePromise = new ExportDescriptorPromise( contract, "Services", true, NoDependencies, _ => ExportDescriptor.Create((c, o) => services.QuickResolve(contract.ContractType), NoMetadata)); result.Add(servicePromise); } return(result); }
public void GetDescriptor_CycleActivatorNotCompleted_ThrowsInternalErrorException() { ExportDescriptorPromise promise = null; promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), depdendencies => { ExportDescriptor cycleDescriptor = promise.GetDescriptor(); CompositeActivator activator = cycleDescriptor.Activator; Exception ex = Assert.ThrowsAny <Exception>(() => activator(null, null)); Assert.Equal("Microsoft.Internal.Assumes+InternalErrorException", ex.GetType().ToString()); return(ExportDescriptor.Create(Activator, new Dictionary <string, object> { { "key", "value" } })); }); // Invoke the GetDescriptor method to start the test. Assert.NotNull(promise.GetDescriptor()); }
public void Ctor_Dependencies(CompositionContract contract, string origin, bool isShared, IEnumerable <CompositionDependency> dependencies) { int calledDependencies = 0; int calledGetDescriptor = 0; var descriptor = ExportDescriptor.Create(Activator, new Dictionary <string, object>()); var promise = new ExportDescriptorPromise(contract, origin, isShared, () => { calledDependencies++; return(dependencies); }, getDependencies => { Assert.Equal(dependencies, getDependencies); calledGetDescriptor++; return(descriptor); }); Assert.Same(contract, promise.Contract); Assert.Same(origin, promise.Origin); Assert.Equal(isShared, promise.IsShared); // The Dependencies parameter should only be invoked once. Assert.Equal(0, calledDependencies); Assert.Equal(0, calledGetDescriptor); Assert.Equal(dependencies, promise.Dependencies); Assert.Equal(1, calledDependencies); Assert.Equal(0, calledGetDescriptor); Assert.Same(promise.Dependencies, promise.Dependencies); Assert.Equal(1, calledDependencies); Assert.Equal(0, calledGetDescriptor); // The GetDescriptor parameter should only be invoked once. ExportDescriptor actualDescriptor = promise.GetDescriptor(); Assert.Same(descriptor, actualDescriptor); Assert.Equal(1, calledDependencies); Assert.Equal(1, calledGetDescriptor); Assert.Same(actualDescriptor, promise.GetDescriptor()); Assert.Equal(1, calledDependencies); Assert.Equal(1, calledGetDescriptor); }
public void GetDescriptor_CycleActivatorCompleted_Success() { ExportDescriptorPromise promise = null; CompositeActivator activator = null; promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), depdendencies => { ExportDescriptor cycleDescriptor = promise.GetDescriptor(); activator = cycleDescriptor.Activator; return(ExportDescriptor.Create(Activator, new Dictionary <string, object> { { "key", "value" } })); }); ExportDescriptor descriptor = promise.GetDescriptor(); Assert.Equal("hi", descriptor.Activator(null, null)); Assert.Equal("hi", activator(null, null)); }
public void ResolveRequiredDependency_PromisesReturnsOneTarget_ReturnsStatisfied() { var descriptor = ExportDescriptor.Create(Activator, new Dictionary <string, object>()); var target = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", false, () => Enumerable.Empty <CompositionDependency>(), dependencies => { return(ExportDescriptor.Create(Activator, new Dictionary <string, object>())); }); var accessor = new SubAccessor { Result = new ExportDescriptorPromise[] { target } }; var contract = new CompositionContract(typeof(int)); CompositionDependency dependency = accessor.ResolveRequiredDependency("Site", contract, true); Assert.Same(contract, accessor.Contract); Assert.Same(contract, dependency.Contract); Assert.Equal("Site", dependency.Site); Assert.True(dependency.IsPrerequisite); Assert.Same(target, dependency.Target); }
public void GetDescriptor_CycleMetadataNotCompleted_MethodsThrowNotImplementedException() { ExportDescriptorPromise promise = null; promise = new ExportDescriptorPromise(new CompositionContract(typeof(int)), "Origin", true, () => Enumerable.Empty <CompositionDependency>(), depdendencies => { ExportDescriptor cycleDescriptor = promise.GetDescriptor(); IDictionary <string, object> metadata = cycleDescriptor.Metadata; Assert.Throws <NotImplementedException>(() => metadata.Add("key", "value")); Assert.Throws <NotImplementedException>(() => metadata.Clear()); Assert.Throws <NotImplementedException>(() => metadata.Add(default(KeyValuePair <string, object>))); Assert.Throws <NotImplementedException>(() => metadata.CopyTo(null, 0)); Assert.Throws <NotImplementedException>(() => metadata.Contains(default(KeyValuePair <string, object>))); Assert.Throws <NotImplementedException>(() => metadata.ContainsKey("key")); Assert.Throws <NotImplementedException>(() => metadata.Count); Assert.Throws <NotImplementedException>(() => metadata.IsReadOnly); Assert.Throws <NotImplementedException>(() => metadata.GetEnumerator()); Assert.Throws <NotImplementedException>(() => ((IEnumerable)metadata).GetEnumerator()); Assert.Throws <NotImplementedException>(() => metadata.Keys); Assert.Throws <NotImplementedException>(() => metadata.Remove("key")); Assert.Throws <NotImplementedException>(() => metadata.Remove(default(KeyValuePair <string, object>))); Assert.Throws <NotImplementedException>(() => metadata.TryGetValue("key", out object _)); Assert.Throws <NotImplementedException>(() => metadata.Values); Assert.Throws <NotImplementedException>(() => metadata["key"]); Assert.Throws <NotImplementedException>(() => metadata["key"] = "value"); return(ExportDescriptor.Create(Activator, new Dictionary <string, object> { { "key", "value" } })); }); // Invoke the GetDescriptor method to start the test. Assert.NotNull(promise.GetDescriptor()); }
public static CompositionDependency Satisfied(CompositionContract contract, ExportDescriptorPromise target, bool isPrerequisite, object site);