Exemple #1
0
        internal void ParseFromMarketOrderPriceZero(OrderSide side)
        {
            var order = new OrderUpdate(
                orderId: 0,
                tradeId: 0,
                orderType: Market,
                orderStatus: New,
                createdTimestamp: 0,
                setPrice: 0.4M,
                side: side,
                pair: TradingPair.Parse("EOSETH"),
                setQuantity: 40M)
            {
                AverageFilledPrice = 0M,
                FilledQuantity     = 10M,
            };

            var exec = TradeExecution.FromOrder(order);

            Assert.Equal(exec.From.Locked, decimal.Zero);

            if (side == OrderSide.Sell)
            {
                Assert.Equal(10M, exec.From.Free);
                Assert.Equal(decimal.Zero, exec.To.Free);
            }
            else
            {
                Assert.Equal(decimal.Zero, exec.From.Free);
                Assert.Equal(10M, exec.To.Free);
            }

            Assert.Equal(exec.To.Locked, decimal.Zero);
        }
Exemple #2
0
        internal void ParseFromNonMarketBuyOrderForeignCommission(OrderUpdate.OrderTypes type)
        {
            var order = new OrderUpdate(
                orderId: 0,
                tradeId: 0,
                orderType: type,
                orderStatus: Filled,
                createdTimestamp: 0,
                setPrice: 0.2M,
                side: OrderSide.Buy,
                pair: TradingPair.Parse("EOSETH"),
                setQuantity: 100M)
            {
                FilledQuantity     = 100M,
                AverageFilledPrice = 0.15M,
                LastFillIncrement  = 100M,
                LastFillPrice      = 0.15M,
                Commission         = 96.42M,
                CommissionAsset    = new Currency("BNB"),
            };

            var exec = TradeExecution.FromOrder(order);

            Assert.Equal(0M, exec.From.Free);
            Assert.Equal(100M * 0.2M, exec.From.Locked);
            Assert.Equal(100M, exec.To.Free);
            Assert.Equal(0M, exec.To.Locked);
        }
        public void ExecuteMarketOrderPartialSellMoreThanOne()
        {
            var trading = GetTradingProvider <ExecuteMarketOrderHappyFlowImplementation>();

            Assert.Throws <ArgumentOutOfRangeException>(
                () => trading.ExecutePartialMarketOrderSell(TradingPair.Parse("EOSETH"), 1.00000001M));
        }
        public void GetFilledBuyStoplossOrderUnMutated()
        {
            var order = new OrderUpdate(
                orderId: 9,
                tradeId: 8,
                orderStatus: OrderUpdate.OrderStatus.New,
                orderType: OrderTypes.StopLoss,
                createdTimestamp: 302,
                setPrice: 2.1M,
                side: OrderSide.Buy,
                pair: TradingPair.Parse("TRXETH"),
                setQuantity: 18.6M)
            {
                StopPrice = 1.9M,
            };

            var candle = new BacktestingCandle(0, 1, 1, 2, 1, 0, "EOSETH");

            GetFilledOrder(order, candle, 434424233);
            Assert.Equal(OrderStatus.Filled, order.Status);
            Assert.Equal(OrderTypes.StopLoss, order.OrderType);
            Assert.Equal(1.9M, order.AverageFilledPrice);
            Assert.Equal(1.9M, order.LastFillPrice);
            Assert.Equal(18.6M, order.FilledQuantity);
            Assert.Equal(18.6M, order.LastFillIncrement);
            Assert.Equal(434424233, order.FilledTimestamp);
        }
Exemple #5
0
        internal void ParseFromMarketSellOrderNewHappyFlow()
        {
            var order = new OrderUpdate(
                orderId: 0,
                tradeId: 0,
                orderType: Market,
                orderStatus: New,
                createdTimestamp: 0,
                setPrice: 0.4M,
                side: OrderSide.Sell,
                pair: TradingPair.Parse("EOSETH"),
                setQuantity: 40M)
            {
                FilledQuantity     = 40M,
                AverageFilledPrice = 0.401M,
            };

            var exec = TradeExecution.FromOrder(order);

            Assert.Equal(order.Pair.Left, exec.From.Symbol);
            Assert.Equal(order.Pair.Right, exec.To.Symbol);
            Assert.Equal(40M, exec.From.Free);
            Assert.Equal(0, exec.From.Locked);
            Assert.Equal(40M * 0.401M, exec.To.Free);
            Assert.Equal(0, exec.To.Locked);
        }
