public void TransferMoney_HappyPath_TransfersMoney()
{
// Arrange
var model = new TransferMoneyModel
{
SourceAccountNumber = "test1",
DestinationAccountNumber = "test2",
Amount = 123
};
var controller = new AccountController(bankServiceMock.Object, sessionManagerMock.Object, emailService.Object);
// Act
RedirectToRouteResult result = controller.TransferMoney(model) as RedirectToRouteResult;
// Assert
Assert.IsNotNull(result);
// assert TransferMoney was called on the bank service
bankServiceMock.Verify(m => m.TransferMoney("test1", "test2", 123), Times.Once);
// assert the source account number was stored in the session
sessionManagerMock.Verify(m => m.Store("SourceAccountNumber", "test1"));
// assert the confirmation email was sent
emailService.Verify(m => m.SendTransferEmailConfirmation("test1", "test2", 123), Times.Once);
// assert the result is a redirect to Index
Assert.AreSame("Index", result.RouteValues["action"]);
}
// GET api/values
// POST api/values
public string Post(TransferMoneyModel model)
{
var from = AccountService.GetAccount(model.FromAccount);
var to = AccountService.GetAccount(model.ToAccount);
var result = TransactionService.Transfer(from, to, model.Amount);
return(result.ToString());
}
public void Transfer(TransferMoneyModel model)
{
//TODO: - show refactoring strength when having UTs (->domsrv)
var from = _db.Accounts.FirstOrDefault(a => a.Iban == model.IbanFrom);
var to = _db.Accounts.FirstOrDefault(a => a.Iban == model.IbanTo);
var transferService = new TransferService();
transferService.Transfer(from, to, model.Amount);
_db.SaveChanges();
}
public async Task <ActionResult> Transfer(int id, [FromBody] TransferMoneyModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var sender = await _context.Accounts.FindAsync(id);
var recepient = await _context.Accounts.FindAsync(model.RecipientId);
if (sender == null || recepient == null)
{
return(NotFound("Account not found"));
}
if (sender.Balance < model.Amount)
{
return(BadRequest("Not enough money, milord)"));
}
using (var transaction = _context.Database.BeginTransaction())
{
try
{
var transfer = new Transfer()
{
SenderId = sender.Id,
RecipientId = recepient.Id,
Amount = model.Amount
};
_context.Transfers.Add(transfer);
sender.Balance -= model.Amount;
recepient.Balance += model.Amount;
await _context.SaveChangesAsync();
await transaction.CommitAsync();
}
catch (Exception)
{
transaction.Rollback();
return(StatusCode(500));
}
}
return(Ok());
}
public void TransferMoney_WithSameAccount_HasInvalidModelState()
{
// Arrange
var model = new TransferMoneyModel
{
SourceAccountNumber = "test1",
DestinationAccountNumber = "test1",
Amount = 123
};
var controller = new AccountController(bankServiceMock.Object, sessionManagerMock.Object, emailService.Object);
// Act
ViewResult result = controller.TransferMoney(model) as ViewResult;
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(controller.ModelState.Count > 0);
Assert.IsTrue(controller.ModelState.ContainsKey("SameAccount"));
}
public ActionResult TransferMoney(TransferMoneyModel model)
{
if (model.SourceAccountNumber == model.DestinationAccountNumber)
{
ModelState.AddModelError("SameAccount", "The source and destination accounts must be different");
}
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
bankService.TransferMoney(model.SourceAccountNumber, model.DestinationAccountNumber, model.Amount);
}
catch (InsufficientFundsException)
{
ModelState.AddModelError("InsufficientFunds", "There were insufficient funds to complete the transfer.");
}
catch (AccountNotFoundException ex)
{
ModelState.AddModelError("AccountNotFound", $"There was a problem finding account {ex.AccountNumber}.");
}
catch
{
ModelState.AddModelError("TransferFailed", "There was a problem with the transfer, please contact your bank.");
}
if (!ModelState.IsValid)
{
return(View(model));
}
this.sessionManager.Store("SourceAccountNumber", model.SourceAccountNumber);
this.emailService.SendTransferEmailConfirmation(model.SourceAccountNumber, model.DestinationAccountNumber, model.Amount);
return(RedirectToAction("Index"));
}
public ActionResult TransferMoney(TransferMoneyModel model, int id)
{
Card card = db.Cards.Find(id);
model.Balance = card.Transactions.Sum(p => p.Sum);
ViewBag.toCardID = new SelectList(db.Cards, "ID", "CardNumber", model.toCardID);
if (model.UserTypePin == card.Pin)
{
if (model.Sum <= model.Balance)
{
Transaction tr = new Transaction();
tr.OperationDate = DateTime.Now;
tr.CardID = id;
tr.Sum = -model.Sum;
tr.Decription = model.Description;
db.Transactions.Add(tr);
db.SaveChanges();
card.Balance = card.Transactions.Sum(p => p.Sum);
Transaction tr1 = new Transaction();
tr1.OperationDate = DateTime.Now;
tr1.CardID = model.toCardID;
tr1.Sum = model.Sum;
tr1.Decription = "Перевод с карты " + tr.Card.CardNumber;
db.Transactions.Add(tr1);
db.SaveChanges();
Card cardTo = db.Cards.Find(id);
card.Balance = card.Transactions.Sum(p => p.Sum);
return(RedirectToAction("Details", "Card", new { id = tr.CardID }));
}
return(View(model));
}
return(View(model));
}
public void TransferMoney_WithInsufficientFunds_HasInvalidModelState()
{
// Arrange
var model = new TransferMoneyModel
{
SourceAccountNumber = "test1",
DestinationAccountNumber = "test2",
Amount = 123
};
bankServiceMock.Setup(m => m.TransferMoney(model.SourceAccountNumber, model.DestinationAccountNumber, model.Amount))
.Throws(new InsufficientFundsException());
var controller = new AccountController(bankServiceMock.Object, sessionManagerMock.Object, emailService.Object);
// Act
ViewResult result = controller.TransferMoney(model) as ViewResult;
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(controller.ModelState.Count > 0);
Assert.IsTrue(controller.ModelState.ContainsKey("InsufficientFunds"));
}
public void Transfer(TransferMoneyModel model)
{
new TransferCommandHandler(_db).Transfer(model);
}
