public async Task ThenAccountsAreReturnedWithTheirBalanceAndAUriToGetAccountDetails()
{
var pageNumber = 123;
var pageSize = 9084;
var toDate = DateTime.Now.AddDays(-1).ToString("yyyyMMddHHmmss");
var accountsResponse = new GetPagedEmployerAccountsResponse
{
AccountsCount = 2,
Accounts = new List <Domain.Models.Account.Account>
{
new Domain.Models.Account.Account {
HashedId = "ABC123", Id = 123, Name = "Test 1"
},
new Domain.Models.Account.Account {
HashedId = "ABC999", Id = 987, Name = "Test 2"
}
}
};
Mediator.Setup(x => x.SendAsync(It.Is <GetPagedEmployerAccountsQuery>(q => q.PageNumber == pageNumber && q.PageSize == pageSize && q.ToDate == toDate)))
.ReturnsAsync(accountsResponse);
var balancesResponse = new GetAccountBalancesResponse
{
Accounts = new List <AccountBalance>
{
new AccountBalance {
AccountId = accountsResponse.Accounts[0].Id, Balance = 987.65m, IsLevyPayer = 1
},
new AccountBalance {
AccountId = accountsResponse.Accounts[1].Id, Balance = 123.45m, IsLevyPayer = 1
}
}
};
Mediator.Setup(x => x.SendAsync(It.Is <GetAccountBalancesRequest>(q => q.AccountIds.TrueForAll(id => accountsResponse.Accounts.Any(a => a.Id == id)))))
.ReturnsAsync(balancesResponse);
UrlHelper.Setup(x => x.Route("GetAccount", It.Is <object>(o => o.IsEquivalentTo(new { hashedAccountId = accountsResponse.Accounts[0].HashedId })))).Returns($"/api/accounts/{accountsResponse.Accounts[0].HashedId}");
UrlHelper.Setup(x => x.Route("GetAccount", It.Is <object>(o => o.IsEquivalentTo(new { hashedAccountId = accountsResponse.Accounts[1].HashedId })))).Returns($"/api/accounts/{accountsResponse.Accounts[1].HashedId}");
var response = await Controller.GetAccounts(toDate, pageSize, pageNumber);
Assert.IsNotNull(response);
Assert.IsInstanceOf <OkNegotiatedContentResult <PagedApiResponseViewModel <AccountWithBalanceViewModel> > >(response);
var model = response as OkNegotiatedContentResult <PagedApiResponseViewModel <AccountWithBalanceViewModel> >;
model?.Content?.Data.Should().NotBeNull();
model.Content.Page.Should().Be(pageNumber);
model.Content.Data.Should().HaveCount(accountsResponse.AccountsCount);
foreach (var expectedAccount in accountsResponse.Accounts)
{
var returnedAccount = model.Content.Data.SingleOrDefault(x => x.AccountId == expectedAccount.Id && x.AccountHashId == expectedAccount.HashedId && x.AccountName == expectedAccount.Name);
returnedAccount.Should().NotBeNull();
returnedAccount.Balance.Should().Be(balancesResponse.Accounts.Single(b => b.AccountId == returnedAccount.AccountId).Balance);
returnedAccount.Href.Should().Be($"/api/accounts/{returnedAccount.AccountHashId}");
returnedAccount.IsLevyPayer.Should().Be(true);
}
}
public void GetBalance_AccountProvidedInCommandLine_UsesDefaultAccount()
{
string account = "rKsphokjVPYm9UqCrarZiNdFTpnTraayKH";
var response = new GetAccountBalancesResponse()
{
Success = true,
Validated = true,
Balances = new GetAccountBalancesResponse.Balance[] {
new GetAccountBalancesResponse.Balance()
{
Value = 3, Currency = "XRP", Counterparty = null
}
}
};
clientMock.Setup(c => c.GetAccountBalancesAsync(account)).Returns(Task.FromResult(response));
var cmd = new GetBalanceCommand(clientMock.Object, accountProviderMock.Object);
cmd.Execute(new string[] { account }, output, errorOutput);
Assert.AreEqual("", errorOutput.ToString());
Assert.AreEqual("", errorOutput.ToString());
clientMock.Verify(c => c.GetAccountBalancesAsync(account), Times.Once);
}
public async Task AndAnAccountHasNoBalanceThenTheBalanceIsZero()
{
var accountsResponse = new GetPagedEmployerAccountsResponse
{
AccountsCount = 1,
Accounts = new List <Domain.Models.Account.Account>
{
new Domain.Models.Account.Account {
HashedId = "ABC123", Id = 123, Name = "Test 1"
}
}
};
Mediator.Setup(x => x.SendAsync(It.IsAny <GetPagedEmployerAccountsQuery>()))
.ReturnsAsync(accountsResponse);
var balancesResponse = new GetAccountBalancesResponse {
Accounts = new List <AccountBalance>()
};
Mediator.Setup(x => x.SendAsync(It.IsAny <GetAccountBalancesRequest>()))
.ReturnsAsync(balancesResponse);
var response = await Controller.GetAccounts(DateTime.Now.AddDays(-1).ToString("yyyyMMddHHmmss"));
var model = response as OkNegotiatedContentResult <PagedApiResponseViewModel <AccountWithBalanceViewModel> >;
model.Content.Data.First().Balance.Should().Be(0);
}
public void Arrange()
{
Mediator = new Mock <IMediator>();
Logger = new Mock <ILog>();
Mapper = new Mock <IMapper>();
HashingService = new Mock <IHashingService>();
var orchestrator = new AccountsOrchestrator(Mediator.Object, Logger.Object, Mapper.Object, HashingService.Object);
Controller = new EmployerAccountsController(orchestrator);
UrlHelper = new Mock <UrlHelper>();
Controller.Url = UrlHelper.Object;
var accountsResponse = new GetPagedEmployerAccountsResponse
{
Accounts = new List <Domain.Models.Account.Account>()
};
Mediator.Setup(x => x.SendAsync(It.IsAny <GetPagedEmployerAccountsQuery>())).ReturnsAsync(accountsResponse);
var balancesResponse = new GetAccountBalancesResponse {
Accounts = new List <AccountBalance>()
};
Mediator.Setup(x => x.SendAsync(It.IsAny <GetAccountBalancesRequest>())).ReturnsAsync(balancesResponse);
}
public async Task ThenTheAccountWithBalanceIsReturned()
{
var hashedAccountId = "ABC123";
var account = new AccountDetailViewModel
{
HashedAccountId = hashedAccountId,
AccountId = 123,
DateRegistered = DateTime.Now.AddYears(-1),
OwnerEmail = "*****@*****.**",
DasAccountName = "Test",
ApprenticeshipEmployerType = ApprenticeshipEmployerType.Levy.ToString(),
LegalEntities = new ResourceList(new List <ResourceViewModel> {
new ResourceViewModel {
Href = "/api/123", Id = "123"
}
}),
PayeSchemes = new ResourceList(new List <ResourceViewModel> {
new ResourceViewModel {
Href = "/api/XXX", Id = "XXX"
}
})
};
var accountBalanceResponse = new GetAccountBalancesResponse
{
Accounts = new List <AccountBalance> {
new AccountBalance {
AccountId = account.AccountId, Balance = 123.45m
}
}
};
ApiService.Setup(x => x.GetAccount(hashedAccountId, It.IsAny <CancellationToken>())).ReturnsAsync(account);
Mediator.Setup(x => x.SendAsync(It.Is <GetAccountBalancesRequest>(q => q.AccountIds.Single() == account.AccountId))).ReturnsAsync(accountBalanceResponse);
Mediator.Setup(x => x.SendAsync(It.IsAny <GetTransferAllowanceQuery>())).ReturnsAsync(new GetTransferAllowanceResponse {
TransferAllowance = new TransferAllowance()
});
var response = await Controller.GetAccount(hashedAccountId);
Assert.IsNotNull(response);
Assert.IsInstanceOf <OkNegotiatedContentResult <AccountDetailViewModel> >(response);
var model = response as OkNegotiatedContentResult <AccountDetailViewModel>;
model?.Content.Should().NotBeNull();
model?.Content?.DasAccountId.Should().Be(hashedAccountId);
model?.Content?.HashedAccountId.Should().Be(hashedAccountId);
model?.Content?.AccountId.Should().Be(account.AccountId);
model?.Content?.DasAccountName.Should().Be(account.DasAccountName);
model?.Content?.DateRegistered.Should().Be(account.DateRegistered);
model?.Content?.OwnerEmail.Should().Be(account.OwnerEmail);
model?.Content?.Balance.Should().Be(accountBalanceResponse.Accounts.Single().Balance);
}
public void Arrange()
{
_mediator = new Mock <IMediator>();
_log = new Mock <ILog>();
_hashingService = new Mock <IHashingService>();
_apiService = new Mock <IEmployerAccountsApiService>();
_mapper = new Mock <IMapper>();
_orchestrator = new AccountsOrchestrator(_mediator.Object, _log.Object, _mapper.Object, _hashingService.Object, _apiService.Object);
var accountsResponse = new PagedApiResponseViewModel <AccountWithBalanceViewModel>()
{
Page = 123,
TotalPages = 123,
Data = new List <AccountWithBalanceViewModel>
{
new AccountWithBalanceViewModel {
AccountHashId = "ABC123", AccountId = 123, AccountName = "Test 1", IsLevyPayer = true
},
new AccountWithBalanceViewModel {
AccountHashId = "ABC999", AccountId = 987, AccountName = "Test 2", IsLevyPayer = true
}
}
};
var balanceResponse = new GetAccountBalancesResponse
{
Accounts = new List <AccountBalance>
{
new AccountBalance {
AccountId = 123, Balance = 20, RemainingTransferAllowance = 20, StartingTransferAllowance = 10
},
new AccountBalance {
AccountId = 987, Balance = 200, RemainingTransferAllowance = 200, StartingTransferAllowance = 100
},
}
};
_apiService.Setup(s => s.GetAccounts(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(accountsResponse);
_mediator
.Setup(x => x.SendAsync(It.IsAny <GetAccountBalancesRequest>()))
.ReturnsAsync(balanceResponse);
}
public AccountBalances GetAccountBalances()
{
GetAccountBalancesResponse response = _proxy.GetAccountBalances(new GetAccountBalancesRequest());
if (response.ReturnStatus.Code != 0)
{
throw new Exception(response.ReturnStatus.Description);
}
AccountBalances balances = new AccountBalances();
balances.Currency = response.Currency;
balances.AvailableFunds = response.AvailableFunds;
balances.Balance = response.Balance;
balances.Credit = response.Credit;
balances.Exposure = response.Exposure;
return(balances);
}
public async Task ThenTheAccountWithBalanceIsReturned()
{
var hashedAccountId = "ABC123";
var accountResponse = new GetEmployerAccountByHashedIdResponse
{
Account = new AccountDetail
{
HashedId = hashedAccountId,
AccountId = 123,
Name = "Test",
OwnerEmail = "*****@*****.**",
CreatedDate = DateTime.Now.AddYears(-1),
LegalEntities = new List <long> {
1, 4
},
PayeSchemes = new List <string> {
"ZZZ/123", "XXX/123"
}
}
};
var accountBalanceResponse = new GetAccountBalancesResponse
{
Accounts = new List <AccountBalance> {
new AccountBalance {
AccountId = accountResponse.Account.AccountId, Balance = 123.45m
}
}
};
Mediator.Setup(x => x.SendAsync(It.Is <GetEmployerAccountByHashedIdQuery>(q => q.HashedAccountId == hashedAccountId))).ReturnsAsync(accountResponse);
Mediator.Setup(x => x.SendAsync(It.Is <GetAccountBalancesRequest>(q => q.AccountIds.Single() == accountResponse.Account.AccountId))).ReturnsAsync(accountBalanceResponse);
Mediator.Setup(x => x.SendAsync(It.IsAny <GetTransferAllowanceQuery>())).ReturnsAsync(new GetTransferAllowanceResponse {
TransferAllowance = new TransferAllowance()
});
UrlHelper.Setup(x => x.Route("GetLegalEntity", It.Is <object>(o => o.IsEquivalentTo(new { hashedAccountId, legalEntityId = accountResponse.Account.LegalEntities[0].ToString() }))))
.Returns($"/api/accounts/{hashedAccountId}/legalentities/{accountResponse.Account.LegalEntities[0]}");
UrlHelper.Setup(x => x.Route("GetLegalEntity", It.Is <object>(o => o.IsEquivalentTo(new { hashedAccountId, legalEntityId = accountResponse.Account.LegalEntities[1].ToString() }))))
.Returns($"/api/accounts/{hashedAccountId}/legalentities/{accountResponse.Account.LegalEntities[1]}");
UrlHelper.Setup(x => x.Route("GetPayeScheme", It.Is <object>(o => o.IsEquivalentTo(new { hashedAccountId, payeSchemeRef = accountResponse.Account.PayeSchemes[0].Replace(@"/", "%2f") }))))
.Returns($"/api/accounts/{hashedAccountId}/payeschemes/{accountResponse.Account.PayeSchemes[0].Replace(@"/", "%2f")}");
UrlHelper.Setup(x => x.Route("GetPayeScheme", It.Is <object>(o => o.IsEquivalentTo(new { hashedAccountId, payeSchemeRef = accountResponse.Account.PayeSchemes[1].Replace(@"/", "%2f") }))))
.Returns($"/api/accounts/{hashedAccountId}/payeschemes/{accountResponse.Account.PayeSchemes[1].Replace(@"/", "%2f")}");
var response = await Controller.GetAccount(hashedAccountId);
Assert.IsNotNull(response);
Assert.IsInstanceOf <OkNegotiatedContentResult <AccountDetailViewModel> >(response);
var model = response as OkNegotiatedContentResult <AccountDetailViewModel>;
model?.Content.Should().NotBeNull();
model.Content.DasAccountId.Should().Be(hashedAccountId);
model.Content.HashedAccountId.Should().Be(hashedAccountId);
model.Content.AccountId.Should().Be(accountResponse.Account.AccountId);
model.Content.DasAccountName.Should().Be(accountResponse.Account.Name);
model.Content.DateRegistered.Should().Be(accountResponse.Account.CreatedDate);
model.Content.OwnerEmail.Should().Be(accountResponse.Account.OwnerEmail);
foreach (var legalEntity in accountResponse.Account.LegalEntities)
{
var matchedEntity = model.Content.LegalEntities.Single(x => x.Id == legalEntity.ToString());
matchedEntity.Href.Should().Be($"/api/accounts/{hashedAccountId}/legalentities/{legalEntity}");
}
foreach (var payeScheme in accountResponse.Account.PayeSchemes)
{
var matchedScheme = model.Content.PayeSchemes.Single(x => x.Id == payeScheme);
matchedScheme.Href.Should().Be($"/api/accounts/{hashedAccountId}/payeschemes/{payeScheme.Replace(@"/", "%2f")}");
}
model.Content.Balance.Should().Be(accountBalanceResponse.Accounts.Single().Balance);
}