Exemple #6
0
        internal void ParseFromNonMarketSellOrderCancelledHappyFlow(OrderUpdate.OrderTypes orderType)
        {
            var order = new OrderUpdate(
                orderId: 0,
                tradeId: 0,
                orderType: orderType,
                orderStatus: Cancelled,
                createdTimestamp: 0,
                setPrice: 0.2M,
                side: OrderSide.Sell,
                pair: TradingPair.Parse("EOSETH"),
                setQuantity: 100M);
            var exec = TradeExecution.FromOrder(order);

            Assert.NotNull(exec);

            var symbol = new Currency("EOS");

            Assert.Equal(symbol, exec.From.Symbol);
            Assert.Equal(symbol, exec.To.Symbol);
            Assert.Equal(0M, exec.From.Free);
            Assert.Equal(100M, exec.From.Locked);
            Assert.Equal(100M, exec.To.Free);
            Assert.Equal(0M, exec.To.Locked);
        }
        public void PlaceLimitPartialBuyNotZero()
        {
            var trading = GetTradingProvider <PlaceLimitOrderHappyFlowImplementation>();

            Assert.Throws <ArgumentOutOfRangeException>(
                () => trading.PlacePartialLimitOrderBuy(TradingPair.Parse("EOSETH"), 10M, 0M));
        }
        public void PlaceLimitOrderNeverConfirmed()
        {
            var trading = GetTradingProvider <PlaceLimitOrderNeverConfirmedImplementation>();

            Assert.Throws <OrderFailedException>(
                () => trading.PlaceLimitOrderBuy(TradingPair.Parse("EOSETH"), 10, 1));
        }
        public void ExecuteMarketOrderNeverFilled()
        {
            var trading = GetTradingProvider <ExecuteMarketOrderNeverFilledImplementation>();

            Assert.Throws <OrderFailedException>(
                () => trading.ExecuteMarketOrderBuy(TradingPair.Parse("EOSETH"), 10));
        }
Exemple #10
0
        public void PlaceLimitPartialSellNotNegative()
        {
            var trading = GetTradingProvider <PlaceLimitOrderHappyFlowImplementation>();

            Assert.Throws <ArgumentOutOfRangeException>(
                () => trading.PlacePartialLimitOrderSell(TradingPair.Parse("EOSETH"), 10M, -1M));
        }
Exemple #11
0
        /// <summary>
        /// Initializes a new instance of the <see cref="IndicatorCommand{T}"/> class.
        /// </summary>
        /// <param name="indicator">The indicator method.</param>
        /// <param name="inputs">The candles to use indicator over.</param>
        protected IndicatorCommand(Func <IEnumerable <BacktestingCandle>, T> indicator, params string[] inputs)
        {
            _indicator = indicator;
            if (inputs.Length != 4)
            {
                throw new InvalidCommandException($"{GetType().Name} needs exactly 3 arguments");
            }

            try
            {
                _pair = TradingPair.Parse(inputs[1]);
            }
            catch (Exception)
            {
                throw new InvalidCommandException($"{inputs[1]} is not a valid trading pair.");
            }

            if (!(long.TryParse(inputs[2], out _epoch) && DateTimeOffset.FromUnixTimeMilliseconds(_epoch) != null))
            {
                throw new InvalidCommandException($"{_epoch} is not a valid ms epoch");
            }

            if (!(int.TryParse(inputs[3], out _n) && _n > 0))
            {
                throw new InvalidCommandException($"{_n} is not a valid value for n");
            }
        }
        public void ExecuteMarketOrderPartialBuyNotNegative()
        {
            var trading = GetTradingProvider <ExecuteMarketOrderHappyFlowImplementation>();

            Assert.Throws <ArgumentOutOfRangeException>(
                () => trading.ExecutePartialMarketOrderBuy(TradingPair.Parse("EOSETH"), -1M));
        }
