wehub-resource-sync
900 lines
43 KiB
C#
900 lines
43 KiB
C#
/*
|
|
* QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
|
|
* Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
using System;
|
|
using NUnit.Framework;
|
|
using QuantConnect.Data;
|
|
using QuantConnect.Util;
|
|
using QuantConnect.Orders;
|
|
using QuantConnect.Algorithm;
|
|
using QuantConnect.Brokerages;
|
|
using QuantConnect.Interfaces;
|
|
using QuantConnect.Securities;
|
|
using QuantConnect.Data.Market;
|
|
using QuantConnect.Orders.Fees;
|
|
using QuantConnect.Securities.Option;
|
|
using QuantConnect.Tests.Engine.DataFeeds;
|
|
using Option = QuantConnect.Securities.Option.Option;
|
|
|
|
namespace QuantConnect.Tests.Common.Securities
|
|
{
|
|
[TestFixture]
|
|
public class SecurityMarginModelTests
|
|
{
|
|
private static Symbol _symbol;
|
|
private static FakeOrderProcessor _fakeOrderProcessor;
|
|
|
|
[TestCase(1)]
|
|
[TestCase(2)]
|
|
[TestCase(50)]
|
|
public void MarginRemainingForLeverage(decimal leverage)
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
algorithm.SetCash(1000);
|
|
|
|
var spy = InitAndGetSecurity(algorithm, 0);
|
|
spy.Holdings.SetHoldings(25, 100);
|
|
spy.SetLeverage(leverage);
|
|
|
|
var spyMarginAvailable = spy.Holdings.HoldingsValue - spy.Holdings.HoldingsValue * (1 / leverage);
|
|
|
|
var marginRemaining = algorithm.Portfolio.MarginRemaining;
|
|
Assert.AreEqual(1000 + spyMarginAvailable, marginRemaining);
|
|
}
|
|
|
|
[TestCase(1)]
|
|
[TestCase(2)]
|
|
[TestCase(50)]
|
|
public void MarginUsedForPositionWhenPriceDrops(decimal leverage)
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
|
|
// (1000 * 20) = 20k
|
|
// Initial and maintenance margin = (1000 * 20) / leverage = X
|
|
var spy = InitAndGetSecurity(algorithm, 0);
|
|
spy.Holdings.SetHoldings(20, 1000);
|
|
spy.SetLeverage(leverage);
|
|
|
|
// Drop 40% price from $20 to $12
|
|
// 1000 * 12 = 12k
|
|
Update(spy, 12);
|
|
|
|
var marginForPosition = spy.BuyingPowerModel.GetReservedBuyingPowerForPosition(
|
|
new ReservedBuyingPowerForPositionParameters(spy)).AbsoluteUsedBuyingPower;
|
|
Assert.AreEqual(1000 * 12 / leverage, marginForPosition);
|
|
}
|
|
|
|
[TestCase(1)]
|
|
[TestCase(2)]
|
|
[TestCase(50)]
|
|
public void MarginUsedForPositionWhenPriceIncreases(decimal leverage)
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
algorithm.SetCash(1000);
|
|
|
|
// (1000 * 20) = 20k
|
|
// Initial and maintenance margin = (1000 * 20) / leverage = X
|
|
var spy = InitAndGetSecurity(algorithm, 0);
|
|
spy.Holdings.SetHoldings(25, 1000);
|
|
spy.SetLeverage(leverage);
|
|
|
|
// Increase from $20 to $40
|
|
// 1000 * 40 = 400000
|
|
Update(spy, 40);
|
|
|
|
var marginForPosition = spy.BuyingPowerModel.GetReservedBuyingPowerForPosition(
|
|
new ReservedBuyingPowerForPositionParameters(spy)).AbsoluteUsedBuyingPower;
|
|
Assert.AreEqual(1000 * 40 / leverage, marginForPosition);
|
|
}
|
|
|
|
[Test]
|
|
public void ZeroTargetWithZeroHoldingsIsNotAnError()
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algorithm, 0);
|
|
|
|
var model = new SecurityMarginModel();
|
|
var result = model.GetMaximumOrderQuantityForTargetBuyingPower(algorithm.Portfolio, security, 0, 0);
|
|
|
|
Assert.AreEqual(0, result.Quantity);
|
|
Assert.IsTrue(result.Reason.IsNullOrEmpty());
|
|
Assert.IsFalse(result.IsError);
|
|
}
|
|
|
|
[TestCase(0)]
|
|
[TestCase(1)]
|
|
[TestCase(-1)]
|
|
public void ReturnsMinimumOrderValueReason(decimal holdings)
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algorithm, 0);
|
|
var model = new SecurityMarginModel();
|
|
security.Holdings.SetHoldings(security.Price, holdings);
|
|
var currentSignedUsedMargin = model.GetInitialMarginRequirement(security, security.Holdings.Quantity);
|
|
var totalPortfolioValue = algorithm.Portfolio.TotalPortfolioValue;
|
|
var sign = Math.Sign(security.Holdings.Quantity) == 0 ? 1 : Math.Sign(security.Holdings.Quantity);
|
|
// we increase it slightly, should not trigger a new order because it's increasing final margin usage, rounds down
|
|
var newTarget = currentSignedUsedMargin / (totalPortfolioValue) + 0.00001m * sign;
|
|
|
|
var result = model.GetMaximumOrderQuantityForTargetBuyingPower(algorithm.Portfolio, security, newTarget, 0);
|
|
Assert.AreEqual(0m, result.Quantity);
|
|
Assert.IsFalse(result.IsError);
|
|
Assert.IsTrue(result.Reason.Contains("The order quantity is less than the lot size of", StringComparison.InvariantCultureIgnoreCase));
|
|
}
|
|
|
|
[TestCase(1)]
|
|
[TestCase(-1)]
|
|
public void ReducesPositionWhenMarginAboveTargetWhenNegativeFreeMargin(decimal holdings)
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algorithm, 0);
|
|
var model = new SecurityMarginModel();
|
|
security.Holdings.SetHoldings(security.Price, holdings);
|
|
|
|
var security2 = InitAndGetSecurity(algorithm, 0, symbol: "AAPL");
|
|
// eat up all our TPV
|
|
security2.Holdings.SetHoldings(security.Price, (algorithm.Portfolio.TotalPortfolioValue / security.Price) * 2);
|
|
|
|
var currentSignedUsedMargin = model.GetInitialMarginRequirement(security, security.Holdings.Quantity);
|
|
var totalPortfolioValue = algorithm.Portfolio.TotalPortfolioValue;
|
|
var sign = Math.Sign(security.Holdings.Quantity) == 0 ? 1 : Math.Sign(security.Holdings.Quantity);
|
|
// we inverse the sign here so that new target is less than current, we expect a reduction
|
|
var newTarget = currentSignedUsedMargin / (totalPortfolioValue) + 0.00001m * sign * -1;
|
|
|
|
Assert.IsTrue(0 > algorithm.Portfolio.MarginRemaining);
|
|
var result = model.GetMaximumOrderQuantityForTargetBuyingPower(algorithm.Portfolio, security, newTarget, 0);
|
|
// Reproduces GH issue #5763 a small Reduction in the target should reduce the position
|
|
Assert.AreEqual(1m * sign * -1, result.Quantity);
|
|
Assert.IsFalse(result.IsError);
|
|
}
|
|
|
|
[TestCase(1, 0)]
|
|
[TestCase(-1, 0)]
|
|
[TestCase(1, 0.001d)]
|
|
[TestCase(-1, 0.001d)]
|
|
public void ReducesPositionWhenMarginAboveTargetBasedOnSetting(decimal holdings, decimal minimumOrderMarginPortfolioPercentage)
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algorithm, 0);
|
|
var model = new SecurityMarginModel();
|
|
security.Holdings.SetHoldings(security.Price, holdings);
|
|
|
|
var currentSignedUsedMargin = model.GetInitialMarginRequirement(security, security.Holdings.Quantity);
|
|
var totalPortfolioValue = algorithm.Portfolio.TotalPortfolioValue;
|
|
var sign = Math.Sign(security.Holdings.Quantity) == 0 ? 1 : Math.Sign(security.Holdings.Quantity);
|
|
// we inverse the sign here so that new target is less than current, we expect a reduction
|
|
var newTarget = currentSignedUsedMargin / (totalPortfolioValue) + 0.00001m * sign * -1;
|
|
|
|
var result = model.GetMaximumOrderQuantityForTargetBuyingPower(algorithm.Portfolio, security, newTarget, minimumOrderMarginPortfolioPercentage);
|
|
|
|
if (minimumOrderMarginPortfolioPercentage == 0)
|
|
{
|
|
// Reproduces GH issue #5763 a small Reduction in the target should reduce the position
|
|
Assert.AreEqual(1m * sign * -1, result.Quantity);
|
|
Assert.IsFalse(result.IsError);
|
|
}
|
|
else
|
|
{
|
|
Assert.AreEqual(0, result.Quantity);
|
|
Assert.IsFalse(result.IsError);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ZeroTargetWithNonZeroHoldingsReturnsNegativeOfQuantity()
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algorithm, 0);
|
|
security.Holdings.SetHoldings(200, 10);
|
|
|
|
var model = new SecurityMarginModel();
|
|
var result = model.GetMaximumOrderQuantityForTargetBuyingPower(algorithm.Portfolio, security, 0, 0);
|
|
|
|
Assert.AreEqual(-10, result.Quantity);
|
|
Assert.IsTrue(result.Reason.IsNullOrEmpty());
|
|
Assert.IsFalse(result.IsError);
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_ZeroToFullLong()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 5);
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * security.BuyingPowerModel.GetLeverage(security));
|
|
// (100000 * 2 * 0.9975 setHoldingsBuffer) / 25 - fee ~=7979m
|
|
Assert.AreEqual(7979m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_ZeroToFullLong_NonAccountCurrency_ZeroQuoteCurrency()
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
algorithm.Portfolio.CashBook.Clear();
|
|
algorithm.Portfolio.SetAccountCurrency("EUR");
|
|
algorithm.Portfolio.SetCash(10000);
|
|
// We don't have quote currency - we will get a "loan"
|
|
algorithm.Portfolio.SetCash(Currencies.USD, 0, 0.88m);
|
|
var security = InitAndGetSecurity(algorithm, 5);
|
|
|
|
algorithm.Settings.FreePortfolioValue =
|
|
algorithm.Portfolio.TotalPortfolioValue * algorithm.Settings.FreePortfolioValuePercentage;
|
|
|
|
var actual = algorithm.CalculateOrderQuantity(_symbol, 1m * security.BuyingPowerModel.GetLeverage(security));
|
|
// (10000 * 2 * 0.9975 setHoldingsBuffer) / 25 * 0.88 conversion rate - 5 USD fee * 0.88 conversion rate ~=906m
|
|
Assert.AreEqual(906m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algorithm));
|
|
}
|
|
|
|
[TestCase("Long")]
|
|
[TestCase("Short")]
|
|
public void GetReservedBuyingPowerForPosition_NonAccountCurrency_ZeroQuoteCurrency(string position)
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
algorithm.Portfolio.CashBook.Clear();
|
|
algorithm.Portfolio.SetAccountCurrency("EUR");
|
|
algorithm.Portfolio.SetCash(10000);
|
|
algorithm.Portfolio.SetCash(Currencies.USD, 0, 0.88m);
|
|
var security = InitAndGetSecurity(algorithm, 5);
|
|
security.Holdings.SetHoldings(security.Price,
|
|
(position == "Long" ? 1 : -1) * 100);
|
|
|
|
var actual = security.BuyingPowerModel.GetReservedBuyingPowerForPosition(new ReservedBuyingPowerForPositionParameters(security));
|
|
// 100quantity * 25price * 0.88rate * 0.5 MaintenanceMarginRequirement = 1100
|
|
Assert.AreEqual(1100, actual.AbsoluteUsedBuyingPower);
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_ZeroToFullLong_NonAccountCurrency()
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
algorithm.Portfolio.CashBook.Clear();
|
|
algorithm.Portfolio.SetAccountCurrency("EUR");
|
|
algorithm.Portfolio.SetCash(10000);
|
|
// We have 1000 USD too
|
|
algorithm.Portfolio.SetCash(Currencies.USD, 1000, 0.88m);
|
|
var security = InitAndGetSecurity(algorithm, 5);
|
|
|
|
algorithm.Settings.FreePortfolioValue =
|
|
algorithm.Portfolio.TotalPortfolioValue * algorithm.Settings.FreePortfolioValuePercentage;
|
|
|
|
var actual = algorithm.CalculateOrderQuantity(_symbol, 1m * security.BuyingPowerModel.GetLeverage(security));
|
|
// ((10000 + 1000 USD * 0.88 rate) * 2 * 0.9975 setHoldingsBuffer) / 25 * 0.88 rate - 5 USD fee * 0.88 rate ~=986m
|
|
Assert.AreEqual(986m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algorithm));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_Long_TooBigOfATarget()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 5);
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * security.BuyingPowerModel.GetLeverage(security) + 0.1m);
|
|
// (100000 * 2.1* 0.9975 setHoldingsBuffer) / 25 - fee ~=8378m
|
|
Assert.AreEqual(8378m, actual);
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_Long_TooBigOfATarget_NonAccountCurrency()
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
algorithm.Portfolio.CashBook.Clear();
|
|
algorithm.Portfolio.SetAccountCurrency("EUR");
|
|
algorithm.Portfolio.SetCash(10000);
|
|
// We don't have quote currency - we will get a "loan"
|
|
algorithm.Portfolio.SetCash(Currencies.USD, 0, 0.88m);
|
|
var security = InitAndGetSecurity(algorithm, 5);
|
|
|
|
algorithm.Settings.FreePortfolioValue =
|
|
algorithm.Portfolio.TotalPortfolioValue * algorithm.Settings.FreePortfolioValuePercentage;
|
|
|
|
var actual = algorithm.CalculateOrderQuantity(_symbol, 1m * security.BuyingPowerModel.GetLeverage(security) + 0.1m);
|
|
// (10000 * 2.1 * 0.9975 setHoldingsBuffer) / 25 * 0.88 conversion rate - 5 USD fee * 0.88 conversion rate ~=951m
|
|
Assert.AreEqual(951m, actual);
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual, security, algorithm));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_ZeroToFullShort()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 5);
|
|
var actual = algo.CalculateOrderQuantity(_symbol, -1m * security.BuyingPowerModel.GetLeverage(security));
|
|
// (100000 * 2 * 0.9975 setHoldingsBuffer) / 25 - fee~=-7979m
|
|
Assert.AreEqual(-7979m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_ZeroToFullShort_NonAccountCurrency_ZeroQuoteCurrency()
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
algorithm.Portfolio.CashBook.Clear();
|
|
algorithm.Portfolio.SetAccountCurrency("EUR");
|
|
algorithm.Portfolio.SetCash(10000);
|
|
algorithm.Portfolio.SetCash(Currencies.USD, 0, 0.88m);
|
|
var security = InitAndGetSecurity(algorithm, 5);
|
|
|
|
algorithm.Settings.FreePortfolioValue =
|
|
algorithm.Portfolio.TotalPortfolioValue * algorithm.Settings.FreePortfolioValuePercentage;
|
|
|
|
var actual = algorithm.CalculateOrderQuantity(_symbol, -1m * security.BuyingPowerModel.GetLeverage(security));
|
|
// (10000 * - 2 * 0.9975 setHoldingsBuffer) / 25 * 0.88 conversion rate - 5 USD fee * 0.88 conversion rate ~=906m
|
|
Assert.AreEqual(-906m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algorithm));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_ZeroToFullShort_NonAccountCurrency()
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
algorithm.Portfolio.CashBook.Clear();
|
|
algorithm.Portfolio.SetAccountCurrency("EUR");
|
|
algorithm.Portfolio.SetCash(10000);
|
|
algorithm.Portfolio.SetCash(Currencies.USD, 1000, 0.88m);
|
|
var security = InitAndGetSecurity(algorithm, 5);
|
|
|
|
algorithm.Settings.FreePortfolioValue =
|
|
algorithm.Portfolio.TotalPortfolioValue * algorithm.Settings.FreePortfolioValuePercentage;
|
|
|
|
var actual = algorithm.CalculateOrderQuantity(_symbol, -1m * security.BuyingPowerModel.GetLeverage(security));
|
|
// ((10000 + 1000 * 0.88)* - 2 * 0.9975 setHoldingsBuffer) / 25 * 0.88 conversion rate - 5 USD fee * 0.88 conversion rate ~=986m
|
|
Assert.AreEqual(-986m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algorithm));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_Short_TooBigOfATarget()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 5);
|
|
var actual = algo.CalculateOrderQuantity(_symbol, -1m * security.BuyingPowerModel.GetLeverage(security) - 0.1m);
|
|
// (100000 * - 2.1m * 0.9975 setHoldingsBuffer) / 25 - fee~=-8378m
|
|
Assert.AreEqual(-8378m, actual);
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_Short_TooBigOfATarget_NonAccountCurrency()
|
|
{
|
|
var algorithm = GetAlgorithm();
|
|
algorithm.Portfolio.CashBook.Clear();
|
|
algorithm.Portfolio.SetAccountCurrency("EUR");
|
|
algorithm.Portfolio.SetCash(10000);
|
|
algorithm.Portfolio.SetCash(Currencies.USD, 0, 0.88m);
|
|
var security = InitAndGetSecurity(algorithm, 5);
|
|
|
|
algorithm.Settings.FreePortfolioValue =
|
|
algorithm.Portfolio.TotalPortfolioValue * algorithm.Settings.FreePortfolioValuePercentage;
|
|
|
|
var actual = algorithm.CalculateOrderQuantity(_symbol, -1m * security.BuyingPowerModel.GetLeverage(security) - 0.1m);
|
|
// (10000 * - 2.1 * 0.9975 setHoldingsBuffer) / 25 * 0.88 conversion rate - 5 USD fee * 0.88 conversion rate ~=951m
|
|
Assert.AreEqual(-951m, actual);
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual, security, algorithm));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_ZeroToFullLong_NoFee()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 0);
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * security.BuyingPowerModel.GetLeverage(security));
|
|
// (100000 * 2 * 0.9975 setHoldingsBuffer) / 25 =7980m
|
|
Assert.AreEqual(7980m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_Long_TooBigOfATarget_NoFee()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 0);
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * security.BuyingPowerModel.GetLeverage(security) + 0.1m);
|
|
// (100000 * 2.1m* 0.9975 setHoldingsBuffer) / 25 = 8379m
|
|
Assert.AreEqual(8379m, actual);
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_ZeroToFullShort_NoFee()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 0);
|
|
var actual = algo.CalculateOrderQuantity(_symbol, -1m * security.BuyingPowerModel.GetLeverage(security));
|
|
var order = new MarketOrder(_symbol, actual, DateTime.UtcNow);
|
|
// (100000 * 2 * 0.9975 setHoldingsBuffer) / 25 = -7980m
|
|
Assert.AreEqual(-7980m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void SetHoldings_Short_TooBigOfATarget_NoFee()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 0);
|
|
var actual = algo.CalculateOrderQuantity(_symbol, -1m * security.BuyingPowerModel.GetLeverage(security) - 0.1m);
|
|
// (100000 * -2.1 * 0.9975 setHoldingsBuffer) / 25 = -8379m
|
|
Assert.AreEqual(-8379m, actual);
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentDefault_Equity()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Equity);
|
|
var model = security.BuyingPowerModel;
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * model.GetLeverage(security));
|
|
// (100000 * 2 * 0.9975) / 25 - 1 order due to fees
|
|
Assert.AreEqual(7979m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
Assert.AreEqual(algo.Portfolio.Cash, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentAppliesForCashAccount_Equity()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
algo.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Cash);
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Equity);
|
|
var requiredFreeBuyingPowerPercent = 0.05m;
|
|
var model = security.BuyingPowerModel = new SecurityMarginModel(1, requiredFreeBuyingPowerPercent);
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * model.GetLeverage(security));
|
|
// (100000 * 1 * 0.95 * 0.9975) / 25 - 1 order due to fees
|
|
Assert.AreEqual(3790m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual * 1.0025m, security, algo));
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual * 1.0025m + security.SymbolProperties.LotSize + 9, security, algo));
|
|
var expectedBuyingPower = algo.Portfolio.Cash * (1 - requiredFreeBuyingPowerPercent);
|
|
Assert.AreEqual(expectedBuyingPower, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentAppliesForMarginAccount_Equity()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
algo.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Margin);
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Equity);
|
|
var requiredFreeBuyingPowerPercent = 0.05m;
|
|
var model = security.BuyingPowerModel = new SecurityMarginModel(2, requiredFreeBuyingPowerPercent);
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * model.GetLeverage(security));
|
|
// (100000 * 2 * 0.95 * 0.9975) / 25 - 1 order due to fees
|
|
Assert.AreEqual(7580m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual * 1.0025m, security, algo));
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual * 1.0025m + security.SymbolProperties.LotSize + 9, security, algo));
|
|
var expectedBuyingPower = algo.Portfolio.Cash * (1 - requiredFreeBuyingPowerPercent);
|
|
Assert.AreEqual(expectedBuyingPower, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentCashAccountWithLongHoldings_Equity()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
algo.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Cash);
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Equity);
|
|
var requiredFreeBuyingPowerPercent = 0.05m;
|
|
var model = security.BuyingPowerModel = new SecurityMarginModel(1, requiredFreeBuyingPowerPercent);
|
|
security.Holdings.SetHoldings(25, 2000);
|
|
security.SettlementModel.ApplyFunds(new ApplyFundsSettlementModelParameters(algo.Portfolio, security, DateTime.UtcNow.AddDays(-10), new CashAmount(-2000 * 25, Currencies.USD), null));
|
|
|
|
// Margin remaining 50k + used 50k + initial margin 50k - 5k free buying power percent (5% of 100k)
|
|
Assert.AreEqual(145000, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Sell));
|
|
// Margin remaining 50k - 5k free buying power percent (5% of 100k)
|
|
Assert.AreEqual(45000, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, -1m * model.GetLeverage(security));
|
|
// ((100k - 5) * -1 * 0.95 * 0.9975 - (50k holdings)) / 25 - 1 order due to fees
|
|
Assert.AreEqual(-5790m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual * 1.0025m, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentMarginAccountWithLongHoldings_Equity()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
algo.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Margin);
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Equity);
|
|
var requiredFreeBuyingPowerPercent = 0.05m;
|
|
var model = security.BuyingPowerModel = new SecurityMarginModel(2, requiredFreeBuyingPowerPercent);
|
|
security.Holdings.SetHoldings(25, 2000);
|
|
security.SettlementModel.ApplyFunds(new ApplyFundsSettlementModelParameters(algo.Portfolio, security, DateTime.UtcNow.AddDays(-10), new CashAmount(-2000 * 25, Currencies.USD), null));
|
|
|
|
// Margin remaining 75k + used 25k + initial margin 25k - 5k free buying power percent (5% of 100k)
|
|
Assert.AreEqual(120000, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Sell));
|
|
// Margin remaining 75k - 5k free buying power percent
|
|
Assert.AreEqual(70000, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, -1m * model.GetLeverage(security));
|
|
// ((100k - 5) * -2 * 0.95 * 0.9975 - (50k holdings)) / 25 - 1 order due to fees
|
|
Assert.AreEqual(-9580m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual * 1.0025m, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentMarginAccountWithShortHoldings_Equity()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
algo.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Margin);
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Equity);
|
|
var requiredFreeBuyingPowerPercent = 0.05m;
|
|
var model = security.BuyingPowerModel = new SecurityMarginModel(2, requiredFreeBuyingPowerPercent);
|
|
security.Holdings.SetHoldings(25, -2000);
|
|
security.SettlementModel.ApplyFunds(new ApplyFundsSettlementModelParameters(algo.Portfolio, security, DateTime.UtcNow.AddDays(-10), new CashAmount(2000 * 25, Currencies.USD), null));
|
|
|
|
// Margin remaining 75k + used 25k + initial margin 25k - 5k free buying power percent (5% of 100k)
|
|
Assert.AreEqual(120000, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
// Margin remaining 75k - 5k free buying power percent
|
|
Assert.AreEqual(70000, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Sell));
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * model.GetLeverage(security));
|
|
// ((100k - 5) * 2 * 0.95 * 0.9975 - (-50k holdings)) / 25 - 1 order due to fees
|
|
Assert.AreEqual(9580m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
Assert.IsFalse(HasSufficientBuyingPowerForOrder(actual * 1.0025m, security, algo));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentDefault_Option()
|
|
{
|
|
const decimal price = 25m;
|
|
const decimal underlyingPrice = 25m;
|
|
|
|
var tz = TimeZones.NewYork;
|
|
var equity = new QuantConnect.Securities.Equity.Equity(
|
|
SecurityExchangeHours.AlwaysOpen(tz),
|
|
new SubscriptionDataConfig(typeof(TradeBar), Symbols.SPY, Resolution.Minute, tz, tz, true, false, false),
|
|
new Cash(Currencies.USD, 0, 1m),
|
|
SymbolProperties.GetDefault(Currencies.USD),
|
|
ErrorCurrencyConverter.Instance,
|
|
RegisteredSecurityDataTypesProvider.Null
|
|
);
|
|
equity.SetMarketPrice(new Tick { Value = underlyingPrice });
|
|
|
|
var optionPutSymbol = Symbol.CreateOption(Symbols.SPY, Market.USA, OptionStyle.American, OptionRight.Put, 207m, new DateTime(2015, 02, 27));
|
|
var security = new Option(
|
|
SecurityExchangeHours.AlwaysOpen(tz),
|
|
new SubscriptionDataConfig(typeof(TradeBar), optionPutSymbol, Resolution.Minute, tz, tz, true, false, false),
|
|
new Cash(Currencies.USD, 0, 1m),
|
|
new OptionSymbolProperties("", Currencies.USD, 100, 0.01m, 1),
|
|
ErrorCurrencyConverter.Instance,
|
|
RegisteredSecurityDataTypesProvider.Null
|
|
);
|
|
security.SetMarketPrice(new Tick { Value = price });
|
|
security.Underlying = equity;
|
|
|
|
var algo = GetAlgorithm();
|
|
security.SetLocalTimeKeeper(algo.TimeKeeper.GetLocalTimeKeeper(tz));
|
|
var actual = security.BuyingPowerModel.GetMaximumOrderQuantityForTargetBuyingPower(
|
|
new GetMaximumOrderQuantityForTargetBuyingPowerParameters(algo.Portfolio, security, 1, 0)).Quantity;
|
|
|
|
// (100000 * 1) / (25 * 100 contract multiplier) - 1 order due to fees
|
|
Assert.AreEqual(39m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
Assert.AreEqual(algo.Portfolio.Cash, security.BuyingPowerModel.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentAppliesForCashAccount_Option()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
algo.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Cash);
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Option);
|
|
var requiredFreeBuyingPowerPercent = 0.05m;
|
|
var model = security.BuyingPowerModel = new SecurityMarginModel(1, requiredFreeBuyingPowerPercent);
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * model.GetLeverage(security));
|
|
// (100000 * 1 * 0.95) / (25 * 100 contract multiplier) - 1 order due to fees
|
|
Assert.AreEqual(37m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
var expectedBuyingPower = algo.Portfolio.Cash * (1 - requiredFreeBuyingPowerPercent);
|
|
Assert.AreEqual(expectedBuyingPower, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentAppliesForMarginAccount_Option()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
algo.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Margin);
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Option);
|
|
var requiredFreeBuyingPowerPercent = 0.05m;
|
|
var model = security.BuyingPowerModel = new SecurityMarginModel(2, requiredFreeBuyingPowerPercent);
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * model.GetLeverage(security));
|
|
// (100000 * 2 * 0.95) / (25 * 100 contract multiplier) - 1 order due to fees
|
|
Assert.AreEqual(75m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
var expectedBuyingPower = algo.Portfolio.Cash * (1 - requiredFreeBuyingPowerPercent);
|
|
Assert.AreEqual(expectedBuyingPower, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentDefault_Future()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Future, "ES", time: new DateTime(2020, 1, 27));
|
|
var model = security.BuyingPowerModel;
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * model.GetLeverage(security));
|
|
// (100000 * 1 * 0.9975 ) / 6600 - 1 order due to fees
|
|
Assert.AreEqual(13m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
Assert.AreEqual(algo.Portfolio.Cash, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentAppliesForCashAccount_Future()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
algo.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Cash);
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Future);
|
|
var requiredFreeBuyingPowerPercent = 0.05m;
|
|
var model = security.BuyingPowerModel = new SecurityMarginModel(1, requiredFreeBuyingPowerPercent);
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * model.GetLeverage(security));
|
|
// ((100000 - 5) * 1 * 0.95 * 0.9975 / (25 * 50)
|
|
Assert.AreEqual(75m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
var expectedBuyingPower = algo.Portfolio.Cash * (1 - requiredFreeBuyingPowerPercent);
|
|
Assert.AreEqual(expectedBuyingPower, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
}
|
|
|
|
[Test]
|
|
public void FreeBuyingPowerPercentAppliesForMarginAccount_Future()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
algo.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Margin);
|
|
var security = InitAndGetSecurity(algo, 5, SecurityType.Future);
|
|
var requiredFreeBuyingPowerPercent = 0.05m;
|
|
var model = security.BuyingPowerModel = new SecurityMarginModel(2, requiredFreeBuyingPowerPercent);
|
|
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * model.GetLeverage(security));
|
|
// ((100000 - 5) * 2 * 0.95 * 0.9975 / (25 * 50)
|
|
Assert.AreEqual(151m, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
var expectedBuyingPower = algo.Portfolio.Cash * (1 - requiredFreeBuyingPowerPercent);
|
|
Assert.AreEqual(expectedBuyingPower, model.GetBuyingPower(algo.Portfolio, security, OrderDirection.Buy));
|
|
}
|
|
|
|
[TestCase(0)]
|
|
[TestCase(10000)]
|
|
public void NonAccountCurrency_GetBuyingPower(decimal nonAccountCurrencyCash)
|
|
{
|
|
var algo = GetAlgorithm();
|
|
algo.Portfolio.CashBook.Clear();
|
|
algo.Portfolio.SetAccountCurrency("EUR");
|
|
algo.Portfolio.SetCash(10000);
|
|
algo.Portfolio.SetCash(Currencies.USD, nonAccountCurrencyCash, 0.88m);
|
|
var security = InitAndGetSecurity(algo, 0);
|
|
Assert.AreEqual(10000m + algo.Portfolio.CashBook[Currencies.USD].ValueInAccountCurrency,
|
|
algo.Portfolio.TotalPortfolioValue);
|
|
|
|
var quantity = security.BuyingPowerModel.GetBuyingPower(
|
|
new BuyingPowerParameters(algo.Portfolio, security, OrderDirection.Buy)).Value;
|
|
|
|
Assert.AreEqual(10000m + algo.Portfolio.CashBook[Currencies.USD].ValueInAccountCurrency,
|
|
quantity);
|
|
}
|
|
|
|
[Test]
|
|
public void NonAccountCurrencyFees()
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 0);
|
|
algo.SetCash("EUR", 0, 100);
|
|
security.FeeModel = new NonAccountCurrencyCustomFeeModel();
|
|
|
|
// ((100000 - 100 * 100) * 2 * 0.9975 / (25)
|
|
var actual = algo.CalculateOrderQuantity(_symbol, 1m * security.BuyingPowerModel.GetLeverage(security));
|
|
Assert.AreEqual(7182m, actual);
|
|
// ((100000 - 100 * 100) * 2 / (25)
|
|
var quantity = security.BuyingPowerModel.GetMaximumOrderQuantityForTargetBuyingPower(
|
|
algo.Portfolio, security, 1m, 0).Quantity;
|
|
Assert.AreEqual(7200m, quantity);
|
|
|
|
// the maximum order quantity can be executed
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(quantity, security, algo)); ;
|
|
}
|
|
|
|
[TestCase(1)]
|
|
[TestCase(-1)]
|
|
public void GetMaximumOrderQuantityForTargetDeltaBuyingPower_NoHoldings(int side)
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 5);
|
|
|
|
// we use our entire buying power
|
|
var buyingPower = algo.Portfolio.MarginRemaining * side;
|
|
var actual = security.BuyingPowerModel.GetMaximumOrderQuantityForDeltaBuyingPower(
|
|
new GetMaximumOrderQuantityForDeltaBuyingPowerParameters(algo.Portfolio,
|
|
security,
|
|
buyingPower,
|
|
0)).Quantity;
|
|
|
|
// (100000 * 2 ) / 25 =8k - 1 fees
|
|
Assert.AreEqual(7999 * side, actual);
|
|
}
|
|
|
|
[TestCase(100, 510, false)]
|
|
[TestCase(-100, 510, false)]
|
|
[TestCase(-100, 50000, true)]
|
|
[TestCase(100, -510, false)]
|
|
[TestCase(-100, -510, false)]
|
|
[TestCase(100, -50000, true)]
|
|
public void GetMaximumOrderQuantityForTargetDeltaBuyingPower_WithHoldings(decimal quantity, decimal buyingPowerDelta, bool invertsSide)
|
|
{
|
|
// TPV = 100k
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 0);
|
|
|
|
// SPY @ $25 * Quantity Shares = Holdings
|
|
// Quantity = 100 -> 2500; TPV = 102500
|
|
// Quantity = -100 -> -2500; TPV = 97500
|
|
security.Holdings.SetHoldings(security.Price, quantity);
|
|
|
|
// Used Buying Power = Holdings / Leverage
|
|
// Target BP = Used BP + buyingPowerDelta
|
|
// Target Holdings = Target BP / Unit
|
|
// Max Order For Delta BP = Target Holdings - Current Holdings
|
|
|
|
// EX. -100 Quantity, 510 BP Delta.
|
|
// Used BP = -2500 / 2 = -1250
|
|
// Target BP = -1250 + 510 = -740
|
|
// Target Holdings = -740 / 12.5 = -59.2 -> ~-59
|
|
// Max Order = -59 - (-100) = 41
|
|
var actual = security.BuyingPowerModel.GetMaximumOrderQuantityForDeltaBuyingPower(
|
|
new GetMaximumOrderQuantityForDeltaBuyingPowerParameters(algo.Portfolio,
|
|
security,
|
|
buyingPowerDelta,
|
|
0)).Quantity;
|
|
|
|
// Calculate expected using logic above
|
|
var targetBuyingPower = ((quantity * (security.Price / security.Leverage)) + buyingPowerDelta);
|
|
var targetHoldings = (targetBuyingPower / (security.Price / security.Leverage));
|
|
targetHoldings -= (targetHoldings % security.SymbolProperties.LotSize);
|
|
|
|
var expectedQuantity = targetHoldings - quantity;
|
|
|
|
|
|
Assert.AreEqual(expectedQuantity, actual);
|
|
Assert.IsTrue(HasSufficientBuyingPowerForOrder(actual, security, algo));
|
|
|
|
if (invertsSide)
|
|
{
|
|
Assert.AreNotEqual(Math.Sign(quantity), Math.Sign(actual));
|
|
}
|
|
}
|
|
|
|
[TestCase(true, 1, 1)]
|
|
[TestCase(true, 1, -1)]
|
|
[TestCase(true, -1, -1)]
|
|
[TestCase(true, -1, 1)]
|
|
// reducing the position to target 0 is valid
|
|
[TestCase(false, 0, -1)]
|
|
[TestCase(false, 0, 1)]
|
|
public void NegativeMarginRemaining(bool isError, int target, int side)
|
|
{
|
|
var algo = GetAlgorithm();
|
|
var security = InitAndGetSecurity(algo, 5);
|
|
security.Holdings.SetHoldings(security.Price, 1000 * side);
|
|
algo.Portfolio.CashBook.Add(algo.AccountCurrency, -100000, 1);
|
|
var fakeOrderProcessor = new FakeOrderProcessor();
|
|
algo.Transactions.SetOrderProcessor(fakeOrderProcessor);
|
|
|
|
Assert.IsTrue(algo.Portfolio.MarginRemaining < 0);
|
|
|
|
var quantity = security.BuyingPowerModel.GetMaximumOrderQuantityForTargetBuyingPower(
|
|
new GetMaximumOrderQuantityForTargetBuyingPowerParameters(algo.Portfolio,
|
|
security,
|
|
target * side,
|
|
0)).Quantity;
|
|
if (!isError)
|
|
{
|
|
Assert.AreEqual(1000 * side * -1, quantity);
|
|
}
|
|
else
|
|
{
|
|
// even if we don't have margin 'GetMaximumOrderQuantityForTargetBuyingPower' doesn't care
|
|
Assert.AreNotEqual(0, quantity);
|
|
}
|
|
|
|
var order = new MarketOrder(security.Symbol, quantity, new DateTime(2020, 1, 1));
|
|
fakeOrderProcessor.AddTicket(order.ToOrderTicket(algo.Transactions));
|
|
var actual = security.BuyingPowerModel.HasSufficientBuyingPowerForOrder(
|
|
new HasSufficientBuyingPowerForOrderParameters(algo.Portfolio,
|
|
security,
|
|
order));
|
|
Assert.AreEqual(!isError, actual.IsSufficient);
|
|
}
|
|
|
|
private static QCAlgorithm GetAlgorithm()
|
|
{
|
|
SymbolCache.Clear();
|
|
// Initialize algorithm
|
|
var algo = new QCAlgorithm();
|
|
algo.SetFinishedWarmingUp();
|
|
_fakeOrderProcessor = new FakeOrderProcessor();
|
|
algo.Transactions.SetOrderProcessor(_fakeOrderProcessor);
|
|
return algo;
|
|
}
|
|
|
|
private static Security InitAndGetSecurity(QCAlgorithm algo, decimal fee, SecurityType securityType = SecurityType.Equity, string symbol = "SPY", DateTime? time = null)
|
|
{
|
|
algo.SubscriptionManager.SetDataManager(new DataManagerStub(algo));
|
|
Security security;
|
|
if (securityType == SecurityType.Equity)
|
|
{
|
|
security = algo.AddEquity(symbol);
|
|
_symbol = security.Symbol;
|
|
}
|
|
else if (securityType == SecurityType.Option)
|
|
{
|
|
security = algo.AddOption(symbol);
|
|
_symbol = security.Symbol;
|
|
}
|
|
else if (securityType == SecurityType.Future)
|
|
{
|
|
security = algo.AddFuture(symbol == "SPY" ? "ES" : symbol);
|
|
_symbol = security.Symbol;
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("SecurityType not implemented");
|
|
}
|
|
|
|
security.FeeModel = new ConstantFeeModel(fee);
|
|
Update(security, 25, time);
|
|
return security;
|
|
}
|
|
|
|
private static void Update(Security security, decimal close, DateTime? time = null)
|
|
{
|
|
security.SetMarketPrice(new TradeBar
|
|
{
|
|
Time = time ?? DateTime.Now,
|
|
Symbol = security.Symbol,
|
|
Open = close,
|
|
High = close,
|
|
Low = close,
|
|
Close = close
|
|
});
|
|
}
|
|
|
|
private bool HasSufficientBuyingPowerForOrder(decimal orderQuantity, Security security, IAlgorithm algo)
|
|
{
|
|
var order = new MarketOrder(security.Symbol, orderQuantity, DateTime.UtcNow);
|
|
_fakeOrderProcessor.AddTicket(order.ToOrderTicket(algo.Transactions));
|
|
var hashSufficientBuyingPower = security.BuyingPowerModel.HasSufficientBuyingPowerForOrder(algo.Portfolio,
|
|
security, new MarketOrder(security.Symbol, orderQuantity, DateTime.UtcNow));
|
|
return hashSufficientBuyingPower.IsSufficient;
|
|
}
|
|
|
|
internal class NonAccountCurrencyCustomFeeModel : FeeModel
|
|
{
|
|
public string FeeCurrency = "EUR";
|
|
public decimal FeeAmount = 100m;
|
|
|
|
public override OrderFee GetOrderFee(OrderFeeParameters parameters)
|
|
{
|
|
return new OrderFee(new CashAmount(FeeAmount, FeeCurrency));
|
|
}
|
|
}
|
|
}
|
|
}
|