public void RegisterSingleton_ShouldRegisterOnlyOwnComponents()
{
// Arrange
var typesProvider = Substitute.For <ITypesProvider>();
typesProvider.GetTypes().Returns(new[] { typeof(TransientNotSingletonClass).GetTypeInfo(), typeof(SingletonNotTransientClass).GetTypeInfo() });
var serviceRegistrator = new ServiceRegistrator(typesProvider);
var singletonsCount = 0;
var transientCount = 0;
void RegisterStub(Type toImplement, Type implementation)
{
if (implementation == typeof(SingletonNotTransientClass) && toImplement == typeof(SingletonNotTransientClass))
{
singletonsCount++;
}
if (implementation == typeof(TransientNotSingletonClass) && toImplement == typeof(TransientNotSingletonClass))
{
transientCount++;
}
}
// Act
Register(serviceRegistrator, RegisterStub, RegisterMethod.Singleton);
// Assert
Assert.Multiple(() =>
{
Assert.That(singletonsCount, Is.EqualTo(1));
Assert.That(transientCount, Is.EqualTo(0));
});
}
private void FindAndRegister(params Type[] types)
{
ITypeFinder finder = new Fakes.FakeTypeFinder(types);
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
}
// Entry point for the application.
public static void Main(string[] args)
{
IConfiguration config = ServiceBootstrapper.BuildConfiguration(args, ServiceBootstrapper.BuildConfigurationOptions.RandomizeUrls);
IApplication app = ServiceBootstrapper.StartApplication(config);
ILogger logger = app.Services.GetService <ILogger <Startup> >();
logger.LogInformation("Started the server...");
logger.LogInformation($"Now listening on: {config["server.urls"]}");
logger.LogInformation("Application started.Press Ctrl + C to shut down.");
var registrator = new ServiceRegistrator(config);
registrator.RegisterOperationService("1.0").ContinueWith(task =>
{
if (task.Status == TaskStatus.RanToCompletion)
{
logger.LogInformation($"Service operation 1.0 registered with url {registrator.Url}");
}
else
{
logger.LogCritical($"Failed to register service operation 1.0 with url {registrator.Url}", task.Exception);
}
});
using (WaitHandle handle = ServiceBootstrapper.DisposeOnInterupt(app))
{
handle.WaitOne();
}
}
public TinyCrmFixture()
{
Container = ServiceRegistrator
.GetContainer()
.BeginLifetimeScope();
DbContext = Container.Resolve <TinyCrmDbContext>();
}
private StashboxContainer(ExpressionFactory expressionFactory, ServiceRegistrator serviceRegistrator,
RegistrationBuilder registrationBuilder, ContainerConfigurator containerConfigurator, Action <ContainerConfigurator> config = null)
{
this.expressionFactory = expressionFactory;
this.containerConfigurator = containerConfigurator;
this.serviceRegistrator = serviceRegistrator;
this.registrationBuilder = registrationBuilder;
config?.Invoke(this.containerConfigurator);
}
public void NestedNewServices_AreFound()
{
var finder = TestSupport.TypeFinder();
var registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
container.Resolve <OuterService2.InnerService>().ShouldNotBe(null);
}
public void InternalServices_AreFound()
{
var finder = TestSupport.TypeFinder();
var registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
container.Resolve <IInternalService>().ShouldBeTypeOf <InternalService>();
}
public void ResolveAll_WithTypeArgument_GivesAnArray_OfTheRequestedArrayType()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
var services = container.ResolveAll(typeof(IBarometer));
Assert.That(services, Is.InstanceOf <IBarometer[]>());
}
public void CanResolve_MultipleServices()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
var services = container.ResolveAll <IBarometer>();
Assert.That(services.Count(), Is.EqualTo(2));
}
private StashboxContainer(IStashboxContainer parentContainer, ServiceRegistrator serviceRegistrator,
RegistrationBuilder registrationBuilder, ResolutionStrategy resolutionStrategy, ExpressionFactory expressionFactory,
ExpressionBuilder expressionBuilder, ContainerConfigurator containerConfigurator, Action <ContainerConfigurator> config = null)
: this(expressionFactory, serviceRegistrator, registrationBuilder, containerConfigurator, config)
{
this.resolutionStrategy = resolutionStrategy;
this.expressionBuilder = expressionBuilder;
this.ContainerContext = new ContainerContext(parentContainer.ContainerContext, resolutionStrategy,
expressionFactory, this.containerConfigurator.ContainerConfiguration);
}
public void Services_AreAdded_ToTheContainer()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(SelfService), typeof(NonAttributed));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
Assert.That(container.Resolve <SelfService>(), Is.InstanceOf <SelfService>());
Assert.That(new TestDelegate(() => container.Resolve <NonAttributed>()), Throws.Exception);
}
public void Services_CanOverride_OtherServices_ByServiceType()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(ReplacedService), typeof(ReplacingReplacedService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FilterServices(registrator.FindServices()));
Assert.That(container.Resolve <IReplacedInterface>(), Is.InstanceOf <ReplacingReplacedService>());
Assert.That(container.ResolveAll <IReplacedInterface>().Count(), Is.EqualTo(1));
}
public void Requesting_NoConfigurations_DoesntResolveServices_ThatUsesConfigurations()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
var services = registrator.FilterServices(registrator.FindServices());
registrator.RegisterServices(services);
Assert.That(container.ResolveAll <IBarometer>().Count(), Is.EqualTo(0));
}
public void GenericServices_CanBeResolved_ByServiceInterface()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(GenericInterfacedService <>));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
Assert.That(container.Resolve <IGenericService <int> >(), Is.InstanceOf <GenericInterfacedService <int> >());
Assert.That(container.Resolve <IGenericService <string> >(), Is.InstanceOf <GenericInterfacedService <string> >());
}
public void Requesting_MultipleConfigurations_GivesAllMatchingServices()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
var services = registrator.FilterServices(registrator.FindServices(), "High", "Medium", "Low");
registrator.RegisterServices(services);
Assert.That(container.ResolveAll <IBarometer>().Count(), Is.EqualTo(2));
}
public void RequstingConfiguration_AlsoRegisterd_ServicesWithoutConfiguration()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(SelfService), typeof(HighService), typeof(LowService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FilterServices(registrator.FindServices(), "High"));
Assert.That(container.Resolve <SelfService>(), Is.InstanceOf <SelfService>());
Assert.That(container.Resolve <IBarometer>(), Is.InstanceOf <HighService>());
Assert.That(container.ResolveAll <IBarometer>().Count(), Is.EqualTo(1));
}
public void Resolves_OnlyRequestedConfiguration()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
var services = registrator.FilterServices(registrator.FindServices(), "High");
registrator.RegisterServices(services);
Assert.That(container.Resolve <IBarometer>(), Is.InstanceOf <HighService>());
Assert.That(container.ResolveAll <IBarometer>().Count(), Is.EqualTo(1));
}
public ICoreServiceLocator GetContainer(DotlessConfiguration configuration)
{
var builder = new Autofac.ContainerBuilder();
var registrar = new ServiceRegistrator();
registrar.RegisterServices(new CompilerServiceRegistrar(builder), configuration);
var container = builder.Build();
return(new CompilerServiceLocator(container));
}
public void CanDependOn_MultipleServices()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
container.AddComponent("bw", typeof(BarometerWatcher), typeof(BarometerWatcher));
var watcher = container.Resolve <BarometerWatcher>();
Assert.That(watcher.Barometers.Count(), Is.EqualTo(2));
}
public void Services_DependingOn_MultipleServices_CanBeSingletons()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
container.AddComponent("bw", typeof(BarometerWatcher), typeof(BarometerWatcher));
var watcher = container.Resolve <BarometerWatcher>();
var watcher2 = container.Resolve <BarometerWatcher>();
Assert.That(watcher, Is.SameAs(watcher));
}
public void CanResolve_ServiceWithDependency_OnComponentInstance()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(DependingServiceWithMissingDependency).Assembly.GetTypes());
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
container.AddComponentInstance("ud", typeof(UnregisteredDependency), new UnregisteredDependency());
var service = container.Resolve <DependingServiceWithMissingDependency>();
Assert.That(service, Is.InstanceOf <DependingServiceWithMissingDependency>());
}
public void Service_CanDecorate_ServiceOfSameType()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(DecoratingService), typeof(InterfacedService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
var service = container.Resolve <IService>();
Assert.That(service, Is.InstanceOf <DecoratingService>());
Assert.That(((DecoratingService)service).decorated, Is.InstanceOf <InterfacedService>());
}
public void Register_ShouldThrowWhenClassDeclaredToImplementDerivingClass(RegisterMethod registerMethod)
{
// Arrange
var typesProvider = Substitute.For <ITypesProvider>();
typesProvider.GetTypes().Returns(new[] { typeof(DummyClassDeclaringImplementationOfDerivingClass).GetTypeInfo(), typeof(DummyClass4).GetTypeInfo() });
var serviceRegistrator = new ServiceRegistrator(typesProvider);
// Act
// Assert
Assert.That(() => Register(serviceRegistrator, (toImplement, implementation) => { }, registerMethod),
Throws.InstanceOf <RegistrationException>());
}
public void Register_ShouldThrowWhenClassDoesNotImplementGivenInterface(RegisterMethod registerMethod)
{
// Arrange
var typesProvider = Substitute.For <ITypesProvider>();
typesProvider.GetTypes().Returns(new[] { typeof(IDummyClassImplementingInterface).GetTypeInfo(), typeof(DummyClassNotImplementingInterface).GetTypeInfo() });
var serviceRegistrator = new ServiceRegistrator(typesProvider);
// Act
// Assert
Assert.That(() => Register(serviceRegistrator, (toImplement, implementation) => { }, registerMethod),
Throws.InstanceOf <RegistrationException>());
}
public void Services_AreSingletons()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(SelfService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
var one = container.Resolve <SelfService>();
var two = container.Resolve <SelfService>();
Assert.That(object.ReferenceEquals(one, two));
}
public void Services_CanDepend_OnGenericServiceInterface()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(GenericInterfaceDependingService), typeof(GenericInterfacedService <>));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
var service = container.Resolve <GenericInterfaceDependingService>();
Assert.That(service, Is.InstanceOf <GenericInterfaceDependingService>());
Assert.That(service.service, Is.InstanceOf <GenericInterfacedService <int> >());
}
public void Services_CanDepend_OnEachOther()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(SelfService), typeof(DependingService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
var service = container.Resolve <DependingService>();
Assert.That(service, Is.InstanceOf <DependingService>());
Assert.That(service.service, Is.InstanceOf <SelfService>());
}
public void CanRegister_MultipleServices_DependingOnSame_ServiceArray()
{
ITypeFinder finder = new Fakes.FakeTypeFinder(typeof(HighService), typeof(LowService));
ServiceRegistrator registrator = new ServiceRegistrator(finder, container);
registrator.RegisterServices(registrator.FindServices());
container.AddComponent("bw", typeof(BarometerWatcher), typeof(BarometerWatcher));
container.AddComponent("ac", typeof(AltitudeComparer), typeof(AltitudeComparer));
var watcher = container.Resolve <BarometerWatcher>();
var comparer = container.Resolve <AltitudeComparer>();
Assert.That(watcher.Barometers[0], Is.SameAs(comparer.Barometers[0]));
Assert.That(watcher.Barometers[1], Is.SameAs(comparer.Barometers[1]));
}
private static void Register(ServiceRegistrator registrator, Action <Type, Type> registrationStub, RegisterMethod registerMethod)
{
switch (registerMethod)
{
case RegisterMethod.Singleton:
registrator.RegisterSingletons(registrationStub);
return;
case RegisterMethod.Transient:
registrator.RegisterTransient(registrationStub);
return;
default:
throw new ArgumentOutOfRangeException("Not supported method!");
}
}
public static void RegisterService(IConfiguration configuration, CalculationOperation operation, string version, ILogger logger)
{
var registrator = new ServiceRegistrator(configuration);
registrator.Register(operation, version).ContinueWith(task =>
{
if (task.Status == TaskStatus.RanToCompletion)
{
logger.LogInformation($"Service {operation} {version} registered with url {registrator.Url}");
}
else
{
logger.LogCritical($"Failed to register service {operation} {version} with url {registrator.Url}", task.Exception);
}
});
}