Exemple #13
0
        public CallResult <BinancePlacedOrder> PlaceOrder(string symbol, OrderSide side, OrderType type,
                                                          decimal quantity, string newClientOrderId = null,
                                                          decimal?price      = null, TimeInForce?timeInForce = null, decimal?stopPrice = null,
                                                          decimal?icebergQty = null,
                                                          OrderResponseType?orderResponseType = null, int?receiveWindow = null)
        {
            var order = _implementation.PlaceTestOrder(symbol, side, type, quantity, newClientOrderId, price, timeInForce,
                                                       stopPrice, icebergQty, orderResponseType, receiveWindow);

            if (order.Success)
            {
                var data = order.Data;
                data.OrderId = _orderIdGenerator.Next();

                // PlaceTestOrder does not propagate this data, set it manually.
                data.Type = type;
                data.Side = side;
                var ev = new OrderUpdate(
                    orderId: data.OrderId,
                    tradeId: 0,
                    orderStatus: data.Type == OrderType.Market ? OrderUpdate.OrderStatus.Filled : OrderUpdate.OrderStatus.New,
                    orderType: BinanceUtilities.ToInternal(data.Type),
                    createdTimestamp: 0,
                    setPrice: data.Price,
                    side: BinanceUtilities.ToInternal(data.Side),
                    pair: TradingPair.Parse(symbol),
                    setQuantity: data.OriginalQuantity);
                _parent.ScheduleObserverEvent(ev);
            }

            return(order);
        }
Exemple #14
0
        public void PriceLastTradeNonZero(string input)
        {
            var pair  = TradingPair.Parse(input);
            var data  = _container.DataProvider;
            var query = data.GetCurrentPriceTopAsk(pair);

            Assert.True(query > 0, $"{query} is not a valid price ({pair})");
        }
Exemple #15
0
 public void PlaceStoplossOrderRefused()
 {
     var trading = GetTradingProvider<PlaceStoplossOrderHappyFlowImplementation>();
     var c1 = new Currency(TestAllocationManager.RefuseCoin);
     var c2 = new Currency("ETH");
     Assert.Throws<OrderRefusedException>(() =>
         trading.PlaceStoplossSell(TradingPair.Parse(c1, c2), 10, 1));
 }
Exemple #16
0
        public void LowestAskHigherThanHighestBid(string input)
        {
            var pair   = TradingPair.Parse(input);
            var data   = _container.DataProvider;
            var topAsk = data.GetCurrentPriceTopAsk(pair);
            var topBid = data.GetCurrentPriceTopBid(pair);

            Assert.True(topAsk >= topBid, $"Top bid is higher than lowest ask (bid: {topBid}, ask: {topAsk}");
        }
        public void ExecuteMarketOrderRefused()
        {
            var trading = GetTradingProvider <ExecuteMarketOrderHappyFlowImplementation>();
            var c1      = new Currency(TestAllocationManager.RefuseCoin);
            var c2      = new Currency("ETH");

            Assert.Throws <OrderRefusedException>(() =>
                                                  trading.ExecuteMarketOrderSell(TradingPair.Parse(c1, c2), 10));
        }
Exemple #18
0
        public void ParsingWithWhitspace()
        {
            var pair = GetTradingPair("BNB", "ETH");

            TradingPair.AddParseEntry("BNBETH", pair);
            var parsed = TradingPair.Parse(" BNB ETH ");

            Assert.Equal(pair.Left, parsed.Left);
            Assert.Equal(pair.Right, parsed.Right);
            Assert.Equal(pair.PriceDecimals, parsed.PriceDecimals);
        }
Exemple #19
0
        // [InlineData(1200)]
        public void GetCandlesHappyFlow(int limit)
        {
            var candles = _container.DataProvider.GetCandles(
                TradingPair.Parse("EOSETH"),
                limit);

            Assert.Equal(limit, candles.Length);
            Assert.All(candles, x =>
            {
                var unused = x ?? throw new Exception("Some candles where null");
            });
        }
Exemple #20
0
        public void GetCustomCandlesIdentity()
        {
            const string source  = @"
               TradingPairs: [EOSETH]
               CandleWidth: 5
            ";
            var          config  = ParseAlgorithmConfiguration(source);
            var          data    = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderHappyFlowImplementation>(config);
            var          candles = data.GetCandles(TradingPair.Parse("EOSETH"), 1);

            Assert.Equal(6.6M, candles[0].Close);
        }
Exemple #21
0
        public void ParsingHappyFlow()
        {
            var pair = GetTradingPair("BNB", "ETH", 2);

            TradingPair.AddParseEntry("BNBETH", pair);
            var parsed = TradingPair.Parse("BNBETH");

            Assert.Equal(pair.Left, parsed.Left);
            Assert.Equal(pair.Right, parsed.Right);
            Assert.Equal(pair.QuantityDecimals, parsed.QuantityDecimals);
            Assert.Equal(pair.PriceDecimals, parsed.PriceDecimals);
        }
