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));
}
