public void CreateFromFactory_executes_factory_with_resolved_parameters([Frozen] IFulfilsResolutionRequests resolver,
InstanceCreator sut,
IFactoryAdapter factory,
ResolutionPath path,
IServiceRegistration registration,
object resolved,
[MockParam(typeof(string), Name = "Foo")] ParameterInfo paramOne,
object paramOneValue,
[MockParam(typeof(int), Name = "Bar")] ParameterInfo paramTwo,
object paramTwoValue)
{
// Arrange
Mock.Get(factory).SetupGet(x => x.RequiresParameterResolution).Returns(true);
Mock.Get(factory).Setup(x => x.GetParameters()).Returns(new [] { paramOne, paramTwo });
Mock.Get(resolver)
.Setup(x => x.Resolve(It.Is <ResolutionRequest>(r => r.Name == paramOne.Name && r.ServiceType == paramOne.ParameterType)))
.Returns(() => ResolutionResult.Success(path, paramOneValue));
Mock.Get(resolver)
.Setup(x => x.Resolve(It.Is <ResolutionRequest>(r => r.Name == paramTwo.Name && r.ServiceType == paramTwo.ParameterType)))
.Returns(() => ResolutionResult.Success(path, paramTwoValue));
Mock.Get(factory)
.Setup(x => x.Execute(It.Is <object[]>(e => e.Length == 2 && e[0] == paramOneValue && e[1] == paramTwoValue)))
.Returns(resolved);
// Act
var result = sut.CreateFromFactory(factory, path, registration);
// Assert
Mock.Get(factory)
.Verify(x => x.Execute(It.Is <object[]>(e => e.Length == 2 && e[0] == paramOneValue && e[1] == paramTwoValue)), Times.Once);
Assert.That(result, Is.SameAs(resolved));
}
ResolutionPath CreateRegisteredNameResolutionPath(ResolutionPath parentPath, string name)
{
var registration = new InstanceRegistration(name)
{
Name = RegisteredName,
ServiceType = typeof(string),
};
return(parentPath.CreateChild(registration));
}
public void ThrowOnCircularDependency_does_not_throw_when_there_is_no_circular_dependency(IServiceRegistration registration1,
IServiceRegistration registration2,
IServiceRegistration registration3,
CircularDependencyDetector sut)
{
// Arrange
var path = new ResolutionPath(new [] { registration1, registration2 });
// Act & assert
Assert.That(() => sut.ThrowOnCircularDependency(registration3, path), Throws.Nothing);
}
public void GetCopyWithoutName_copies_service_type(Type type, string name, ResolutionPath path)
{
// Arrange
var sut = new ResolutionRequest(type, name, path);
// Act
var result = sut.GetCopyWithoutName();
// Assert
Assert.That(result.ServiceType, Is.SameAs(type));
}
public void Resolve_can_create_dictionary_of_instances_by_enum_values([Frozen, ResolvesToFailure] IResolver proxiedResolver,
[Frozen] IDictionaryFactory dictionaryFactory,
[Frozen] IServiceRegistrationProvider registrationProvider,
NamedInstanceDictionaryResolverProxy sut,
ResolutionRequest request,
SampleEnum[] names,
ResolutionPath path)
{
// Arrange
var serviceType = request.ServiceType;
var keyType = typeof(SampleEnum);
var valueType = typeof(ISampleService);
Mock.Get(dictionaryFactory)
.Setup(x => x.IsGenericDictionaryType(serviceType))
.Returns(true);
Mock.Get(dictionaryFactory)
.Setup(x => x.GetKeyType(serviceType))
.Returns(keyType);
Mock.Get(dictionaryFactory)
.Setup(x => x.GetValueType(serviceType))
.Returns(valueType);
Mock.Get(dictionaryFactory)
.Setup(x => x.Create(keyType, valueType))
.Returns(() => new Dictionary <SampleEnum, ISampleService>());
var registrations = names
.Select(x => x.ToString())
.Select(x => Mock.Of <IServiceRegistration>(r => r.Name == x && r.ServiceType == valueType))
.ToArray();
Mock.Get(registrationProvider)
.Setup(x => x.GetAll(valueType))
.Returns(registrations);
Mock.Get(proxiedResolver)
.Setup(x => x.Resolve(It.Is <ResolutionRequest>(r => r.ServiceType == valueType)))
.Returns((ResolutionRequest r) => ResolutionResult.Success(path, new SampleServiceImplementationOne()));
// Act
var result = sut.Resolve(request);
// Assert
Mock.Get(proxiedResolver)
.Verify(x => x.Resolve(It.Is <ResolutionRequest>(r => r.ServiceType == valueType)), Times.Exactly(names.Length));
foreach (var name in names.Select(x => x.ToString()).ToArray())
{
Mock.Get(proxiedResolver)
.Verify(x => x.Resolve(It.Is <ResolutionRequest>(r => r.Name == name)), Times.Once);
}
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.ResolvedObject, Is.InstanceOf <IDictionary <SampleEnum, ISampleService> >());
var resolvedObject = (IDictionary <SampleEnum, ISampleService>)result.ResolvedObject;
Assert.That(resolvedObject, Has.Count.EqualTo(names.Length));
}
public void ThrowOnCircularDependency_throws_exception_when_there_is_a_circular_dependency(IServiceRegistration registration1,
IServiceRegistration registration2,
IServiceRegistration registration3,
CircularDependencyDetector sut)
{
// Arrange
var path = new ResolutionPath(new [] { registration1, registration2, registration3 });
// Act & assert
Assert.That(() => sut.ThrowOnCircularDependency(registration2, path),
Throws.InstanceOf <CircularDependencyException>());
}
public void Contains_returns_false_for_type_and_name_when_path_does_not_contain_any_matching_types(IServiceRegistration registration,
string name)
{
// Arrange
Mock.Get(registration).SetupGet(x => x.ServiceType).Returns(typeof(string));
var sut = new ResolutionPath(registration);
// Act
var result = sut.Contains(typeof(int), name);
// Assert
Assert.That(result, Is.False);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:BoDi.Internal.DynamicResolutionObjectContainerProxy"/> class.
/// </summary>
/// <param name="proxiedContainer">The proxied container.</param>
/// <param name="resolutionPath">The resolution path up to the point at which this instance was resolved.</param>
public DynamicResolutionObjectContainerProxy(ObjectContainer proxiedContainer, ResolutionPath resolutionPath)
{
if (proxiedContainer == null)
{
throw new ArgumentNullException(nameof(proxiedContainer));
}
this.proxiedContainer = proxiedContainer;
this.resolutionPath = resolutionPath ?? new ResolutionPath();
exceptionTransformer = new ExceptionTransformer();
proxiedContainer.ObjectCreated += InvokeObjectCreated;
}
public void HasCircularDependency_returns_true_when_there_is_a_circular_dependency(IServiceRegistration registration1,
IServiceRegistration registration2,
IServiceRegistration registration3,
CircularDependencyDetector sut)
{
// Arrange
var path = new ResolutionPath(new [] { registration1, registration2, registration3 });
// Act
var result = sut.HasCircularDependency(registration2, path);
// Assert
Assert.That(result, Is.True);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:CSF.FlexDi.Resolution.Proxies.ServiceResolvingContainerProxy"/> class.
/// </summary>
/// <param name="proxiedResolver">Proxied resolver.</param>
/// <param name="resolutionPath">Resolution path.</param>
public ServiceResolvingContainerProxy(IContainer proxiedResolver, ResolutionPath resolutionPath)
{
if (resolutionPath == null)
{
throw new ArgumentNullException(nameof(resolutionPath));
}
if (proxiedResolver == null)
{
throw new ArgumentNullException(nameof(proxiedResolver));
}
this.resolutionPath = resolutionPath;
this.proxiedResolver = proxiedResolver;
}
public void Contains_returns_true_for_type_and_name_when_request_has_no_name(IServiceRegistration registration,
string name)
{
// Arrange
Mock.Get(registration).SetupGet(x => x.ServiceType).Returns(typeof(string));
Mock.Get(registration).SetupGet(x => x.Name).Returns(name);
var sut = new ResolutionPath(registration);
// Act
var result = sut.Contains(typeof(string));
// Assert
Assert.That(result, Is.True);
}
public void Contains_returns_false_for_type_and_name_when_registration_in_path_has_different_name(IServiceRegistration registration,
string name,
string otherName)
{
// Arrange
Mock.Get(registration).SetupGet(x => x.ServiceType).Returns(typeof(string));
Mock.Get(registration).SetupGet(x => x.Name).Returns(name);
var sut = new ResolutionPath(registration);
// Act
var result = sut.Contains(typeof(string), otherName);
// Assert
Assert.That(result, Is.False);
}
public void Contains_returns_true_for_registration_when_registration_in_path_matches(IServiceRegistration registration1,
IServiceRegistration registration2,
string name)
{
// Arrange
Mock.Get(registration1).SetupGet(x => x.ServiceType).Returns(typeof(string));
Mock.Get(registration1).SetupGet(x => x.Name).Returns(name);
Mock.Get(registration2).SetupGet(x => x.ServiceType).Returns(typeof(string));
Mock.Get(registration2).SetupGet(x => x.Name).Returns(name);
var sut = new ResolutionPath(registration1);
// Act
var result = sut.Contains(registration2);
// Assert
Assert.That(result, Is.True);
}
public void Resolve_calls_throw_on_circular_dependency_from_detector_service(IDetectsCircularDependencies detector,
[ResolvesToFailure] IResolver proxiedResolver,
ResolutionPath path,
[Registration] IServiceRegistration registration)
{
// Arrange
var request = new ResolutionRequest(typeof(ISampleService), path);
Mock.Get(proxiedResolver).Setup(x => x.GetRegistration(request)).Returns(registration);
var sut = new CircularDependencyPreventingResolverProxy(proxiedResolver, detector);
// Act
sut.Resolve(request);
// Assert
Mock.Get(detector).Verify(x => x.ThrowOnCircularDependency(registration, path), Times.Once);
}
public void Resolve_gets_registered_name_when_request_is_for_registeredName([Frozen, ResolvesToFailure] IResolver proxiedResolver,
RegisteredNameInjectingResolverProxy sut,
IServiceRegistration currentReg,
string registeredName)
{
// Arrange
var path = new ResolutionPath(currentReg);
var request = new ResolutionRequest(typeof(string), "registeredName", path);
Mock.Get(currentReg).SetupGet(x => x.Name).Returns(registeredName);
// Act
var result = sut.Resolve(request);
// Assert
Mock.Get(proxiedResolver).Verify(x => x.Resolve(request), Times.Never);
Assert.That(result.ResolvedObject, Is.EqualTo(registeredName));
}
public void Contains_returns_false_for_typed_registration_when_impl_types_differ(TypedRegistration registration1,
TypedRegistration registration2,
string name)
{
// Arrange
Mock.Get(registration1).SetupGet(x => x.ServiceType).Returns(typeof(string));
Mock.Get(registration1).SetupGet(x => x.ImplementationType).Returns(typeof(string));
Mock.Get(registration1).SetupGet(x => x.Name).Returns(name);
Mock.Get(registration2).SetupGet(x => x.ServiceType).Returns(typeof(string));
Mock.Get(registration2).SetupGet(x => x.ImplementationType).Returns(typeof(int));
Mock.Get(registration2).SetupGet(x => x.Name).Returns(name);
var sut = new ResolutionPath(registration1);
// Act
var result = sut.Contains(registration2);
// Assert
Assert.That(result, Is.False);
}
public void Resolve_returns_result_from_proxy_when_resolution_is_successful([Frozen, ResolvesToFailure] IResolver proxiedResolver,
UnregisteredServiceResolverProxy sut,
ResolutionRequest request,
ResolutionPath path,
object resolved)
{
// Arrange
var successResult = ResolutionResult.Success(path, resolved);
Mock.Get(proxiedResolver)
.Setup(x => x.Resolve(request))
.Returns(successResult);
// Act
var result = sut.Resolve(request);
// Assert
Assert.That(result, Is.SameAs(successResult));
}
public void Resolve_does_not_add_anything_to_the_cache_if_resolution_fails(IResolver proxiedResolver,
[Registration] IServiceRegistration registration,
ICachesResolvedServiceInstances cache,
ResolutionRequest request,
ResolutionPath resolutionPath)
{
// Arrange
object cachedItem = null;
Mock.Get(proxiedResolver).Setup(x => x.GetRegistration(request)).Returns(registration);
Mock.Get(proxiedResolver).Setup(x => x.Resolve(request)).Returns(ResolutionResult.Failure(resolutionPath));
Mock.Get(cache).Setup(x => x.TryGet(registration, out cachedItem)).Returns(false);
var sut = new CachingResolverProxy(proxiedResolver, cache);
// Act
var result = sut.Resolve(request);
// Assert
Mock.Get(cache).Verify(x => x.Add(registration, It.IsAny <object>()), Times.Never);
}
public void Resolve_adds_item_from_proxied_resolver_to_the_cache(IResolver proxiedResolver,
[Registration] IServiceRegistration registration,
ICachesResolvedServiceInstances cache,
ResolutionRequest request,
ISampleService resolved,
ResolutionPath resolutionPath)
{
// Arrange
object cachedItem = null;
Mock.Get(proxiedResolver).Setup(x => x.GetRegistration(request)).Returns(registration);
Mock.Get(proxiedResolver).Setup(x => x.Resolve(request)).Returns(ResolutionResult.Success(resolutionPath, resolved));
Mock.Get(cache).Setup(x => x.TryGet(registration, out cachedItem)).Returns(false);
var sut = new CachingResolverProxy(proxiedResolver, cache);
// Act
var result = sut.Resolve(request);
// Assert
Mock.Get(cache).Verify(x => x.Add(registration, resolved), Times.Once);
}
public void Resolve_resolves_from_proxied_resolver_if_item_is_not_cached(IResolver proxiedResolver,
[Registration] IServiceRegistration registration,
ICachesResolvedServiceInstances cache,
ResolutionRequest request,
ISampleService resolved,
ResolutionPath resolutionPath)
{
// Arrange
object cachedItem = null;
Mock.Get(proxiedResolver).Setup(x => x.GetRegistration(request)).Returns(registration);
Mock.Get(proxiedResolver).Setup(x => x.Resolve(request)).Returns(ResolutionResult.Success(resolutionPath, resolved));
Mock.Get(cache).Setup(x => x.TryGet(registration, out cachedItem)).Returns(false);
var sut = new CachingResolverProxy(proxiedResolver, cache);
// Act
var result = sut.Resolve(request);
// Assert
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.ResolvedObject, Is.SameAs(resolved));
}
public void GetCopyWithoutName_does_not_copy_the_name(Type type, string name, ResolutionPath path)
{
// Arrange
var sut = new ResolutionRequest(type, name, path);
// Act
var result = sut.GetCopyWithoutName();
// Assert
Assert.That(result.Name, Is.Null);
}
object CreateInstance(IFactoryAdapter adapter, ResolutionPath path, IServiceRegistration registration) => adapter.Execute(new object[0]);
public void CreateFromFactory_executes_factory_if_it_does_not_need_parameter_resolution([Frozen] IFulfilsResolutionRequests resolver,
InstanceCreator sut,
IFactoryAdapter factory,
ResolutionPath path,
IServiceRegistration registration,
object resolved)
{
// Arrange
Mock.Get(factory).SetupGet(x => x.RequiresParameterResolution).Returns(false);
Mock.Get(factory).Setup(x => x.Execute(It.Is <object[]>(e => e.Length == 0))).Returns(resolved);
// Act
var result = sut.CreateFromFactory(factory, path, registration);
// Assert
Mock.Get(factory).Verify(x => x.Execute(It.Is <object[]>(e => e.Length == 0)), Times.Once);
Assert.That(result, Is.SameAs(resolved));
}
public void Resolve_resolves_unregistered_service_when_resolution_is_unsuccesful([Frozen, ResolvesToFailure] IResolver proxiedResolver,
[Frozen] IResolvesRegistrations registrationResolver,
[Frozen] IServiceRegistrationProvider unregisteredRegistrationProvider,
UnregisteredServiceResolverProxy sut,
ResolutionPath path,
ResolutionRequest request,
ResolutionResult resolutionResult,
IServiceRegistration registration)
{
// Arrange
Mock.Get(proxiedResolver)
.Setup(x => x.Resolve(request))
.Returns(ResolutionResult.Failure(path));
Mock.Get(unregisteredRegistrationProvider)
.Setup(x => x.Get(request))
.Returns(registration);
Mock.Get(registrationResolver)
.Setup(x => x.Resolve(request, registration))
.Returns(resolutionResult);
// Act
var result = sut.Resolve(request);
// Assert
Assert.That(result, Is.SameAs(resolutionResult));
}
public void Resolve_does_not_use_fallback_resolver_if_primary_resolver_returns_success_result([ResolvesToFailure] IResolver primaryResolver,
[ResolvesToFailure] IResolver fallbackResolver,
ResolutionRequest request,
ResolutionPath path,
object resolved)
{
// Arrange
var sut = new FallbackResolverProxy(primaryResolver, fallbackResolver);
Mock.Get(primaryResolver)
.Setup(x => x.Resolve(request))
.Returns(ResolutionResult.Success(path, resolved));
// Act
sut.Resolve(request);
// Assert
Mock.Get(primaryResolver).Verify(x => x.Resolve(request), Times.Once);
Mock.Get(fallbackResolver).Verify(x => x.Resolve(request), Times.Never);
}
