コード例 #1
0
        public void NoRiskPage_Initialize_Display()
        {
            mockExposureDataRepository
            .Setup(x => x.GetDailySummariesAsync(AppConstants.DaysOfExposureInformationToDisplay))
            .Returns(Task.FromResult(new List <DailySummary>()));

            var exposureCheckPageViewModel = CreateViewModel();
            var parameters = ExposureCheckPage.BuildNavigationParams(new V1ExposureRiskCalculationConfiguration());

            exposureCheckPageViewModel.Initialize(parameters);
            Assert.False(exposureCheckPageViewModel.IsVisibleLowRiskContact);
            Assert.True(exposureCheckPageViewModel.IsVisibleNoRiskContact);
        }
コード例 #2
0
        public async void NoRiskPage_Initialize_Display()
        {
            mockExposureDataRepository
            .Setup(x => x.GetDailySummariesAsync(AppConstants.TermOfExposureRecordValidityInDays))
            .Returns(Task.FromResult(new List <DailySummary>()));

            var exposureCheckPageViewModel = CreateViewModel();
            var parameters = ExposureCheckPage.BuildNavigationParams(new V1ExposureRiskCalculationConfiguration());

            exposureCheckPageViewModel.Initialize(parameters);
            await exposureCheckPageViewModel.Setup();

            Assert.False(exposureCheckPageViewModel.IsExposureDetected);
        }
コード例 #3
0
        public void LowRiskPage_Initialize_Display()
        {
            var dummyDailySummaries = new List <DailySummary>()
            {
                new DailySummary()
                {
                    DateMillisSinceEpoch = (new DateTime().AddDays(0).Date).ToUnixEpochMillis(),
                    DaySummary           = new ExposureSummaryData()
                    {
                        ScoreSum = 1700
                    },
                },
                new DailySummary()
                {
                    DateMillisSinceEpoch = (new DateTime().AddDays(1).Date).ToUnixEpochMillis(),
                    DaySummary           = new ExposureSummaryData()
                    {
                        ScoreSum = 1700
                    },
                },
                new DailySummary()
                {
                    DateMillisSinceEpoch = (new DateTime().AddDays(2).Date).ToUnixEpochMillis(),
                    DaySummary           = new ExposureSummaryData()
                    {
                        ScoreSum = 1000
                    },
                },
            };
            var dummyExposureWindows = new List <ExposureWindow>()
            {
                new ExposureWindow()
                {
                    DateMillisSinceEpoch = (new DateTime().AddDays(0).Date).ToUnixEpochMillis(),
                    ScanInstances        = new List <ScanInstance>()
                    {
                        new ScanInstance()
                        {
                            SecondsSinceLastScan = 840,
                        }
                    },
                },
                new ExposureWindow()
                {
                    DateMillisSinceEpoch = (new DateTime().AddDays(1).Date).ToUnixEpochMillis(),
                    ScanInstances        = new List <ScanInstance>()
                    {
                        new ScanInstance()
                        {
                            SecondsSinceLastScan = 840,
                        }
                    },
                },
                new ExposureWindow()
                {
                    DateMillisSinceEpoch = (new DateTime().AddDays(2).Date).ToUnixEpochMillis(),
                    ScanInstances        = new List <ScanInstance>()
                    {
                        new ScanInstance()
                        {
                            SecondsSinceLastScan = 900,
                        }
                    },
                },
            };

            mockUserDataRepository
            .Setup(x => x.GetDaysOfUse())
            .Returns(14);

            mockDateTimeUtility
            .Setup(x => x.UtcNow)
            .Returns((new DateTime()).AddDays(14));

            mockExposureDataRepository
            .Setup(x => x.GetDailySummariesAsync(AppConstants.TermOfExposureRecordValidityInDays))
            .ReturnsAsync(dummyDailySummaries);

            mockExposureDataRepository
            .Setup(x => x.GetExposureWindowsAsync(AppConstants.TermOfExposureRecordValidityInDays))
            .ReturnsAsync(dummyExposureWindows);

            var riskConfiguration = new V1ExposureRiskCalculationConfiguration()
            {
                DailySummary_DaySummary_ScoreSum = new Threshold()
                {
                    Op    = Threshold.OPERATION_GREATER_EQUAL,
                    Value = 1170,
                },
                ExposureWindow_ScanInstance_SecondsSinceLastScanSum = new Threshold()
                {
                    Op    = Threshold.OPERATION_GREATER_EQUAL,
                    Value = 900,
                },
            };

            var exposureCheckPageViewModel = CreateViewModel();
            var parameters = ExposureCheckPage.BuildNavigationParams(riskConfiguration);

            exposureCheckPageViewModel.Initialize(parameters);

            Assert.True(exposureCheckPageViewModel.IsExposureDetected);

            Assert.Equal(14, exposureCheckPageViewModel.ExposureCheckScores.Count());

            var dates = Enumerable.Range(0, 14)
                        .Select(offset => new DateTime().AddDays(offset).Date.ToUnixEpochMillis())
                        .ToList();

            dates.Sort((a, b) => b.CompareTo(a));

            // Sort DESC
            for (int i = 0; i < 14; i++)
            {
                Assert.Equal(dates[i], exposureCheckPageViewModel.ExposureCheckScores[i].DateMillisSinceEpoch);
            }

            Assert.Equal(dummyDailySummaries[2].DateMillisSinceEpoch, exposureCheckPageViewModel.ExposureCheckScores[11].DateMillisSinceEpoch);
            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[11].IsScoreVisible);
            Assert.False(exposureCheckPageViewModel.ExposureCheckScores[11].IsDurationTimeVisible);
            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[11].IsReceived);

            Assert.Equal(dummyDailySummaries[1].DateMillisSinceEpoch, exposureCheckPageViewModel.ExposureCheckScores[12].DateMillisSinceEpoch);
            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[12].IsScoreVisible);
            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[12].IsDurationTimeVisible);
            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[12].IsReceived);

            Assert.Equal(dummyDailySummaries[0].DateMillisSinceEpoch, exposureCheckPageViewModel.ExposureCheckScores[13].DateMillisSinceEpoch);
            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[13].IsScoreVisible);
            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[13].IsDurationTimeVisible);
            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[13].IsReceived);
        }
