Example #1
0
        public void CalculateWomWhenThereIsNoLaySize()
        {
            var rc = new RunnerChangeStub().WithSelectionId(1).WithBestAvailableToBack(0, 2.5, 10.99);

            _runner.OnRunnerChange(rc, 0);

            Assert.Equal(1, _runner.Wom());
        }
Example #2
0
        public void HandleNullTradedList()
        {
            var runnerChange = new RunnerChangeStub()
                               .WithTraded(null, null);

            _runner.OnRunnerChange(runnerChange, 0);

            Assert.Equal(0, _runner.TradedLadder.GetSizeForPrice(10));
        }
Example #3
0
        public void OnRunnerChangePublishTimeIsSet()
        {
            var runnerChange = new RunnerChangeStub();
            var mc           = new MarketChangeStub().WithRunnerChange(runnerChange);

            _market.OnChange(_change.WithMarketChange(mc).WithPublishTime(98765).Build());

            Assert.Equal(98765, _market.Runners[12345].LastPublishTime);
        }
Example #4
0
        public void BestLayReturnsZeroIfLevelDoesNotExist()
        {
            var rc = new RunnerChangeStub()
                     .WithSelectionId(1).WithBestAvailableToLay(1, 2.5, 100);

            _runner.OnRunnerChange(rc, 0);
            Assert.Equal(0, _runner.BestAvailableToLay.Price(0));
            Assert.Equal(0, _runner.BestAvailableToLay.Size(0));
        }
Example #5
0
        public void LastPublishTimeIsSetInTradeLadder()
        {
            const long expectedTimeStamp = 98765;
            var        runnerChange      = new RunnerChangeStub();

            _runner.OnRunnerChange(runnerChange, expectedTimeStamp);

            Assert.Equal(98765, _runner.TradedLadder.LastPublishTime);
        }
Example #6
0
        public void SetTotalMatched()
        {
            const int expectedTotalMatched = 10;
            var       runnerChange         = new RunnerChangeStub()
                                             .WithTotalMatched(expectedTotalMatched);

            _runner.OnRunnerChange(runnerChange, 0);

            Assert.Equal(expectedTotalMatched, _runner.TotalMatched);
        }
        public void ReturnOverroundForSingleRunner(double price)
        {
            var rc = new RunnerChangeStub().WithSelectionId(1).WithBestAvailableToBack(0, price, 100);
            var mc = new MarketChangeStub().WithMarketId("1.2345").WithRunnerChange(rc);

            _market.OnChange(_change.WithMarketChange(mc).Build());
            var expected = 1 / price;

            Assert.Equal(expected, _market.Overround());
        }
Example #8
0
        public void SetLastTradedPrice()
        {
            const int expectedLastTradedPrice = 10;
            var       runnerChange            = new RunnerChangeStub()
                                                .WithLastTradedPrice(expectedLastTradedPrice);

            _runner.OnRunnerChange(runnerChange, 0);

            Assert.Equal(expectedLastTradedPrice, _runner.LastTradedPrice);
        }
Example #9
0
        public void OnlyProcessMessageForCorrectRunner()
        {
            var runnerChange = new RunnerChangeStub()
                               .WithSelectionId(54321)
                               .WithLastTradedPrice(10);

            _runner.OnRunnerChange(runnerChange, 0);

            Assert.Null(_runner.LastTradedPrice);
        }
        public void ReturnOverroundForMultipleRunners(double price1, double price2)
        {
            var rc  = new RunnerChangeStub().WithSelectionId(1).WithBestAvailableToBack(0, price1, 100);
            var rc2 = new RunnerChangeStub().WithSelectionId(2).WithBestAvailableToBack(0, price2, 100);
            var mc  = new MarketChangeStub().WithMarketId("1.2345").WithRunnerChange(rc).WithRunnerChange(rc2);

            _market.OnChange(_change.WithMarketChange(mc).Build());
            var expected = (1 / price1) + (1 / price2);

            Assert.Equal(expected, _market.Overround());
        }
