public void TransferHandler_Execute_AccountNotFoundException()
{
var accountHandler = new Moq.Mock <IAccountHandler>();
var ammount = new Models.Money();
var origin = new Models.Account();
var destiny = new Models.Account();
var transactionId = Guid.NewGuid();
var transaction = new Models.Transfer()
{
Ammount = ammount,
Origin = origin,
Destiny = destiny
};
accountHandler
.Setup(a => a.BlockAmmount(origin, ammount))
.Returns(transactionId);
accountHandler
.Setup(a => a.SendMoney(destiny, ammount, transactionId))
.Throws(new AccountNotFoundException());
var transferHandler = new TransferHandler(accountHandler.Object);
Action throwException = () => transferHandler.Execute(transaction);
Assert.Throws <AccountNotFoundException>(throwException);
accountHandler.Verify(a => a.BlockAmmount(origin, ammount), Moq.Times.Once);
accountHandler.Verify(a => a.SendMoney(destiny, ammount, transactionId), Moq.Times.Once);
accountHandler.Verify(a => a.ConfirmTransaction(transactionId), Moq.Times.Never);
accountHandler.Verify(a => a.RevertTransaction(transactionId), Moq.Times.Once);
}
public void TransferHandler_Execute_NotEnoughMoneyException()
{
var accountHandler = new Moq.Mock <IAccountHandler>();
var ammount = new Models.Money();
var origin = new Models.Account();
var transaction = new Models.Transfer()
{
Ammount = ammount,
Origin = origin,
Destiny = new Models.Account()
};
accountHandler
.Setup(a => a.BlockAmmount(origin, ammount))
.Throws(new NotEnoughMoneyException());
var transferHandler = new TransferHandler(accountHandler.Object);
Action throwException = () => transferHandler.Execute(transaction);
Assert.Throws <NotEnoughMoneyException>(throwException);
accountHandler.Verify(a => a.BlockAmmount(origin, ammount), Moq.Times.Once);
accountHandler.Verify(a => a.SendMoney(Moq.It.IsAny <Models.Account>(), Moq.It.IsAny <Models.Money>(), Moq.It.IsAny <Guid>()), Moq.Times.Never);
accountHandler.Verify(a => a.ConfirmTransaction(Moq.It.IsAny <Guid>()), Moq.Times.Never);
accountHandler.Verify(a => a.RevertTransaction(Moq.It.IsAny <Guid>()), Moq.Times.Never);
}
public IActionResult Transfer(TransferViewModel model)
{
if (ModelState.IsValid)
{
var command = new TransferCommand
{
AccountId_Sender = model.AccountIdSender,
AccountId_Reciever = model.AccountIdReciever,
Amount = model.Amount
};
var query = new TransferHandler(new BankContext()).Handler(command);
if (query.IsCompletedSuccessfully)
{
TempData["Success"] = $"{model.Amount.ToString("C")} transferred from {model.BalanceSender} to {model.AccountIdReciever}";
return(View());
}
else
{
TempData["Error"] = $"Transfer failed";
return(View());
}
}
return(NotFound());
}
public void TransferHandler_Execute_Succesfull()
{
var accountHandler = new Moq.Mock <IAccountHandler>();
var ammount = new Models.Money();
var origin = new Models.Account();
var destiny = new Models.Account();
var transactionId = Guid.NewGuid();
var transaction = new Models.Transfer()
{
Ammount = ammount,
Origin = origin,
Destiny = destiny
};
accountHandler
.Setup(a => a.BlockAmmount(origin, ammount))
.Returns(transactionId);
var transferHandler = new TransferHandler(accountHandler.Object);
var proccessedTransactionId = transferHandler.Execute(transaction);
Assert.Equal(transactionId, proccessedTransactionId);
accountHandler.Verify(a => a.BlockAmmount(origin, ammount), Moq.Times.Once);
accountHandler.Verify(a => a.SendMoney(destiny, ammount, transactionId), Moq.Times.Once);
accountHandler.Verify(a => a.ConfirmTransaction(transactionId), Moq.Times.Once);
accountHandler.Verify(a => a.RevertTransaction(Moq.It.IsAny <Guid>()), Moq.Times.Never);
}
public IActionResult TransferNoney(TransferMoney transferMoney)
{
var transferHandler = new TransferHandler(new AccountService());
var id = Convert.ToInt32(HttpContext.User.Claims.First(c => c.Type == "id").Value);
transferHandler.Handle(transferMoney, id);
return(Ok());
}
/// <summary>Starts and shows progress for an upload.</summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected override void MainBWorker_DoWork(object sender, DoWorkEventArgs e)
{
TransferHandler.UploadAsync(RemoteFile, LocalFile, Overwrite);
while (TransferHandler.Busy)
{
MainBWorker.ReportProgress(Convert.ToInt32(TransferHandler.Progress * 100));
Thread.Sleep(100);
}
}
private OperationHandler initializeChain()
{
//init from end to beginning of chain
var takeLoanHandler = new TakeLoanHandler(null);
var openLoanAccountHandler = new OpenLoanAccountHandler(takeLoanHandler);
var openDepositAccountHandler = new OpenDepositAccountHandler(openLoanAccountHandler);
var openDebitAccountHandler = new OpenDebitAccountHandler(openDepositAccountHandler);
var openAccountHandler = new OpenAccountHandler(openDebitAccountHandler);
var chargeInstallmentHandler = new ChargeInstallmentHandler(openAccountHandler);
var transferHandler = new TransferHandler(chargeInstallmentHandler);
return(transferHandler); //first handler
}
public void VerifyCorrectBalanceAfterTransfer(decimal fromBalance, decimal toBalance, decimal amount)
{
var db = new MockDb();
var transactionHandler = new TransferHandler(db);
var fromAccount = new Account()
{
Balance = fromBalance
};
var toAccount = new Account()
{
Balance = toBalance
};
transactionHandler.Transfer(fromAccount, toAccount, amount);
Assert.True(fromAccount.Balance == fromBalance - amount);
Assert.True(toAccount.Balance == toBalance + amount);
}
public void ExecuteExceptionsTest(long amountParam, int accountListIdx, int toAccountIdx, string errorMsg)
{
var transfer = new Mock <Transfer>();
var bank = new Mock <Bank>();
var accountList = GetAccountList(accountListIdx);
bank.Setup(t => t.getAccounts()).Returns(accountList);
bank.Setup(t => t.accountPrefix).Returns("B");
transfer.Setup(t => t.Money).Returns(new Money(amountParam));
transfer.SetupGet(t => t.Bank).Returns(bank.Object);
transfer.Setup(t => t.FromAccount).Returns(accountList.ElementAtOrDefault(0));
transfer.Setup(t => t.ToAccountNumber).Returns(GetAccountList(2)[toAccountIdx].AccountNumber.ToString);
var transferHandler = new TransferHandler(null);
Assert.Throws(Is.TypeOf <Exception>()
.And.Message.EqualTo(errorMsg),
() => transferHandler.handle(transfer.Object));
}
public ActionResult CreateTransfer(ShoesTransferViewModel model, FormCollection form)
{
TransferHandler handler = new TransferHandler();
TransferRecord record = new TransferRecord()
{
outlet_Id = model.transferRecord.outlet_Id,
dateOfTransfer = model.transferRecord.dateOfTransfer
};
habib.TransferRecords.Add(record);
habib.SaveChanges();
int outletId = Convert.ToInt32(model.transferRecord.outlet_Id);
record.shoesTransfered = handler.TransferShoes(record.transfer_Id, outletId, model.shoes, model.sizes, model.colors, model.qty);
habib.SaveChanges();
return(View("OutletSelect"));
}
public void ShouldntBeAbleToWithdrawMoreThanBalanceYo(decimal fromBalance, decimal toBalance, decimal amount)
{
var db = new MockDb();
var transactionHandler = new TransferHandler(db);
var fromAccount = new Account()
{
Balance = fromBalance
};
var toAccount = new Account()
{
Balance = toBalance
};
var result = transactionHandler.Transfer(fromAccount, toAccount, amount);
//Assert.Throws<InvalidTransactionException>(() => transactionHandler.Transfer(fromAccount, toAccount, amount));
Assert.False(result.IsSuccessful);
Assert.True(fromAccount.Balance == fromBalance);
}
private static void Exchange()
{
Console.WriteLine("Schimb Valutar:");
Console.WriteLine("Dati moneda curenta: (max. 3 litere)");
string fCurrency = Console.ReadLine();
Console.WriteLine("Dati moneda in care doriti sa se faca schimbul valutar: (max. 3 litere)");
string tCurrency = Console.ReadLine();
Console.WriteLine("Dati suma pe care doriti sa o cumparati:");
bool ok = Double.TryParse(Console.ReadLine(), out double val);
ECurrency fromCurrency = ECurrency.NO_CURRENCY;
ECurrency toCurrency = ECurrency.NO_CURRENCY;
ProcessInput(fCurrency, ref fromCurrency, tCurrency, ref toCurrency);
if (ok)
{
TransferHandler handler = new TransferHandler();
handler.CashOut(fromCurrency, toCurrency, val);
}
}
public void Transfer_InsufficientFunds()
{
var options = new DbContextOptionsBuilder <BankContext>()
.UseInMemoryDatabase(databaseName: "NegativeAmount")
.Options;
using (var context = new BankContext(options))
{
var sender = new Account
{
AccountId = 4,
Frequency = "Daily",
Balance = 500
};
var reciever = new Account
{
AccountId = 5,
Frequency = "Daily"
};
context.Accounts.AddRange(sender, reciever);
context.SaveChanges();
}
using (var context = new BankContext(options))
{
var command = new TransferCommand()
{
AccountId_Sender = 4,
AccountId_Reciever = 5,
Amount = 1000
};
var handler = new TransferHandler(context);
Assert.ThrowsAsync <InsufficientFundsException>(() => handler.Handler(command));
}
}
public virtual T ReloadToken(string transferId)
{
return(TransferHandler.ReloadToken(transferId));
}
public virtual TransferStatus GetTransferStatus(string transferId)
{
return(TransferHandler.GetTransferStatus(transferId));
}
public virtual TransferStatus CancelTransfer(string transferId, AbortReason reason)
{
return(TransferHandler.CancelTransfer(transferId, reason));
}
public virtual TransferStatus CompleteTransfer(string transferId)
{
return(TransferHandler.CompleteTransfer(transferId));
}
public virtual OperationResult PauseTransfer(string transferId)
{
TransferHandler.PauseTransfer(transferId);
return(new OperationResult.OK());
}
public static int TransferAsyncAll(int size, Action<object> process)
{
var scanResults = ConnectionManager.RemoteClient.Search<Object>(s => s
.Index(SrcIndexName)
.Type(SrcIndexType)
.From(0)
.Size(size)
.MatchAll()
.SearchType(SearchType.Scan)
.Scroll(ScrollTime)
);
if (scanResults == null) return 0;
TransferHandler handler = new TransferHandler(TransferCall);
AnsycState state = new AnsycState
{
Handler = handler,
Process = process
};
if (string.IsNullOrEmpty(scanResults.ScrollId)) return 0;
handler.BeginInvoke(scanResults.ScrollId, process, TransferCallback, state);
return Convert.ToInt32(scanResults.Total);
}
public static int TransferAsync(int size, DateTime from,DateTime to,Action<object> process)
{
//from = from.AddHours(-8);
//to = to.AddHours(-8);
var scanResults = ConnectionManager.RemoteClient.Search<Object>(s => s
.Index(SrcIndexName)
.Type(SrcIndexType)
.From(0)
.Size(size)
.Query(q=>q.Range(r=>r.OnField("TimeStamp").Greater(from).LowerOrEquals(to)))
.SearchType(SearchType.Scan)
.Scroll(ScrollTime)
);
if (scanResults == null) return 0;
TransferHandler handler = new TransferHandler(TransferCall);
AnsycState state = new AnsycState
{
Handler = handler,
Process = process
};
if (string.IsNullOrEmpty(scanResults.ScrollId)) return 0;
handler.BeginInvoke(scanResults.ScrollId, process, TransferCallback, state);
return Convert.ToInt32(scanResults.Total);
}
private void recreateOriginalText()
{
TransferHandler.MBM2XML("F:\\smt4_jpn\\RomFS");
TransferHandler.XML2PO("F:\\smt4_jpn\\RomFS");
}
public TransactionController(TransferHandler transferHandler)
{
_transferHandler = transferHandler;
}
