public async Task Then_No_Provider_Acknowledged_Rules_Are_Returned()
        {
            //Arrange
            const int ukPrn = 12345;

            var acknowledgement = new UserRuleAcknowledgement
            {
                TypeOfRule = RuleType.GlobalRule,
                UkPrn      = ukPrn
            };

            var rule = new GlobalRule
            {
                ActiveFrom = DateTime.Now.AddDays(2),
                UserRuleAcknowledgements = new List <UserRuleAcknowledgement> {
                    acknowledgement
                }
            };

            var fundingRules = new GetFundingRulesApiResponse
            {
                Rules       = new List <ReservationRule>(),
                GlobalRules = new List <GlobalRule> {
                    rule
                }
            };

            _service.Setup(s => s.GetFundingRules()).ReturnsAsync(fundingRules);

            //Act
            var actual = await _handler.Handle(new GetNextUnreadGlobalFundingRuleQuery { Id = ukPrn.ToString() }, new CancellationToken());

            //Assert
            Assert.IsNull(actual.Rule);
        }
Example #2
0
        public void Then_The_UkPrn_Is_Set_If_The_Id_Is_Numeric()
        {
            //Arrange
            var expectedUkPrn = 45345;

            //Act
            var actual = new UserRuleAcknowledgement(expectedUkPrn.ToString(), 1, RuleType.GlobalRule);

            //Assert
            Assert.AreEqual(expectedUkPrn, actual.UkPrn);
        }
Example #3
0
        public void Then_The_UserId_Is_Set_If_The_Id_Is_A_Guid()
        {
            //Arrange
            var expectedUserId = Guid.NewGuid();

            //Act
            var actual = new UserRuleAcknowledgement(expectedUserId.ToString(), 1, RuleType.GlobalRule);

            //Assert
            Assert.AreEqual(expectedUserId, actual.UserId);
        }
Example #4
0
        private static Domain.Entities.UserRuleNotification MapUserRuleAcknowledgement(IUserRuleAcknowledgementRequest request)
        {
            var userRuleNotification = new UserRuleAcknowledgement(request.Id, request.RuleId, request.TypeOfRule);

            return(new Domain.Entities.UserRuleNotification
            {
                CourseRuleId = userRuleNotification.CourseRuleId,
                GlobalRuleId = userRuleNotification.GlobalRuleId,
                UkPrn = userRuleNotification.UkPrn,
                UserId = userRuleNotification.UserId
            });
        }
        public async Task Then_Will_Return_Nearest_Rules_That_Has_Not_Been_Acknowledged_By_User()
        {
            //Arrange
            const int ukPrn = 12345;

            var acknowledgement = new UserRuleAcknowledgement
            {
                TypeOfRule = RuleType.GlobalRule,
                UkPrn      = ukPrn
            };

            var acknowledgeRule = new GlobalRule
            {
                ActiveFrom = DateTime.Now.AddDays(2),
                UserRuleAcknowledgements = new List <UserRuleAcknowledgement> {
                    acknowledgement
                }
            };

            var expectedRule = new GlobalRule
            {
                ActiveFrom = DateTime.Now.AddDays(3),
                UserRuleAcknowledgements = new List <UserRuleAcknowledgement>()
            };

            var futureRule = new GlobalRule
            {
                ActiveFrom = DateTime.Now.AddDays(4),
                UserRuleAcknowledgements = new List <UserRuleAcknowledgement>()
            };

            var fundingRules = new GetFundingRulesApiResponse
            {
                Rules       = new List <ReservationRule>(),
                GlobalRules = new List <GlobalRule> {
                    acknowledgeRule, expectedRule, futureRule
                }
            };

            _service.Setup(s => s.GetFundingRules()).ReturnsAsync(fundingRules);

            //Act
            var actual = await _handler.Handle(new GetNextUnreadGlobalFundingRuleQuery { Id = ukPrn.ToString() }, new CancellationToken());

            //Assert
            Assert.IsNotNull(actual.Rule);
            Assert.AreEqual(expectedRule, actual.Rule);
        }
Example #6
0
        public void Then_The_RuleId_Is_Correctly_Set_Based_On_The_Type(short ruleType)
        {
            //Arrange
            const int expectedRuleId = 543;

            //Act
            var actual = new UserRuleAcknowledgement("1", expectedRuleId, (RuleType)ruleType);

            //Assert
            if (((RuleType)ruleType).Equals(RuleType.GlobalRule))
            {
                Assert.AreEqual(expectedRuleId, actual.GlobalRuleId);
            }
            if (((RuleType)ruleType).Equals(RuleType.CourseRule))
            {
                Assert.AreEqual(expectedRuleId, actual.CourseRuleId);
            }
        }