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 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 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 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 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 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 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 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 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 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 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 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 async Task SourceGetById()
{
var container = ComponentTestFactory.BuildContainer();
var(_, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var component = container.GetInstance <SourceComponent>();
SourceGetListRp source = await component.Create(new Models.SourcePostRp()
{
Name = "test",
ProductId = product,
});
var result = await component.GetByIdWithDetail(source.Id, OwlveyCalendar.year2019);
Assert.Equal(1, result.Quality.Availability);
}
public async Task journeyMaintenanceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var(customerId, productId) = await ComponentTestFactory.BuildCustomerProduct(container);
var journeyComponent = container.GetInstance <JourneyComponent>();
var journeyQueryComponent = container.GetInstance <JourneyQueryComponent>();
var journeyInstance = await journeyComponent.Create(new Models.JourneyPostRp()
{
Name = "test",
ProductId = productId,
});
var journeys = await journeyQueryComponent.GetListByProductId(productId);
Assert.NotEmpty(journeys);
await journeyComponent.Update(journeyInstance.Id, new Models.JourneyPutRp()
{
Name = "change",
Description = "change",
AvailabilitySlo = 0.95m,
LatencySlo = 2000m,
ExperienceSlo = 0.95m,
Avatar = "http://change.org",
Group = "change group",
AvailabilitySLA = 0.8m,
LatencySLA = 800m
});
var journeyDetail = await journeyQueryComponent.GetJourneyById(journeyInstance.Id);
Assert.NotNull(journeyDetail);
Assert.Equal("change", journeyDetail.Name);
Assert.Equal("change group", journeyDetail.Group);
Assert.Equal("change", journeyDetail.Description);
Assert.Equal("http://change.org", journeyDetail.Avatar);
Assert.Equal(0.95m, journeyDetail.AvailabilitySLO);
Assert.Equal(0.8m, journeyDetail.SLAValue.Availability);
Assert.Equal(800m, journeyDetail.SLAValue.Latency);
}
public async Task FeatureMaintenanceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var(_, productId) = await ComponentTestFactory.BuildCustomerProduct(container);
var featureComponent = container.GetInstance <FeatureComponent>();
var featureQueryComponent = container.GetInstance <FeatureQueryComponent>();
await featureComponent.CreateFeature(new Models.FeaturePostRp()
{
Name = "test",
ProductId = productId
});
var features = await featureQueryComponent.GetFeatures(productId);
Assert.NotEmpty(features);
}
public async Task SquadUserMaintenanceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var(customer, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var squadComponent = container.GetInstance <SquadComponent>();
var squadQueryComponent = container.GetInstance <SquadQueryComponent>();
var squadResponse = await squadComponent.CreateSquad(new Models.SquadPostRp()
{
Name = "test",
CustomerId = customer
});
var squad = await squadQueryComponent.GetSquadById(squadResponse.Id);
var userComponent = container.GetInstance <UserComponent>();
var userQueryComponent = container.GetInstance <UserQueryComponent>();
var response = await userComponent.CreateUser(new Models.UserPostRp()
{
Email = "*****@*****.**"
});
var id = response.Id;
var user = await userQueryComponent.GetUserById(id);
await squadComponent.RegisterMember(squad.Id, user.Id);
squad = await squadQueryComponent.GetSquadById(squad.Id);
Assert.NotEmpty(squad.Members);
await squadComponent.UnRegisterMember(squad.Id, user.Id);
squad = await squadQueryComponent.GetSquadById(squad.Id);
Assert.Empty(squad.Members);
}
public async Task FeatureMaintenanceSquadSucces()
{
var container = ComponentTestFactory.BuildContainer();
var(customer, productId) = await ComponentTestFactory.BuildCustomerProduct(container);
var squadComponent = container.GetInstance <SquadComponent>();
var squadQueryComponent = container.GetInstance <SquadQueryComponent>();
var featureComponent = container.GetInstance <FeatureComponent>();
var featureQueryComponent = container.GetInstance <FeatureQueryComponent>();
var feature = await featureComponent.CreateFeature(new Models.FeaturePostRp()
{
Name = "test",
ProductId = productId
});
var squad = await squadComponent.CreateSquad(new Models.SquadPostRp()
{
Name = "test",
CustomerId = customer
});
await featureComponent.RegisterSquad(new Models.SquadFeaturePostRp()
{
FeatureId = feature.Id,
SquadId = squad.Id
});
var detail = await featureQueryComponent.GetFeatureByIdWithQuality(feature.Id,
new DatePeriodValue( OwlveyCalendar.January201903, OwlveyCalendar.January201906));
Assert.NotEmpty(detail.Squads);
var squadDetail = await squadQueryComponent.GetSquadById(squad.Id);
Assert.NotEmpty(squadDetail.Features);
}
public async Task journeyIdempotenceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var(customerId, productId) = await ComponentTestFactory.BuildCustomerProduct(container);
var journeyComponent = container.GetInstance <JourneyComponent>();
var journeyQueryComponent = container.GetInstance <JourneyQueryComponent>();
var journeyInstance = await journeyComponent.Create(new Models.JourneyPostRp()
{
Name = "test",
ProductId = productId,
});
journeyInstance = await journeyComponent.Create(new Models.JourneyPostRp()
{
Name = "test",
ProductId = productId,
});
}
public async Task journeyMapMaintenanceSucces()
{
var container = ComponentTestFactory.BuildContainer();
var(_, productId) = await ComponentTestFactory.BuildCustomerProduct(container);
var journey = await ComponentTestFactory.BuildJourney(container, productId);
var feature = await ComponentTestFactory.BuildFeature(container, productId);
var component = container.GetInstance <JourneyMapComponent>();
await component.CreateMap(new Models.JourneyMapPostRp()
{
FeatureId = feature,
JourneyId = journey
});
var journeys = await component.GetMaps(journey);
Assert.NotEmpty(journeys);
}
public async Task SourceMaintenanceSuccess()
{
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 target = await component.GetByName(product, "test");
Assert.NotNull(target);
Assert.NotNull(target.Avatar);
target = await component.GetById(target.Id);
Assert.NotNull(target);
Assert.NotNull(target.Avatar);
}
public async Task FeatureSeriesTest()
{
var container = ComponentTestFactory.BuildContainer();
var(customer, product) = await ComponentTestFactory.BuildCustomerProduct(container, defaultValues : true);
var productQueryComponent = container.GetInstance <ProductQueryComponent>();
var products = await productQueryComponent.GetProducts(customer);
product = products.ElementAt(0).Id;
var featureQueryComponent = container.GetInstance <FeatureQueryComponent>();
var features = await featureQueryComponent.GetFeatures(product);
var daily = await featureQueryComponent.GetDailyAvailabilitySeriesById(features.ElementAt(0).Id,
OwlveyCalendar.StartJanuary2019,
OwlveyCalendar.StartJuly2019);
Assert.Equal(163, daily.Series[0].Items.Count());
Assert.Equal(163, daily.Series[1].Items.Count());
Assert.NotEmpty(features);
}
public async Task IndicatorComplementSuccess()
{
var container = ComponentTestFactory.BuildContainer();
var(_, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var source = await ComponentTestFactory.BuildSource(container, product);
var source2 = await ComponentTestFactory.BuildSource(container, product, name : "second source");
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);
var complement = await component.GetSourcesComplement(feature);
Assert.NotEmpty(complement);
}
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);
}
public async Task SourceItemEndMiddle()
{
var container = ComponentTestFactory.BuildContainer();
var(_, product) = await ComponentTestFactory.BuildCustomerProduct(container);
var source = await ComponentTestFactory.BuildSource(container, product : product);
var sourceComponent = container.GetInstance <SourceComponent>();
var itemComponent = container.GetInstance <SourceItemComponent>();
await itemComponent.CreateAvailabilityItem(new SourceItemAvailabilityPostRp()
{
SourceId = source,
Start = OwlveyCalendar.January201905,
End = OwlveyCalendar.January201910,
Good = 900,
Total = 1000
});
var items = await itemComponent.GetBySourceIdAndDateRange(source, OwlveyCalendar.January201908, OwlveyCalendar.January201912);
Assert.NotEmpty(items);
}
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 FeatureDetail()
{
var container = ComponentTestFactory.BuildContainer();
var(customer, product) = await ComponentTestFactory.BuildCustomerProduct(container, defaultValues : true);
var sourceComponent = container.GetInstance <SourceComponent>();
var sourceItemComponent = container.GetInstance <SourceItemComponent>();
var featureComponent = container.GetInstance <FeatureComponent>();
var indicatorComponent = container.GetInstance <IndicatorComponent>();
var featureQueryComponent = container.GetInstance <FeatureQueryComponent>();
var feature = await featureComponent.CreateFeature(new FeaturePostRp()
{
Name = "test", ProductId = product
});
var source = await sourceComponent.Create(new SourcePostRp()
{
Name = "testSource", ProductId = product
});
await sourceItemComponent.CreateAvailabilityItem(new SourceItemAvailabilityPostRp()
{
Start = OwlveyCalendar.January201903,
End = OwlveyCalendar.January201903,
SourceId = source.Id,
Total = 1000,
Good = 800
});
await sourceItemComponent.CreateLatencyItem(new SourceItemLatencyPostRp()
{
Start = OwlveyCalendar.January201903,
End = OwlveyCalendar.January201903,
SourceId = source.Id,
Measure = 1500
});
await sourceItemComponent.CreateExperienceItem(new SourceItemExperiencePostRp()
{
Start = OwlveyCalendar.January201903,
End = OwlveyCalendar.January201903,
SourceId = source.Id,
Measure = 0.9m
});
await indicatorComponent.Create(feature.Id, source.Id);
var featureResult = await featureQueryComponent.GetFeatureByIdWithQuality(feature.Id, OwlveyCalendar.january2019);
Assert.NotEmpty(featureResult.Indicators);
Assert.Equal(0.8m, featureResult.Availability);
Assert.Equal(0.8m, featureResult.Indicators.First().Measure.Availability);
Assert.Equal(1000, featureResult.Indicators.First().Measure.Total);
Assert.Equal(800, featureResult.Indicators.First().Measure.Good);
Assert.Equal(1500m, featureResult.Latency);
Assert.Equal(1500m, featureResult.Indicators.First().Measure.Latency);
Assert.Equal(0.9m, featureResult.Experience);
Assert.Equal(0.9m, featureResult.Indicators.First().Measure.Experience);
}
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);
}
