public virtual Response Process(SessionActivity sessionActivity)
        {
            var response = new Response();

            var coverages = _coverageMiner.Mine(sessionActivity);

            foreach (var coverage in coverages)
            {
                var valid = _coverageValidator.Validate(coverage);

                if (!valid)
                {
                    response.Message = "The coverage is not valid";

                    return(response);
                }

                var coverageModel = _coverageMapper.Map(coverage);

                var responseModel = _coverageSender.Send(coverageModel);

                if (!responseModel.Successful)
                {
                    response.Message = responseModel.Message;

                    return(response);
                }

                response = _responseMapper.Map(responseModel);
            }

            response.Successful = true;
            response.Message    = "The policy has been received";
            return(response);
        }
Пример #2
0
        public void Mine()
        {
            _dataServiceMock.Setup(c => c.ServeCoverage(TestSessionActivity)).Returns(_coverages);

            var result = _coverageMiner.Mine(TestSessionActivity);

            Assert.AreSame(_coverages, result);

            _dataServiceMock.Verify(c => c.ServeCoverage(TestSessionActivity), Times.Once);

            _dataServiceMock.VerifyNoOtherCalls();
        }
        public void Mine()
        {
            // Arrange
            _dataServicesMock.Setup(c => c.CoverageService(_sessionActivity)).Returns(_coverage);

            // Act
            var result = _coverageMiner.Mine(_sessionActivity);

            // Assert
            Assert.AreSame(_coverage, result);

            _dataServicesMock.Verify(c => c.CoverageService(_sessionActivity), Times.Once);

            _dataServicesMock.VerifyNoOtherCalls();
        }