public async Task <ActionResult <AccountModel> > AccountAsync(int accountingNumber, string accountNumber, DateTimeOffset?statusDate = null) { if (string.IsNullOrWhiteSpace(accountNumber)) { throw new IntranetExceptionBuilder(ErrorCode.ValueCannotBeNullOrWhiteSpace, nameof(accountNumber)) .WithValidatingType(typeof(string)) .WithValidatingField(nameof(accountNumber)) .Build(); } IGetAccountQuery query = new GetAccountQuery { AccountingNumber = accountingNumber, AccountNumber = accountNumber, StatusDate = statusDate?.LocalDateTime.Date ?? DateTime.Today }; IAccount account = await _queryBus.QueryAsync <IGetAccountQuery, IAccount>(query); if (account == null) { throw new IntranetExceptionBuilder(ErrorCode.ValueShouldBeKnown, nameof(accountNumber)) .WithValidatingType(typeof(string)) .WithValidatingField(nameof(accountNumber)) .Build(); } AccountModel accountModel = _accountingModelConverter.Convert <IAccount, AccountModel>(account); return(Ok(accountModel)); }
public async Task Throws_Bad_Request_With_Missing_Account( GetAccountQuery query, [Frozen] Mock <IRepository> repo, GetAccountHandler sut) { repo.Setup(p => p.FindAsync(It.IsAny <IScalar <Account> >())).ReturnsAsync((Account)null); await Assert.ThrowsAsync <BadRequestException>(async() => { await sut.Handle(query, new CancellationToken()); }); }
public async Task <IActionResult> Get(Guid accountId) { var query = new GetAccountQuery { UserId = CurrentUserId, AccountId = accountId }; return(Ok(await _mediator.Send(query))); }
public async Task Returns_BadRequest_On_Invalid_ModelState( GetAccountQuery query, AccountsController sut) { sut.ModelState.AddModelError("YoBadRequest", "Something's funky, bail!"); var result = await sut.Get(query) as BadRequestObjectResult; Assert.True(result != null); Assert.True(result.StatusCode == 400); }
public async Task <IActionResult> GetById([FromQuery] GetAccountQuery query) { var result = await _mediator.Send(query); if (result?.Account == null) { return(NotFound()); } return(Ok(result)); }
public async Task Returns_Forbidden_On_AuthorizationException( GetAccountQuery query, [Frozen] Mock <IMediator> mediator, AccountsController sut) { mediator.Setup(p => p.Send(It.IsAny <IRequest <AccountModel> >(), It.IsAny <CancellationToken>())).ThrowsAsync(new AuthorizationException("Whoops")); var result = await sut.Get(query) as ForbidResult; Assert.True(result != null); }
public async Task Returns_BadRequest_On_BadRequestException( GetAccountQuery query, [Frozen] Mock <IMediator> mediator, AccountsController sut) { mediator.Setup(p => p.Send(It.IsAny <IRequest <AccountModel> >(), It.IsAny <CancellationToken>())).ThrowsAsync(new BadRequestException("Uh-oh")); var result = await sut.Get(query) as BadRequestObjectResult; Assert.True(result != null); Assert.True(result.StatusCode == 400); }
public async Task Returns_InternalServerError_On_Exception( GetAccountQuery query, [Frozen] Mock <IMediator> mediator, AccountsController sut) { mediator.Setup(p => p.Send(It.IsAny <IRequest <AccountModel> >(), It.IsAny <CancellationToken>())).ThrowsAsync(new ApplicationException("Whoops")); var result = await sut.Get(query) as ObjectResult; Assert.True(result != null); Assert.True(result.StatusCode == 500); }
public async Task Then_The_Api_Is_Called_With_The_Request_And_The_Account_Is_Returned( GetAccountQuery query, GetAccountResponse apiResponse, [Frozen] Mock <IAccountsApiClient <AccountsConfiguration> > apiClient, GetAccountQueryHandler handler ) { apiClient.Setup(x => x.Get <GetAccountResponse>(It.Is <GetAccountRequest>(x => x.HashedAccountId == query.HashedAccountId))).ReturnsAsync(apiResponse); var actual = await handler.Handle(query, CancellationToken.None); actual.Should().BeEquivalentTo(apiResponse); }
public void ThrowNotFoundException() { // Arrange GetAccountQuery query = new GetAccountQuery() { Id = 100 }; // Act // Assert Assert.ThrowsAsync <NotFoundException> (() => handler.Handle(query, CancellationToken.None)); }
public async Task ReturnSingleAccountBasedOnIdSuccessfuly() { // Arrange GetAccountQuery query = new GetAccountQuery() { Id = 10 }; // Act var result = await handler.Handle(query, CancellationToken.None); // Assert Assert.Equal(10, result.Id); Assert.IsType <AccountViewModel> (result); }
public async Task Returns_Ok_With_Valid_Request( GetAccountQuery query, AccountModel model, [Frozen] Mock <IMediator> mediator, AccountsController sut) { mediator.Setup(p => p.Send(It.IsAny <IRequest <AccountModel> >(), It.IsAny <CancellationToken>())).ReturnsAsync(model); var result = await sut.Get(query) as OkObjectResult; Assert.True(result != null); Assert.True(result.StatusCode == 200); Assert.True((AccountModel)result.Value == model); }
public void And_No_Account_Then_Throws_EntityNotFoundException( GetAccountQuery query, [Frozen] ValidationResult validationResult, [Frozen] Mock <IAccountsService> mockService, GetAccountQueryHandler handler) { validationResult.ValidationDictionary.Clear(); mockService .Setup(service => service.GetAccount(It.IsAny <long>())) .ReturnsAsync((Domain.Account.Account)null); var act = new Func <Task>(async() => await handler.Handle(query, CancellationToken.None)); act.Should().Throw <EntityNotFoundException <Domain.Entities.Account> >(); }
public async Task Then_Gets_Account_Details_From_Service( GetAccountQuery query, Domain.Account.Account account, [Frozen] ValidationResult validationResult, [Frozen] Mock <IAccountsService> mockService, GetAccountQueryHandler handler) { validationResult.ValidationDictionary.Clear(); mockService .Setup(service => service.GetAccount(query.Id)) .ReturnsAsync(account); var result = await handler.Handle(query, CancellationToken.None); result.Account.Should().BeEquivalentTo(account); }
public async Task Succeed_With_Valid_Request( GetAccountQuery query, Account account, AccountModel model, [Frozen] Mock <IReadOnlyRepository> repo, GetAccountHandler sut) { model.AccountId = account.Id; repo.Setup(p => p.FindAsync(It.IsAny <IScalar <Account> >())).ReturnsAsync(account); var result = await sut.Handle(query, new CancellationToken()); repo.Verify(p => p.FindAsync(It.IsAny <IScalar <Account> >()), Times.Once()); Assert.True(result.AccountId == account.Id); }
public async Task Then_If_NotFound_Response_Then_Null_Returned( GetAccountQuery query, [Frozen] Mock <IAccountsApiClient <AccountsConfiguration> > accountApiClient, GetAccountQueryHandler handler) { //Arrange accountApiClient.Setup(x => x.Get <GetAccountByIdResponse>( It.IsAny <GetAccountByIdRequest>())) .ReturnsAsync((GetAccountByIdResponse)null); //Act var actual = await handler.Handle(query, CancellationToken.None); //Assert actual.AccountId.Should().BeNull(); actual.HashedAccountId.Should().BeNull(); }
public async Task GetListAccount() { var query = new GetAccountQuery { UserId = new Guid("05541516-ccf1-41f4-b6ac-b2aa7d807b8c"), CultureId = new Guid("714b19c9-7c5b-47f9-9a99-46639db1595d") }; var result = await _handler.Execute(query); Assert.IsNotNull(result); Assert.AreEqual(result.AccountPresentations.Count, 1); var account = result.AccountPresentations.First(); Assert.AreEqual(account.KeyId, new Guid("714b19c9-7c5b-47f9-9a99-46639db1595d")); Assert.AreEqual(account.Balance, 2000); Assert.AreEqual(account.DisplayName, "[BNK] Bank"); }
public void And_Fails_Validation_Then_Throws_ValidationException( GetAccountQuery query, string propertyName, Domain.Account.Account account, [Frozen] Mock <IValidator <GetAccountQuery> > mockValidator, [Frozen] ValidationResult validationResult, [Frozen] Mock <IAccountsService> mockService, GetAccountQueryHandler handler) { validationResult.AddError(propertyName); mockValidator .Setup(validator => validator.ValidateAsync(It.IsAny <GetAccountQuery>())) .ReturnsAsync(validationResult); var act = new Func <Task>(async() => await handler.Handle(query, CancellationToken.None)); act.Should().Throw <ArgumentException>() .WithMessage($"*{propertyName}*"); }
public async Task Then_The_Query_Is_Handled_And_Data_Returned( GetAccountQuery query, GetAccountByIdResponse apiResponse, [Frozen] Mock <IAccountsApiClient <AccountsConfiguration> > accountsApiClient, GetAccountQueryHandler handler) { //Arrange var expectedGetUrl = new GetAccountByIdRequest(query.AccountId); accountsApiClient .Setup(x => x.Get <GetAccountByIdResponse>( It.Is <GetAccountByIdRequest>(c => c.GetUrl.Equals(expectedGetUrl.GetUrl)))) .ReturnsAsync(apiResponse); //Act var actual = await handler.Handle(query, CancellationToken.None); //Assert actual.Should().BeEquivalentTo(apiResponse); }
public async Task <IActionResult> Get([FromRoute] GetAccountQuery query) { return(await Execute(query)); }
public async Task <IActionResult> GetAccountById([FromRoute] Guid id) { var query = new GetAccountQuery(id); return(Ok(_mapper.Map <AccountResponse>(await _bus.Send(query)))); }
public async Task <IActionResult> Get(GetAccountQuery query) { return(await Handle <GetAccountQuery, AccountModel>(query, Ok)); }
public async Task <IActionResult> GetAccountDetail([FromBody] GetAccountRequest request) { try { _logger.LogInformation("Get account number(Account Number: {AccountNumber}) with account type {AccountType}.", request.AccountNumber, request.AccountPIN); //validate parameters if (request.AccountNumber.Length == 0) { _logger.LogInformation("No account number found from request."); return(new JsonResult(new GetAccountResponse() { StatusCode = Convert.ToInt32(HttpStatusCode.OK), Message = Convert.ToString(HttpStatusCode.OK), Payload = new GetAccountResponsePayload() { MessageDetail = "No account number found." } })); } if (request.AccountPIN.Length == 0) { _logger.LogInformation("No account PIN found from request."); return(new JsonResult(new GetAccountResponse() { StatusCode = Convert.ToInt32(HttpStatusCode.OK), Message = Convert.ToString(HttpStatusCode.OK), Payload = new GetAccountResponsePayload() { MessageDetail = "No account PIN found." } })); } //call query handler var query = new GetAccountQuery(request.AccountNumber, request.AccountPIN); var queryResult = await _mediator.Send(query); return(new JsonResult(new GetAccountResponse() { StatusCode = queryResult.StatusCode, Message = queryResult.Message, MessageDetail = queryResult.MessageDetails, Payload = new GetAccountResponsePayload() { AcctId = queryResult.AcctId, FirstName = queryResult.FirstName, MiddleName = queryResult.MiddleName, LastName = queryResult.LastName, AccountNumber = queryResult.AccountNumber, AccountPIN = queryResult.AccountPIN, AccountType = queryResult.AccountType, AccountStatus = queryResult.AccountStatus, InitialAmountDeposit = queryResult.InitialAmountDeposit, DateCreated = queryResult.DateCreated, DateUpdated = queryResult.DateUpdated, MessageDetail = queryResult.MessageDetails } })); } catch (Exception ex) { _logger.LogError("Get account number request failed. Exception error message: {exceptionMessage}", ex.ToString()); return(new JsonResult(new GetAccountResponse() { StatusCode = Convert.ToInt32(HttpStatusCode.BadRequest), Message = Convert.ToString(HttpStatusCode.BadRequest), MessageDetail = "Get contact group list request failed. Exception error message: " + ex.ToString() })); } }
public async Task <GetAccountQuery.Result> Account([FromUri] GetAccountQuery query) { return(await _queryDispatcher.Execute <GetAccountQuery, GetAccountQuery.Result>(query)); }