public async Task GetSingleQuoteData_ShouldReturnQueryResultWithError_WhenErrorSendingRequestWithHttpClient()
{
var client = new AlphaVantageClient(_mockHttpFactory.Object, _mockAlphaVantageOptionsAccessor.Object, _mockParserFactory.Object, _mockLogger.Object);
_mockHttpFactory = new Mock <IHttpClientFactory>();
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
.Throws <Exception>();
var httpClient = new HttpClient(handlerMock.Object);
_mockHttpFactory.Setup(x => x.CreateClient(It.IsAny <string>())).Returns(httpClient);
var query = new SingleQuoteQuery(-1);
var queryResult = await client.GetSingleQuoteData(query, "MSFT", "NASDAQ");
Assert.True(queryResult.HasError);
Assert.NotNull(queryResult.ErrorMessage);
}
public EquitiesPriceCache()
{
EquityPrices = new Dictionary <string, EquityPrices>();
using (var client = new AlphaVantageClient(ApiKey))
{
foreach (var supportedEquity in SupportedEquities)
{
try
{
var setting = new Dictionary <string, string> {
{ "symbol", supportedEquity }
};
var priceFetchTask = client.RequestPureJsonAsync(ApiFunction.TIME_SERIES_DAILY, setting);
Task.WaitAll(priceFetchTask);
var pricesResult = priceFetchTask.Result;
var prices = JsonConvert.DeserializeObject <EquityPrices>(pricesResult);
EquityPrices.Add(supportedEquity, prices);
}
catch (Exception ex)
{
Log.Error(ex, "EquitiesPriceCache");
}
}
}
}
public async Task GetSingleQuoteData_ShouldReturnSingleQuoteQueryResultWithoutError_WhenSuccessful()
{
var singleQuoteData = new SingleQuoteData(
symbolId: 1,
ticker: "MSFT",
high: 1,
low: 2,
open: 3,
previousClose: 4,
volume: 5,
change: 6,
price: 7,
changePercent: 0.9m,
lastUpdated: DateTime.UtcNow,
lastTradingDay: DateTime.UtcNow
);
var client = new AlphaVantageClient(_mockHttpFactory.Object, _mockAlphaVantageOptionsAccessor.Object, _mockParserFactory.Object, _mockLogger.Object);
SetupMockHttpClient("mockData", HttpStatusCode.OK);
_singleQuoteDataCsvParser.Setup(x => x.ParseJson(-1, It.IsAny <string>())).Returns(singleQuoteData);
var query = new SingleQuoteQuery(-1);
var queryResult = await client.GetSingleQuoteData(query, "MSFT", "NASDAQ");
Assert.False(queryResult.HasError);
Assert.Equal("MSFT", queryResult.Data.Ticker);
Assert.Equal(singleQuoteData.LastUpdated, queryResult.Data.LastUpdated);
}
public async Task ReturnSearchResults()
{
using var client = new AlphaVantageClient(_apiKey);
using var stocksClient = client.Stocks();
var searchMatches = await stocksClient.SearchSymbolAsync("BA");
searchMatches.Should().NotBeNull()
.And.HaveCountGreaterThan(1);
foreach (var searchMatch in searchMatches)
{
searchMatch.Should().NotBeNull()
.And.Match <SymbolSearchMatch>(sm =>
string.IsNullOrWhiteSpace(sm.Symbol) == false &&
string.IsNullOrWhiteSpace(sm.Name) == false &&
string.IsNullOrWhiteSpace(sm.Type) == false &&
string.IsNullOrWhiteSpace(sm.Region) == false &&
string.IsNullOrWhiteSpace(sm.Timezone) == false &&
string.IsNullOrWhiteSpace(sm.Currency) == false &&
sm.MarketOpen != default &&
sm.MarketClose != default &&
sm.MatchScore <= 1 && sm.MatchScore > 0
);
}
}
public async Task ReturnEmptyCollection_OnMeaninglessKeyword()
{
using var client = new AlphaVantageClient(_apiKey);
using var stocksClient = client.Stocks();
var searchMatches = await stocksClient.SearchSymbolAsync("wrong_symbol_name");
searchMatches.Should().NotBeNull().And.BeEmpty();
}
public async Task ThrowException_OnNonExistingSymbol()
{
using var client = new AlphaVantageClient(_apiKey);
using var stocksClient = client.Stocks();
await Assert.ThrowsAsync <AlphaVantageParsingException>(async() =>
{
await stocksClient.GetGlobalQuoteAsync("wrong_symbol_name");
});
}
public async Task GetSingleQuoteData_ShouldReturnQueryResultWithError_WhenHttpRequestNotOK()
{
var client = new AlphaVantageClient(_mockHttpFactory.Object, _mockAlphaVantageOptionsAccessor.Object, _mockParserFactory.Object, _mockLogger.Object);
SetupMockHttpClient("", HttpStatusCode.Unauthorized);
var query = new SingleQuoteQuery(-1);
var queryResult = await client.GetSingleQuoteData(query, "MSFT", "NASDAQ");
Assert.True(queryResult.HasError);
}
public async Task ReturnValidResult_IfRequestVwapForIntradayInterval(Interval interval)
{
using var client = new AlphaVantageClient(_apiKey);
var symbol = "IBM";
var indicatorType = TechIndicatorType.VWAP;
var result = await client.GetTechIndicatorTimeSeriesAsync(symbol, indicatorType, interval);
AssertTechIndicatorResultValid(result, interval, indicatorType, 1);
}
public async Task ThrowException_IfRequestVwapNotForIntradayInterval(Interval interval)
{
using var client = new AlphaVantageClient(_apiKey);
var symbol = "IBM";
var indicatorType = TechIndicatorType.VWAP;
await Assert.ThrowsAsync <AlphaVantageException>(async() =>
{
await client.GetTechIndicatorTimeSeriesAsync(symbol, indicatorType, interval);
});
}
public async Task ThrowExceptionOnIncorrectRequest()
{
const ApiFunction function = ApiFunction.TIME_SERIES_INTRADAY;
var query = GetQuery("wrong_symbol", "15min");
using var client = new AlphaVantageClient(_apiKey);
await Assert.ThrowsAsync <AlphaVantageException>(async() =>
{
await client.RequestParsedJsonAsync(function, query);
});
}
public async Task ReturnJsonString_OnCorrectRequest_WithoutClean()
{
const ApiFunction function = ApiFunction.TIME_SERIES_INTRADAY;
var query = GetQuery("AAPL", "15min");
using var client = new AlphaVantageClient(_apiKey);
var response = await client.RequestPureJsonAsync(function, query);
response
.Should().NotBeNull()
.And
.Contain("Time Series (15min)");
}
public async Task ThrowException_ForIntradayIntervals(Interval interval)
{
using var client = new AlphaVantageClient(_apiKey);
using var cryptoClient = client.Crypto();
var fromCurrency = DigitalCurrency.BTC;
var toCurrency = PhysicalCurrency.ILS;
await Assert.ThrowsAsync <AlphaVantageException>(async() =>
{
await cryptoClient.GetTimeSeriesAsync(fromCurrency, toCurrency, interval);
});
}
public async Task TestDefaultClient()
{
//setup
var ticker = "IBM";
var retriever = new AlphaVantageClient("demo");
//execute
var result = await retriever.GetStockOverview(ticker);
//validate
Assert.NotNull(result);
Assert.Equal(ticker, result.Symbol);
}
public async Task GetSingleQuoteData_ShouldReturnQueryResultWithError_WhenParsingError()
{
var query = new SingleQuoteQuery(-1);
var client = new AlphaVantageClient(_mockHttpFactory.Object, _mockAlphaVantageOptionsAccessor.Object, _mockParserFactory.Object, _mockLogger.Object);
SetupMockHttpClient("", HttpStatusCode.OK);
_singleQuoteDataCsvParser.Setup(x => x.ParseJson(It.IsAny <int>(), It.IsAny <string>())).Throws(new Exception());
var queryResult = await client.GetSingleQuoteData(query, "MSFT", "NASDAQ");
Assert.True(queryResult.HasError);
Assert.NotNull(queryResult.ErrorMessage);
}
public async Task ReturnValidResult_WithMultipleParameters(Interval interval)
{
using var client = new AlphaVantageClient(_apiKey);
var symbol = "IBM";
var indicatorType = TechIndicatorType.BBANDS;
var query = new Dictionary <string, string>()
{
{ "time_period", "20" },
{ "series_type", "close" }
};
var result = await client.GetTechIndicatorTimeSeriesAsync(symbol, indicatorType, interval, query);
AssertTechIndicatorResultValid(result, interval, indicatorType, 3);
}
public async Task ReturnJsonDocument_OnCorrectRequest_WithoutClean()
{
const ApiFunction function = ApiFunction.TIME_SERIES_INTRADAY;
var query = GetQuery("AAPL", "15min");
using var client = new AlphaVantageClient(_apiKey);
var response = await client.RequestParsedJsonAsync(function, query);
response
.Should().NotBeNull()
.And
.Match <JsonDocument>(
resp => resp.RootElement.EnumerateObject()
.LastOrDefault().NameEquals("Time Series (15min)")
);
}
public static async Task CryptoDemo()
{
// use your AlphaVantage API key
string apiKey = "1";
// there are 5 more constructors available
using var client = new AlphaVantageClient(apiKey);
using var cryptoClient = client.Crypto();
CryptoTimeSeries cryptoTimeSeries =
await cryptoClient.GetTimeSeriesAsync(DigitalCurrency.BTC, PhysicalCurrency.ILS, Interval.Weekly);
CryptoRating cryptoRating = await cryptoClient.GetCryptoRatingAsync(DigitalCurrency.BTC);
CryptoExchangeRate exchangeRate =
await cryptoClient.GetExchangeRateAsync(DigitalCurrency.BTC, PhysicalCurrency.ILS);
}
public static async Task ForexDemo()
{
// use your AlphaVantage API key
string apiKey = "1";
// there are 5 more constructors available
using var client = new AlphaVantageClient(apiKey);
using var forexClient = client.Forex();
ForexTimeSeries forexTimeSeries = await forexClient.GetTimeSeriesAsync(
PhysicalCurrency.USD,
PhysicalCurrency.ILS,
Interval.Daily,
OutputSize.Compact);
ForexExchangeRate forexExchangeRate = await forexClient.GetExchangeRateAsync(PhysicalCurrency.USD, PhysicalCurrency.ILS);
}
public async Task ReturnResultWithSameTypeAsParser()
{
var function = ApiFunction.TIME_SERIES_INTRADAY;
var symbol = "AAPL";
var interval = "15min";
var query = new Dictionary <string, string>()
{
{ nameof(symbol), symbol },
{ nameof(interval), interval }
};
using var client = new AlphaVantageClient(_apiKey);
using var typedClient = new TestTypedAlphaVantageClient(client);
var typedResponse = await typedClient.RequestApiAsync(new TestParser(), function, query);
typedResponse.Should().BeOfType <string>().And.Be("Meta Data");
}
public static async void Run([TimerTrigger("0 */1 * * * *")] TimerInfo myTimer, ILogger log)
{
log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
log.LogInformation("BEGIN GetTimeSeriesDailyAdjusted");
string apiKey = System.Environment.GetEnvironmentVariable("AlphaVantageAPIKey", EnvironmentVariableTarget.Process);
AlphaVantageClient client = new AlphaVantageClient(apiKey, "compact");
var data = await client.GetTimeSeriesDailyAdjusted("MSFT");
string connectionString = System.Environment.GetEnvironmentVariable("AzureStorageConnectionString", EnvironmentVariableTarget.Process);
string containerName = System.Environment.GetEnvironmentVariable("AzureStorageContainer", EnvironmentVariableTarget.Process);
AlphaVantageStorage alphaVantageStorage = new AlphaVantageStorage(connectionString, containerName);
await alphaVantageStorage.TimeSeriesDailyAdjustedLoad(data);
log.LogInformation("END GetTimeSeriesDailyAdjusted");
}
