public async Task SquadProductMaintenanceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var(customer, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var squadComponent = container.GetInstance <SquadComponent>();
var squadQueryComponent = container.GetInstance <SquadQueryComponent>();
var squadProductComponent = container.GetInstance <SquadProductComponent>();
await squadComponent.CreateSquad(new Models.SquadPostRp()
{
Name = "test",
CustomerId = customer
});
var squad = await squadQueryComponent.GetSquadByName(customer, "test");
await squadProductComponent.CreateSquadProduct(new Models.SquadProductPostRp()
{
SquadId = squad.Id,
ProductId = product
});
var all = await squadProductComponent.GetAll();
Assert.NotEmpty(all);
}
public async Task IndicatorMaintenanceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var(_, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var source = await ComponentTestFactory.BuildSource(container, product);
var feature = await ComponentTestFactory.BuildFeature(container, product);
var component = container.GetInstance <IndicatorComponent>();
await component.Create(feature, source);
var indicators = await component.GetByFeature(feature);
Assert.NotEmpty(indicators);
foreach (var item in indicators)
{
var indicator = await component.GetById(item.Id);
Assert.NotNull(indicator);
Assert.NotNull(indicator.FeatureAvatar);
Assert.NotNull(indicator.Feature);
Assert.NotNull(indicator.Source);
Assert.NotNull(indicator.SourceAvatar);
}
await component.Delete(indicators.Single().Id);
indicators = await component.GetByFeature(feature);
Assert.Empty(indicators);
}
public async void SourceListSuccess()
{
var container = ComponentTestFactory.BuildContainer();
var data = await ComponentTestFactory.BuildCustomerProduct(container);
var component = container.GetInstance <SourceComponent>();
var componentItems = container.GetInstance <SourceItemComponent>();
var source = await component.Create(new SourcePostRp()
{
Name = "testSource", ProductId = data.product
});
await componentItems.CreateAvailabilityItem(new SourceItemAvailabilityPostRp()
{
SourceId = source.Id, Start = OwlveyCalendar.StartJanuary2019,
End = OwlveyCalendar.EndJanuary2019,
Good = 800, Total = 1000
});
var items = await componentItems.GetAvailabilityItems(source.Id, OwlveyCalendar.january2019);
Assert.Equal(0.788m, items.First().Measure);
Assert.Equal(33, items.First().Total);
Assert.Equal(26, items.First().Good);
var result = await component.GetByIdWithDetail(source.Id, OwlveyCalendar.january2019);
Assert.Equal(1023, result.Quality.Total);
}
public async Task SourceQueryAvailability()
{
var container = ComponentTestFactory.BuildContainer();
var(_, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var component = container.GetInstance <SourceComponent>();
var sourceItemComponent = container.GetInstance <SourceItemComponent>();
await component.Create(new Models.SourcePostRp()
{
Name = "test",
ProductId = product
});
var testSource = await component.GetByName(product, "test");
var item = await sourceItemComponent.CreateAvailabilityItem(new SourceItemAvailabilityPostRp()
{
SourceId = testSource.Id,
Total = 1000,
Good = 800,
Start = OwlveyCalendar.January201904,
End = OwlveyCalendar.January201906
});
var result = await sourceItemComponent.GetBySourceIdAndDateRange(testSource.Id, OwlveyCalendar.January201903, OwlveyCalendar.January201907);
Assert.NotEmpty(result);
result = await sourceItemComponent.GetBySourceIdAndDateRange(testSource.Id, OwlveyCalendar.January201905, OwlveyCalendar.January201907);
Assert.NotEmpty(result);
}
public async Task SourceItemMaintenanceSuccess()
{
var container = ComponentTestFactory.BuildContainer();
var(_, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var component = container.GetInstance <SourceComponent>();
await component.Create(new Models.SourcePostRp()
{
Name = "test",
ProductId = product
});
var source = await component.GetByName(product, "test");
var itemComponent = container.GetInstance <SourceItemComponent>();
await itemComponent.CreateAvailabilityItem(new SourceItemAvailabilityPostRp()
{
SourceId = source.Id,
Start = DateTime.Now,
End = DateTime.Now,
Good = 900,
Total = 1000
});
var list = await itemComponent.GetBySource(source.Id);
Assert.NotEmpty(list);
}
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 async Task IndicatorDeleteSuccess()
{
var container = ComponentTestFactory.BuildContainer();
var dbcontext = container.GetInstance <FalconDbContext>();
var featureComponent = container.GetInstance <FeatureComponent>();
var indicatorComponent = container.GetInstance <IndicatorComponent>();
var featureQueryComponent = container.GetInstance <FeatureQueryComponent>();
var sourceComponent = container.GetInstance <SourceComponent>();
var journeyComponent = container.GetInstance <JourneyComponent>();
var journeyQueryComponent = container.GetInstance <JourneyQueryComponent>();
var data = await ComponentTestFactory.BuildCustomerWithSquad(container,
OwlveyCalendar.January201903, OwlveyCalendar.January201905);
await journeyComponent.Delete(data.journeyId);
var journey = await journeyQueryComponent.GetJourneyById(data.journeyId);
Assert.Null(journey);
var feature = await featureQueryComponent.GetFeatureById(data.featureId);
Assert.NotNull(feature);
var map = dbcontext.JourneyMaps.Where(c => c.JourneyId == data.journeyId).ToList();
Assert.Empty(map);
}
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 IncidentMaintenance()
{
var container = ComponentTestFactory.BuildContainer();
var component = container.GetInstance <IncidentComponent>();
var(customer, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var(result, _) = await component.Post(new Models.IncidentPostRp()
{
Key = "test01",
ProductId = product, Title = "test"
});
var items = await component.GetByProduct(product);
Assert.NotEmpty(items);
result = await component.Put(result.Id, new Models.IncidentPutRp()
{
Title = "change"
});
var tmp = await component.Get(result.Id);
Assert.Equal("change", tmp.Title);
}
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 IncidentAssociations()
{
var container = ComponentTestFactory.BuildContainer();
var incidentComponent = container.GetInstance <IncidentComponent>();
var featureComponent = container.GetInstance <FeatureComponent>();
var featureQueryComponent = container.GetInstance <FeatureQueryComponent>();
var(customer, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var(result, _) = await incidentComponent.Post(new Models.IncidentPostRp()
{
Key = "test01",
ProductId = product,
Title = "test"
});
var items = await incidentComponent.GetByProduct(product);
Assert.NotEmpty(items);
var feature = await featureComponent.CreateFeature(new Models.FeaturePostRp()
{
Name = "test", ProductId = product
});
await incidentComponent.RegisterFeature(result.Id, feature.Id);
var featureDetail = await featureQueryComponent.GetFeatureByIdWithQuality(feature.Id,
OwlveyCalendar.january2019);
Assert.NotEmpty(featureDetail.Incidents);
}
public async void Maintenance()
{
var container = ComponentTestFactory.BuildContainer();
var(_, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var sourceComponent = container.GetInstance <SourceComponent>();
var source = await sourceComponent.Create(new Models.SourcePostRp()
{
Name = "test",
ProductId = product
});
var component = container.GetInstance <ReliabilityRiskComponent>();
var risk = await component.Create(new ReliabilityRiskPostRp()
{
Name = "test", SourceId = source.Id
});
var risks = await component.GetRisks(source.Id);
Assert.NotEmpty(risks);
var target = await component.GetRiskById(risk.Id);
Assert.NotNull(target);
}
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 void CacheSuccess()
{
var container = ComponentTestFactory.BuildContainer();
var cache = container.GetInstance <CacheComponent>();
var modified = cache.GetLastModified();
Assert.NotNull(modified);
}
public async Task Backup()
{
#region Components
var container = ComponentTestFactory.BuildContainer();
var customerComponet = container.GetInstance <CustomerComponent>();
var customerQueryComponet = container.GetInstance <CustomerQueryComponent>();
var productComponent = container.GetInstance <ProductComponent>();
var productQueryComponent = container.GetInstance <ProductQueryComponent>();
var squadQueryComponent = container.GetInstance <SquadQueryComponent>();
var sourceComponent = container.GetInstance <SourceComponent>();
var migrationComponent = container.GetInstance <MigrationComponent>();
var journeyComponent = container.GetInstance <JourneyQueryComponent>();
var featureComponent = container.GetInstance <FeatureQueryComponent>();
var sourceItemComponent = container.GetInstance <SourceItemComponent>();
var securityComponent = container.GetInstance <SecurityRiskComponent>();
var reliabilityComponent = container.GetInstance <ReliabilityRiskComponent>();
#endregion
var result = await customerComponet.CreateCustomer(new Models.CustomerPostRp()
{
Name = "test", Default = true
});
var product = await productComponent.CreateProduct(new Models.ProductPostRp()
{
Name = "test", CustomerId = result.Id
});
var SecurityThreat = await securityComponent.CreateThreat(new Models.SecurityThreatPostRp()
{
Name = "test"
});
var source = await sourceComponent.Create(new Models.SourcePostRp()
{
Name = "test", ProductId = product.Id
});
var SecurityRisk = await securityComponent.Create(new Models.SecurityRiskPost()
{
SourceId = source.Id, Name = SecurityThreat.Name
});
var reliabilityThreat = await reliabilityComponent.CreateThreat(new Models.ReliabilityThreatPostRp()
{
Name = "test threat"
});
var reliabilityRisk = await reliabilityComponent.Create(new Models.ReliabilityRiskPostRp()
{
Name = "test risk", SourceId = source.Id
});
var stream = await migrationComponent.Backup(true);
}
public async Task DefaultThreats()
{
var container = ComponentTestFactory.BuildContainer();
var component = container.GetInstance <SecurityRiskComponent>();
await component.CreateDefault();
var threats = await component.GetThreats();
Assert.NotEmpty(threats);
}
public async Task SourceItemsGetById()
{
var container = ComponentTestFactory.BuildContainer();
var(_, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var component = container.GetInstance <SourceComponent>();
var sourceItems = container.GetInstance <SourceItemComponent>();
SourceGetListRp source = await component.Create(new Models.SourcePostRp()
{
Name = "test",
ProductId = product,
});
await sourceItems.CreateAvailabilityItem(new SourceItemAvailabilityPostRp()
{
Start = OwlveyCalendar.StartJanuary2019,
End = OwlveyCalendar.EndJanuary2019,
Good = 800,
Total = 1000,
SourceId = source.Id
});
await sourceItems.CreateLatencyItem(new SourceItemLatencyPostRp()
{
Start = OwlveyCalendar.StartJanuary2019,
End = OwlveyCalendar.EndJanuary2019,
Measure = 1200,
SourceId = source.Id
});
await sourceItems.CreateExperienceItem(new SourceItemExperiencePostRp()
{
Start = OwlveyCalendar.StartJanuary2019,
End = OwlveyCalendar.EndJanuary2019,
Good = 800,
Total = 1000,
SourceId = source.Id
});
var result = await sourceItems.GetAvailabilityItems(source.Id, OwlveyCalendar.year2019);
Assert.NotEmpty(result);
var latency_result = await sourceItems.GetLatencyItems(source.Id, OwlveyCalendar.year2019);
Assert.NotEmpty(latency_result);
var experience_result = await sourceItems.GetExperienceItems(source.Id, OwlveyCalendar.year2019);
Assert.NotEmpty(experience_result);
}
public async void SourcesByProduct()
{
//GetByProductIdWithAvailability
var container = ComponentTestFactory.BuildContainer();
var data = await ComponentTestFactory.BuildCustomerWithSquad(container, OwlveyCalendar.StartJanuary2017, OwlveyCalendar.EndDecember2019);
var sourceComponent = container.GetInstance <SourceComponent>();
var result = await sourceComponent.GetByProductIdWithAvailability(data.productId, OwlveyCalendar.StartJanuary2017, OwlveyCalendar.EndDecember2019);
Assert.Single(result.Items);
}
public async Task Maintentance()
{
var container = ComponentTestFactory.BuildContainer();
var(_, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var sourceComponent = container.GetInstance <SourceComponent>();
var source = await sourceComponent.Create(new Models.SourcePostRp()
{
Name = "test",
ProductId = product
});
var component = container.GetInstance <SecurityRiskComponent>();
var threat = await component.CreateThreat(new Models.SecurityThreatPostRp()
{
Name = "test"
});
var risk = await component.Create(new Models.SecurityRiskPost()
{
SourceId = source.Id
});
var risks = await component.GetRisks(source.Id);
Assert.NotEmpty(risks);
var riskGet = await component.GetRiskById(risk.Id);
Assert.NotNull(riskGet);
await component.UpdateRisk(risk.Id,
new Models.SecurityRiskPut()
{
AgentSkillLevel = 3
});
riskGet = await component.GetRiskById(risk.Id);
Assert.Equal(3, riskGet.AgentSkillLevel);
await component.DeleteRisk(risk.Id);
risks = await component.GetRisks(source.Id);
Assert.Empty(risks);
}
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 async Task UserMaintenanceIdempotenceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var userComponent = container.GetInstance <UserComponent>();
var userQueryComponent = container.GetInstance <UserQueryComponent>();
await userComponent.CreateUser(new Models.UserPostRp()
{
Email = "*****@*****.**"
});
var users = await userQueryComponent.GetUsers();
Assert.NotEmpty(users);
var response = await userComponent.CreateUser(new Models.UserPostRp()
{
Email = "*****@*****.**"
});
var id = response.Id;
var result = await userQueryComponent.GetUserById(id);
Assert.NotNull(result);
Assert.NotNull(result.Avatar);
await userComponent.PutUser(id, new Models.UserPutRp()
{
Avatar = "change",
Email = "change",
Name = "name"
});
result = await userQueryComponent.GetUserById(id);
Assert.Equal("change", result.Avatar);
Assert.Equal("name", result.Name);
Assert.Equal("change", result.Email);
await userComponent.DeleteUser(id);
result = await userQueryComponent.GetUserById(id);
Assert.Null(result);
}
public async void Maintenance()
{
var container = ComponentTestFactory.BuildContainer();
var component = container.GetInstance <ReliabilityRiskComponent>();
await component.CreateThreat(new ReliabilityThreatPostRp()
{
Name = "test"
});
var threats = await component.GetThreats();
Assert.NotEmpty(threats);
}
public async void DefaultThreats()
{
var container = ComponentTestFactory.BuildContainer();
var component = container.GetInstance <ReliabilityRiskComponent>();
await component.CreateDefault();
var threats = await component.GetThreats();
foreach (var item in threats)
{
Assert.False(String.IsNullOrWhiteSpace(item.Name));
Assert.Equal(10, item.ETTD);
Assert.NotNull(item.Description);
Assert.True(item.Reference.StartsWith("http"));
}
}
public async Task SquadgetDetailSucces()
{
var container = ComponentTestFactory.BuildContainer();
var(customer, product) = await ComponentTestFactory.BuildCustomerProduct(container, defaultValues : true);
var squadComponent = container.GetInstance <SquadComponent>();
var squadQueryComponent = container.GetInstance <SquadQueryComponent>();
var squads = await squadQueryComponent.GetSquads(customer);
var result = await squadQueryComponent.GetSquadByIdWithQuality(squads.First().Id,
new DatePeriodValue(OwlveyCalendar.StartJanuary2019, OwlveyCalendar.EndJuly2019));
Assert.NotEmpty(result.Features);
}
public async Task UserMaintenanceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var userComponent = container.GetInstance <UserComponent>();
var userQueryComponent = container.GetInstance <UserQueryComponent>();
await userComponent.CreateUser(new Models.UserPostRp()
{
Email = "*****@*****.**"
});
var users = await userQueryComponent.GetUsers();
Assert.NotEmpty(users);
}
public async Task SourceCreation()
{
var container = ComponentTestFactory.BuildContainer();
var(_, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var component = container.GetInstance <SourceComponent>();
var result = await component.Create(new Models.SourcePostRp()
{
Name = "test",
ProductId = product
});
Assert.Equal("test", result.Name);
}
public static async Task <(int customer, int squad)> BuildCustomerSquad(Container container, string name = "test")
{
var customer = await ComponentTestFactory.BuildCustomer(container);
var squadComponent = container.GetInstance <SquadComponent>();
var squadQueryComponent = container.GetInstance <SquadQueryComponent>();
await squadComponent.CreateSquad(new Models.SquadPostRp()
{
Name = "test",
CustomerId = customer
});
var squad = await squadQueryComponent.GetSquadByName(customer, "test");
return(customer, squad.Id);
}
public async Task SquadListSuccess()
{
var container = ComponentTestFactory.BuildContainer();
var squadQueryComponent = container.GetInstance <SquadQueryComponent>();
var(_, _, _, _, _, squad) = await ComponentTestFactory.BuildCustomerWithSquad(container,
OwlveyCalendar.January201903,
OwlveyCalendar.January201905);
var points = await squadQueryComponent.GetSquadByIdWithQuality(
squad,
new DatePeriodValue(
OwlveyCalendar.January201903,
OwlveyCalendar.January201905));
Assert.Equal(0.191m, points.Debt.Availability);
}
public async Task journeyCreateSuccess()
{
var container = ComponentTestFactory.BuildContainer();
var(customerId, productId, journeyId, featureId, _, _) = await ComponentTestFactory.BuildCustomerWithSquad(container, OwlveyCalendar.StartJanuary2019, OwlveyCalendar.EndJanuary2019);
var journeyComponent = container.GetInstance <JourneyComponent>();
var journeyQueryComponent = container.GetInstance <JourneyQueryComponent>();
var result = await journeyComponent.Create(new Models.JourneyPostRp()
{
Name = "test", ProductId = productId
});
Assert.Equal(result.SLAValue.Availability, 0.99m);
Assert.Equal(result.SLAValue.Latency, 1000m);
}
public async Task journeyGraphQuerySuccess()
{
var container = ComponentTestFactory.BuildContainer();
var(customerId, productI, journeyId, featureId, _, _) = await ComponentTestFactory.BuildCustomerWithSquad(container, OwlveyCalendar.StartJanuary2019, OwlveyCalendar.EndJanuary2019);
var journeyComponent = container.GetInstance <JourneyComponent>();
var journeyQueryComponent = container.GetInstance <JourneyQueryComponent>();
var graph = await journeyQueryComponent.GetGraph(journeyId,
new DatePeriodValue(OwlveyCalendar.StartJanuary2019, OwlveyCalendar.EndJanuary2019));
Assert.NotNull(graph);
Assert.NotEmpty(graph.Nodes);
Assert.NotEmpty(graph.Edges);
}
