public void List_ShouldReturn_CreatedTransfers()
{
Transfer createdTransfer1, createdTransfer2;
IEnumerable <Transfer> queriedTransfers;
using (var dataLayer = DataLayerHelper.CreateDataLayer())
using (var categoriesController = new CategoriesController(dataLayer))
using (var currenciesController = new CurrenciesController(dataLayer))
using (var partnersController = new PartnersController(dataLayer))
using (var transfersController = new TransfersController(dataLayer))
{
var category = categoriesController.CreateCategory(TestDataProvider.CreateNewCategory());
var partner = partnersController.CreatePartner(TestDataProvider.CreateNewPartner());
var currency = currenciesController.CreateCurrency(TestDataProvider.CreateNewCurrency());
var newTransfer1 = TestDataProvider.CreateNewTransfer(
category.Id,
partner.Id,
currency.Id,
TestDataProvider.CreateNewTransferItem());
createdTransfer1 = transfersController.CreateTransfer(newTransfer1);
var newTransfer2 = TestDataProvider.CreateNewTransfer(
category.Id,
partner.Id,
currency.Id,
TestDataProvider.CreateNewTransferItem());
createdTransfer2 = transfersController.CreateTransfer(newTransfer2);
queriedTransfers = transfersController.List();
}
AssertTransfersInList(queriedTransfers, createdTransfer1, createdTransfer2);
}
public TransfersControllerTests()
{
_trustRepository = new Mock <ITrustsRepository>();
_academiesRepository = new Mock <IAcademiesRepository>();
_projectsRepository = new Mock <IProjectsRepository>();
_session = new Mock <ISession>();
var tempDataProvider = new Mock <ITempDataProvider>();
var httpContext = new DefaultHttpContext();
var sessionFeature = new SessionFeature {
Session = _session.Object
};
httpContext.Features.Set <ISessionFeature>(sessionFeature);
var tempDataDictionaryFactory =
new TempDataDictionaryFactory(tempDataProvider.Object);
var tempData = tempDataDictionaryFactory.GetTempData(httpContext);
_subject = new TransfersController(
_trustRepository.Object,
_academiesRepository.Object,
_projectsRepository.Object
)
{
TempData = tempData, ControllerContext = { HttpContext = httpContext }
};
}
public void Get_Normally_ShouldReturn_TransferWithId()
{
CreatedAtActionResult actionResult;
Transfer createdTransfer, queriedTransfer;
using (var dataLayer = DataLayerHelper.CreateDataLayer())
using (var categoriesController = new CategoriesController(dataLayer))
using (var currenciesController = new CurrenciesController(dataLayer))
using (var partnersController = new PartnersController(dataLayer))
using (var transfersController = new TransfersController(dataLayer))
{
var category = categoriesController.CreateCategory(TestDataProvider.CreateNewCategory());
var partner = partnersController.CreatePartner(TestDataProvider.CreateAnotherNewPartner());
var currency = currenciesController.CreateCurrency(TestDataProvider.CreateNewCurrency());
var newTransfer = TestDataProvider.CreateNewTransfer(
category.Id,
partner.Id,
currency.Id,
TestDataProvider.CreateNewTransferItem());
actionResult = (CreatedAtActionResult)transfersController.Create(newTransfer);
createdTransfer = (Transfer)actionResult.Value;
queriedTransfer = transfersController.Get(createdTransfer.Id);
}
Assert.AreEqual(actionResult.ActionName, "Get");
Assert.IsTrue(
queriedTransfer.IsEqualTo(createdTransfer),
"The two transfers should be equal. "
+ $"Expected: {createdTransfer.Stringify()}, actual: {queriedTransfer.Stringify()}.");
}
public void Delete_Normally_ShouldWork()
{
Transfer createdTransfer, queriedTransfer;
IEnumerable <Transfer> listedTransfers;
using (var dataLayer = DataLayerHelper.CreateDataLayer())
using (var categoriesController = new CategoriesController(dataLayer))
using (var currenciesController = new CurrenciesController(dataLayer))
using (var partnersController = new PartnersController(dataLayer))
using (var transfersController = new TransfersController(dataLayer))
{
var category = categoriesController.CreateCategory(TestDataProvider.CreateNewCategory());
var partner = partnersController.CreatePartner(TestDataProvider.CreateAnotherNewPartner());
var currency = currenciesController.CreateCurrency(TestDataProvider.CreateAnotherNewCurrency());
var newTransfer = TestDataProvider.CreateNewTransfer(
category.Id,
partner.Id,
currency.Id,
TestDataProvider.CreateNewTransferItem());
createdTransfer = transfersController.CreateTransfer(newTransfer);
queriedTransfer = transfersController.Get(createdTransfer.Id);
transfersController.Delete(createdTransfer.Id);
listedTransfers = transfersController.List();
}
Assert.AreEqual(createdTransfer.Id, queriedTransfer.Id, "Unexpected ID.");
Assert.AreEqual(false, listedTransfers.Any(), "There should be no transfers returned.");
}
public async Task Then_Gets_Financial_Breakdown_From_Mediator(
long accountId,
GetFinancialBreakdownResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TransfersController transfersController)
{
mockMediator
.Setup(x => x.Send(It.Is <GetFinancialBreakdownQuery>(y => y.AccountId == accountId), It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var actionResult = await transfersController.GetFinancialBreakdown(accountId);
var okObjectResult = actionResult as OkObjectResult;
var value = okObjectResult.Value;
var getFinancialBreakdownResponse = value as GetFinancialBreakdownResponse;
Assert.IsNotNull(actionResult);
Assert.IsNotNull(okObjectResult);
Assert.IsNotNull(value);
Assert.IsNotNull(getFinancialBreakdownResponse);
Assert.AreEqual(mediatorResult.Commitments, getFinancialBreakdownResponse.Commitments);
Assert.AreEqual(mediatorResult.AcceptedPledgeApplications, getFinancialBreakdownResponse.AcceptedPledgeApplications);
Assert.AreEqual(mediatorResult.ApprovedPledgeApplications, getFinancialBreakdownResponse.ApprovedPledgeApplications);
Assert.AreEqual(mediatorResult.TransferConnections, getFinancialBreakdownResponse.TransferConnections);
}
public void Update_WhenRecordDoesNotExist_ShouldThrow()
{
using (var dataLayer = DataLayerHelper.CreateDataLayer())
using (var controller = new TransfersController(dataLayer))
{
var transferUpdate = TestDataProvider.CreateTransferUpdate(1, 1, 1, 1);
controller.Update(transferUpdate);
}
}
public void Create_WhenRecordExists_ShouldThrow()
{
using (var dataLayer = DataLayerHelper.CreateDataLayer())
using (var controller = new TransfersController(dataLayer))
{
var newTransfer = TestDataProvider.CreateNewTransfer(1, 1, 1, TestDataProvider.CreateNewTransferItem());
controller.Create(newTransfer);
controller.Create(newTransfer);
}
}
public void Arrange()
{
_query = new GetTransferConnectionInvitationAuthorizationQuery();
_response = new GetTransferConnectionInvitationAuthorizationResponse {
AuthorizationResult = AuthorizationResult.FeatureAgreementNotSigned, IsValidSender = true, TransferAllowancePercentage = .25m
};
_mapperConfig = new MapperConfiguration(c => c.AddProfile <TransferMappings>());
_mapper = _mapperConfig.CreateMapper();
_mediator = new Mock <IMediator>();
_mediator.Setup(m => m.SendAsync(_query)).ReturnsAsync(_response);
_controller = new TransfersController(null, _mapper, _mediator.Object);
}
public void Arrange()
{
_query = new GetTransferConnectionInvitationsQuery();
_response = new GetTransferConnectionInvitationsResponse
{
TransferConnectionInvitations = new List <TransferConnectionInvitationDto>()
};
_mapperConfig = new MapperConfiguration(c => c.AddProfile <TransferMappings>());
_mapper = _mapperConfig.CreateMapper();
_mediator = new Mock <IMediator>();
_mediator.Setup(m => m.SendAsync(_query)).ReturnsAsync(_response);
_controller = new TransfersController(null, _mapper, _mediator.Object);
}
public TransfersControllerTests()
{
this.rpc = new Mock <IRpcFactory>();
this.propertyManagementRpc = new Mock <IPropertyManagementRpc>();
this.rawTransactionRpc = new Mock <IRawTransactionRpc>();
var anyCancellationToken = It.IsAny <CancellationToken>();
this.rpc.Setup(f => f.CreatePropertyManagementRpcAsync(anyCancellationToken))
.ReturnsAsync(this.propertyManagementRpc.Object);
this.rpc.Setup(f => f.CreateRawTransactionRpcAsync(anyCancellationToken))
.ReturnsAsync(this.rawTransactionRpc.Object);
this.watcher = new Mock <ITransactionConfirmationWatcher>();
this.callbackRepository = new Mock <ICallbackRepository>();
this.ruleRepository = new Mock <IRuleRepository>();
var builder = new ConfigurationBuilder();
builder.AddInMemoryCollection(new System.Collections.Generic.Dictionary <string, string>
{
{ "Api:Default:TransactionTimeout", "00:10" },
{ "Api:Default:RequiredConfirmation", "6" },
{ "Zcoin:Network:Type", "Mainnet" },
{ "Zcoin:Property:Id", "3" },
{ "Zcoin:Property:Type", "Divisible" },
{ "Zcoin:Property:Issuer", "Mainnet:a8ULhhDgfdSiXJhSZVdhb8EuDc6R3ogsaM" },
{ "Zcoin:Property:Distributor", "Mainnet:a8ULhhDgfdSiXJhSZVdhb8EuDc6R3ogsaM" },
});
this.configuration = builder.Build();
this.zcoinConfig = this.configuration.GetZcoinSection();
this.apiConfig = this.configuration.GetApiSection();
this.helper = new ControllerHelper(this.callbackRepository.Object);
this.subject = new TransfersController
(
this.rpc.Object,
this.watcher.Object,
this.ruleRepository.Object,
this.configuration,
this.helper
);
}
public void Create_WhenTitleNull_ShouldThrow()
{
var newTransfer = new NewTransfer
{
CategoryId = 1,
PartnerId = 1,
CurrencyId = 1,
Title = null,
Time = DateTime.UtcNow,
Discount = 0.3M,
Note = null,
Items = null,
};
using (var dataLayer = DataLayerHelper.CreateDataLayer())
using (var controller = new TransfersController(dataLayer))
controller.Create(newTransfer);
}
public void Arrange()
{
_configuration = new EmployerFinanceConfiguration {
TransferAllowancePercentage = .25m
};
_transferAllowance = new TransferAllowance
{
RemainingTransferAllowance = 123.456m,
StartingTransferAllowance = 234.56M,
};
_query = new GetTransferAllowanceQuery();
_response = new GetTransferAllowanceResponse {
TransferAllowance = _transferAllowance, TransferAllowancePercentage = _configuration.TransferAllowancePercentage
};
_mapperConfig = new MapperConfiguration(c => c.AddProfile <TransferMappings>());
_mapper = _mapperConfig.CreateMapper();
_mediator = new Mock <IMediator>();
_mediator.Setup(m => m.SendAsync(_query)).ReturnsAsync(_response);
_controller = new TransfersController(null, _mapper, _mediator.Object);
}
public void Create_Normally_ShouldReturn_Transfer()
{
NewTransfer newTransfer;
Transfer transfer;
using (var dataLayer = DataLayerHelper.CreateDataLayer())
using (var categoriesController = new CategoriesController(dataLayer))
using (var currenciesController = new CurrenciesController(dataLayer))
using (var partnersController = new PartnersController(dataLayer))
using (var transfersController = new TransfersController(dataLayer))
{
var category = categoriesController.CreateCategory(TestDataProvider.CreateNewCategory());
var partner = partnersController.CreatePartner(TestDataProvider.CreateAnotherNewPartner());
var currency = currenciesController.CreateCurrency(TestDataProvider.CreateAnotherNewCurrency());
newTransfer = TestDataProvider.CreateNewTransfer(
category.Id,
partner.Id,
currency.Id,
TestDataProvider.CreateNewTransferItem());
transfer = transfersController.CreateTransfer(newTransfer);
}
Assert.AreEqual(newTransfer.CategoryId, transfer.Category.Id, "Unexpected category.");
Assert.AreEqual(newTransfer.CurrencyId, transfer.Currency.Id, "Unexpected currency.");
Assert.AreEqual(newTransfer.Discount, transfer.Discount, "Unexpected discount.");
Assert.IsTrue(transfer.Id > 0, $"Transfer ID is expected to greater than 0. Actual: {transfer.Id}.");
Assert.AreEqual(newTransfer.Items.Length, transfer.Items.Length, "Unexpected transfer item count.");
Assert.AreEqual(newTransfer.Items[0].Discount, transfer.Items[0].Discount, "Unexpected item discount.");
Assert.IsTrue(
transfer.Items[0].Id > 0,
$"Item ID is expected to greater than 0. Actual: {transfer.Items[0].Id}.");
Assert.AreEqual(newTransfer.Items[0].Name, transfer.Items[0].Name, "Unexpected item name.");
Assert.AreEqual(newTransfer.Items[0].Price, transfer.Items[0].Price, "Unexpected item price.");
Assert.AreEqual(newTransfer.Note, transfer.Note, "Unexpected note.");
Assert.AreEqual(newTransfer.PartnerId, transfer.Partner.Id, "Unexpected partner.");
Assert.AreEqual(newTransfer.Time, transfer.Time, "Unexpected time.");
Assert.AreEqual(newTransfer.Title, transfer.Title, "Unexpected title.");
}
public async Task Then_Gets_Index_From_Mediator(
long accountId,
GetIndexQueryResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TransfersController transfersController)
{
mockMediator
.Setup(x => x.Send(It.Is <GetIndexQuery>(y => y.AccountId == accountId), It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var actionResult = await transfersController.GetIndex(accountId);
var okObjectResult = actionResult as OkObjectResult;
var value = okObjectResult.Value;
var getIndexResponse = value as GetIndexResponse;
Assert.IsNotNull(actionResult);
Assert.IsNotNull(okObjectResult);
Assert.IsNotNull(value);
Assert.IsNotNull(getIndexResponse);
Assert.AreEqual(mediatorResult.PledgesCount, getIndexResponse.PledgesCount);
Assert.AreEqual(mediatorResult.ApplicationsCount, getIndexResponse.ApplicationsCount);
}
public async Task Then_Gets_Validity_From_Mediator(
long senderId,
long receiverId,
int?pledgeApplicationId,
GetTransferValidityQueryResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TransfersController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTransferValidityQuery>(query =>
query.SenderId == senderId && query.ReceiverId == receiverId && query.PledgeApplicationId == pledgeApplicationId),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetTransferValidity(senderId, receiverId, pledgeApplicationId) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTransferValidityResponse;
Assert.IsNotNull(model);
model.IsValid.Should().Be(mediatorResult.IsValid);
}
public void Arrange()
{
_controller = new TransfersController(null, null, null);
}
public void Get_WhenRecordDoesNotExist_ShouldThrow()
{
using (var dataLayer = DataLayerHelper.CreateDataLayer())
using (var controller = new TransfersController(dataLayer))
controller.Get(0);
}
public void Update_Normally_ShouldWork()
{
Category category2;
Transfer createdTransfer, updatedTransfer;
TransferUpdate transferUpdate;
using (var dataLayer = DataLayerHelper.CreateDataLayer())
using (var categoriesController = new CategoriesController(dataLayer))
using (var currenciesController = new CurrenciesController(dataLayer))
using (var partnersController = new PartnersController(dataLayer))
using (var transfersController = new TransfersController(dataLayer))
{
var category1 = categoriesController.CreateCategory(TestDataProvider.CreateNewCategory());
var partner = partnersController.CreatePartner(TestDataProvider.CreateNewPartner());
var currency = currenciesController.CreateCurrency(TestDataProvider.CreateAnotherNewCurrency());
category2 = categoriesController.CreateCategory(TestDataProvider.CreateAnotherNewCategory());
var newTransfer = TestDataProvider.CreateNewTransfer(
category1.Id,
partner.Id,
currency.Id,
TestDataProvider.CreateNewTransferItem());
createdTransfer = transfersController.CreateTransfer(newTransfer);
transferUpdate = TestDataProvider.CreateTransferUpdate(
createdTransfer.Id,
category2.Id,
partner.Id,
currency.Id,
TestDataProvider.CreateTransferItemUpdate(createdTransfer.Items[0].Id));
transfersController.Update(transferUpdate);
updatedTransfer = transfersController.Get(createdTransfer.Id);
}
// Note that EF Core behaves slightly differently when an in-memory database is used, these checks are not
// necessarily enough. Use "curl" or something similar, preferably a REST test-client to make sure
// everything works as expected.
Assert.IsTrue(
updatedTransfer.Category.IsEqualTo(category2),
$"Unexpected category. Expected: ${category2}. Actual: ${updatedTransfer.Category}.");
Assert.IsTrue(
updatedTransfer.Currency.IsEqualTo(createdTransfer.Currency),
$"Unexpected currency. Expected: ${createdTransfer.Currency}. Actual: ${updatedTransfer.Currency}.");
Assert.AreEqual(transferUpdate.Discount, updatedTransfer.Discount, "Unexpected discount.");
Assert.AreEqual(
transferUpdate.Items.Length,
updatedTransfer.Items.Length,
"Unexpected transfer item count.");
Assert.AreEqual(
transferUpdate.Items[0].Discount,
updatedTransfer.Items[0].Discount,
"Unexpected item discount.");
Assert.AreEqual(
createdTransfer.Items[0].Id,
updatedTransfer.Items[0].Id,
"Unexpected item ID");
Assert.AreEqual(transferUpdate.Items[0].Name, updatedTransfer.Items[0].Name, "Unexpected item name.");
Assert.AreEqual(transferUpdate.Items[0].Price, updatedTransfer.Items[0].Price, "Unexpected item price.");
Assert.AreEqual(transferUpdate.Note, updatedTransfer.Note, "Unexpected note.");
Assert.IsTrue(
updatedTransfer.Partner.IsEqualTo(createdTransfer.Partner),
$"Unexpected partner. Expected: ${createdTransfer.Partner}. Actual: ${updatedTransfer.Partner}.");
Assert.AreEqual(transferUpdate.Time, updatedTransfer.Time, "Unexpected time.");
Assert.AreEqual(transferUpdate.Title, updatedTransfer.Title, "Unexpected title.");
}
public void Create_WhenParamNull_ShouldThrow()
{
using (var dataLayer = DataLayerHelper.CreateDataLayer())
using (var controller = new TransfersController(dataLayer))
controller.Create(null);
}
public static Transfer CreateTransfer(this TransfersController controller, NewTransfer newTransfer)
{
var actionResult = (CreatedAtActionResult)controller.Create(newTransfer);
return((Transfer)actionResult.Value);
}
public void Arrange()
{
_mediatorMock = new Mock <IMediator>();
_controller = new TransfersController(null, null, _mediatorMock.Object);
}
