public OrderTick GetPrice(Side side, ExchangePrices prices)
{
if (prices == null)
{
throw new System.Exception();
}
var stakeProvider = _openingStakeProviderFactory.GetStakeProvider("Fixed");
if (side == Side.BACK)
{
var openingPrices = prices.AvailableToBack.OrderByDescending(x => x.Price).ToList();
ValidateHasPrices(openingPrices);
return(GetOrderTick(stakeProvider, openingPrices));
}
else if (side == Side.LAY)
{
var openingPrices = prices.AvailableToLay.OrderBy(x => x.Price).ToList();
ValidateHasPrices(openingPrices);
return(GetOrderTick(stakeProvider, openingPrices));
}
else
{
throw new System.Exception();
}
}
public void ShouldThrowExceptionIfPricesAreNull()
{
var provider = new Mock <IOpeningStakeProvider>();
provider.Setup(x => x.GetStake(It.IsAny <double>(), It.IsAny <List <double> >())).Returns(1);
var mockStakeFactory = new Mock <IOpeningStakeProviderFactory>();
mockStakeFactory.Setup(x => x.GetStakeProvider(It.IsAny <string>())).Returns(provider.Object);
var prices = new ExchangePrices()
{
AvailableToBack = new List <PriceSize>()
{
new PriceSize()
{
Price = 1,
Size = 2
}
},
AvailableToLay = new List <PriceSize>()
{
new PriceSize()
{
Price = 5,
Size = 10
}
}
};
var finder = new OrderPriceFinder(mockStakeFactory.Object);
Assert.ThrowsException <System.Exception>(() => finder.GetPrice(TradePlacement.Models.Side.BACK, null));
}
public void EqualExchangePricesAreEqual()
{
//arange
ExchangePrices first_ep = GetStandartObject();
ExchangePrices second_ep = GetStandartObject();
//act
bool equal = first_ep.Equals(second_ep);
//assert
Assert.IsTrue(equal);
}
public void AvailableToLayCountsAreCorrect()
{
//arange
ExchangePrices first_ep = GetStandartObject();
PrivateObject pr = new PrivateObject(first_ep);
ExchangePrices second_ep = GetStandartObject();
//act
bool equal = (bool)pr.Invoke("isOverExchangePricesHasEqualCount",
first_ep.AvailableToLay.Count, second_ep.AvailableToLay.Count);
//assert
Assert.IsTrue(equal);
}
public void AvailableToBackPriceSizesAreEqualCorrect()
{
//arange
ExchangePrices first_ep = GetStandartObject();
PrivateObject pr = new PrivateObject(first_ep);
ExchangePrices second_ep = GetStandartObject();
//act
bool equal = (bool)pr.Invoke("isPriceSizeCollectionsEqual",
first_ep.AvailableToBack, second_ep.AvailableToBack);
//assert
Assert.IsTrue(equal);
}
public void IsNotNullCorrect()
{
//arrange
ExchangePrices first_ep = new ExchangePrices();
PrivateObject pr = new PrivateObject(first_ep);
ExchangePrices second_ep = new ExchangePrices()
{
AvailableToBack = new ObservableCollection <PriceSize>
{
new PriceSize()
{
Price = 1.0, Size = 100.0
},
new PriceSize()
{
Price = 1.0, Size = 100.0
},
new PriceSize()
{
Price = 1.0, Size = 100.0
}
},
AvailableToLay = new ObservableCollection <PriceSize>
{
new PriceSize()
{
Price = 1.0, Size = 100.0
},
new PriceSize()
{
Price = 1.0, Size = 100.0
},
new PriceSize()
{
Price = 1.0, Size = 100.0
}
}
};
//act
bool equal = (bool)pr.Invoke("isOverExchangePricesNotNull", second_ep);
//correct
Assert.IsTrue(equal);
}
private void _fillMissingData(ExchangePrices ep)
{
if (ep == null)
{
ep = new ExchangePrices();
}
if (ep.AvailableToBack == null)
{
ep.AvailableToBack = new ObservableCollection <PriceSize>();
}
if (ep.AvailableToLay == null)
{
ep.AvailableToLay = new ObservableCollection <PriceSize>();
}
if (ep.TradedVolume == null)
{
ep.TradedVolume = new ObservableCollection <PriceSize>();
}
if (ep.AvailableToBack.Count < 3)
{
AddPriceSize(ep.AvailableToBack, 1.01, 3 - ep.AvailableToBack.Count);
}
if (ep.AvailableToLay.Count < 3)
{
AddPriceSize(ep.AvailableToLay, 1000, 3 - ep.AvailableToLay.Count);
}
if (ep.TradedVolume.Count < 3)
{
AddPriceSize(ep.TradedVolume, 0, 3);
}
}