public async Task RunBasicTests(Func <CandlesRequest> request)
{
// Most basic request
var result = await Rest.GetCandlesAsync(request());
_results.Verify(result.Count > 0, "Retrieved basic candles");
// Test default values
var defaultValueProps =
request().GetType().GetTypeInfo().DeclaredFields.Where(
x => null != x.GetCustomAttribute(typeof(DefaultValueAttribute)));
foreach (var defaultValueProp in defaultValueProps)
{
var defaultValue = (DefaultValueAttribute)defaultValueProp.GetCustomAttribute(typeof(DefaultValueAttribute));
var newRequest = request();
var smartProp = (ISmartProperty)defaultValueProp.GetValue(newRequest);
smartProp.SetValue(defaultValue.Value);
defaultValueProp.SetValue(newRequest, smartProp);
try
{
var testResult = await Rest.GetCandlesAsync(newRequest);
_results.Verify(result.SequenceEqual(testResult), "Testing default value of " + defaultValueProp.Name);
}
catch (Exception ex)
{
_results.Verify(false, "Testing default value of " + defaultValueProp.Name + "\n" + ex);
}
}
}
/// <summary>
/// Downloads a block of 5-second bars from a starting datetime
/// </summary>
/// <param name="symbol"></param>
/// <param name="start"></param>
/// <param name="barsPerRequest"></param>
/// <returns></returns>
private static async Task <List <Candle> > DownloadBars(string symbol, string start, int barsPerRequest)
{
if (_settings.EnableTrace)
{
Console.WriteLine("Requesting {0} bars for {1} from {2}", barsPerRequest, symbol, start);
}
var request = new CandlesRequest
{
instrument = symbol,
granularity = EGranularity.S5,
candleFormat = ECandleFormat.midpoint,
count = barsPerRequest,
start = Uri.EscapeDataString(start)
};
var bars = await Rest.GetCandlesAsync(request);
if (_settings.EnableTrace)
{
if (bars.Count > 0)
{
Console.WriteLine("Received {0} bars: {1} to {2}", bars.Count, bars[0].time, bars[bars.Count - 1].time);
}
else
{
Console.WriteLine("Received 0 bars");
}
}
return(bars);
}
public async void RequestDataUpdate()
{
var candles = await Rest.GetCandlesAsync(Instrument, Granularity);
Items.Clear();
foreach (var candle in candles)
{
Items.Add(new CandleViewModel(candle, this));
}
}
public static async Task <List <Candle> > GetCandlesAsync(string instrument, EGranularity granularity, int count)
{
Func <CandlesRequest> request = () => new CandlesRequest
{
instrument = instrument,
granularity = granularity,
count = count
};
List <Candle> pollCandles = null;
pollCandles = await Rest.GetCandlesAsync(request());
return(pollCandles);
}
protected async Task RunThrustTest(Func <CandlesRequest> request)
{
short count = 0;
var thrustRequest = request();
thrustRequest.count = 100;
var thrustResult = await Rest.GetCandlesAsync(thrustRequest);
// if candles endpoint is working then proceed
if (thrustResult.Count > 0)
{
foreach (Candle candle in thrustResult)
{
// compute close 3x3 value
if (count >= 5)
{
var closeAverage = new SimpleMovingAverage(3)
{
Value = (thrustResult[count - 3].closeBid + thrustResult[count - 4].closeBid + thrustResult[count - 5].closeBid) / 3,
};
var candleOpenBid = Math.Round(candle.openBid, 2);
var candleCloseBid = Math.Round(candle.closeBid, 2);
var candleHighBid = Math.Round(candle.highBid, 2);
var candleLowBid = Math.Round(candle.lowBid, 2);
if (count >= 90) // only need enough to validate the 3x3 computations
{
_results.Add(string.Format("Candle {0} - {1} has open bid ({2}).", thrustRequest.instrument, count, candleOpenBid));
_results.Add(string.Format("Candle {0} - {1} has close bid ({2}).", thrustRequest.instrument, count, candleCloseBid));
_results.Add(string.Format("Candle {0} - {1} has high bid ({2}).", thrustRequest.instrument, count, candleHighBid));
// determine if the candle low is above or below the 3x3
string closePosition = candle.lowBid > closeAverage.Value ? "above" : "below";
char arrow = closePosition == "above" ? (char)30 : (char)31;
_results.Add(string.Format("Candle {0} - {1} has low bid ({2}) {3} 3x3 at {4}. {5}\n", thrustRequest.instrument, count, candleLowBid, closePosition, Math.Round(closeAverage.Value.GetValueOrDefault(), 2), arrow));
}
}
count++;
}
}
else
{
_results.Verify(false, "Thrust tests did not receive candles.");
}
}
//---------------------------------------------------------------------------------------------------
#region Private
private async Task TestCount(Func <CandlesRequest> request, int count, bool isError, string message)
{
var testRequest = request();
testRequest.count = count;
if (!isError)
{
var result = await Rest.GetCandlesAsync(testRequest);
_results.Verify(result.Count == count, message);
}
else
{
var stringResult = await Rest.MakeErrorRequest(testRequest);
_results.Verify(stringResult != null, message);
}
}
public async Task <List <PriceBar> > GetPriceBars(List <Tuple <string, EGranularity> > barSpecsList, int count, ECandleFormat priceFormat = ECandleFormat.midpoint)
{
List <PriceBar> bars = new List <PriceBar>();
foreach (var spec in barSpecsList)
{
Func <CandlesRequest> request = () => new CandlesRequest
{
instrument = spec.Item1,
granularity = spec.Item2,
candleFormat = priceFormat,
count = count
};
List <Candle> pollCandles = null;
pollCandles = await Rest.GetCandlesAsync(request());
if (pollCandles != null && pollCandles.Count > 0)
{
pollCandles.OrderBy(c => Convert.ToDateTime(c.time).ToUniversalTime());
foreach (var candle in pollCandles)
{
var bar = new PriceBar()
{
instrument = spec.Item1, granularity = spec.Item2.ToString()
};
bar.InjectWith(candle, false);
bars.Add(bar);
}
}
}
return(bars);
}