Example #11
0
        public async Task UpdateMarketCacheUsedInStrategies()
        {
            var rc = new RunnerChangeStub().WithSelectionId(1).WithBestAvailableToBack(0, 2.5, 9.99);
            var mc = new MarketChangeStub().WithRunnerChange(rc);

            _subscription.WithMarketChange(mc);
            await _trader.TradeMarket("1.2345", 0, CancellationToken.None);

            Assert.Equal("CASOMM", _subscription.Actions);
            Assert.Equal(1, _strategy.RunnerCount());
        }
Example #12
0
        public void ProcessTraded()
        {
            var runnerChange = new RunnerChangeStub()
                               .WithTraded(10, 100)
                               .WithTraded(11, 10);

            _runner.OnRunnerChange(runnerChange, 0);

            Assert.Equal(100, _runner.TradedLadder.GetSizeForPrice(10));
            Assert.Equal(10, _runner.TradedLadder.GetSizeForPrice(11));
        }
Example #13
0
        public async Task OnMarketCloseNotCalledIfNotCancelled()
        {
            var rc = new RunnerChangeStub().WithBestAvailableToBack(0, 2.5, 2.99);
            var mc = new MarketChangeStub().WithTotalMatched(10).WithRunnerChange(rc);

            _subscription.WithMarketChange(mc);

            await _trader.TradeMarket("1.2345", 0, default);

            Assert.False(_orderManager.OnMarketCloseCalled);
        }
Example #14
0
        public async Task UpdateMarketCacheWithPublishedTime(long pt)
        {
            _subscription.PublishTime = pt;
            var rc = new RunnerChangeStub().WithSelectionId(1).WithBestAvailableToBack(0, 2.5, 9.99);
            var mc = new MarketChangeStub().WithRunnerChange(rc);

            _subscription.WithMarketChange(mc);
            await _trader.TradeMarket("1.2345", 0, CancellationToken.None);

            Assert.Equal("CASOMM", _subscription.Actions);
            Assert.Equal(pt, _strategy.LastPublishedTime());
        }
Example #15
0
        public void CalculateWom(double backSize, double laySize)
        {
            var rc = new RunnerChangeStub()
                     .WithSelectionId(1)
                     .WithBestAvailableToBack(0, 2.5, backSize)
                     .WithBestAvailableToLay(0, 3, laySize);

            _runner.OnRunnerChange(rc, 0);

            var expected = backSize / (backSize + laySize);

            Assert.Equal(expected, _runner.Wom());
        }
Example #16
0
        public void SetBestAvailableToLay()
        {
            var runnerChange = new RunnerChangeStub()
                               .WithBestAvailableToLay(0, 2, 3)
                               .WithBestAvailableToLay(1, 3, 4)
                               .WithBestAvailableToLay(2, 4, 5);

            _runner.OnRunnerChange(runnerChange, 0);

            AssertBestAvailableToLayContains(0, 2, 3);
            AssertBestAvailableToLayContains(1, 3, 4);
            AssertBestAvailableToLayContains(2, 4, 5);
        }
Example #17
0
        public async Task OnMarketCloseCalledIfCancelled()
        {
            var rc = new RunnerChangeStub().WithBestAvailableToBack(0, 2.5, 2.99);
            var mc = new MarketChangeStub().WithTotalMatched(10).WithRunnerChange(rc);

            _subscription.WithMarketChange(mc);

            using var source = new CancellationTokenSource();
            source.Cancel();
            await _trader.TradeMarket("1.2345", 0, source.Token);

            Assert.True(_orderManager.OnMarketCloseCalled);
        }
Example #18
0
        public void SetAdjustmentFactorToZeroIfNull()
        {
            var rc = new RunnerChangeStub()
                     .WithSelectionId(1).WithBestAvailableToLay(1, 2.5, 100);

            _runner.OnRunnerChange(rc, 0);
            var d = new RunnerDefinition
            {
                SelectionId = 1,
            };

            _runner.SetDefinition(d);
            Assert.Equal(0, _runner.AdjustmentFactor);
        }
