docker files fixes from liaqat

src/Managing.Infrastructure.Tests/ExchangeServicesTests.cs

@@ -0,0 +1,200 @@
+using Managing.Common;
+using Managing.Domain.Trades;
+using Managing.Infrastructure.Exchanges;
+using Microsoft.Extensions.Logging;
+using Managing.Domain.Candles;
+using Xunit;
+using static Managing.Common.Enums;
+using Managing.Domain.Accounts;
+using Moq;
+using Managing.Application.Abstractions.Repositories;
+using Managing.Application.Abstractions.Services;
+using Managing.Infrastructure.Exchanges.Abstractions;
+using Managing.Infrastructure.Exchanges.Exchanges;
+using Managing.Infrastructure.Evm;
+using Ticker = Managing.Common.Enums.Ticker;
+using Managing.Infrastructure.Evm.Abstractions;
+
+namespace Managing.Infrastructure.Tests
+{
+    public class ExchangeServicesTests 
+    {
+        private readonly IExchangeService _exchangeService;
+        public readonly string PublicAddress = "";
+
+        public List<ISubgraphPrices> Subgraphs;
+
+        public ExchangeServicesTests()
+        {
+
+            ILoggerFactory doesntDoMuch = new Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory();
+            var candleRepository = new Mock<ICandleRepository>().Object;
+            var evmManager = new EvmManager(Subgraphs);
+            var evmProcessor = new EvmProcessor(new Mock<ILogger<EvmProcessor>>().Object, evmManager);
+            var exchangeProcessors = new List<IExchangeProcessor>()
+            {
+                evmProcessor
+            };
+
+            _exchangeService = new ExchangeService(doesntDoMuch.CreateLogger<ExchangeService>(), candleRepository, exchangeProcessors);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC)]
+        public void Should_Return_Price_For_Given_Ticker(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var price = _exchangeService.GetPrice(account, ticker, DateTime.Now);
+            Assert.IsType<decimal>(price);
+            Assert.InRange(price, 0, 1000000);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.ADA)]
+        public void Should_Return_Candle_For_Given_Ticker(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var candle = _exchangeService.GetCandle(account, ticker, DateTime.Now);
+            Assert.IsType<Candle>(candle);
+            Assert.InRange(candle.High, 0, 1000000);
+            Assert.InRange(candle.Low, 0, 1000000);
+            Assert.InRange(candle.Open, 0, 1000000);
+            Assert.InRange(candle.Close, 0, 1000000);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm)]
+        public void Should_Return_Balance(Enums.TradingExchanges exchange)
+        {
+            var account = GetAccount(exchange);
+            var balance = _exchangeService.GetBalance(account).Result;
+            Assert.IsType<decimal>(balance);
+            Assert.True(balance >= 0);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, "0x2875673415c66bf05091eeff3887e0d40136d5ea443a4e63e7f4e41a6580575e", Ticker.BTC)]
+        public void Should_Return_Trade_For_Given_OrderId(Enums.TradingExchanges exchange, string orderId, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var trade = _exchangeService.GetTrade(account, orderId, ticker).Result;
+            Assert.IsType<Trade>(trade);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC)]
+        public void Should_Return_List_Of_Candle_Given_Ticker(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var candles = _exchangeService.GetCandles(account, ticker, DateTime.Now.AddDays(-10), Timeframe.OneDay).Result;
+            Assert.IsType<List<Candle>>(candles);
+            Assert.InRange(candles.Count, 1, 15);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.ADA, "7INRiu79cv2nCONNlILPu0")]
+        public void Should_Return_Long_Trade(Enums.TradingExchanges exchange, Ticker ticker, string exchangeOrderId)
+        {
+            var account = GetAccount(exchange);
+            var trade = _exchangeService.GetTrade(account, exchangeOrderId, ticker).Result;
+            Assert.IsType<Trade>(trade);
+            Assert.True(trade.Direction == TradeDirection.Long);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.ADA, "AQKzJpDNrfVjuq81baPLfR")]
+        public void Should_Return_Short_Trade(Enums.TradingExchanges exchange, Ticker ticker, string exchangeOrderId)
+        {
+            var account = GetAccount(exchange);
+            var trade = _exchangeService.GetTrade(account, exchangeOrderId, ticker).Result;
+            Assert.IsType<Trade>(trade);
+            Assert.True(trade.Direction == TradeDirection.Short);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC)]
+        public async void Should_Return_Balance_For_Ticker(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var balance = await _exchangeService.GetQuantityInPosition(account, ticker);
+            Assert.IsType<decimal>(balance);
+            Assert.True(balance > 0);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.ADA)]
+        public void Should_Return_Trade_List_For_Ticker(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var trades = _exchangeService.GetTrades(account, ticker).Result;
+            Assert.IsType<List<Trade>>(trades);
+            Assert.True(trades.Count > 0);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm)]
+        public void Should_Return_Fee(Enums.TradingExchanges exchange)
+        {
+            var account = GetAccount(exchange);
+            var fee = _exchangeService.GetFee(account);
+            Assert.IsType<decimal>(fee);
+            Assert.True(fee > 0);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC)]
+        public void Should_Return_Volume(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var volume = _exchangeService.GetVolume(account, ticker);
+            Assert.IsType<decimal>(volume);
+            Assert.True(volume > 0);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC)]
+        public async void Should_Return_Open_Order(Enums.TradingExchanges exchange, Ticker ticker)
+        {
+            var account = GetAccount(exchange);
+            var trades = await _exchangeService.GetOpenOrders(account, ticker);
+            Assert.IsType<List<Trade>>(trades);
+        }
+
+        [Theory]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC, 0.1, TradeDirection.Long)]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC, 700, TradeDirection.Long)]
+        [InlineData(Enums.TradingExchanges.Evm, Ticker.BTC, 700, TradeDirection.Short)]
+        public void Should_Return_Best_Price(
+            Enums.TradingExchanges exchange,
+            Ticker ticker,
+            decimal quantity,
+            TradeDirection direction)
+        {
+            var account = GetAccount(exchange);
+            var lastPrice = _exchangeService.GetPrice(account, ticker, DateTime.UtcNow);
+            var bestPrice = _exchangeService.GetBestPrice(account, ticker, lastPrice, quantity, direction);
+
+            Assert.IsType<decimal>(bestPrice);
+
+            var percentageDiff = ( (bestPrice * 100) / lastPrice) - 100; 
+            Assert.True(Math.Abs(percentageDiff) < 1);
+        }
+
+        private Account GetAccount(Enums.TradingExchanges exchange)
+        {
+            var account = new Account();
+            switch (exchange)
+            {
+                case Enums.TradingExchanges.Evm:
+                    account.Exchange = Enums.TradingExchanges.Evm;
+                    account.Key = PublicAddress;
+                    account.Secret = "PrivateKey";
+                    account.Name = "EvmAccount";
+                    break;
+                default:
+                    break;
+            }
+            return account;
+        }
+    }
+}