public async Task Maintentance()
{
var container = ComponentTestFactory.BuildContainer();
var component = container.GetInstance <SecurityRiskComponent>();
var threat = await component.CreateThreat(new Models.SecurityThreatPostRp()
{
Name = MockUtils.GenerateRandomName()
});
var threats = await component.GetThreats();
Assert.NotEmpty(threats);
var threatGet = await component.GetThreat(threat.Id);
Assert.NotNull(threatGet);
await component.UpdateThreat(threat.Id, new Models.SecurityThreatPutRp()
{
Name = "change"
});
threatGet = await component.GetThreat(threat.Id);
Assert.Equal("change", threatGet.Name);
await component.DeleteThreat(threat.Id);
threatGet = await component.GetThreat(threat.Id);
Assert.Null(threatGet);
}
public async Task SourceItemBatchInteractionsCase()
{
var container = ComponentTestFactory.BuildContainer();
var customer = MockUtils.GenerateRandomName();
var product = MockUtils.GenerateRandomName();
var context = container.GetInstance <FalconDbContext>();
var(_, productId) = await ComponentTestFactory.BuildCustomerProduct(container,
customerName : customer, productName : product);
var itemComponent = container.GetInstance <SourceItemComponent>();
var sourceComponent = container.GetInstance <SourceComponent>();
var items = await itemComponent.CreateInteractionItems(new SourceItemBatchPostRp()
{
Customer = customer,
Product = product,
Kind = Core.Entities.SourceKindEnum.Interaction,
Delimiter = ';',
Items = new List <string>()
{
"OnboardingController::verifyOTPCode;2020-03-01 01:00:00;2020-03-01 01:59:59;75;0;59;1267.0053999999996",
"OnboardingController::verifyOTPCode;2020-03-01 02:00:00;2020-03-01 02:59:59;38;0;36;576.58925",
"OnboardingController::verifyOTPCode;2020-03-01 03:00:00;2020-03-01 03:59:59;22;0;21;571.0088000000001"
}
});
Assert.Equal(1, items.SourceCreated);
Assert.Equal(9, items.ItemsCreated);
}
public static async Task <(int customer, int product)> BuildCustomerProduct(Container container,
string customerName = "customer",
string productName = null,
bool defaultValues = false)
{
productName ??= MockUtils.GenerateRandomName();
var customerComponet = container.GetInstance <CustomerComponent>();
var customerQueryComponent = container.GetInstance <CustomerQueryComponent>();
await customerComponet.CreateCustomer(new Models.CustomerPostRp()
{
Name = customerName, Default = defaultValues
});
var productComponent = container.GetInstance <ProductComponent>();
var customer = await customerQueryComponent.GetCustomerByName(customerName);
var productQueryComponent = container.GetInstance <ProductQueryComponent>();
await productComponent.CreateProduct(new ProductPostRp()
{
CustomerId = customer.Id,
Name = productName
});
var product = await productQueryComponent.GetProductByName(customer.Id, productName);
return(customer.Id, product.Id);
}
public async Task ProductIdempotenceSuccess()
{
var container = ComponentTestFactory.BuildContainer();
var customerId = await ComponentTestFactory.BuildCustomer(container);
var productComponet = container.GetInstance <ProductComponent>();
var productQueryComponent = container.GetInstance <ProductQueryComponent>();
var name = MockUtils.GenerateRandomName();
await productComponet.CreateProduct(new Models.ProductPostRp()
{
CustomerId = customerId,
Name = name
});
await productComponet.CreateProduct(new Models.ProductPostRp()
{
CustomerId = customerId,
Name = name
});
var products = await productQueryComponent.GetProducts(customerId);
Assert.NotEmpty(products);
Assert.Single(products);
}
public async Task SourceItemBatchInteractions()
{
var container = ComponentTestFactory.BuildContainer();
var customer = MockUtils.GenerateRandomName();
var product = MockUtils.GenerateRandomName();
var context = container.GetInstance <FalconDbContext>();
var(_, productId) = await ComponentTestFactory.BuildCustomerProduct(container,
customerName : customer, productName : product);
var itemComponent = container.GetInstance <SourceItemComponent>();
var sourceComponent = container.GetInstance <SourceComponent>();
var items = await itemComponent.CreateInteractionItems(new SourceItemBatchPostRp()
{
Customer = customer, Product = product, Kind = Core.Entities.SourceKindEnum.Interaction,
Items = new List <string>()
{
"Controller::sendAdvisor,2020-03-03 01:00:00,2020-03-03 01:59:59,24,22,20,14164.86935",
"Controller::sendAdvisor,2020-03-04 01:00:00,2020-03-04 01:59:59,24,23,21,14164.86935",
"Controller::getAdvisorInfo,2020-03-03 00:00:00,2020-03-03 23:59:59,200,196,195,18474.299049999998"
}
});
Assert.Equal(2, items.SourceCreated);
Assert.Equal(9, items.ItemsCreated);
var sourceSendAdvisor = await sourceComponent.GetByName(productId, "Controller::sendAdvisor");
Assert.NotNull(sourceSendAdvisor);
var period = new DatePeriodValue(DateTime.Parse("2020-03-03 00:00:00"),
DateTime.Parse("2020-03-03 23:59:59"));
var itemsSendAdvisor = await itemComponent.GetAvailabilityItems(sourceSendAdvisor.Id,
period
);
var all = context.SourcesItems.Where(c => c.SourceId == sourceSendAdvisor.Id && c.Group == Core.Entities.SourceGroupEnum.Availability &&
c.Target >= period.Start && c.Target <= period.End).ToList();
Assert.Equal(0.917m, itemsSendAdvisor.First().Measure);
var itemsSendAdvisorExperience = await itemComponent.GetExperienceItems(sourceSendAdvisor.Id,
new DatePeriodValue(
DateTime.Parse("2020-03-03 00:00:00"),
DateTime.Parse("2020-03-03 23:59:59")
)
);
Assert.Equal(0.833m, itemsSendAdvisorExperience.First().Measure);
var itemsSendAdvisorLatency = await itemComponent.GetLatencyItems(sourceSendAdvisor.Id,
new DatePeriodValue(DateTime.Parse("2020-03-03 00:00:00"),
DateTime.Parse("2020-03-03 23:59:59"))
);
Assert.Equal(14164.86935m, itemsSendAdvisorLatency.First().Measure);
}
public async Task SourceDeleteSuccess()
{
var container = ComponentTestFactory.BuildContainer();
var dbcontext = container.GetInstance <FalconDbContext>();
var source = container.GetInstance <SourceComponent>();
var sourceItemComponent = container.GetInstance <SourceItemComponent>();
var securityRiskComponent = container.GetInstance <SecurityRiskComponent>();
var reliabilityRiskComponent = container.GetInstance <ReliabilityRiskComponent>();
var result = await ComponentTestFactory.BuildCustomerWithSquad(container,
OwlveyCalendar.January201903, OwlveyCalendar.January201905);
var securityRisk = await securityRiskComponent.Create(new SecurityRiskPost()
{
SourceId = result.sourceId,
Name = MockUtils.GenerateRandomName()
});
var reliabilityRisk = await reliabilityRiskComponent.Create(new ReliabilityRiskPostRp()
{
SourceId = result.sourceId,
Name = "test reliabilty"
});
await source.Delete(result.sourceId);
var securityRisks = await securityRiskComponent.GetRisks(result.sourceId);
Assert.Empty(securityRisks);
var reliabilityRisks = await reliabilityRiskComponent.GetRisks(result.sourceId);
Assert.Empty(reliabilityRisks);
var sources = await source.GetById(result.sourceId);
Assert.Null(sources);
var items = await sourceItemComponent.GetBySource(result.sourceId);
Assert.Empty(items);
var expected = dbcontext.SourcesItems.Where(c => c.Source.ProductId == result.productId).ToList();
Assert.Empty(expected);
var indicators = dbcontext.Indicators.Where(c => c.FeatureId == result.featureId).ToList();
Assert.Empty(indicators);
}
public static async Task <int> BuildCustomer(Container container, string name = null, bool defaultValue = false)
{
name ??= MockUtils.GenerateRandomName();
var customerComponet = container.GetInstance <CustomerComponent>();
var customerQueryComponent = container.GetInstance <CustomerQueryComponent>();
await customerComponet.CreateCustomer(new Models.CustomerPostRp()
{
Name = name,
Default = defaultValue
});
var customer = await customerQueryComponent.GetCustomerByName(name);
return(customer.Id);
}
public async Task SquadMaintenanceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var customer = await ComponentTestFactory.BuildCustomer(container);
var squadComponent = container.GetInstance <SquadComponent>();
var squadQueryComponent = container.GetInstance <SquadQueryComponent>();
await squadComponent.CreateSquad(new Models.SquadPostRp()
{
Name = MockUtils.GenerateRandomName(),
CustomerId = customer
});
var squads = await squadQueryComponent.GetSquads(customer);
Assert.NotEmpty(squads);
}
public async Task LastUpdateVersionSuccess()
{
var container = ComponentTestFactory.BuildContainer();
var cache = container.GetInstance <CacheComponent>();
var mark = await cache.GetLastModified();
var mark2 = await cache.GetLastModified();
Assert.Equal(mark, mark2);
Thread.Sleep(500);
var customerComponent = container.GetInstance <CustomerComponent>();
await customerComponent.CreateCustomer(new CustomerPostRp()
{
Name = MockUtils.GenerateRandomName()
});
var mark3 = await cache.GetLastModified();
Assert.NotEqual(mark, mark3);
}
public async Task SourceItemBatchInteractionsEmpty()
{
var container = ComponentTestFactory.BuildContainer();
var customer = MockUtils.GenerateRandomName();
var product = MockUtils.GenerateRandomName();
var(_, _) = await ComponentTestFactory.BuildCustomerProduct(container,
customerName : customer, productName : product);
var itemComponent = container.GetInstance <SourceItemComponent>();
var items = await itemComponent.CreateInteractionItems(new SourceItemBatchPostRp()
{
Customer = customer,
Product = product,
Kind = Core.Entities.SourceKindEnum.Interaction,
Items = new List <string>()
{
}
});
Assert.Equal(0, items.SourceCreated);
Assert.Equal(0, items.ItemsCreated);
}
public async Task SquadFeatureMaintenanceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var(customer, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var featureComponent = container.GetInstance <FeatureComponent>();
var squadComponent = container.GetInstance <SquadComponent>();
var squadQueryComponent = container.GetInstance <SquadQueryComponent>();
var squadResponse = await squadComponent.CreateSquad(new Models.SquadPostRp()
{
Name = MockUtils.GenerateRandomName(),
CustomerId = customer
});
var squad = await squadQueryComponent.GetSquadById(squadResponse.Id);
var feature = await ComponentTestFactory.BuildFeature(container, product);
await featureComponent.RegisterSquad(new SquadFeaturePostRp()
{
SquadId = squad.Id,
FeatureId = feature
});
squad = await squadQueryComponent.GetSquadById(squad.Id);
Assert.NotEmpty(squad.Features);
await featureComponent.UnRegisterSquad(squad.Id, feature);
squad = await squadQueryComponent.GetSquadById(squad.Id);
Assert.Empty(squad.Features);
}
int sourceId, int squadId)> BuildCustomerWithSquad(Container container,
DateTime start, DateTime end)
{
var squadComponent = container.GetInstance <SquadComponent>();
var featureComponent = container.GetInstance <FeatureComponent>();
var journeyComponent = container.GetInstance <JourneyComponent>();
var journeyMapComponent = container.GetInstance <JourneyMapComponent>();
var indicatorComponent = container.GetInstance <IndicatorComponent>();
var sourceComponent = container.GetInstance <SourceComponent>();
var sourceItemComponent = container.GetInstance <SourceItemComponent>();
var squadQueryComponent = container.GetInstance <SquadQueryComponent>();
var(customer, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var journey = await journeyComponent.Create(new Models.JourneyPostRp()
{
Name = MockUtils.GenerateRandomName(),
ProductId = product
});
var feature = await featureComponent.CreateFeature(new Models.FeaturePostRp()
{
Name = MockUtils.GenerateRandomName(),
ProductId = product
});
await journeyMapComponent.CreateMap(new JourneyMapPostRp()
{
FeatureId = feature.Id,
JourneyId = journey.Id
});
var source = await sourceComponent.Create(new SourcePostRp()
{
Name = MockUtils.GenerateRandomName(),
ProductId = product
});
await sourceItemComponent.CreateAvailabilityItem(new SourceItemAvailabilityPostRp()
{
SourceId = source.Id,
Start = start,
End = end,
Total = 1000,
Good = 800
});
await indicatorComponent.Create(feature.Id, source.Id);
var squad = await squadComponent.CreateSquad(new SquadPostRp()
{
Name = MockUtils.GenerateRandomName(),
CustomerId = customer
});
await featureComponent.RegisterSquad(new SquadFeaturePostRp()
{
FeatureId = feature.Id, SquadId = squad.Id
});
return(customer, product, journey.Id, feature.Id, source.Id, squad.Id);
}
