T exec <T>(IReadOnlyContainer container)
{
IServiceRegistration serviceRegistration = new ServiceRegistrationBuilder()
.AddType(typeof(T))
.Build();
ServiceFlags flags = new ServiceFlagsProvider(new AttributesFinder(), new MemberGenerator(new MemberFlagsGenerator())).ProvideFlags(typeof(T));
IService service = new ServiceBuilder()
.AddRegistration(serviceRegistration)
.AddFlags(flags)
.AddInfo(null)
.Build();
object instance = Activator.CreateInstance <T>();
ObjectPostProcessor postProcessor = new ObjectPostProcessor(new InstanceMembersValueInjector(new MemberValueSetter(), new InstanceMembersFinder()),
new InjectMemberValuesInjector(new MemberValueSetter(), new InjectFlagsProvider(), new MemberDeclarationTypeProvider(), new InjectValueProvider()),
new TryInjectMemberValuesInjector(new ServiceAttributeProvider(), new MemberDeclarationTypeProvider(),
new MemberValueSetter(), new InjectValueProvider()),
new AutoMemberValuesInjector(new MemberDeclarationTypeProvider(), new ServiceAttributeProvider(),
new AutoValueGenerator(
new IsEnumerableChecker(new GenericTypeGenerator(), new TypeGenericParametersProvider(), new TypeContainsGenericParametersChecker()),
new EnumerableGenerator(new TypeGenericParametersProvider(), new GenericTypeGenerator()), new TypeIsArrayChecker(),
new ArrayGenerator(), new TypeIsValueTypeChecker(), new ValueTypeActivator()), new MemberValueSetter()));
postProcessor.Process(instance, service, container);
return((T)instance);
}
public async Task Returns_Token_If_IpAddress_IsNull()
{
var registration = new ServiceRegistrationBuilder().ForFirstServiceInstance().WithIpAddress(null).Build();
var token = await _provider.GenerateAsync(registration);
token.Should().NotBeNullOrWhiteSpace();
}
public async Task Calls_TokenProvider()
{
var registration = new ServiceRegistrationBuilder().ForFirstServiceInstance().Build();
await _serviceRegistry.RegisterAsync(registration);
_tokenProvider.Verify(s => s.GenerateAsync(registration), Times.Once);
}
public async Task Removes_Service_When_No_Endpoints_Exists_Anymore()
{
var registration = new ServiceRegistrationBuilder().ForSecondServiceInstance().Build();
var existingService = new ServiceBuilder().ForSecondServiceInstance().Build();
_tokenProvider.Setup(s => s.ValidateAsync("abc")).ReturnsAsync(registration);
_store.Setup(s => s.FindByServiceIdAsync("MyApi")).ReturnsAsync(existingService);
await _serviceRegistry.UnregisterAsync("abc");
_store.Verify(s => s.RemoveAsync("MyApi"), Times.Once);
}
public ServiceRegistry GetServiceRegistry(ServiceRegistryDescriptor descriptor)
{
Args.ThrowIfNull(descriptor, "descriptor");
ServiceRegistrationBuilder builder = new ServiceRegistrationBuilder();
foreach (ServiceDescriptor service in descriptor.Services)
{
ServiceDefinition definition = ResolveDefinition(service);
builder.For(definition.ForType);
builder.Use(definition.UseType);
}
return(builder.Build());
}
public async Task Returns_Service_For_Valid_Token()
{
var registration = new ServiceRegistrationBuilder().ForFirstServiceInstance().Build();
var token = await _provider.GenerateAsync(registration);
var service = await _provider.ValidateAsync(token);
service.Should().NotBeNull();
service.ServiceId.Should().Be(registration.ServiceId);
service.Endpoints.Should().HaveCount(registration.Endpoints.Length);
service.Endpoints.Should().Contain(registration.Endpoints);
service.IpAddress.Should().Be(registration.IpAddress);
}
public async Task Registers_New_Service_When_Not_Exists()
{
var registration = new ServiceRegistrationBuilder().ForFirstServiceInstance().Build();
_store.Setup(s => s.FindByServiceIdAsync("NewService")).ReturnsAsync((Service)null);
Service newService = null;
_store.Setup(s => s.StoreAsync(It.IsAny <Service>())).Callback <Service>(s => newService = s).Returns(Task.CompletedTask);
await _serviceRegistry.RegisterAsync(registration);
newService.Should().NotBeNull();
newService.ServiceId.Should().Be(registration.ServiceId);
newService.DisplayName.Should().Be(registration.DisplayName);
newService.Endpoints.Should().Contain(registration.Endpoints);
}
public async Task Adds_IpAddress_When_Service_Already_Exists_Without_Ip()
{
var registration = new ServiceRegistrationBuilder().ForSecondServiceInstance().Build();
var existingService = new ServiceBuilder().WithoutIpAddresses().Build();
_store.Setup(s => s.FindByServiceIdAsync("MyApi")).ReturnsAsync(existingService);
Service storedService = null;
_store.Setup(s => s.StoreAsync(It.IsAny <Service>())).Callback <Service>(s => storedService = s).Returns(Task.CompletedTask);
await _serviceRegistry.RegisterAsync(registration);
storedService.Should().NotBeNull();
storedService.ServiceId.Should().Be(registration.ServiceId);
storedService.DisplayName.Should().Be(registration.DisplayName);
storedService.IpAddresses.Should().Contain(registration.IpAddress);
}
public async Task Returns_Null_For_Expired_Token()
{
_options.RegisterTokenLifespan = TimeSpan.FromMilliseconds(20);
CreateProvider();
var registration = new ServiceRegistrationBuilder().ForFirstServiceInstance().Build();
var token = await _provider.GenerateAsync(registration);
var service = await _provider.ValidateAsync(token);
service.Should().NotBeNull();
Thread.Sleep(25);
service = await _provider.ValidateAsync(token);
service.Should().BeNull();
}
public async Task Merges_PublicUrls_When_Service_Already_Exists()
{
var registration = new ServiceRegistrationBuilder().ForSecondServiceInstance().WithPublicUrl(new Uri("http://otherurl.com")).Build();
var existingService = new ServiceBuilder().ForFirstServiceInstance().Build();
_store.Setup(s => s.FindByServiceIdAsync("MyApi")).ReturnsAsync(existingService);
Service storedService = null;
_store.Setup(s => s.StoreAsync(It.IsAny <Service>())).Callback <Service>(s => storedService = s).Returns(Task.CompletedTask);
await _serviceRegistry.RegisterAsync(registration);
storedService.Should().NotBeNull();
storedService.ServiceId.Should().Be(registration.ServiceId);
storedService.DisplayName.Should().Be(registration.DisplayName);
storedService.PublicUrls.Should().Contain(registration.PublicUrls);
storedService.PublicUrls.Should().Contain(existingService.PublicUrls);
}
public async Task Removes_Endpoints_And_IpAddress()
{
var registration = new ServiceRegistrationBuilder().ForSecondServiceInstance().Build();
var existingService = new ServiceBuilder().Build();
_tokenProvider.Setup(s => s.ValidateAsync("abc")).ReturnsAsync(registration);
_store.Setup(s => s.FindByServiceIdAsync("MyApi")).ReturnsAsync(existingService);
Service storedService = null;
_store.Setup(s => s.StoreAsync(It.IsAny <Service>())).Callback <Service>(s => storedService = s).Returns(Task.CompletedTask);
await _serviceRegistry.UnregisterAsync("abc");
storedService.Endpoints.Should().HaveCount(1);
storedService.Endpoints.Should().Contain(new Uri("http://api01-qa.com"));
storedService.IpAddresses.Should().HaveCount(1);
storedService.IpAddresses.Should().Contain("10.10.0.1");
}
public async Task Do_Not_Duplicate_PublicUrls_When_Service_Already_Exists_With_Same_Urls()
{
var registration = new ServiceRegistrationBuilder().ForSecondServiceInstance().Build();
var existingService = new ServiceBuilder().ForSecondServiceInstance().Build();
_store.Setup(s => s.FindByServiceIdAsync("MyApi")).ReturnsAsync(existingService);
Service storedService = null;
_store.Setup(s => s.StoreAsync(It.IsAny <Service>())).Callback <Service>(s => storedService = s).Returns(Task.CompletedTask);
await _serviceRegistry.RegisterAsync(registration);
storedService.Should().NotBeNull();
storedService.ServiceId.Should().Be(registration.ServiceId);
storedService.DisplayName.Should().Be(registration.DisplayName);
storedService.PublicUrls.Should().HaveCount(1);
storedService.PublicUrls.Should().Contain(registration.PublicUrls);
storedService.PublicUrls.Should().Contain(existingService.PublicUrls);
}
