public void SerializeXML_OK()
{
//Arrange
CommissionAccount acc = new CommissionAccount("myCommissionXML_SerializeTest", 10.234m, Currency.CHF);
//Act
CommissionAccountSerializer.SerializeXML(acc);
//Assert
Assert.True(File.Exists("myCommissionXML_SerializeTest.xml"));
}
public void SerializeBinaryOK()
{
//Arrange
CommissionAccount acc = new CommissionAccount("myCommission", 10.234m, Currency.CHF);
//Act
CommissionAccountSerializer.SerializeBinary(acc);
//Assert
Assert.True(File.Exists("myCommission.txt"));
}
public void AccountUnsubscribeFromCommissionFail()
{
//Arrange
CommissionAccount acc = new CommissionAccount("123", 10, Currency.AUD);
//Assert
AccountManager nothing = null;
var ex = Assert.Throws <ArgumentNullException>(() => acc.UnsubscribeFromCommission(nothing));
Assert.AreEqual($"{ExceptionMessages.AccountUnsubscribeNullParam() + Environment.NewLine}Parameter name: accountManager", ex.Message);
}
protected double GetCoeffMethod(CommissionMethod method, CommissionAccount account)
{
switch (method)
{
case CommissionMethod.QUANTITY_PERCENT:
return(0.01);
case CommissionMethod.TERM_TICKS:
return(Security.TickSize);
}
return(1);
}
public void DeserializeXML_OK()
{
//Arrange
CommissionAccount baseAcc = new CommissionAccount("myCommissionXML_DeserializeTest", 10.234m, Currency.CHF);
//Act
CommissionAccountSerializer.SerializeXML(baseAcc);
CommissionAccount newAcc = CommissionAccountSerializer.DeserializeXML("myCommissionXML_DeserializeTest.xml");
//Assert
Assert.AreEqual(baseAcc.AccountID, newAcc.AccountID);
Assert.AreEqual(baseAcc.Money.Amount, newAcc.Money.Amount);
Assert.AreEqual(baseAcc.Money.Curr, newAcc.Money.Curr);
}
public void DeserializeBinaryOK()
{
//Arrange
CommissionAccount baseAcc = new CommissionAccount("myCommissionBin_test", 10.234m, Currency.CHF);
//Act
CommissionAccountSerializer.SerializeBinary(baseAcc);
CommissionAccount newAcc = CommissionAccountSerializer.DeserializeBinary("myCommissionBin_test.txt");
//Assert
Assert.AreEqual(baseAcc.AccountID, newAcc.AccountID);
Assert.AreEqual(baseAcc.Money.Amount, newAcc.Money.Amount);
Assert.AreEqual(baseAcc.Money.Curr, newAcc.Money.Curr);
}
protected void CheckCommissions(bool isPassive)
{
if (Order.Side == Side.BUY)
{
CommissionAccount account = (CommissionAccount)TestContent.TradeSettings.Settings.BuyerCommissionAccount;
CommissionMethod method = (CommissionMethod)TestContent.TradeSettings.Settings.BuyerCommissionMethod;
double pv = !isPassive
? (double)TestContent.TradeSettings.Settings.BuyerTakerCommissionProgressive
: (double)TestContent.TradeSettings.Settings.BuyerMakerCommissionProgressive;
List <TransactionDto> currencyForCommission = account == CommissionAccount.SOURCE_ACCOUNT
? TestContent.TermTransactions : TestContent.BaseTransactions;
double commissions = currencyForCommission.FindAll(t => t.Type == Type.trading_commission).Sum(t => t.Amount);
if (method == CommissionMethod.TERM_TICKS)
{
currencyForCommission = account == CommissionAccount.SOURCE_ACCOUNT
? TestContent.BaseTransactions : TestContent.TermTransactions;
}
CalcCommissions(currencyForCommission, method, account, pv, commissions);
}
if (Order.Side == Side.SELL)
{
CommissionAccount account = (CommissionAccount)TestContent.TradeSettings.Settings.SellerCommissionAccount;
CommissionMethod method = (CommissionMethod)TestContent.TradeSettings.Settings.SellerCommissionMethod;
double pv = !isPassive
? (double)TestContent.TradeSettings.Settings.SellerTakerCommissionProgressive
: (double)TestContent.TradeSettings.Settings.SellerMakerCommissionProgressive;
List <TransactionDto> currencyForCommission = account == CommissionAccount.SOURCE_ACCOUNT
? TestContent.BaseTransactions : TestContent.TermTransactions;
double commissions = currencyForCommission.FindAll(t => t.Type == Type.trading_commission).Sum(t => t.Amount);
if (method == CommissionMethod.TERM_TICKS)
{
currencyForCommission = account == CommissionAccount.SOURCE_ACCOUNT
? TestContent.TermTransactions : TestContent.BaseTransactions;
}
CalcCommissions(currencyForCommission, method, account, pv, commissions);
}
}
public void AccountContextOK()
{
IAccountManager manager = new AccountManager10percent();
AccountContext context = new AccountContext(manager);
Account accFrom = new Account("from", 200m, Currency.USD);
Account accTo = new Account("to", 50m, Currency.USD);
CommissionAccount accCommission = new CommissionAccount("commission", 0m, Currency.USD);
accCommission.SubscribeToCommission(context.Manager);
context.Transaction(accFrom, accTo, 100m, Currency.USD);
Assert.AreEqual(90m, accFrom.Money.Amount);
Assert.AreEqual(150m, accTo.Money.Amount);
Assert.AreEqual(10m, accCommission.Money.Amount);
}
public void AccountCheckComission()
{
//Arrange
AccountManager accountManager = new AccountManager(0.01m, Currency.CHF);
Account accFrom = new Account("from", 547.345m, Currency.USD);
Account accTo = new Account("to", 56.234m, Currency.EUR);
CommissionAccount commissionAccount = new CommissionAccount("our money", Currency.CHF);
commissionAccount.SubscribeToCommission(accountManager);
//Act
accountManager.Transaction(accFrom, accTo, 78.12m);
//Assert
Assert.AreEqual(0.771934968m, commissionAccount.Money.Amount);
}
public void AccountManagerConversionOK()
{
//Arrange
AccountManager accM = new AccountManager(0.01m, Currency.USD);
Account acc1 = new Account("1", 10, Currency.USD);
Account acc2 = new Account("2", 20, Currency.GBP);
Account acc3 = new Account("3", 5000, Currency.JPY);
CommissionAccount commissionAccount = new CommissionAccount("ourMoney", Currency.USD);
commissionAccount.SubscribeToCommission(accM);
//Act
accM.Conversion(acc1, Currency.EUR);
accM.Conversion(acc2, Currency.AUD);
accM.Conversion(acc3, Currency.USD);
//Assert
Assert.AreEqual(0.808618m, commissionAccount.Money.Amount);
}
public async Task <TransactionCheckResult> TransactionAsync(string accFromName, string userFromName, string accToName, string userToName, decimal amount)
{
TransactionCheckResult result = new TransactionCheckResult();
if (accFromName == accToName && userFromName == userToName)
{
result.IsSameAccs = true;
return(result);
}
AccountEntity accEntityFrom = await GetAccountEntityAsync(accFromName, userFromName);
AccountEntity accEntityTo = await GetAccountEntityAsync(accToName, userToName);
Account accFrom = new Account(accEntityFrom, AccountCreationOptions.EmptyName);
Account accTo = new Account(accEntityTo, AccountCreationOptions.EmptyName);
decimal coefficient = await _globalRates.GetRateAsync(accFrom.Money.Curr, accTo.Money.Curr);
accFrom.Money.AdjustExchangeRate(accFrom.Money.Curr, accTo.Money.Curr, coefficient);
accTo.Money.AdjustExchangeRate(accFrom.Money.Curr, accTo.Money.Curr, coefficient);
AccountManager accManager = await GetAccountManagerAsync(accEntityFrom, userFromName);
AccountEntity commissionAccEntity = await GetCommissionAccount();
CommissionAccount commissionAcc = new CommissionAccount(commissionAccEntity, AccountCreationOptions.CurrencyOnly);
commissionAcc.SubscribeToCommission(accManager);
try
{
accManager.Transaction(accFrom, accTo, amount);
}
catch (Exception ex)
{
if (ex.Message == ExceptionMessages.TransactionInsufficientFunds())
{
result.IsEnough = false;
return(result);
}
else
{
throw new Exception(ex.Message);
}
}
commissionAcc.UnsubscribeFromCommission(accManager);
result.IsEnough = true;
result.SendAmount = accEntityFrom.Amount - accFrom.Money.Amount;
result.Commission = result.SendAmount - amount;
result.Receive = accTo.Money.Amount - accEntityTo.Amount;
result.CommissionOwner = commissionAccEntity.User.UserName;
result.CommissionAccName = commissionAccEntity.AccountName;
result.CurrFrom = accEntityFrom.Currency;
result.CurrTo = accEntityTo.Currency;
accEntityFrom.Amount = accFrom.Money.Amount;
accEntityTo.Amount = accTo.Money.Amount;
commissionAccEntity.Amount += commissionAcc.Money.Amount;
DBContext.Accounts.Update(accEntityFrom);
DBContext.Accounts.Update(accEntityTo);
DBContext.Accounts.Update(commissionAccEntity);
await DBContext.SaveChangesAsync();
return(result);
}
private CommissionBank()
{
commissionAcc = new CommissionAccount("commAcc", 0, Currency.USD);
}
/*
* public void Invoke(string testName)
* {
* // attribute type we search
* System.Type attributeType = typeof(TestCommissionAttribute);
*
* // find method
* var methodInfo = this.GetType().GetMethods().FirstOrDefault(m =>
* m.GetCustomAttributes(attributeType).Cast<TestCommissionAttribute>().Any() &&
* string.Equals(m.Name, testName, StringComparison.InvariantCultureIgnoreCase));
*
* if (methodInfo != null)
* {
* // method found
* PrintTestName(methodInfo.Name);
* InitializeTestContent();
* try
* {
* methodInfo.Invoke(this, new object[] { methodInfo.Name });
* }
* catch (Exception ex)
* {
* Console.WriteLine(ex.Message);
* }
* }
* }
*
* public void InvokeAll()
* {
* System.Type attributeType = typeof(TestCommissionAttribute);
*
* var methodsInfo = this.GetType().GetMethods().Where(m =>
* m.GetCustomAttributes(attributeType).Cast<TestCommissionAttribute>().Any()).ToList();
*
* foreach (var method in methodsInfo)
* {
* PrintTestName(method.Name);
* InitializeTestContent();
* try
* {
* method.Invoke(this, new object[] { method.Name });
* }
* catch (Exception ex)
* {
* Console.WriteLine(ex.Message);
* }
* }
* }
*
* private void PrintTestName(string testName)
* {
* Console.WriteLine("Start test: {0}", testName);
* }
*/
public void TestsConstructor(string testName, OrderType orderType, Side orderSide, CommissionAccount account, CommissionMethod method, bool isPassive)
{
InitializeTestContent();
TestContent.TradeSettings.Settings.BuyerTakerCommissionProgressive = 7;
TestContent.TradeSettings.Settings.SellerTakerCommissionProgressive = 5;
TestContent.TradeSettings.Settings.BuyerMakerCommissionProgressive = 6;
TestContent.TradeSettings.Settings.SellerMakerCommissionProgressive = 4;
if (orderSide == Side.BUY)
{
TestContent.TradeSettings.Settings.BuyerCommissionAccount = account;
TestContent.TradeSettings.Settings.BuyerCommissionMethod = method;
}
if (orderSide == Side.SELL)
{
TestContent.TradeSettings.Settings.SellerCommissionAccount = account;
TestContent.TradeSettings.Settings.SellerCommissionMethod = method;
}
ConfiguratorService.SaveTradeSetting(User.UserId, TestContent.TradeSettings.Settings);
Order = new OrderCrypto()
{
Destination = Exchange,
Quantity = method == CommissionMethod.TERM_TICKS ? 2 : 0.01,
Side = orderSide,
Type = orderType,
SecurityId = Symbol,
};
if (orderType == OrderType.LIMIT)
{
Order.Price = CalcAggressiveOrderPrice(orderSide);
Order.TimeInForce = isPassive ? TimeInForce.DAY : TimeInForce.IOC;
}
GeneralCheck(testName, isPassive);
}
protected void CalcCommissions(List <TransactionDto> currencyForCommission, CommissionMethod method, CommissionAccount account, double pv, double commissions)
{
string currency = currencyForCommission[0].CurrencyId;
int precision = currency == BaseSymbol || method == CommissionMethod.TERM_TICKS ? 4 : 3;
double calcCommissions = 0;
if (method == CommissionMethod.EXACT_VALUE)
{
calcCommissions = Math.Round(TestContent.BaseTransactions.FindAll(t => t.Type == Type.profit_loss).Sum(t => t.Amount) * pv, precision);
}
if (method == CommissionMethod.QUANTITY_PERCENT)
{
calcCommissions = Math.Round(currencyForCommission.FindAll(t => t.Type == Type.profit_loss).Sum(t => t.Amount) *
pv * GetCoeffMethod(method, account), precision);
}
if (method == CommissionMethod.TERM_TICKS)
{
calcCommissions = Math.Round(Math.Pow(TestContent.BaseTransactions.FindAll(t => t.Type == Type.profit_loss).Sum(t => t.Amount), 2)
* pv * GetCoeffMethod(method, account)
/ currencyForCommission.FindAll(t => t.Type == Type.profit_loss).Sum(t => t.Amount), precision);
}
calcCommissions = calcCommissions > 0 ? -calcCommissions : calcCommissions;
if (CompareDouble(commissions, calcCommissions))
{
Console.WriteLine("{0} Commissions: {1}, Calculate commissions: {2}", currency, commissions, calcCommissions);
}
else
{
Console.WriteLine("Error! {0} Commissions: {1}, Calculate commissions: {2}", currency, commissions, calcCommissions);
TestContent.IsSuccess = false;
}
}