Exemple #22
0
        public void GetCustomCandlesCorrectAmountPartial()
        {
            const string source  = @"
               TradingPairs: [EOSETH]
               CandleWidth: 15
            ";
            var          config  = ParseAlgorithmConfiguration(source);
            var          data    = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config);
            var          candles = data.GetCandles(TradingPair.Parse("EOSETH"), 3);

            Assert.Equal(3, candles.Length);
        }
Exemple #23
0
        public void StandardMovingAverageFourCandles()
        {
            const string source  = @"
               TradingPairs: [EOSETH]
               CandleWidth: 15
            ";
            var          config  = ParseAlgorithmConfiguration(source);
            var          data    = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config);
            var          candles = data.GetCandles(TradingPair.Parse("EOSETH"), 4);
            var          sma     = candles.StandardMovingAverage();

            Assert.Equal(6.5525M, sma);
        }
Exemple #24
0
        public void GetCustomCandlesNoPivotThirtyMinutes()
        {
            const string source  = @"
               TradingPairs: [EOSETH]
               CandleWidth: 30
            ";
            var          config  = ParseAlgorithmConfiguration(source);
            var          data    = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config);
            var          candles = data.GetCandles(TradingPair.Parse("EOSETH"), 2);

            Assert.Equal(5.6M, candles[0].Close);
            Assert.Equal(5.7M, candles[1].Close);
        }
        public void AverageTrueRangeSingleEdge()
        {
            const string source  = @"
               TradingPairs: [EOSETH]
               CandleWidth: 25
            ";
            var          config  = ParseAlgorithmConfiguration(source);
            var          data    = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config);
            var          candles = data.GetCandles(TradingPair.Parse("EOSETH"), 2);
            var          atr     = candles.AverageTrueRange();

            Assert.Equal(2.6M, atr);
        }
 private static OrderUpdate GetSomeOrder(OrderTypes type, decimal setPrice = 0)
 {
     return(new OrderUpdate(
                orderId: 0,
                tradeId: 0,
                orderStatus: OrderUpdate.OrderStatus.Filled,
                orderType: type,
                createdTimestamp: 0,
                setPrice: setPrice,
                side: OrderSide.Buy,
                pair: TradingPair.Parse("EOSETH"),
                setQuantity: 0));
 }
Exemple #27
0
        public void GetCandlesTimestampIncreasing(int limit)
        {
            var candles = _container.DataProvider.GetCandles(
                TradingPair.Parse("EOSETH"),
                limit);
            var increment = (long)TimeSpan.FromMinutes((int)Configuration.Instance.CandleWidth).TotalMilliseconds;
            var diffs     = candles.Pairwise((a, b) => b.OpenTimestamp - a.OpenTimestamp);

            foreach (var diff in diffs)
            {
                Assert.Equal(increment, diff);
            }
        }
        public void LowestLowIsMaximumOfCandleLows()
        {
            const string source    = @"
               TradingPairs: [EOSETH]
               CandleWidth: 5
            ";
            var          config    = ParseAlgorithmConfiguration(source);
            var          data      = GetDataProvider <DataProviderGetCandlesImplementation>(config);
            var          pair      = TradingPair.Parse("EOSETH");
            var          candles   = data.GetCandles(pair, 1300);
            var          lowestLow = data.GetLowestLow(pair, 1300);

            Assert.Equal(candles.Min(x => x.Low), lowestLow);
        }
        public void HighestHighIsMaximumOfCandleHighs()
        {
            const string source      = @"
               TradingPairs: [EOSETH]
               CandleWidth: 5
            ";
            var          config      = ParseAlgorithmConfiguration(source);
            var          data        = GetDataProvider <DataProviderGetCandlesImplementation>(config);
            var          pair        = TradingPair.Parse("EOSETH");
            var          candles     = data.GetCandles(pair, 1300);
            var          highestHigh = data.GetHighestHigh(pair, 1300);

            Assert.Equal(candles.Max(x => x.High), highestHigh);
        }
Exemple #30
0
        public void AddParseEntryOverwrites()
        {
            var pre = GetTradingPair("BNB", "ETH", 0, 0);

            TradingPair.AddParseEntry("BNBETH", pre);

            var post = GetTradingPair("BNB", "ETH", 1, 1);

            TradingPair.AddParseEntry("BNBETH", post);

            var postParse = TradingPair.Parse("BNBETH");

            Assert.NotEqual(pre.QuantityDecimals, postParse.QuantityDecimals);
            Assert.NotEqual(pre.PriceDecimals, postParse.PriceDecimals);
        }