public async Task Then_If_Not_Recognised_AccountIdentifier_Format_Then_Forbidden_Returned(
string identifier,
[Greedy] AccountLegalEntitiesController controller)
{
var accountIdentifier = $"{identifier}";
var controllerResult = await controller.GetList(accountIdentifier) as StatusCodeResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Forbidden);
}
public async Task Then_If_Provider_And_Not_Numeric_Then_BadRequest_Returned(
[Greedy] AccountLegalEntitiesController controller)
{
var identifier = "Abc123";
var accountIdentifier = $"Provider-{identifier}-product";
var controllerResult = await controller.GetList(accountIdentifier) as BadRequestObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
controllerResult.Value.Should().BeEquivalentTo("Account Identifier is not in the correct format.");
}
public void Arrange()
{
Mediator = new Mock <IMediator>();
Logger = new Mock <ILogger>();
Mapper = new Mock <IMapper>();
var orchestrator = new AccountsOrchestrator(Mediator.Object, Logger.Object, Mapper.Object);
Controller = new AccountLegalEntitiesController(orchestrator);
UrlHelper = new Mock <UrlHelper>();
Controller.Url = UrlHelper.Object;
}
public void Arrange()
{
_mediator = new Mock <IMediator>();
_accountLegalEntitiesResponse = new GetAccountLegalEntitiesResponse {
AccountLegalEntities = new List <Domain.AccountLegalEntities.AccountLegalEntity>()
};
_mediator.Setup(x => x.Send(It.Is <GetAccountLegalEntitiesQuery>(c => c.AccountId.Equals(ExpectedAccountId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(_accountLegalEntitiesResponse);
_accountLegalEntitiesController = new AccountLegalEntitiesController(_mediator.Object, Mock.Of <ILogger <AccountLegalEntitiesController> >());
}
public AccountLegalEntitiesControllerTestsFixture()
{
Query = new GetAccountLegalEntitiesQuery {
PageSize = 1000, PageNumber = 1
};
Mediator = new Mock <IMediator>();
AccountLegalEntities = new PagedApiResponseViewModel <AccountLegalEntityViewModel>();
Response = new GetAccountLegalEntitiesResponse {
AccountLegalEntities = AccountLegalEntities
};
Mediator.Setup(m => m.SendAsync(Query)).ReturnsAsync(Response);
Controller = new AccountLegalEntitiesController(Mediator.Object);
}
public async Task And_EntityNotFoundException_Then_Returns_NotFound(
long accountId,
EntityNotFoundException <AccountLegalEntity> notFoundException,
[Frozen] Mock <IMediator> mockMediator,
AccountLegalEntitiesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetAccountReservationStatusQuery>(query => query.AccountId == accountId),
It.IsAny <CancellationToken>()))
.ThrowsAsync(notFoundException);
var result = await controller.GetAccountReservationStatus(accountId, null) as NotFoundResult;
result.StatusCode.Should().Be((int)HttpStatusCode.NotFound);
}
public async Task And_Exception_Then_Returns_InternalServerError(
[Frozen] Mock <IMediator> mockMediator,
[Greedy] AccountLegalEntitiesController controller)
{
var encodedAccountId = "ABC123";
var accountIdentifier = $"Employer-{encodedAccountId}-product";
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetLegalEntitiesForEmployerQuery>(),
It.IsAny <CancellationToken>()))
.Throws <Exception>();
var controllerResult = await controller.GetList(accountIdentifier) as StatusCodeResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task Then_Returns_AccountReservationStatus(
long accountId,
GetAccountReservationStatusResponse response,
[Frozen] Mock <IMediator> mockMediator,
AccountLegalEntitiesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetAccountReservationStatusQuery>(query => query.AccountId == accountId),
It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
var result = await controller.GetAccountReservationStatus(accountId, null) as OkObjectResult;
result.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = result.Value as AccountReservationStatus;
model.Should().BeEquivalentTo(new AccountReservationStatus(response));
}
public async Task And_ArgumentException_Then_Returns_BadRequest(
long accountId,
ArgumentException argumentException,
[Frozen] Mock <IMediator> mockMediator,
AccountLegalEntitiesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetAccountReservationStatusQuery>(query => query.AccountId == accountId),
It.IsAny <CancellationToken>()))
.ThrowsAsync(argumentException);
var result = await controller.GetAccountReservationStatus(accountId, null) as BadRequestObjectResult;
result.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
var model = result.Value.Should().BeOfType <ArgumentErrorViewModel>().Subject;
model.Message.Should().Be(argumentException.Message);
model.Params.Should().Be(argumentException.ParamName);
}
public async Task Then_If_Provider_Account_Identifier_Then_Get_Account_Legal_Entities_Called(
int ukprn,
GetProviderAccountLegalEntitiesQueryResponse mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] AccountLegalEntitiesController controller)
{
var accountIdentifier = $"Provider-{ukprn}-product";
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetProviderAccountLegalEntitiesQuery>(c => c.Ukprn.Equals(ukprn)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetList(accountIdentifier) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetAccountLegalEntitiesListResponse;
model !.Should().BeEquivalentTo((GetAccountLegalEntitiesListResponse)mediatorResult);
}
public async Task Then_If_Employer_Account_Identifier_Then_Get_Account_Legal_Entities_Called_And_Values_UpperCased(
GetLegalEntitiesForEmployerResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] AccountLegalEntitiesController controller)
{
var encodedAccountId = "ABc123";
var accountIdentifier = $"Employer-{encodedAccountId}-product";
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetLegalEntitiesForEmployerQuery>(c => c.EncodedAccountId.Equals(encodedAccountId.ToUpper())),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetList(accountIdentifier) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetAccountLegalEntitiesListResponse;
model !.Should().BeEquivalentTo((GetAccountLegalEntitiesListResponse)mediatorResult);
}
public void Arrange()
{
_expectedLegalEntity = new AccountLegalEntity(
Guid.NewGuid(),
1,
"Test",
2,
3,
true,
true);
_mediator = new Mock <IMediator>();
_accountLegalEntityResult = new GetAccountLegalEntityResult {
LegalEntity = _expectedLegalEntity
};
_mediator.Setup(x => x.Send(It.Is <GetAccountLegalEntityQuery>(q => q.Id.Equals(ExpectedLegalEntityId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(_accountLegalEntityResult);
_accountLegalEntitiesController = new AccountLegalEntitiesController(_mediator.Object, Mock.Of <ILogger <AccountLegalEntitiesController> >());
}
