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