public override void Setup() { base.Setup(); _coverageMinerMock = Fixture.Freeze <Mock <CoverageMiner> >(); _coverageValidatorMock = Fixture.Freeze <Mock <CoverageValidator> >(); _coverageMapperMock = Fixture.Freeze <Mock <CoverageMapper> >(); _coverageSenderMock = Fixture.Freeze <Mock <CoverageSender> >(); _responseMapperMock = Fixture.Freeze <Mock <ResponseMapper> >(); _sessionActivity = new SessionActivity(); _coverages = new List <Coverage> { new Coverage { Name = "Coverage 1" }, new Coverage { Name = "Coverage 2" } }; _coverageModel1 = new CoverageModel(); _coverageModel2 = new CoverageModel(); _responseModel1 = new ResponseModel(); _responseModel2 = new ResponseModel(); _response1 = new Response(); _response2 = new Response(); _coverageProcessor = new CoverageProcessor(_coverageMinerMock.Object, _coverageValidatorMock.Object, _coverageMapperMock.Object, _coverageSenderMock.Object, _responseMapperMock.Object); }
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); }
private async Task MakeAndPublishOnBehalfActivity(SessionActivityType type, Session session) { var accountOwner = await accountsService.GetAccountOwnerUserName(session.AccountId); var sessionActivity = new SessionActivity(type, session.SessionId, accountOwner, session.AccountId); await activityService.PublishActivity(sessionActivity); }
// GET api/values/5 public Response Get(int id) { var sessionActivity = new SessionActivity { Id = id }; return(_vueService.Serve(sessionActivity)); }
public void Process() { var policyProcessor = new PolicyProcessors(); var sessionActivity = new SessionActivity(); var response = policyProcessor.Process(sessionActivity); Assert.IsInstanceOfType(response, typeof(Response)); }
public void Mine() { var policyMiner = new PolicyMiner(); var sessionActivity = new SessionActivity(); var policy = policyMiner.Mine(sessionActivity); Assert.IsInstanceOfType(policy, typeof(Policy)); }
public void GetPolicy() { var dataServices = new DataServices(); var sessionActivity = new SessionActivity(); var policy = dataServices.GetPolicy(sessionActivity); Assert.IsInstanceOfType(policy, typeof(Policy)); }
public void Service() { var vueServices = new VueServices(); var sessionActivity = new SessionActivity(); var response = vueServices.Service(sessionActivity); Assert.IsInstanceOfType(response, typeof(Response)); }
public void PolicyMinersSetup() { _dataFactoryMock = new Mock <DataFactory>(); _policyServiceMock = new Mock <PolicyService>(); _sessionActivity = new SessionActivity(); _policy = new Policy(); _policyMiner = new PolicyMiner(_dataFactoryMock.Object); }
public void Setup() { _dataStorageMock = new Mock <DataStorage.Database.DataStorage>(); _dataFactoryMock = new Mock <DataFactory>(); _policy = new Policy(); _sessionActivity = new SessionActivity(); _policyDataServices = new PolicyDataServices(_dataFactoryMock.Object); }
public void Setup() { _businessServicesFactoryMock = new Mock <BusinessServicesFactory>(); _policyProcessorMock = new Mock <PolicyProcessor>(); _sessionActivity = new SessionActivity(); _response = new Response(); _vueService = new VueService(_businessServicesFactoryMock.Object); }
public async Task <IActionResult> Login(string accountId) { var userName = User.GetUsername(); var sessionId = await sessionService.GenerateSessionId(); var activity = new SessionActivity(SessionActivityType.Login, sessionId, userName, accountId); await activityService.PublishActivity(activity); return(Ok()); }
public void VueInterface() { SessionActivity sessionActivity = new SessionActivity { Id = 7 }; var vueService = new VueServices(); var response = vueService.Service(sessionActivity); Console.WriteLine(response.OwnerName, "\n", response.PolicyName); }
public override void Setup() { base.Setup(); _dataServicesMock = Fixture.Freeze <Mock <DataServices> >(); _sessionActivity = new SessionActivity(); _coverage = new List <Coverage>(); _coverageMiner = new CoverageMiner(_dataServicesMock.Object); }
public Response Serve(SessionActivity sessionActivity) { var response = _policyProcessor.Process(sessionActivity); if (!response.Successful) { return(response); } return(_coverageProcessor.Process(sessionActivity)); }
static void Main() { var session = new SessionActivity { PolicyId = 1 }; var service = new VueService(new BusinessServicesFactory(new DataFactory(), new SenderFactory(new DestinationFactory()))); var response = service.SendPolicyData(session); Console.WriteLine(response.Message); Console.WriteLine(response.Successful.ToString()); }
static void Main() { var session = new SessionActivity { PolicyId = 2 }; var vueService = new VueService(new BusinessServiceFactory(new DataFactory(), new SenderFactory(new DestinationFactory()))); var response = vueService.PolicyService(session); Console.WriteLine(response.OwnerName); Console.WriteLine(response.PolicyNumber); }
public override void Setup() { base.Setup(); _dataStorageMock = Fixture.Freeze <Mock <DataStorage> >(); _sessionActivity = new SessionActivity { Id = 2 }; _policy = new Policy(); _coverages = new List <Coverage>(); _dataService = new DataServices(_dataStorageMock.Object); }
public virtual Response Process(SessionActivity sessionActivity) { var policyMiner = _businessServiceFactory.CreatePolicyMiner(); var policy = policyMiner.Mine(sessionActivity); var policyMapper = _businessServiceFactory.CreatePolicyMapper(); var policyModel = policyMapper.Map(policy); var policySender = _businessServiceFactory.SenderFactory.CreatePolicySender(); var responseModel = policySender.Send(policyModel); var responseMapper = _businessServiceFactory.CreateResponseMapper(); var response = responseMapper.Map(responseModel); return(response); }
public Response Process(SessionActivity sessionActivity) { var policyMiner = new PolicyMiner(); var policy = policyMiner.Mine(sessionActivity); var policyMapper = new PolicyMapper(); var policyModel = policyMapper.Map(policy); var policySender = new PolicySender(); var responseModel = policySender.Send(policyModel); var responseMapper = new ResponseMapper(); var response = responseMapper.Map(responseModel); return(response); }
public void Setup() { _businessServiceFactoryMock = new Mock <BusinessServiceFactory>(); _policyMinerMock = new Mock <PolicyMiners>(); _policyMapperMock = new Mock <PolicyMappers>(); _policySenderMock = new Mock <PolicySender>(); _responseMapperMock = new Mock <ResponseMappers>(); _senderFactoryMock = new Mock <SenderFactory>(); _sessionActivity = new SessionActivity(); _policy = new Policy(); _policyModel = new PolicyModel(); _responseModel = new ResponseModel(); _response = new Response(); _policyProcessor = new PolicyProcessors(_businessServiceFactoryMock.Object); }
public virtual Response Process(SessionActivity sessionActivity) { var policy = _policyMiner.Mine(sessionActivity); var validation = _policyValidator.Validate(policy); if (validation == false) { return(new Response { Message = "Failed validation", Successful = false }); } var policyModel = _policyMapper.Map(policy); var responseModel = _policySender.Send(policyModel); var response = _responseMapper.Map(responseModel); return(response); }
public virtual Response Process(SessionActivity sessionActivity) { var policy = _policyMiner.Mine(sessionActivity); var valid = _policyValidator.Validate(policy); if (!valid) { Response failedResponse = new Response { Successful = false, Message = "This response is not valid" }; return(failedResponse); } var policyModel = _policyMapper.Map(policy); var responseModel = _policySender.Send(policyModel); var response = _responseMapper.Map(responseModel); return(response); }
public void GetPolicyTest() { // Arrange var sessionActivity = new SessionActivity { PolicyId = 7 }; _dataFactoryMock.Setup(c => c.CreatePolicyDataStorage()).Returns(_policyDataStorageMock.Object); _policyDataStorageMock.Setup(c => c.GetData(7)).Returns(new Policy()); // Act var result = _service.GetPolicy(sessionActivity); // Assert Assert.IsInstanceOfType(result, typeof(Policy)); _dataFactoryMock.Verify(c => c.CreatePolicyDataStorage(), Times.Once); _policyDataStorageMock.Verify(c => c.GetData(7), Times.Once); _dataFactoryMock.VerifyNoOtherCalls(); _policyDataStorageMock.VerifyNoOtherCalls(); }
public async Task <IActionResult> Activity(string collabId, int page = 1) { try { await InitClient(); var detail = CollaborationService.GetDetailsAsync(collabId); var ars = CollaborationService.GetActivity(collabId, page); await Task.WhenAll(detail, ars); var cd = new CollaborationDetails { Collab = detail.Result, IsSessionActivityPage = true }; var model = new SessionActivity { Activities = ars.Result, CollaborationDetails = cd }; return(View(model)); } catch (StudioApiException e) { return(HandleError(e)); } }
public Policy Mine(SessionActivity sessionActivity) { var dataService = new DataServices(); return(dataService.GetPolicy(sessionActivity)); }
public async Task PublishActivity(SessionActivity activity) { await publisher.ProduceAsync(activity); }
public Task PublishActivity(Session session, SessionActivityType activityType) { var activity = new SessionActivity(activityType, session.SessionId, session.UserName, session.AccountId); return(PublishActivity(activity)); }
public virtual Response PolicyService(SessionActivity sessionActivity) { var policyProcessor = _businessServiceFactory.CreatePolicyProcessor(); return(policyProcessor.Process(sessionActivity)); }
public Policy GetPolicy(SessionActivity sessionActivity) { var dataStorage = new DataStorage(); return(dataStorage.PolicyData(sessionActivity.Id)); }