コード例 #4
0
        public void LowRiskPage_Initialize_Display()
        {
            mockExposureDataRepository
            .Setup(x => x.GetDailySummariesAsync(AppConstants.DaysOfExposureInformationToDisplay))
            .ReturnsAsync(new List <DailySummary>()
            {
                new DailySummary()
                {
                    DateMillisSinceEpoch = (1000 * 60 * 60 * 24),
                    DaySummary           = new ExposureSummaryData()
                    {
                        ScoreSum = 1700
                    },
                },
                new DailySummary()
                {
                    DateMillisSinceEpoch = (1000 * 60 * 60 * 24) * 2,
                    DaySummary           = new ExposureSummaryData()
                    {
                        ScoreSum = 1700
                    },
                },
                new DailySummary()
                {
                    DateMillisSinceEpoch = (1000 * 60 * 60 * 24) * 3,
                    DaySummary           = new ExposureSummaryData()
                    {
                        ScoreSum = 1000
                    },
                },
            });

            mockExposureDataRepository
            .Setup(x => x.GetExposureWindowsAsync(AppConstants.DaysOfExposureInformationToDisplay))
            .ReturnsAsync(new List <ExposureWindow>()
            {
                new ExposureWindow()
                {
                    DateMillisSinceEpoch = (1000 * 60 * 60 * 24),
                    ScanInstances        = new List <ScanInstance>()
                    {
                        new ScanInstance()
                        {
                            SecondsSinceLastScan = 900,
                        }
                    },
                },
                new ExposureWindow()
                {
                    DateMillisSinceEpoch = (1000 * 60 * 60 * 24) * 2,
                    ScanInstances        = new List <ScanInstance>()
                    {
                        new ScanInstance()
                        {
                            SecondsSinceLastScan = 840,
                        }
                    },
                },
                new ExposureWindow()
                {
                    DateMillisSinceEpoch = (1000 * 60 * 60 * 24) * 3,
                    ScanInstances        = new List <ScanInstance>()
                    {
                        new ScanInstance()
                        {
                            SecondsSinceLastScan = 840,
                        }
                    },
                },
            });

            var riskConfiguration = new V1ExposureRiskCalculationConfiguration()
            {
                DailySummary_DaySummary_ScoreSum = new Threshold()
                {
                    Op    = Threshold.OPERATION_GREATER_EQUAL,
                    Value = 1170,
                },
                ExposureWindow_ScanInstance_SecondsSinceLastScanSum = new Threshold()
                {
                    Op    = Threshold.OPERATION_GREATER_EQUAL,
                    Value = 900,
                },
            };

            var exposureCheckPageViewModel = CreateViewModel();
            var parameters = ExposureCheckPage.BuildNavigationParams(riskConfiguration);

            exposureCheckPageViewModel.Initialize(parameters);

            Assert.True(exposureCheckPageViewModel.IsVisibleLowRiskContact);
            Assert.False(exposureCheckPageViewModel.IsVisibleNoRiskContact);

            Assert.Equal(3, exposureCheckPageViewModel.ExposureCheckScores.Count());

            // Sort DESC
            Assert.Equal((1000 * 60 * 60 * 24) * 3, exposureCheckPageViewModel.ExposureCheckScores[0].DateMillisSinceEpoch);
            Assert.Equal((1000 * 60 * 60 * 24) * 2, exposureCheckPageViewModel.ExposureCheckScores[1].DateMillisSinceEpoch);
            Assert.Equal(1000 * 60 * 60 * 24, exposureCheckPageViewModel.ExposureCheckScores[2].DateMillisSinceEpoch);

            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[0].IsScoreVisible);
            Assert.False(exposureCheckPageViewModel.ExposureCheckScores[0].IsDurationTimeVisible);

            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[1].IsScoreVisible);
            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[1].IsDurationTimeVisible);

            Assert.True(exposureCheckPageViewModel.ExposureCheckScores[2].IsScoreVisible);
            Assert.False(exposureCheckPageViewModel.ExposureCheckScores[2].IsDurationTimeVisible);
        }