Exemple #1
0
        public async Task WhenFundingIsPaused_AndFromManage_ThenBackLinkSetToManage(
            string expectedBackLink,
            uint ukprn,
            [Frozen] Mock <IMediator> mockMediator,
            GetFundingRulesResult result,
            [Frozen] Mock <IUrlHelper> mockUrlHelper,
            [Frozen] Mock <IExternalUrlHelper> mockExternalUrlHelper,
            GlobalRule rule,
            ProviderReservationsController controller)
        {
            //Arrange
            rule.ActiveFrom = DateTime.UtcNow.AddDays(-5);
            result.GlobalRules.Add(rule);

            mockMediator
            .Setup(x => x.Send(It.IsAny <GetFundingRulesQuery>(), CancellationToken.None))
            .ReturnsAsync(result);
            mockUrlHelper
            .Setup(x => x.RouteUrl(It.IsAny <UrlRouteContext>()))
            .Returns(expectedBackLink);
            mockExternalUrlHelper
            .Setup(x => x.GenerateDashboardUrl(It.IsAny <string>()))
            .Returns("unexpectedUrl");
            controller.Url = mockUrlHelper.Object;
            //Act
            var viewResult = await controller.Start(ukprn, true) as ViewResult;

            //Assert
            Assert.NotNull(viewResult);
            Assert.NotNull(viewResult.Model as string);
            Assert.AreEqual(expectedBackLink, viewResult.Model as string);
            mockUrlHelper.Verify(x => x.RouteUrl(It.Is <UrlRouteContext>(y => y.RouteName == RouteNames.ProviderManage)), Times.Once);
            mockExternalUrlHelper.Verify(x => x.GenerateDashboardUrl(It.IsAny <string>()), Times.Never);
        }
        public void ThenWillHaveActiveAccountRules()
        {
            //Arrange
            var result = new GetFundingRulesResult
            {
                GlobalRules  = new List <GlobalRule>(),
                AccountRules = new List <ReservationRule>()
            };

            var expectedActiveRule = new ReservationRule
            {
                ActiveFrom = DateTime.Now.AddDays(-2),
                ActiveTo   = DateTime.Now.AddDays(2)
            };

            //Act
            result.AccountRules.Add(expectedActiveRule);

            //Assert
            Assert.AreEqual(1, result.AccountRules.Count);
            Assert.AreEqual(1, result.ActiveAccountRules.Count());

            var activeRule = result.ActiveAccountRules.First();

            Assert.AreEqual(expectedActiveRule, activeRule);
        }
        public void ThenWillHaveNoActiveGlobalRules()
        {
            //Arrange
            var result = new GetFundingRulesResult
            {
                GlobalRules  = new List <GlobalRule>(),
                AccountRules = new List <ReservationRule>()
            };

            var expectedGlobalRule = new GlobalRule
            {
                ActiveFrom = DateTime.Now.AddDays(2)
            };

            result.GlobalRules.Add(expectedGlobalRule);

            //Assert
            Assert.AreEqual(1, result.GlobalRules.Count);
            Assert.IsEmpty(result.ActiveGlobalRules);
        }