Esempio n. 1
0
        public void Exit_Steps_Delegates_To_Service()
        {
            var input = "6 5 4, 3 2 1";
            IList <IList <int> > numericInput = new List <IList <int> >
            {
                new List <int>()
                {
                    6, 5, 4
                },
                new List <int>()
                {
                    3, 2, 1
                }
            };
            IList <int> flattenedInput = new List <int>()
            {
                6, 5, 4, 3, 2, 1
            };

            var       validatorRepository = NumericValidatorTestHelper.SetupValidator(numericInput);
            const int expectedExitSteps   = 337;
            var       serviceRepository   = SetupService(flattenedInput, expectedExitSteps);

            var controller = CreateController(validatorRepository, serviceRepository);
            var result     = SuccessfulDetermineExitSteps(controller, input);

            Assert.Equal(expectedExitSteps, result.Result);
            Assert.Equal(input, result.Input);
            Assert.Equal(flattenedInput, result.InputRows);

            validatorRepository.Verify(validator => validator.Validate(input), Times.Once);
            serviceRepository.Verify(service => service.DetermineExitSteps(flattenedInput), Times.Once);
        }
Esempio n. 2
0
        public void Calculate_Delegates_To_Service()
        {
            var input = "1 2 3, 5 6 8";
            IList <IList <int> > numericInput = new List <IList <int> >
            {
                new List <int>()
                {
                    1, 2, 3
                },
                new List <int>()
                {
                    5, 6, 9
                }
            };

            var       validatorRepository = NumericValidatorTestHelper.SetupValidator(numericInput);
            const int expectedResult      = 378929;
            var       serviceRepository   = SetupService(numericInput, expectedResult);

            var controller = CreateController(validatorRepository, serviceRepository);
            var result     = SuccessfulCompute(controller, input);

            Assert.Equal(expectedResult, int.Parse(result.Result));
            Assert.Equal(input, result.Input);
            Assert.Equal(numericInput, result.InputRows);

            validatorRepository.Verify(validator => validator.Validate(input), Times.Once);
            serviceRepository.Verify(service => service.Compute(numericInput), Times.Once);
        }
Esempio n. 3
0
        public void Exit_Steps_Performs_Validation()
        {
            var input = string.Empty;
            var validatorRepository = NumericValidatorTestHelper.SetupValidator(null, false);
            var serviceRepository   = SetupService(null);

            var controller       = CreateController(validatorRepository, serviceRepository);
            var controllerResult = controller.DetermineExitSteps(input);

            ControllerTestHelper <ExitStepResponse> .BadRequestResult(controllerResult);

            validatorRepository.Verify(validator => validator.Validate(input), Times.Once);
            serviceRepository.Verify(service => service.DetermineExitSteps(null), Times.Never);
        }
Esempio n. 4
0
        public void Calculate_Perfoms_Validation()
        {
            var input = string.Empty;
            var validatorRepository = NumericValidatorTestHelper.SetupValidator(null, false);
            var serviceRepository   = SetupService(null);

            var controller       = CreateController(validatorRepository, serviceRepository);
            var controllerResult = controller.Calculate(input);

            ControllerTestHelper <CheckSumResponse> .BadRequestResult(controllerResult);

            validatorRepository.Verify(validator => validator.Validate(input), Times.Once);
            serviceRepository.Verify(service => service.Compute(null), Times.Never);
        }