public void GetCurrent_WithoutLocatorProvider_ReturnsConfiguredServiceLocator_WithBootstrapConfigurationEntries()
{
ServiceLocator.SetLocatorProvider(null);
var entry1 = new ServiceConfigurationEntry(
typeof(IService1),
new ServiceImplementationInfo(typeof(Service1), LifetimeKind.InstancePerDependency));
var entry2 = new ServiceConfigurationEntry(
typeof(IService2),
new ServiceImplementationInfo(typeof(Service2), LifetimeKind.InstancePerDependency));
SafeServiceLocator.BootstrapConfiguration.Register(entry1);
SafeServiceLocator.BootstrapConfiguration.Register(entry2);
var serviceLocatorProviderMock = MockRepository.GenerateStrictMock <IServiceLocatorProvider> ();
var fakeServiceLocator = MockRepository.GenerateStub <IServiceLocator>();
serviceLocatorProviderMock
.Expect(mock => mock.GetServiceLocator(Arg <ReadOnlyCollection <ServiceConfigurationEntry> > .List.Equal(new[] { entry1, entry2 })))
.Return(fakeServiceLocator);
ConfigureServiceLocatorProvider(serviceLocatorProviderMock);
var result = SafeServiceLocator.Current;
serviceLocatorProviderMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeServiceLocator));
}
public void GetInstance_DecoratedCompound_DecoratesCompound_DoesNotDecorateImplementations()
{
var implementation1 = new ServiceImplementationInfo(typeof(TestImplementation1), LifetimeKind.InstancePerDependency, RegistrationType.Multiple);
var implementation2 = new ServiceImplementationInfo(typeof(TestImplementation2), LifetimeKind.InstancePerDependency, RegistrationType.Multiple);
var decorator = new ServiceImplementationInfo(typeof(TestDecorator1), LifetimeKind.InstancePerDependency, RegistrationType.Decorator);
var compound = new ServiceImplementationInfo(typeof(TestCompound), LifetimeKind.InstancePerDependency, RegistrationType.Compound);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), implementation1, implementation2, decorator, compound);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
var instance = serviceLocator.GetInstance(typeof(ITestType));
Assert.That(instance, Is.TypeOf <TestDecorator1>());
var decoratorInstance = (TestDecorator1)instance;
Assert.That(decoratorInstance.DecoratedObject, Is.TypeOf <TestCompound>());
var compoundInstance = (TestCompound)decoratorInstance.DecoratedObject;
Assert.That(compoundInstance.InnerObjects, Is.Not.Empty);
Assert.That(
compoundInstance.InnerObjects.Select(i => i.GetType()),
Is.EqualTo(new[] { typeof(TestImplementation1), typeof(TestImplementation2) }));
}
public void CreateFromAttributes_Multiple_EntriesAreSortedCorrectly()
{
var attribute1 = Tuple.Create(
typeof(TestMultipleConcreteImplementationAttributesType1),
new ImplementationForAttribute(typeof(ITestMultipleConcreteImplementationAttributesType))
{
Lifetime = LifetimeKind.Singleton, Position = 0
});
var attribute2 = Tuple.Create(
typeof(TestMultipleConcreteImplementationAttributesType2),
new ImplementationForAttribute(typeof(ITestMultipleConcreteImplementationAttributesType))
{
Lifetime = LifetimeKind.InstancePerDependency, Position = -1
});
var attributes = new[] { attribute1, attribute2 };
var entry = ServiceConfigurationEntry.CreateFromAttributes(typeof(ITestMultipleConcreteImplementationAttributesType), attributes);
Assert.That(entry.ServiceType, Is.EqualTo(typeof(ITestMultipleConcreteImplementationAttributesType)));
Assert.That(entry.ImplementationInfos.Count, Is.EqualTo(2));
Assert.That(entry.ImplementationInfos[0].ImplementationType, Is.EqualTo(typeof(TestMultipleConcreteImplementationAttributesType2)));
Assert.That(entry.ImplementationInfos[0].Lifetime, Is.EqualTo(LifetimeKind.InstancePerDependency));
Assert.That(entry.ImplementationInfos[1].ImplementationType, Is.EqualTo(typeof(TestMultipleConcreteImplementationAttributesType1)));
Assert.That(entry.ImplementationInfos[1].Lifetime, Is.EqualTo(LifetimeKind.Singleton));
}
public override void OnActionExecuting(System.Web.Mvc.ActionExecutingContext filterContext)
{
if (!this.Required)
{
return;
}
if (this.MobiContext.Service.ServiceData.ServiceStatus == MobiChat.Data.ServiceStatus.Free)
{
return;
}
else if (this.MobiContext.Service.ServiceData.ServiceStatus == MobiChat.Data.ServiceStatus.Offline)
{
Log.Error("Service status is offline.");
filterContext.Result = this.ErrorView();
return;
}
else if (this.MobiContext.Service.ServiceData.ServiceStatus == MobiChat.Data.ServiceStatus.Updating)
{
Log.Error("Service is updating.");
filterContext.Result = this.ErrorView();
return;
}
ServiceConfigurationEntry sce = this.MobiContext.GetConfiguration();
if (sce.IsAgeVerificationRequired)
{
filterContext.Result = this.AvsView(filterContext);
return;
}
return;
}
public void CreateFromAttributes_IncompatibleType()
{
var attribute = Tuple.Create(typeof(object), new ImplementationForAttribute(typeof(ITestSingletonConcreteImplementationAttributeType)));
Assert.That(
() => ServiceConfigurationEntry.CreateFromAttributes(typeof(ITestSingletonConcreteImplementationAttributeType), new[] { attribute }),
Throws.InvalidOperationException.With.Message.EqualTo("The implementation type 'System.Object' does not implement the service type."));
}
public void Initialize_WithSingleInfo()
{
var implementationInfo = new ServiceImplementationInfo(typeof(TestConcreteImplementationAttributeType), LifetimeKind.Singleton);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestSingletonConcreteImplementationAttributeType), implementationInfo);
Assert.That(serviceConfigurationEntry.ServiceType, Is.EqualTo(typeof(ITestSingletonConcreteImplementationAttributeType)));
Assert.That(serviceConfigurationEntry.ImplementationInfos, Is.EqualTo(new[] { implementationInfo }));
}
public void GetServiceLocator_IncludesBootstrapConfiguration()
{
var entry = new ServiceConfigurationEntry(typeof(IService), new ServiceImplementationInfo(typeof(Service), LifetimeKind.InstancePerDependency));
var sloc = _provider.GetServiceLocator(Array.AsReadOnly(new[] { entry }));
Assert.That(sloc, Is.TypeOf <DefaultServiceLocator> ());
Assert.That(sloc.GetInstance <IService>(), Is.Not.Null.And.TypeOf <Service>());
}
public void Register_ServiceConfigurationEntry_AddsEntryToRegistrations_AndToBootstrapLocator()
{
var entry = new ServiceConfigurationEntry(typeof(IService), new ServiceImplementationInfo(typeof(Service), LifetimeKind.Singleton));
_configuration.Register(entry);
Assert.That(_configuration.Registrations, Is.EqualTo(new[] { entry }));
Assert.That(_configuration.BootstrapServiceLocator.GetInstance <IService>(), Is.Not.Null.And.TypeOf <Service>());
}
public void ToString_TwoEntries()
{
var entry = new ServiceConfigurationEntry(
typeof(IComparable),
new ServiceImplementationInfo(typeof(int), LifetimeKind.Singleton, RegistrationType.Single),
new ServiceImplementationInfo(typeof(string), LifetimeKind.InstancePerDependency, RegistrationType.Decorator));
Assert.That(entry.ToString(), Is.EqualTo(
"System.IComparable implementations: [{System.Int32, Singleton, Single}, {System.String, InstancePerDependency, Decorator}]"));
}
public void Initialize_WithEnumerable()
{
var info1 = new ServiceImplementationInfo(typeof(TestConcreteImplementationAttributeType), LifetimeKind.Singleton);
var info2 = new ServiceImplementationInfo(typeof(TestConcreteImplementationAttributeType), LifetimeKind.Singleton);
var entry = new ServiceConfigurationEntry(typeof(ITestSingletonConcreteImplementationAttributeType), new[] { info1, info2 });
Assert.That(entry.ServiceType, Is.EqualTo(typeof(ITestSingletonConcreteImplementationAttributeType)));
Assert.That(entry.ImplementationInfos, Is.EqualTo(new[] { info1, info2 }));
}
public void Register_SingleAndMultipleImplementations_ThrowsInvalidOperationException()
{
var single = new ServiceImplementationInfo(typeof(TestImplementation1), LifetimeKind.InstancePerDependency, RegistrationType.Single);
var multiple = new ServiceImplementationInfo(typeof(TestImplementation2), LifetimeKind.InstancePerDependency, RegistrationType.Multiple);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), single, multiple);
var serviceLocator = CreateServiceLocator();
Assert.That(
() => serviceLocator.Register(serviceConfigurationEntry),
Throws.InvalidOperationException.With.Message.EqualTo(
"Service type 'Remotion.UnitTests.ServiceLocation.DefaultServiceLocatorTests.TestDomain.ITestType': "
+ "Registrations of type 'Single' and 'Multiple' are mutually exclusive."));
}
public void Register_SingleWithMultipleRegistrations_ThrowsInvalidOperationException()
{
var implementation1 = new ServiceImplementationInfo(typeof(TestImplementation1), LifetimeKind.InstancePerDependency, RegistrationType.Single);
var implementation2 = new ServiceImplementationInfo(typeof(TestImplementation2), LifetimeKind.InstancePerDependency, RegistrationType.Single);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), implementation1, implementation2);
var serviceLocator = CreateServiceLocator();
Assert.That(
() => serviceLocator.Register(serviceConfigurationEntry),
Throws.InvalidOperationException.With.Message.EqualTo(
"Cannot register multiple implementations with registration type 'Single' "
+ "for service type 'Remotion.UnitTests.ServiceLocation.DefaultServiceLocatorTests.TestDomain.ITestType'."));
}
public void Register_ServiceConfigurationEntry_IfLocatorThrows_NoRegistrationIsAdded()
{
// This causes the association between IServiceWithAttribute and ServiceWithAttribute1 to be stored in the BootstrapServiceLocator, so it will
// later throw on Register.
_configuration.BootstrapServiceLocator.GetInstance <IServiceWithAttribute>();
var entry = new ServiceConfigurationEntry(
typeof(IServiceWithAttribute),
new ServiceImplementationInfo(typeof(ServiceWithAttribute2), LifetimeKind.Singleton));
Assert.That(() => _configuration.Register(entry), Throws.InvalidOperationException);
Assert.That(_configuration.Registrations, Is.Empty);
Assert.That(_configuration.BootstrapServiceLocator.GetInstance <IServiceWithAttribute> (), Is.Not.Null.And.TypeOf <ServiceWithAttribute1> ());
}
public void GetInstance_ServiceTypeWithFactoryReturningNull_ThrowsActivationException()
{
var implementation = ServiceImplementationInfo.CreateSingle <ITestTypeWithErrors> (() => null);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestTypeWithErrors), implementation);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
Assert.That(
() => serviceLocator.GetInstance(typeof(ITestTypeWithErrors)),
Throws.TypeOf <ActivationException> ().With.Message.EqualTo(
"The registered factory returned null instead of an instance implementing the requested service type "
+ "'Remotion.UnitTests.ServiceLocation.DefaultServiceLocatorTests.TestDomain.ITestTypeWithErrors'."));
}
public void GetInstance_DecoratorIsInstance_ImplementationIsSingleton_DecoratorBehaveAsSingleton()
{
var implementation = new ServiceImplementationInfo(typeof(TestImplementation1), LifetimeKind.Singleton, RegistrationType.Single);
var decorator = new ServiceImplementationInfo(typeof(TestDecorator1), LifetimeKind.InstancePerDependency, RegistrationType.Decorator);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), implementation, decorator);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
var instance1 = serviceLocator.GetInstance(typeof(ITestType));
var instance2 = serviceLocator.GetInstance(typeof(ITestType));
Assert.That(instance1, Is.SameAs(instance2));
Assert.That(((TestDecorator1)instance1).DecoratedObject, Is.SameAs(((TestDecorator1)instance2).DecoratedObject));
}
public void GetInstance_CompoundIsSingleton_ImplementationIsInstancePerDependency_ImplementationsBehaveAsSingleton()
{
var compound = new ServiceImplementationInfo(typeof(TestCompound), LifetimeKind.Singleton, RegistrationType.Compound);
var implementation = new ServiceImplementationInfo(typeof(TestImplementation1), LifetimeKind.InstancePerDependency, RegistrationType.Multiple);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), compound, implementation);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
var instance1 = serviceLocator.GetInstance(typeof(ITestType));
var instance2 = serviceLocator.GetInstance(typeof(ITestType));
Assert.That(instance1, Is.SameAs(instance2));
Assert.That(((TestCompound)instance1).InnerObjects, Is.EqualTo(((TestCompound)instance2).InnerObjects));
}
public bool TryGetServiceConfiguration()
{
this._serviceConfigurationEntry = MobiContext.Current.Service.GetConfiguration(MobiContext.Current.Service.ServiceData.FallbackCountry, this._mobileOperator);
if (this._serviceConfigurationEntry == null)
{
this._serviceConfigurationEntry = MobiContext.Current.Service.GetConfiguration(MobiContext.Current.Service.ServiceData.FallbackCountry);
}
if (this._serviceConfigurationEntry == null)
{
Log.Error("SendMessageBase:: ServiceConfiguratioEtnry could not be loaded for " + this._service.Name);
this.Status = false;
this.Message = this.ErrorMessage;
return(true);
}
return(false);
}
public void GetAllInstances_WithMixedLifetimeKind_ReturnsSingletonAsSingletonAndInstanceAsInstance()
{
var implementation1 = new ServiceImplementationInfo(typeof(TestImplementation1), LifetimeKind.Singleton, RegistrationType.Multiple);
var implementation2 = new ServiceImplementationInfo(typeof(TestImplementation2), LifetimeKind.InstancePerDependency, RegistrationType.Multiple);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), implementation1, implementation2);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
var instances1 = serviceLocator.GetAllInstances(typeof(ITestType)).ToArray();
var instances2 = serviceLocator.GetAllInstances(typeof(ITestType)).ToArray();
Assert.That(instances1, Is.Not.SameAs(instances2));
Assert.That(instances1[0], Is.SameAs(instances2[0]));
Assert.That(instances1[1], Is.Not.SameAs(instances2[1]));
}
public void GetInstance_DecoratorIsSingleton_ImplementationIsInstancePerDependency_DecoratorBehaveAsInstance()
{
// Integration test to ensure behavior even if ctor-check in ServiceImplementationInfo is removed.
var implementation = new ServiceImplementationInfo(typeof(TestImplementation1), LifetimeKind.InstancePerDependency, RegistrationType.Single);
var decorator = new ServiceImplementationInfo(typeof(TestDecorator1), LifetimeKind.InstancePerDependency, RegistrationType.Decorator);
PrivateInvoke.SetNonPublicField(decorator, "_lifetime", LifetimeKind.Singleton);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), implementation, decorator);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
var instance1 = serviceLocator.GetInstance(typeof(ITestType));
var instance2 = serviceLocator.GetInstance(typeof(ITestType));
Assert.That(instance1, Is.Not.SameAs(instance2));
Assert.That(((TestDecorator1)instance1).DecoratedObject, Is.Not.SameAs(((TestDecorator1)instance2).DecoratedObject));
}
public void GetInstance_ImplementationIsRegisteredAsFactoryWithSingletonLifetime_AndSingletonIsLazyInitialized()
{
TestImplementation1 expectedInstance = null;
var serviceImplementation = ServiceImplementationInfo.CreateSingle(() => expectedInstance = new TestImplementation1(), LifetimeKind.Singleton);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), serviceImplementation);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
Assert.That(expectedInstance, Is.Null);
var instance1 = serviceLocator.GetInstance(typeof(ITestType));
Assert.That(expectedInstance, Is.Not.Null);
var instance2 = serviceLocator.GetInstance(typeof(ITestType));
Assert.That(instance1, Is.SameAs(instance2));
}
public void CreateFromAttributes_Single()
{
var attribute = new ImplementationForAttribute(typeof(ITestSingletonConcreteImplementationAttributeType))
{
Lifetime = LifetimeKind.Singleton
};
var entry = ServiceConfigurationEntry.CreateFromAttributes(
typeof(ITestSingletonConcreteImplementationAttributeType),
new[]
{
Tuple.Create(typeof(TestConcreteImplementationAttributeType), attribute)
});
Assert.That(entry.ServiceType, Is.EqualTo(typeof(ITestSingletonConcreteImplementationAttributeType)));
Assert.That(entry.ImplementationInfos.Count, Is.EqualTo(1));
Assert.That(entry.ImplementationInfos[0].ImplementationType, Is.EqualTo(typeof(TestConcreteImplementationAttributeType)));
Assert.That(entry.ImplementationInfos[0].Lifetime, Is.EqualTo(LifetimeKind.Singleton));
}
public void GetAllInstances_ImplementationIsRegisteredAsFactoryWithInstanceLifetime()
{
TestImplementation1 expectedInstance = null;
var serviceImplementation = ServiceImplementationInfo.CreateMultiple(
() => expectedInstance = new TestImplementation1(),
LifetimeKind.InstancePerDependency);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), serviceImplementation);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
var instance1 = serviceLocator.GetAllInstances(typeof(ITestType)).SingleOrDefault();
Assert.That(expectedInstance, Is.Not.Null);
var instance2 = serviceLocator.GetAllInstances(typeof(ITestType)).SingleOrDefault();
Assert.That(instance1, Is.Not.SameAs(instance2));
}
public void GetInstance_WithFactoryReturningWrongType_ThrowsActivationException()
{
Func <ITestType> factory = () => new TestImplementation1();
Func <object> factoryAsObject = factory;
var implementation = ServiceImplementationInfo.CreateSingle <ITestTypeWithErrors> (() => null);
PrivateInvoke.SetNonPublicField(implementation, "_factory", factoryAsObject);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestTypeWithErrors), implementation);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
Assert.That(
() => serviceLocator.GetInstance(typeof(ITestTypeWithErrors)),
Throws.TypeOf <ActivationException>().With.Message.EqualTo(
"The instance returned by the registered factory does not implement the requested type "
+ "'Remotion.UnitTests.ServiceLocation.DefaultServiceLocatorTests.TestDomain.ITestTypeWithErrors'. "
+ "(Instance type: 'Remotion.UnitTests.ServiceLocation.DefaultServiceLocatorTests.TestDomain.TestImplementation1'.)"));
}
public void Register_CompoundWithMultipleRegistrations_ThrowsInvalidOperationException()
{
var compound1 = new ServiceImplementationInfo(
typeof(TestCompoundWithMultipleRegistrations1),
LifetimeKind.InstancePerDependency,
RegistrationType.Compound);
var compound2 = new ServiceImplementationInfo(
typeof(TestCompoundWithMultipleRegistrations2),
LifetimeKind.InstancePerDependency,
RegistrationType.Compound);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestCompoundWithErrors), compound1, compound2);
var serviceLocator = CreateServiceLocator();
Assert.That(
() => serviceLocator.Register(serviceConfigurationEntry),
Throws.InvalidOperationException.With.Message.EqualTo(
"Cannot register multiple implementations with registration type 'Compound' "
+ "for service type 'Remotion.UnitTests.ServiceLocation.DefaultServiceLocatorTests.TestDomain.ITestCompoundWithErrors'."));
}
public void Initialization_AndDispose_ServiceLocator_ServiceConfigurationEntries()
{
ServiceLocator.SetLocatorProvider(() => _locator1);
Assert.That(ServiceLocator.Current, Is.SameAs(_locator1));
var entry1 = new ServiceConfigurationEntry(typeof(object), new ServiceImplementationInfo(typeof(DomainType1), LifetimeKind.InstancePerDependency));
var entry2 = new ServiceConfigurationEntry(typeof(IFormattable), new ServiceImplementationInfo(typeof(DomainType2), LifetimeKind.Singleton));
using (new ServiceLocatorScope(entry1, entry2))
{
Assert.That(ServiceLocator.Current, Is.Not.SameAs(_locator1));
Assert.That(ServiceLocator.Current, Is.TypeOf <DefaultServiceLocator> ());
Assert.That(ServiceLocator.Current.GetInstance(typeof(object)), Is.TypeOf <DomainType1> ());
Assert.That(ServiceLocator.Current.GetInstance(typeof(object)), Is.Not.SameAs(ServiceLocator.Current.GetInstance(typeof(object))));
Assert.That(ServiceLocator.Current.GetInstance(typeof(IFormattable)), Is.TypeOf <DomainType2> ());
Assert.That(ServiceLocator.Current.GetInstance(typeof(IFormattable)), Is.SameAs(ServiceLocator.Current.GetInstance(typeof(IFormattable))));
}
Assert.That(ServiceLocator.Current, Is.SameAs(_locator1));
}
public void CreateFromAttributes_EqualPositions_DifferentRegistrationTypes()
{
var attribute1 = Tuple.Create(
typeof(TestMultipleConcreteImplementationAttributesType1),
new ImplementationForAttribute(typeof(ITestMultipleConcreteImplementationAttributesType))
{
Lifetime = LifetimeKind.Singleton, Position = 1, RegistrationType = RegistrationType.Compound
});
var attribute2 = Tuple.Create(
typeof(TestMultipleConcreteImplementationAttributesType2),
new ImplementationForAttribute(typeof(ITestMultipleConcreteImplementationAttributesType))
{
Lifetime = LifetimeKind.InstancePerDependency, Position = 1, RegistrationType = RegistrationType.Multiple
});
var attributes = new[] { attribute1, attribute2 };
ServiceConfigurationEntry.CreateFromAttributes(typeof(ITestMultipleConcreteImplementationAttributesType), attributes);
}
public void GetInstance_ImplementationIsRegisteredAsFactoryWithSingletonLifetime_DecoratedFactoryIsUsed()
{
TestImplementation1 expectedInstance = null;
var implementation = ServiceImplementationInfo.CreateSingle(() => expectedInstance = new TestImplementation1(), LifetimeKind.Singleton);
var decorator = new ServiceImplementationInfo(typeof(TestDecorator1), LifetimeKind.InstancePerDependency, RegistrationType.Decorator);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), implementation, decorator);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
var instance1 = serviceLocator.GetInstance(typeof(ITestType));
Assert.That(expectedInstance, Is.Not.Null);
Assert.That(((TestDecorator1)instance1).DecoratedObject, Is.SameAs(expectedInstance));
var instance2 = serviceLocator.GetInstance(typeof(ITestType));
Assert.That(instance1, Is.SameAs(instance2));
Assert.That(((TestDecorator1)instance1).DecoratedObject, Is.SameAs(((TestDecorator1)instance2).DecoratedObject));
}
public void GetAllInstances_DecoratesImplementations()
{
var implementation1 = new ServiceImplementationInfo(typeof(TestImplementation1), LifetimeKind.InstancePerDependency, RegistrationType.Multiple);
var implementation2 = new ServiceImplementationInfo(typeof(TestImplementation2), LifetimeKind.InstancePerDependency, RegistrationType.Multiple);
var decorator = new ServiceImplementationInfo(typeof(TestDecorator1), LifetimeKind.InstancePerDependency, RegistrationType.Decorator);
var serviceConfigurationEntry = new ServiceConfigurationEntry(typeof(ITestType), implementation1, implementation2, decorator);
var serviceLocator = CreateServiceLocator();
serviceLocator.Register(serviceConfigurationEntry);
var instances = serviceLocator.GetAllInstances(typeof(ITestType)).ToArray();
Assert.That(instances, Has.All.TypeOf <TestDecorator1>());
var decoratorInstance1 = (TestDecorator1)instances[0];
Assert.That(decoratorInstance1.DecoratedObject, Is.TypeOf <TestImplementation1>());
var decoratorInstance2 = (TestDecorator1)instances[1];
Assert.That(decoratorInstance2.DecoratedObject, Is.TypeOf <TestImplementation2>());
}
public ServiceConfigurationEntry GetConfiguration(Data.Country country, Data.MobileOperator mobileOperator)
{
ServiceConfigurationEntry sce = null;
if (mobileOperator == null)
{
if (this._countryConfigurationEntryMap.ContainsKey(country.ID))
{
return(this._countryConfigurationEntryMap[country.ID]);
}
sce = ServiceConfigurationEntry.CreateManager().Load(this._serviceData, country);
if (sce != null)
{
this._countryConfigurationEntryMap.Add(country.ID, sce);
}
return(sce);
}
else
{
return(ServiceConfigurationEntry.CreateManager().Load(this._serviceData, country, mobileOperator));
}
}
public void Initialize_WithEnumerable_Empty()
{
var entry = new ServiceConfigurationEntry(typeof(ITestSingletonConcreteImplementationAttributeType), new ServiceImplementationInfo[0]);
Assert.That(entry.ImplementationInfos, Is.Empty);
}
