public void CannotAddAPolicyAlreadyExisting()
{
// Arrange
var repository = new PolicyRepository();
var controller = new PolicyController(repository);
var newPolicy = new Policy()
{
PolicyNumber = 462946,
PolicyHolder = new PolicyHolder()
{
Name = "Peter Parker",
Age = 34,
Gender = Gender.Male
}
};
// Act
var response = controller.Add(newPolicy);
// Assert
var policies = ((IList <Policy>)repository.Get());
Assert.AreEqual(7, policies.Count);
Assert.IsTrue(policies.IndexOf(newPolicy) == -1);
Assert.IsInstanceOfType(response.Result, typeof(BadRequestResult));
}
public void UpdateAPolicy()
{
// Arrange
var repository = new PolicyRepository();
var controller = new PolicyController(repository);
var updatePolicy = new Policy()
{
PolicyNumber = 383002,
PolicyHolder = new PolicyHolder()
{
Name = "Peter Parker",
Age = 34,
Gender = Gender.Male
}
};
// Act
var response = controller.Update(383002, updatePolicy);
// Assert
var policies = ((IList <Policy>)repository.Get());
Assert.AreEqual(7, policies.Count);
Assert.AreEqual(response.Value, updatePolicy);
Assert.IsTrue(policies.IndexOf(updatePolicy) > -1);
Assert.IsInstanceOfType(response.Value, typeof(Policy));
}
public async Task GetFundingPeriods_GivenTwoFundingPeriodContainedInConfigs_ReturnsCollectionWithTwoFundingPeriods()
{
//Arrange
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
policiesApiClient
.GetFundingConfigurationsByFundingStreamId(Arg.Is(fundingStreamId))
.Returns(new ApiResponse <IEnumerable <FundingConfiguration> >(HttpStatusCode.OK,
new[] { new FundingConfiguration {
FundingPeriodId = "fp1"
}, new FundingConfiguration {
FundingPeriodId = "fp3"
} }));
policiesApiClient
.GetFundingPeriods()
.Returns(new ApiResponse <IEnumerable <FundingPeriod> >(HttpStatusCode.OK, GetFundingPeriods()));
PolicyController policyController = CreateController(policiesApiClient);
//Act
IActionResult result = await policyController.GetFundingPeriods(fundingStreamId);
//Assert
result
.Should()
.BeAssignableTo <OkObjectResult>();
IEnumerable <Reference> fundingPeriods = (result as OkObjectResult).Value as IEnumerable <Reference>;
fundingPeriods
.Should()
.HaveCount(2);
}
/// <summary>
/// Bu fonksiyon policy seçmemize yarar.
/// </summary>
/// <returns></returns>
private static string ChoosePolicy()
{
PolicyController policyController = new PolicyController();
List <PolicyModel> policyModels = policyController.GetPolicyModels();
int counter = 0;
foreach (var policy in policyModels)
{
counter += 1;
Console.WriteLine(counter + ") " + policy.Name + ": " + policy.Description + "\n");
}
do
{
Console.Write("Seçim: ");
int policyNumber = Convert.ToInt32(Console.ReadLine());
if (policyNumber > 0 && policyNumber <= policyModels.Count)
{
policyController.CreatePolicy(policyNumber);
return(policyModels[policyNumber - 1].ID);
}
else
{
Console.WriteLine("Policy Tekrar Seçiniz.");
}
} while (true);
}
public async Task GetFundingStreams_GivenTwoFundingStreamsReturned_ReturnsTwoFundingStreams()
{
//Arrange
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
policiesApiClient
.GetFundingStreams()
.Returns(new ApiResponse <IEnumerable <FundingStream> >(HttpStatusCode.OK, GetFundingStreams()));
PolicyController policyController = CreateController(policiesApiClient);
//Act
IActionResult result = await policyController.GetFundingStreams(false);
//Assert
result
.Should()
.BeAssignableTo <OkObjectResult>();
IEnumerable <FundingStream> fundingStreams = (result as OkObjectResult).Value as IEnumerable <FundingStream>;
fundingStreams
.Should()
.HaveCount(3);
}
public void CannotUpdateAPolicyThatDoesntExist()
{
// Arrange
var repository = new PolicyRepository();
var controller = new PolicyController(repository);
var updatePolicy = new Policy()
{
PolicyNumber = 1111111,
PolicyHolder = new PolicyHolder()
{
Name = "Peter Parker",
Age = 34,
Gender = Gender.Male
}
};
// Act
var response = controller.Update(383002, updatePolicy);
// Assert
var policies = ((IList <Policy>)repository.Get());
Assert.AreEqual(7, policies.Count);
Assert.IsTrue(policies.IndexOf(updatePolicy) == -1);
Assert.IsInstanceOfType(response.Result, typeof(NotFoundResult));
}
public async Task DeleteOk()
{
// arrange
Mock <IPolicyService> moqService = new Mock <IPolicyService>();
var policy = new Policy
{
PolicyNumber = 11111,
PolicyHolderId = 22222,
PolicyHolder = new PolicyHolder
{
Id = 2222,
Age = 22,
Gender = Gender.Male,
Name = "Sebastian"
}
};
moqService.Setup(get => get.GetByPolicyNumber(policy.PolicyNumber)).ReturnsAsync(policy);
moqService.Setup(r => r.Remove(policy.PolicyNumber));
//act
var controller = new PolicyController(moqService.Object);
var resultOk = await controller.Delete(policy.PolicyNumber) as ActionResult;
//assert
Assert.AreEqual(204, ((Microsoft.AspNetCore.Mvc.StatusCodeResult)resultOk).StatusCode);
}
public override void Execute(PolicyController controller)
{
ResourceController rc = controller.island.GetComponentInChildren <ResourceController>();
rc.current.Add(changes);
rc.current.SetMin();
rc.UpdateCurrentUI();
}
public void GetAllPoliciesTest()
{
PolicyController pc = new PolicyController();
var result = pc.Policies() as ViewResult;
List <Policy> actualElements = result.ViewBag.policies;
List <Policy> expectedItems = uw.Policies.GetAll().ToList();
Assert.AreEqual(expectedItems.Count, actualElements.Count);
}
public void ControllerTestFail(int policyId, int memberId, int benefitId)
{
Mock <IPolicyRepo> mock = new Mock <IPolicyRepo>();
mock.Setup(p => p.GetEligibleClaimAmount(policyId, memberId, benefitId)).Returns(d);
PolicyController pc = new PolicyController(mock.Object);
var result = (BadRequestResult)pc.GetEligibleClaimAmount(policyId, memberId, benefitId);
Assert.AreEqual(400, result.StatusCode);
}
public void PolicyGetProviderList_Controller_ValidInput_ReturnsOkResponseStatus(int policyId)
{
Mock <IPolicyRepo> mock = new Mock <IPolicyRepo>();
mock.Setup(p => p.GetChainOfProviders(policyId)).Returns(providerPolicies);
PolicyController pc = new PolicyController(mock.Object);
var result = pc.GetChainOfProviders(policyId) as OkObjectResult;
Assert.AreEqual(200, result.StatusCode);
}
public void EligibleBenefitTest_Controller_ValidInput_ReturnsOkResultStatus(int policyId, int memberId)
{
Mock <IPolicyRepo> mock = new Mock <IPolicyRepo>();
mock.Setup(p => p.GetEligibleBenefits(policyId, memberId)).Returns(s);
PolicyController pc = new PolicyController(mock.Object);
var result = pc.GetEligibleBenefit(policyId, memberId) as OkObjectResult;
Assert.AreEqual(200, result.StatusCode);
}
public Form1()
{
InitializeComponent();
dataClass = new PolicyController();
policies = new DownloadManager();
EventManager.EventManager.DownloadingInProgress += Downloading;
EventManager.EventManager.FinishDownloading += FinishDownload;
EventManager.EventManager.OnStartDownloading();
}
public void createPolicyOkTest()
{
Mock <IPolicyApplicationService> policyApplicationServiceMock = new Mock <IPolicyApplicationService>();
PolicyController policyController = new PolicyController(policyApplicationServiceMock.Object);
policyApplicationServiceMock.Setup(x => x.CreatePolicy(It.IsAny <PolicyRequest>())).Returns(getPolicyResponse());
var response = policyController.CreatePolicy(getPolicyRequest());
Assert.IsTrue(response.id > 0);
}
public void ControllerPassTest(int policyId)
{
Mock <IPolicyRepo> mock = new Mock <IPolicyRepo>();
mock.Setup(p => p.GetChainOfProviders(policyId)).Returns(providerPolicies);
PolicyController pc = new PolicyController(mock.Object);
var result = pc.GetChainOfProviders(policyId) as OkObjectResult;
Assert.AreEqual(200, result.StatusCode);
}
public void DeletePolicyTest()
{
PolicyController pc = new PolicyController();
Policy policy = new Policy();
policy.id_policy = 5;
var result = pc.DeletePolicy(policy) as RedirectResult;
Assert.AreEqual("~/Policy/Policies", result.Url);
}
public void RemovePolicyInstance(PolicyController pc)
{
// Use title to find the policy to remove
int pcid = policiesByEcology[pc.ecologyLevel]
.FindIndex((spc) => spc.title == pc.title);
if (pcid >= 0)
{
policiesByEcology[pc.ecologyLevel].RemoveAt(pcid);
}
}
public void CreatePolicyTest()
{
PolicyController pc = new PolicyController();
Policy policy = new Policy();
policy.policy_name = "unit testing";
policy.policy_description = "unit testing";
var result = pc.Policy(policy) as RedirectResult;
Assert.AreEqual("~/Policy/Policies", result.Url);
}
public void GetAllPolicies()
{
// Arrange
var repository = new PolicyRepository();
var controller = new PolicyController(repository);
// Act
IList <Policy> response = (IList <Policy>)controller.Get();
// Assert
Assert.AreEqual(7, response.Count);
}
public void EditPolicyTest()
{
PolicyController pc = new PolicyController();
Policy policy = new Policy();
policy.id_policy = 5;
policy.policy_name = "unit testing editing";
policy.policy_description = "unit testing editing";
var result = pc.SaveChanges(policy) as RedirectResult;
Assert.AreEqual("~/Policy/Policies", result.Url);
}
public void ControllerTestPass(int policyId, int memberId, int benefitId)
{
// double d=0.0;
// IActionResult i;
Mock <IPolicyRepo> mock = new Mock <IPolicyRepo>();
mock.Setup(p => p.GetEligibleClaimAmount(policyId, memberId, benefitId)).Returns(d);
PolicyController pc = new PolicyController(mock.Object);
OkObjectResult result = pc.GetEligibleClaimAmount(policyId, memberId, benefitId) as OkObjectResult;
Assert.AreEqual(200, result.StatusCode);
}
public void PolicyGetProviderList_Controller_InvalidInput_ReturnsBadRequestStatus(int policyId)
{
Mock <IPolicyRepo> mock = new Mock <IPolicyRepo>();
mock.Setup(p => p.GetChainOfProviders(policyId)).Returns(providerPolicies);
PolicyController pc = new PolicyController(mock.Object);
var result = (BadRequestResult)pc.GetChainOfProviders(policyId);
Assert.AreEqual(400, result.StatusCode);
}
public async Task Add_Calls_With_Null_Retunrs_400()
{
//Arrange
var repositoryMock = new Mock <IRepository <InsurancePolicy> >();
var sut = new PolicyController(null);
//Act
var result = await sut.Add(null) as BadRequestResult;
//Assert
Assert.IsNotNull(result);
repositoryMock.Verify(x => x.Add(It.IsAny <InsurancePolicy>()), Times.Never);
}
public void DeleteAPolicy()
{
// Arrange
var repository = new PolicyRepository();
var controller = new PolicyController(repository);
// Act
var response = controller.Remove(383002);
// Assert
Assert.IsTrue(response.Value);
Assert.AreEqual(6, ((IList <Policy>)repository.Get()).Count);
}
public void CannotDeleteAPolicyThatDoesntExist()
{
// Arrange
var repository = new PolicyRepository();
var controller = new PolicyController(repository);
// Act
var response = controller.Remove(1);
// Assert
Assert.AreEqual(7, ((IList <Policy>)repository.Get()).Count);
Assert.IsInstanceOfType(response.Result, typeof(NotFoundResult));
}
public void Get()
{
// arrange
Mock <IPolicyService> moqService = new Mock <IPolicyService>();
moqService.Setup(get => get.Get()).ReturnsAsync(_policies);
PolicyController contrl = new PolicyController(moqService.Object);
//act
var PolicyController = new PolicyController(moqService.Object);
var result = PolicyController.Get().Result;
//assert
Assert.AreEqual(result.Count(), _policies.Count);
}
public async Task GetOk(int policyNumber)
{
// arrange
Mock <IPolicyService> moqService = new Mock <IPolicyService>();
var police = _policies.Where(a => a.PolicyNumber == policyNumber).FirstOrDefault();
moqService.Setup(get => get.GetByPolicyNumber(policyNumber)).ReturnsAsync(police);
PolicyController contrl = new PolicyController(moqService.Object);
//act
var controller = new PolicyController(moqService.Object);
var resultOk = await controller.GetByPolicyNumber(policyNumber) as ActionResult <Policy>;
//assert
Assert.AreEqual(resultOk.Value.PolicyHolderId, police.PolicyHolderId);
}
public async Task GetFundingStreams_GivenTwoFundingStreamsReturned_ReturnsOneFundingStreamWhenSecurityTrimmed()
{
//Arrange
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
policiesApiClient
.GetFundingStreams()
.Returns(new ApiResponse <IEnumerable <FundingStream> >(HttpStatusCode.OK, GetFundingStreams()));
IAuthorizationHelper authorizationHelper = CreateAuthorizationHelper();
authorizationHelper
.GetUserFundingStreamPermissions(Arg.Any <ClaimsPrincipal>(), "DSG")
.Returns(new FundingStreamPermission {
CanCreateSpecification = false
});
authorizationHelper
.GetUserFundingStreamPermissions(Arg.Any <ClaimsPrincipal>(), "PSG")
.Returns(new FundingStreamPermission {
CanCreateSpecification = true
});
authorizationHelper
.GetUserFundingStreamPermissions(Arg.Any <ClaimsPrincipal>(), "Missing")
.Returns((FundingStreamPermission)null);
PolicyController policyController = CreateController(policiesApiClient, authorizationHelper);
//Act
IActionResult result = await policyController.GetFundingStreams(true);
//Assert
result
.Should()
.BeAssignableTo <OkObjectResult>();
IEnumerable <FundingStream> fundingStreams = (result as OkObjectResult).Value as IEnumerable <FundingStream>;
fundingStreams
.Should()
.HaveCount(1);
fundingStreams
.First()
.Id
.Should()
.Be("PSG");
}
public async Task GetBadRequest(int policyNumber)
{
// arrange
Mock <IPolicyService> moqService = new Mock <IPolicyService>();
var police = _policies.Where(a => a.PolicyNumber == policyNumber).FirstOrDefault();
moqService.Setup(get => get.GetByPolicyNumber(policyNumber)).ReturnsAsync(police);
PolicyController contrl = new PolicyController(moqService.Object);
//act
var controller = new PolicyController(moqService.Object);
var resultBad = await controller.GetByPolicyNumber(policyNumber) as ActionResult <Policy>;
//assert
Assert.AreEqual(((ObjectResult)resultBad.Result).StatusCode, 404);
}
public async Task DeleteBadRequest()
{
// arrange
Mock <IPolicyService> moqService = new Mock <IPolicyService>();
Policy policy = null;
int policyNumber = 12345;
moqService.Setup(get => get.GetByPolicyNumber(policyNumber)).ReturnsAsync(policy);
moqService.Setup(r => r.Remove(policyNumber));
//act
var controller = new PolicyController(moqService.Object);
var resultOk = await controller.Delete(policyNumber) as ActionResult;
//assert
Assert.AreEqual(404, ((Microsoft.AspNetCore.Mvc.ObjectResult)resultOk).StatusCode);
}