Example #19
0
        public void StrategyIsToldWhatHasBeenUpdated()
        {
            var rc = new RunnerChangeStub()
                     .WithSelectionId(1)
                     .WithBestAvailableToBack(0, 2.5, 100)
                     .WithBestAvailableToLay(0, 3.0, 200);
            var mc = new MarketChangeStub().WithRunnerChange(rc);

            _market.OnChange(_change.WithMarketChange(mc).Build());

            GetOrders(mc, 0);
            Assert.Single(Market.Runners);
            Assert.Equal(mc, _mChange);
        }
Example #20
0
        public async Task UpdateMarketCacheWithMultipleChanges()
        {
            var rc  = new RunnerChangeStub().WithSelectionId(1).WithBestAvailableToBack(0, 2.5, 9.99);
            var mc  = new MarketChangeStub().WithRunnerChange(rc);
            var rc2 = new RunnerChangeStub().WithSelectionId(2).WithBestAvailableToBack(0, 2.5, 9.99);
            var mc2 = new MarketChangeStub().WithRunnerChange(rc2);

            _subscription.WithMarketChanges(new List <MarketChange> {
                mc, mc2
            });
            await _trader.TradeMarket("1.2345", 0, CancellationToken.None);

            Assert.Equal("CASOMM", _subscription.Actions);
            Assert.Equal(2, _strategy.RunnerCount());
        }
Example #21
0
        public void CalculateWomForOneLevel(double backSize1, double backSize2, double laySize1, double laySize2)
        {
            var rc = new RunnerChangeStub()
                     .WithSelectionId(1)
                     .WithBestAvailableToBack(0, 2.5, backSize1)
                     .WithBestAvailableToBack(1, 2.5, backSize2)
                     .WithBestAvailableToLay(0, 3, laySize1)
                     .WithBestAvailableToLay(1, 3, laySize2);

            _runner.OnRunnerChange(rc, 0);

            var expected = backSize1 / (backSize1 + laySize1);

            Assert.Equal(expected, _runner.Wom());
        }
Example #22
0
        public void UpdateTraded()
        {
            var runnerChange = new RunnerChangeStub()
                               .WithTraded(10, 100)
                               .WithTraded(11, 10);

            _runner.OnRunnerChange(runnerChange, 0);

            var runnerChange2 = new RunnerChangeStub().WithTraded(10, 50);

            _runner.OnRunnerChange(runnerChange2, 0);

            Assert.Equal(50, _runner.TradedLadder.GetSizeForPrice(10));
            Assert.Equal(10, _runner.TradedLadder.GetSizeForPrice(11));
        }
Example #23
0
        public void OnlySetLastTradedPriceIfNotNull()
        {
            const int expectedLastTradedPrice = 10;

            var runnerChange1 = new RunnerChangeStub()
                                .WithLastTradedPrice(expectedLastTradedPrice);

            _runner.OnRunnerChange(runnerChange1, 0);

            var runnerChange2 = new RunnerChangeStub();

            _runner.OnRunnerChange(runnerChange2, 0);

            Assert.Equal(expectedLastTradedPrice, _runner.LastTradedPrice);
        }
        public void ReturnOverroundOnlyIfRunnerHasBestPriceAvailable(double price)
        {
            var rc  = new RunnerChangeStub().WithSelectionId(1).WithBestAvailableToBack(0, price, 100);
            var rc2 = new RunnerChangeStub().WithSelectionId(2).WithBestAvailableToBack(1, 2, 100);
            var rc3 = new RunnerChangeStub().WithSelectionId(3);
            var mc  = new MarketChangeStub()
                      .WithMarketId("1.2345")
                      .WithRunnerChange(rc)
                      .WithRunnerChange(rc2)
                      .WithRunnerChange(rc3);

            _market.OnChange(_change.WithMarketChange(mc).Build());
            var expected = 1 / price;

            Assert.Equal(expected, _market.Overround());
        }
Example #25
0
        public void UpdateBestAvailableToLay()
        {
            var runnerChange1 = new RunnerChangeStub()
                                .WithBestAvailableToLay(0, 2, 3)
                                .WithBestAvailableToLay(1, 3, 4)
                                .WithBestAvailableToLay(2, 4, 5);

            _runner.OnRunnerChange(runnerChange1, 0);

            var runnerChange2 = new RunnerChangeStub()
                                .WithBestAvailableToLay(1, 5, 6);

            _runner.OnRunnerChange(runnerChange2, 0);

            AssertBestAvailableToLayContains(1, 5, 6);
        }
