예제 #1
0
        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);
        }
예제 #2
0
        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);
        }
예제 #3
0
        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);
        }
예제 #4
0
        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);
        }
예제 #5
0
        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);
        }
예제 #6
0
        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);
        }
예제 #7
0
        public async Task FeatureDeleteSuccess()
        {
            var container             = ComponentTestFactory.BuildContainer();
            var dbcontext             = container.GetInstance <FalconDbContext>();
            var featureComponent      = container.GetInstance <FeatureComponent>();
            var featureQueryComponent = container.GetInstance <FeatureQueryComponent>();
            var data = await ComponentTestFactory.BuildCustomerWithSquad(container,
                                                                         OwlveyCalendar.January201903, OwlveyCalendar.January201905);

            await featureComponent.DeleteFeature(data.featureId);

            var feature = await featureQueryComponent.GetFeatureById(data.featureId);

            Assert.Null(feature);

            var indicators = dbcontext.Indicators.Where(c => c.FeatureId == data.featureId).ToList();

            Assert.Empty(indicators);
        }