787 lines
31 KiB
C#
787 lines
31 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Services;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Moq;
|
|
using NUnit.Framework;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Controllers;
|
|
using LCU.API.Internal.Operations.IncentiveApiLib.Services;
|
|
using LCU.API.Internal.Operations.IncentiveApiLib.Persistence;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Services.AutoDecision;
|
|
using LCU.Library.Internal.IncentiveApiModels.Common;
|
|
using LCU.Library.Internal.IncentiveApiModels.Entities;
|
|
using LCU.Library.Internal.IncentiveApiModels.Enums;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Models;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Exceptions;
|
|
using LCU.API.Internal.Operations.IncentiveApi.Models.DataTransfer;
|
|
|
|
namespace Application.UnitTests.Controllers
|
|
{
|
|
public class ActivityControllerTest
|
|
{
|
|
private ActivityController _controller;
|
|
private Mock<IActivityService> _mockActivityService;
|
|
private Mock<IActivityDetailService> _mockActivityDetailService;
|
|
private Mock<IUserService> _mockUserService;
|
|
private Mock<ICurrentUserService> _mockCurrentUserService;
|
|
private Mock<IDashboardService> _mockDashboardService;
|
|
private Mock<IActivityDecisionService> _mockActivityDecisionService;
|
|
private Mock<IEStatementService> _mockEStatementService;
|
|
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
_mockActivityService = new Mock<IActivityService>();
|
|
_mockActivityDetailService = new Mock<IActivityDetailService>();
|
|
_mockUserService = new Mock<IUserService>();
|
|
_mockCurrentUserService = new Mock<ICurrentUserService>();
|
|
_mockDashboardService = new Mock<IDashboardService>();
|
|
_mockActivityDecisionService = new Mock<IActivityDecisionService>();
|
|
_mockEStatementService = new Mock<IEStatementService>();
|
|
_controller = new ActivityController(_mockActivityService.Object, _mockActivityDetailService.Object, _mockUserService.Object,
|
|
_mockCurrentUserService.Object, _mockDashboardService.Object, _mockActivityDecisionService.Object, _mockEStatementService.Object);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Get_OK()
|
|
{
|
|
var filter = new ActivityFilter()
|
|
{
|
|
Limit = 999,
|
|
Page = 1
|
|
};
|
|
var results = new PagedResult<Activity>();
|
|
results.Items = new List<Activity>()
|
|
{
|
|
new Activity()
|
|
{
|
|
Id = 1
|
|
}
|
|
};
|
|
results.Total = 1;
|
|
|
|
_mockActivityService
|
|
.Setup(service => service.ListByFilterAsync(filter)).ReturnsAsync(results);
|
|
var result = await _controller.Get(filter);
|
|
Assert.NotNull(result);
|
|
|
|
var okResult = result as OkObjectResult;
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task POST_OK()
|
|
{
|
|
var activity = new Activity()
|
|
{
|
|
Product = Product.CheckCard,
|
|
State = ActivityState.Created,
|
|
EmployeeId = "55",
|
|
DepartmentId = 55,
|
|
SourceId = "444",
|
|
SourceSystem = SystemType.Dna
|
|
};
|
|
_mockActivityService
|
|
.Setup(service => service.SaveActivityAsync(activity)).ReturnsAsync(1);
|
|
|
|
var result = await _controller.CreateActivity(activity);
|
|
Assert.NotNull(result);
|
|
|
|
var okResult = result as OkObjectResult;
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Get_CurrentUserActivity_OK()
|
|
{
|
|
var user1 = new ApplicationUser()
|
|
{
|
|
Email = "[email protected]",
|
|
FirstName = "Test",
|
|
LastName = "McTester"
|
|
};
|
|
var user = new AppUser()
|
|
{
|
|
Role = Role.Admin,
|
|
AdEmail = "[email protected]",
|
|
BaseRole = "Tester",
|
|
EmployeeId = "11771",
|
|
FullName = "Test McTester",
|
|
HomeDepartment = "HOME",
|
|
PersonId = 565
|
|
};
|
|
var range = new MonthRange(2021,1,2021,2);
|
|
var goals = new EmployeeProgress(user, range, new List<IPayoutRule>());
|
|
|
|
_mockCurrentUserService.Setup(service => service.GetCurrentUser()).Returns(user1);
|
|
_mockUserService.Setup(service => service.GetUserByAdEmailAsync(user1.Email)).ReturnsAsync(user);
|
|
_mockDashboardService
|
|
.Setup(service => service.GetEmployeeProgressForMonthRangeAsync(goals.Employee, range))
|
|
.ReturnsAsync(goals);
|
|
|
|
var result = await _controller.GetCurrentUserProgress(range.FromMonth, range.FromYear, range.ToMonth, range.ToYear);
|
|
Assert.NotNull(result);
|
|
|
|
var okResult = result as OkObjectResult;
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Get_CurrentUserDepartmentProgress_OK()
|
|
{
|
|
var user1 = new ApplicationUser()
|
|
{
|
|
Email = "[email protected]",
|
|
FirstName = "Test",
|
|
LastName = "McTester"
|
|
};
|
|
var user = new AppUser()
|
|
{
|
|
Role = Role.Admin,
|
|
AdEmail = "[email protected]",
|
|
BaseRole = "Tester",
|
|
EmployeeId = "11771",
|
|
FullName = "Test McTester",
|
|
HomeDepartment = "HOME",
|
|
PersonId = 565,
|
|
Departments = new List<UserDepartment> {
|
|
new UserDepartment {
|
|
DepartmentId = 1,
|
|
StartDate = new DateTime(2021, 7, 1),
|
|
EndDate = new DateTime(2021, 7, 31)
|
|
}
|
|
}
|
|
};
|
|
var range = new MonthRange(2021,1,2021,2);
|
|
var goals = new List<DepartmentProgress> { new DepartmentProgress(1, range) };
|
|
|
|
_mockCurrentUserService.Setup(service => service.GetCurrentUser()).Returns(user1);
|
|
_mockUserService.Setup(service => service.GetUserByAdEmailAsync(user1.Email)).ReturnsAsync(user);
|
|
_mockActivityService
|
|
.Setup(service => service.GetDepartmentActivityForMonthRangeAsync(user.Departments, range))
|
|
.ReturnsAsync(goals);
|
|
|
|
var result = await _controller.GetCurrentUserProgress(range.FromMonth, range.FromYear, range.ToMonth, range.ToYear);
|
|
Assert.NotNull(result);
|
|
|
|
var okResult = result as OkObjectResult;
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Get_CurrentUserRegionProgress_OK()
|
|
{
|
|
var user1 = new ApplicationUser()
|
|
{
|
|
Email = "[email protected]",
|
|
FirstName = "Test",
|
|
LastName = "McTester"
|
|
};
|
|
var user = new AppUser()
|
|
{
|
|
Role = Role.RegionalManager,
|
|
AdEmail = "[email protected]",
|
|
BaseRole = "Tester",
|
|
EmployeeId = "11771",
|
|
FullName = "Test McTester",
|
|
HomeDepartment = "HOME",
|
|
PersonId = 565,
|
|
Departments = new List<UserDepartment> {
|
|
new UserDepartment {
|
|
DepartmentId = 1,
|
|
StartDate = new DateTime(2021, 7, 1),
|
|
EndDate = new DateTime(2021, 7, 31),
|
|
Role = Role.RegionalManager,
|
|
Department = new Department()
|
|
{
|
|
Id = 5,
|
|
State = DepartmentState.Active,
|
|
DepartmentName = "Dept 1",
|
|
RegionCode = Region.North.Code
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var range = new MonthRange(2021,1,2021,2);
|
|
var progress = new RegionProgress(Region.North, range);
|
|
|
|
_mockCurrentUserService.Setup(service => service.GetCurrentUser()).Returns(user1);
|
|
_mockUserService.Setup(service => service.GetUserByAdEmailAsync(user1.Email)).ReturnsAsync(user);
|
|
_mockDashboardService
|
|
.Setup(service => service.GetRegionProgressForMonthRangeAsync(Region.North, range))
|
|
.ReturnsAsync(progress);
|
|
|
|
var result = await _controller.GetRegionProgress(range.FromMonth, range.FromYear, range.ToMonth, range.ToYear, Region.East.Code);
|
|
Assert.NotNull(result);
|
|
|
|
var okResult = result as OkObjectResult;
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivityStateChanges_OK()
|
|
{
|
|
_mockActivityService
|
|
.Setup(service => service.GetActivityStateChanges(It.IsAny<int>())).ReturnsAsync(
|
|
new List<ActivityStateChange>()
|
|
{
|
|
new ActivityStateChange()
|
|
{
|
|
Id = 1,
|
|
ActivityId = 5
|
|
},
|
|
new ActivityStateChange()
|
|
{
|
|
Id = 2,
|
|
ActivityId = 5
|
|
},
|
|
new ActivityStateChange()
|
|
{
|
|
Id = 3,
|
|
ActivityId = 5
|
|
}
|
|
});
|
|
|
|
var result = await _controller.GetActivityStateChanges(5);
|
|
Assert.NotNull(result);
|
|
|
|
var okResult = result as OkObjectResult;
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
|
|
|
|
var value = okResult.Value as IReadOnlyCollection<ActivityStateChange>;
|
|
Assert.NotNull(value);
|
|
Assert.AreEqual(3, value.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetActivityStateChanges_Exception()
|
|
{
|
|
_mockActivityService.Setup(x => x.GetActivityStateChanges(It.IsAny<int>()))
|
|
.ThrowsAsync(new Exception("oops"));
|
|
|
|
var result = await _controller.GetActivityStateChanges(5);
|
|
Assert.NotNull(result);
|
|
|
|
var badResult = result as StatusCodeResult;
|
|
Assert.NotNull(badResult);
|
|
Assert.AreEqual(500, badResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Get_Single_Ok()
|
|
{
|
|
|
|
_mockActivityService.Setup(x => x.GetActivity(5))
|
|
.ReturnsAsync(new Activity()
|
|
{
|
|
Id = 5,
|
|
});
|
|
|
|
var result = await _controller.Get(5);
|
|
Assert.NotNull(result);
|
|
|
|
var okResult = result as OkObjectResult;
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
|
|
|
|
var value = okResult.Value as Activity;
|
|
Assert.NotNull(value);
|
|
Assert.AreEqual(5, value.Id);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Get_Single_NotFound()
|
|
{
|
|
_mockActivityService.Setup(x => x.GetActivity(1))
|
|
.ThrowsAsync(new NotFoundException("Not Found"));
|
|
|
|
var result = await _controller.Get(1);
|
|
Assert.NotNull(result);
|
|
|
|
var badRequestResult = result as BadRequestObjectResult;
|
|
Assert.NotNull(badRequestResult);
|
|
Assert.AreEqual(400, badRequestResult.StatusCode);
|
|
Assert.AreEqual("Activity Not Found.", badRequestResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task Get_Single_Exception()
|
|
{
|
|
_mockActivityService.Setup(x => x.GetActivity(1))
|
|
.ThrowsAsync(new Exception("Internal Server Error"));
|
|
|
|
var result = await _controller.Get(1);
|
|
Assert.NotNull(result);
|
|
|
|
var badResult = result as StatusCodeResult;
|
|
Assert.NotNull(badResult);
|
|
Assert.AreEqual(500, badResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ManuallyUpdateActivityState_Ok()
|
|
{
|
|
var stateChange = new ActivityStateChange
|
|
{
|
|
ActivityId = 11,
|
|
Note = "Change",
|
|
State = ActivityState.Accepted
|
|
};
|
|
var activityResult = new Activity
|
|
{
|
|
Id = 11,
|
|
State = ActivityState.Accepted
|
|
};
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync(new AppUser());
|
|
_mockActivityService.Setup(mock => mock.ValidateCanApplyActivityStateChange(It.IsAny<AppUser>(), stateChange));
|
|
_mockActivityService.Setup(mock => mock.ApplyStateChange(stateChange,true))
|
|
.ReturnsAsync(activityResult);
|
|
|
|
var result = await _controller.ManuallyUpdateActivityState(stateChange);
|
|
|
|
Assert.NotNull(result);
|
|
|
|
var okResult = result as OkObjectResult;
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ManuallyUpdateActivityState_AppUserNotFound()
|
|
{
|
|
var stateChange = new ActivityStateChange
|
|
{
|
|
ActivityId = 11,
|
|
Note = "Change",
|
|
State = ActivityState.Accepted
|
|
};
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns((ApplicationUser)null);
|
|
|
|
var result = await _controller.ManuallyUpdateActivityState(stateChange);
|
|
Assert.NotNull(result);
|
|
|
|
var unauthorizedResult = result as UnauthorizedObjectResult;
|
|
Assert.NotNull(unauthorizedResult);
|
|
Assert.AreEqual(401, unauthorizedResult.StatusCode);
|
|
Assert.AreEqual("No AD User Found.", unauthorizedResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ManuallyUpdateActivityState_UserNotFound()
|
|
{
|
|
var stateChange = new ActivityStateChange
|
|
{
|
|
ActivityId = 11,
|
|
Note = "Change",
|
|
State = ActivityState.Accepted
|
|
};
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync((AppUser)null);
|
|
|
|
var result = await _controller.ManuallyUpdateActivityState(stateChange);
|
|
Assert.NotNull(result);
|
|
|
|
var unauthorizedResult = result as UnauthorizedObjectResult;
|
|
Assert.NotNull(unauthorizedResult);
|
|
Assert.AreEqual(401, unauthorizedResult.StatusCode);
|
|
Assert.AreEqual("No AD User Found.", unauthorizedResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ManuallyUpdateActivityState_BadActivityStateChangeException()
|
|
{
|
|
var stateChange = new ActivityStateChange
|
|
{
|
|
ActivityId = 11,
|
|
Note = "Change",
|
|
State = ActivityState.Accepted
|
|
};
|
|
var activityResult = new Activity
|
|
{
|
|
Id = 11,
|
|
State = ActivityState.Accepted
|
|
};
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync(new AppUser());
|
|
_mockActivityService.Setup(mock => mock.ValidateCanApplyActivityStateChange(It.IsAny<AppUser>(), stateChange))
|
|
.ThrowsAsync(new BadActivityStateChangeException("Bad activity state change."));
|
|
|
|
var result = await _controller.ManuallyUpdateActivityState(stateChange);
|
|
|
|
Assert.NotNull(result);
|
|
|
|
var badRequestResult = result as BadRequestObjectResult;
|
|
Assert.NotNull(badRequestResult);
|
|
Assert.AreEqual(400, badRequestResult.StatusCode);
|
|
Assert.AreEqual("Bad activity state change.", badRequestResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ManuallyUpdateActivityState_NotAuthorizedException()
|
|
{
|
|
var stateChange = new ActivityStateChange
|
|
{
|
|
ActivityId = 11,
|
|
Note = "Change",
|
|
State = ActivityState.Accepted
|
|
};
|
|
var activityResult = new Activity
|
|
{
|
|
Id = 11,
|
|
State = ActivityState.Accepted
|
|
};
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync(new AppUser());
|
|
_mockActivityService.Setup(mock => mock.ValidateCanApplyActivityStateChange(It.IsAny<AppUser>(), stateChange))
|
|
.ThrowsAsync(new NotAuthorizedException("Not Authorized."));
|
|
|
|
var result = await _controller.ManuallyUpdateActivityState(stateChange);
|
|
|
|
Assert.NotNull(result);
|
|
|
|
var objectResult = result as ObjectResult;
|
|
Assert.NotNull(objectResult);
|
|
Assert.AreEqual(403, objectResult.StatusCode);
|
|
Assert.AreEqual("Not Authorized.", objectResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ManuallyUpdateActivityState_NotFoundException()
|
|
{
|
|
var stateChange = new ActivityStateChange
|
|
{
|
|
ActivityId = 11,
|
|
Note = "Change",
|
|
State = ActivityState.Accepted
|
|
};
|
|
var activityResult = new Activity
|
|
{
|
|
Id = 11,
|
|
State = ActivityState.Accepted
|
|
};
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync(new AppUser());
|
|
_mockActivityService.Setup(mock => mock.ValidateCanApplyActivityStateChange(It.IsAny<AppUser>(), stateChange))
|
|
.ThrowsAsync(new NotFoundException("Activity Not Found."));
|
|
|
|
var result = await _controller.ManuallyUpdateActivityState(stateChange);
|
|
|
|
Assert.NotNull(result);
|
|
|
|
var badRequestResult = result as BadRequestObjectResult;
|
|
Assert.NotNull(badRequestResult);
|
|
Assert.AreEqual(400, badRequestResult.StatusCode);
|
|
Assert.AreEqual("Activity Not Found.", badRequestResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ManuallyUpdateActivityState_Exception()
|
|
{
|
|
var stateChange = new ActivityStateChange
|
|
{
|
|
ActivityId = 11,
|
|
Note = "Change",
|
|
State = ActivityState.Accepted
|
|
};
|
|
var activityResult = new Activity
|
|
{
|
|
Id = 11,
|
|
State = ActivityState.Accepted
|
|
};
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync(new AppUser());
|
|
_mockActivityService.Setup(mock => mock.ValidateCanApplyActivityStateChange(It.IsAny<AppUser>(), stateChange))
|
|
.ThrowsAsync(new Exception("Internal Server Error."));
|
|
|
|
var result = await _controller.ManuallyUpdateActivityState(stateChange);
|
|
|
|
Assert.NotNull(result);
|
|
|
|
var badResult = result as StatusCodeResult;
|
|
Assert.NotNull(badResult);
|
|
Assert.AreEqual(500, badResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task RequestTransfer_Ok()
|
|
{
|
|
var request = new ActivityTransferRequest
|
|
{
|
|
ActivityStateBeforeTransfer = ActivityState.Accepted,
|
|
RequestedActivityId = 1,
|
|
NewDepartmentId = 2,
|
|
NewEmployeeId = "C0000"
|
|
};
|
|
|
|
var response = new ActivityTransferAction
|
|
{
|
|
ActivityStateBeforeTransfer = ActivityState.Accepted,
|
|
RequestedActivityId = 1,
|
|
NewActivity = new Activity
|
|
{
|
|
Product = Product.CreditCard,
|
|
Type = ActivityType.Referral,
|
|
Detail = new ActivityDetail
|
|
{
|
|
Activity = new Activity
|
|
{
|
|
Product = Product.CreditCard,
|
|
Type = ActivityType.Referral,
|
|
},
|
|
AccountNumber = "1234567890"
|
|
}
|
|
}
|
|
};
|
|
|
|
_mockActivityService.Setup(mock => mock.RequestTransfer(request)).ReturnsAsync(response).Verifiable();
|
|
|
|
var result = await _controller.RequestTransfer(request);
|
|
|
|
_mockActivityService.Verify();
|
|
Assert.NotNull(result);
|
|
var okResult = result as OkObjectResult;
|
|
|
|
var activityTransfer = okResult.Value as ActivityTransferAction;
|
|
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual("XXXXXX7890", activityTransfer.NewActivity.Detail.AccountNumber);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task RequestTransfer_NotFoundException()
|
|
{
|
|
var request = new ActivityTransferRequest
|
|
{
|
|
ActivityStateBeforeTransfer = ActivityState.Accepted,
|
|
RequestedActivityId = 1,
|
|
NewDepartmentId = 2,
|
|
NewEmployeeId = "C0000"
|
|
};
|
|
_mockActivityService.Setup(mock => mock.RequestTransfer(It.IsAny<ActivityTransferRequest>()))
|
|
.ThrowsAsync(new NotFoundException(""));
|
|
|
|
var result = await _controller.RequestTransfer(request);
|
|
|
|
Assert.NotNull(result);
|
|
var badRequestResult = result as BadRequestObjectResult;
|
|
Assert.NotNull(badRequestResult);
|
|
Assert.AreEqual(400, badRequestResult.StatusCode);
|
|
Assert.AreEqual("Activity Not Found.", badRequestResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task RequestTransfer_BadActivityTransferRequestException()
|
|
{
|
|
var request = new ActivityTransferRequest
|
|
{
|
|
ActivityStateBeforeTransfer = ActivityState.Accepted,
|
|
RequestedActivityId = 1,
|
|
NewDepartmentId = 2,
|
|
NewEmployeeId = "C0000"
|
|
};
|
|
_mockActivityService.Setup(mock => mock.RequestTransfer(It.IsAny<ActivityTransferRequest>()))
|
|
.ThrowsAsync(new BadActivityTransferActionException("Cannot complete request."));
|
|
|
|
var result = await _controller.RequestTransfer(request);
|
|
|
|
Assert.NotNull(result);
|
|
var badRequestResult = result as BadRequestObjectResult;
|
|
Assert.NotNull(badRequestResult);
|
|
Assert.AreEqual(400, badRequestResult.StatusCode);
|
|
Assert.AreEqual("Cannot complete request.", badRequestResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task RequestTransfer_Exception()
|
|
{
|
|
var request = new ActivityTransferRequest
|
|
{
|
|
ActivityStateBeforeTransfer = ActivityState.Accepted,
|
|
RequestedActivityId = 1,
|
|
NewDepartmentId = 2,
|
|
NewEmployeeId = "C0000"
|
|
};
|
|
_mockActivityService.Setup(mock => mock.RequestTransfer(It.IsAny<ActivityTransferRequest>()))
|
|
.ThrowsAsync(new Exception("Internal Server Error."));
|
|
|
|
var result = await _controller.RequestTransfer(request);
|
|
|
|
Assert.NotNull(result);
|
|
var badResult = result as StatusCodeResult;
|
|
Assert.NotNull(badResult);
|
|
Assert.AreEqual(500, badResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ApproveTransfer_Ok()
|
|
{
|
|
var approval = new ActivityTransferApprovalRequest
|
|
{
|
|
Id = 1,
|
|
ApprovalState = ActivityTransferState.Accepted
|
|
};
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync(new AppUser());
|
|
_mockActivityService.Setup(mock => mock.ApproveTransfer(It.IsAny<AppUser>(), approval))
|
|
.ReturnsAsync(new ActivityTransferAction { Id = 1 } );
|
|
|
|
var result = await _controller.ApproveTransfer(approval);
|
|
|
|
Assert.NotNull(result);
|
|
var okResult = result as OkObjectResult;
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ApproveTransfer_AppUserNotFound()
|
|
{
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns((ApplicationUser)null);
|
|
|
|
var result = await _controller.ApproveTransfer(new ActivityTransferApprovalRequest());
|
|
|
|
Assert.NotNull(result);
|
|
var unauthorizedResult = result as UnauthorizedObjectResult;
|
|
Assert.NotNull(unauthorizedResult);
|
|
Assert.AreEqual(401, unauthorizedResult.StatusCode);
|
|
Assert.AreEqual("No AD User Found.", unauthorizedResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ApproveTransfer_UserNotFound()
|
|
{
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync((AppUser)null);
|
|
|
|
var result = await _controller.ApproveTransfer(new ActivityTransferApprovalRequest());
|
|
|
|
Assert.NotNull(result);
|
|
var unauthorizedResult = result as UnauthorizedObjectResult;
|
|
Assert.NotNull(unauthorizedResult);
|
|
Assert.AreEqual(401, unauthorizedResult.StatusCode);
|
|
Assert.AreEqual("No AD User Found.", unauthorizedResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ApproveTransfer_NotFoundException()
|
|
{
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync(new AppUser());
|
|
_mockActivityService
|
|
.Setup(mock => mock.ApproveTransfer(It.IsAny<AppUser>(), It.IsAny<ActivityTransferApprovalRequest>()))
|
|
.ThrowsAsync(new NotFoundException(""));
|
|
|
|
var result = await _controller.ApproveTransfer(new ActivityTransferApprovalRequest());
|
|
|
|
Assert.NotNull(result);
|
|
var badRequestResult = result as BadRequestObjectResult;
|
|
Assert.NotNull(badRequestResult);
|
|
Assert.AreEqual(400, badRequestResult.StatusCode);
|
|
Assert.AreEqual("Activity Transfer Not Found.", badRequestResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ApproveTransfer_BadActivityTransferActionException()
|
|
{
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync(new AppUser());
|
|
_mockActivityService
|
|
.Setup(mock => mock.ApproveTransfer(It.IsAny<AppUser>(), It.IsAny<ActivityTransferApprovalRequest>()))
|
|
.ThrowsAsync(new BadActivityTransferActionException("Cannot complete request."));
|
|
|
|
var result = await _controller.ApproveTransfer(new ActivityTransferApprovalRequest());
|
|
|
|
Assert.NotNull(result);
|
|
var badRequestResult = result as BadRequestObjectResult;
|
|
Assert.NotNull(badRequestResult);
|
|
Assert.AreEqual(400, badRequestResult.StatusCode);
|
|
Assert.AreEqual("Cannot complete request.", badRequestResult.Value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ApproveTransfer_Exception()
|
|
{
|
|
_mockCurrentUserService.Setup(mock => mock.GetCurrentUser())
|
|
.Returns(new ApplicationUser { Email = "[email protected]" });
|
|
_mockUserService.Setup(mock => mock.GetUserByAdEmailAsync(It.Is<string>(s => s == "[email protected]")))
|
|
.ReturnsAsync(new AppUser());
|
|
_mockActivityService
|
|
.Setup(mock => mock.ApproveTransfer(It.IsAny<AppUser>(), It.IsAny<ActivityTransferApprovalRequest>()))
|
|
.ThrowsAsync(new Exception("Internal Server Error."));
|
|
|
|
var result = await _controller.ApproveTransfer(new ActivityTransferApprovalRequest());
|
|
|
|
Assert.NotNull(result);
|
|
var badResult = result as StatusCodeResult;
|
|
Assert.NotNull(badResult);
|
|
Assert.AreEqual(500, badResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetTransferAction_Ok()
|
|
{
|
|
var actionFromService = new ActivityTransferAction
|
|
{
|
|
Id = 1,
|
|
State = ActivityTransferState.Requested
|
|
};
|
|
_mockActivityService.Setup(mock => mock.GetRequestedTransfer(1))
|
|
.ReturnsAsync(actionFromService);
|
|
|
|
var result = await _controller.GetTransferAction(1);
|
|
|
|
Assert.NotNull(result);
|
|
var okResult = result as OkObjectResult;
|
|
Assert.NotNull(okResult);
|
|
Assert.AreEqual(200, okResult.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task GetTransferAction_Exception()
|
|
{
|
|
_mockActivityService.Setup(mock => mock.GetRequestedTransfer(1))
|
|
.ThrowsAsync(new Exception("Internal Server Error."));
|
|
|
|
var result = await _controller.GetTransferAction(1);
|
|
|
|
Assert.NotNull(result);
|
|
var badResult = result as StatusCodeResult;
|
|
Assert.NotNull(badResult);
|
|
Assert.AreEqual(500, badResult.StatusCode);
|
|
}
|
|
}
|
|
}
|