Example #26
0
        public void CalculateWomForThreeLevels(double backSize1, double backSize2, double backSize3, double laySize1, double laySize2, double laySize3)
        {
            var rc = new RunnerChangeStub()
                     .WithSelectionId(1)
                     .WithBestAvailableToBack(0, 2.5, backSize1)
                     .WithBestAvailableToBack(1, 2.5, backSize2)
                     .WithBestAvailableToBack(2, 2.5, backSize3)
                     .WithBestAvailableToLay(0, 3, laySize1)
                     .WithBestAvailableToLay(1, 3, laySize2)
                     .WithBestAvailableToLay(2, 3, laySize3);

            _runner.OnRunnerChange(rc, 0);

            var totalBackSize = backSize1 + backSize2 + backSize3;
            var expected      = totalBackSize / (totalBackSize + laySize1 + laySize2 + laySize3);

            Assert.Equal(expected, _runner.Wom(3));
        }
Example #27
0
        public async Task AdjustBankForMarketLiability(double bank, double liability)
        {
            var rc = new RunnerChangeStub().WithBestAvailableToBack(0, 2.5, 2.99);
            var mc = new MarketChangeStub().WithTotalMatched(10).WithRunnerChange(rc);

            _subscription.WithMarketChange(mc);

            var orc = new OrderRunnerChangeStub().WithUnmatchedBack(2.5, liability);
            var oc  = new OrderChangeStub().WithOrderRunnerChange(orc);

            _subscription.WithOrderChange(oc);
            _subscription.WithMarketChange(mc);

            _trader.AddStrategy(new StrategySpy());
            await _trader.TradeMarket("1.2345", bank, default);

            Assert.Equal(Math.Round((bank - Math.Round(liability, 2)) / 2, 2), _strategy.Stake);
        }
Example #28
0
        public async Task ProcessLastMessageBeforeCancelling()
        {
            var source = new CancellationTokenSource();

            _subscription.CancelAfterThisManyMessages(2, source);

            var rc  = new RunnerChangeStub().WithSelectionId(1).WithBestAvailableToBack(0, 2.5, 9.99);
            var mc  = new MarketChangeStub().WithRunnerChange(rc);
            var rc2 = new RunnerChangeStub().WithSelectionId(2).WithBestAvailableToBack(0, 2.5, 9.99);
            var mc2 = new MarketChangeStub().WithRunnerChange(rc2);

            _subscription.WithMarketChange(mc);
            _subscription.WithMarketChange(mc2);

            await _trader.TradeMarket("1.2345", 0, source.Token);

            Assert.Equal(1, _strategy.MarketUpdateCount);
        }
Example #29
0
        public async Task StopProcessingMessageIfCancelled()
        {
            var source = new CancellationTokenSource();

            _subscription.CancelAfterThisManyMessages(1, source);

            var rc  = new RunnerChangeStub().WithSelectionId(1).WithBestAvailableToBack(0, 2.5, 9.99);
            var mc  = new MarketChangeStub().WithRunnerChange(rc);
            var rc2 = new RunnerChangeStub().WithSelectionId(2).WithBestAvailableToBack(0, 2.5, 9.99);
            var mc2 = new MarketChangeStub().WithRunnerChange(rc2);

            _subscription.WithMarketChange(mc);
            _subscription.WithMarketChange(mc2);

            await _trader.TradeMarket("1.2345", 0, source.Token);

            Assert.Equal("CASOMD", _subscription.Actions);
        }
Example #30
0
        public void HandleRunnerDefinitionForRunnerThatDoesNotExist()
        {
            var rc = new RunnerChangeStub();
            var rd = new RunnerDefinition
            {
                SelectionId = 1, AdjustmentFactor = 54.32,
            };
            var md = new MarketDefinition
            {
                Runners = new List <RunnerDefinition> {
                    rd
                },
            };
            var mc = new MarketChangeStub()
                     .WithMarketDefinition(md)
                     .WithRunnerChange(rc);

            _market.OnChange(_change.WithMarketChange(mc).Build());
        }