public void Setup()
{
_keys = GetKeys();
var client = new NexosisClient();
_sut = new ContestRepository(_keys, client);
}
public async Task ProcessesQuotas()
{
var handler = new FakeHttpMessageHandler {
ContentResult = new StringContent("{ }")
};
handler.ResponseHeaders.Add("nexosis-account-datasetcount-allotted", new[] { "100" });
handler.ResponseHeaders.Add("nexosis-account-datasetcount-current", new[] { "99" });
handler.ResponseHeaders.Add("nexosis-account-predictioncount-allotted", new[] { "50" });
handler.ResponseHeaders.Add("nexosis-account-predictioncount-current", new[] { "49" });
handler.ResponseHeaders.Add("nexosis-account-sessioncount-allotted", new[] { "1000" });
handler.ResponseHeaders.Add("nexosis-account-sessioncount-current", new[] { "999" });
var target = new NexosisClient("abcdefg", "https://nada.nexosis.com/not-here", new ApiConnection.HttpClientFactory(() => handler));
var result = await target.GetAccountBalance();
Assert.Equal(100, result.DataSetCount.Allotted);
Assert.Equal(99, result.DataSetCount.Current);
Assert.Equal(50, result.PredictionCount.Allotted);
Assert.Equal(49, result.PredictionCount.Current);
Assert.Equal(1000, result.SessionCount.Allotted);
Assert.Equal(999, result.SessionCount.Current);
}
public async Task CanHandleErrorResponse()
{
var data = new ErrorResponse
{
StatusCode = 500,
ErrorType = "SomethingWentWrong",
Message = "An error occurred",
ErrorDetails = new Dictionary <string, object> {
{ "error", "details" }
}
};
var handler = new FakeHttpMessageHandler {
ReturnStatus = HttpStatusCode.InternalServerError, ContentResult = new StringContent(JsonConvert.SerializeObject(data)),
};
var target = new NexosisClient("abcdefg", "https://nada.nexosis.com/not-here", new ApiConnection.HttpClientFactory(() => handler));
var exception = await Assert.ThrowsAsync <NexosisClientException>(async() => await target.GetAccountBalance());
Assert.Equal(HttpStatusCode.InternalServerError, exception.StatusCode);
Assert.NotNull(exception.ErrorResponse);
Assert.Equal(data.ErrorType, exception.ErrorResponse.ErrorType);
Assert.Equal(data.Message, exception.ErrorResponse.Message);
Assert.Equal(data.ErrorDetails, exception.ErrorResponse.ErrorDetails);
}
public void GetsKeyFromEnvironment()
{
Environment.SetEnvironmentVariable(NexosisClient.NexosisApiKeyEnvironmentVariable, "abcdefg");
var target = new NexosisClient();
Assert.Equal("abcdefg", target.ApiKey);
}
// gets results for a session and saves to local db
private static async Task Results(string database, Guid sessionId)
{
var api = new NexosisClient(Environment.GetEnvironmentVariable("NEXOSIS_PROD_KEY"));
var results = await api.Sessions.GetResults(sessionId);
// only save results if we actually have them
if (results.Status != Status.Completed)
{
Console.Out.WriteLine($"Unable to get results from session in {results.Status} state.");
return;
}
// save results
using (var db = OpenDatabase(database))
{
// if there is more to save, then do it
UpdateSession(sessionId, db, results);
using (var tran = db.BeginTransaction())
{
CleanResults(sessionId, db);
foreach (var item in results.Data)
{
AddResult(sessionId, db, item);
}
tran.Commit();
}
db.Close();
}
}
// pulls data from local db and submits to API
private static async Task UploadData(string database, string dataSetName, DateTimeOffset?startDate, DateTimeOffset?endDate, string source = null, string interval = "hour")
{
var columns = new Dictionary <string, ColumnMetadata>
{
{ "timestamp", new ColumnMetadata {
DataType = ColumnType.Date, Role = ColumnRole.Timestamp
} },
{ "value", new ColumnMetadata {
DataType = ColumnType.Numeric, Role = ColumnRole.Target
} }
};
var api = new NexosisClient("249c5810fd58403c9e2bfeae423a72fd"); //Environment.GetEnvironmentVariable("NEXOSIS_PROD_KEY"));
using (var db = OpenDatabase(database))
{
var measurements = LoadMeasurements(db, startDate, endDate, source, interval);
var batchSize = 5000;
// there is a limit on request size so we batch the data that is to be uploaded
for (int i = 0; i < ((measurements.Count / batchSize) + 1); i++)
{
var ds = await api.DataSets.Create(
DataSet.From(dataSetName,
new DataSetDetail {
Columns = columns, Data = measurements.Skip(i *batchSize).Take(batchSize).ToList()
}
));
Console.Out.WriteLine($"Added to data set named {ds.DataSetName}.");
}
db.Close();
}
}
public NexosisClient_TestsBase(object data)
{
JsonConvert.DefaultSettings = () => { return(new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
}); };
handler = new FakeHttpMessageHandler {
ContentResult = new StringContent(JsonConvert.SerializeObject(data))
};
target = new NexosisClient("abcdefg", baseUri.ToString(), new ApiConnection.HttpClientFactory(() => handler));
}
public async Task AddsUserAgentToRequest()
{
var handler = new FakeHttpMessageHandler {
ContentResult = new StringContent(JsonConvert.SerializeObject(new { }))
};
var target = new NexosisClient("abcdefg", "https://nada.nexosis.com/not-here", new ApiConnection.HttpClientFactory(() => handler));
await target.GetAccountBalance();
Assert.True(handler.Request.Headers.Contains("User-Agent"));
Assert.Equal(NexosisClient.ClientVersion, handler.Request.Headers.GetValues("User-Agent").First());
}
public async Task ProcessesCostAndBalance()
{
var handler = new FakeHttpMessageHandler {
ContentResult = new StringContent("{ }")
};
handler.ResponseHeaders.Add("nexosis-request-cost", new[] { "123.12 USD" });
handler.ResponseHeaders.Add("nexosis-account-balance", new[] { "999.99 USD" });
var target = new NexosisClient("abcdefg", "https://nada.nexosis.com/not-here", new ApiConnection.HttpClientFactory(() => handler));
var result = await target.GetAccountBalance();
Assert.Equal(123.12m, result.Cost.Amount);
Assert.Equal("USD", result.Cost.Currency);
Assert.Equal(999.99m, result.Balance.Amount);
Assert.Equal("USD", result.Balance.Currency);
}
// submits a forecast session
private static async Task Forecast(string database, string dataSetName, DateTimeOffset startDate, DateTimeOffset endDate, string interval = "Day")
{
var api = new NexosisClient(Environment.GetEnvironmentVariable("NEXOSIS_PROD_KEY"));
if (!Enum.TryParse(interval, /*ignoreCase*/ true, out ResultInterval parsedInterval))
{
parsedInterval = ResultInterval.Day;
}
// given the name of the dataset, the 'column' of the data to predict on and the date range, it is easy to kick it off.
var foreacstSession = await api.Sessions.CreateForecast(Sessions.Forecast(dataSetName, startDate, endDate, parsedInterval, "value"));
using (var db = OpenDatabase(database))
{
SetupSessionResults(db);
AddSessionRecord(db, foreacstSession.SessionId, dataSetName, foreacstSession.RequestedDate);
}
Console.Out.WriteLine($"Creating hourly forecast on {dataSetName} data from {startDate:O} to {endDate:O}. Session id: {foreacstSession.SessionId}");
}
public IntegrationTestFixture()
{
string baseUrl = "https://ml.nexosis.com/v1";
baseUrl = Environment.GetEnvironmentVariable(NexosisClient.NexosisApiUriEnvironmentVariable);
ForecastDataSetName = "forecast.015ce681-ca24-449d-a673-699aff25a0cc";
Client = new NexosisClient(Environment.GetEnvironmentVariable(NexosisClient.NexosisApiKeyEnvironmentVariable)
, baseUrl
, new ApiConnection.HttpClientFactory());
var dataSetTask = Client.DataSets.Create(DataSet.From(ForecastDataSetName,
DataSetGenerator.Run(DateTime.Parse("2016-01-01"), DateTime.Parse("2017-03-26"), "instances")));
dataSetTask.GetAwaiter().GetResult();
var keyedDatasetTask = Client.DataSets.Create(DataSet.From(ModelDataSetName,
DataSetGenerator.Run(90, 10, "instances")));
keyedDatasetTask.GetAwaiter().GetResult();
}
private static async Task ListItems(string listType, string database)
{
var api = new NexosisClient(Environment.GetEnvironmentVariable("NEXOSIS_PROD_KEY"));
if (listType.Equals("data", StringComparison.OrdinalIgnoreCase))
{
var results = await api.DataSets.List();
foreach (var r in results.Items)
{
Console.Out.WriteLine(r.DataSetName);
}
}
else if (listType.Equals("remote-sessions", StringComparison.OrdinalIgnoreCase))
{
var results = await api.Sessions.List();
Console.Out.WriteLine("SessionId \tRequested Date \tStart Date \tEnd Date \tType \tStatus");
foreach (var r in results.Items)
{
Console.Out.WriteLine($"{r.SessionId:D}\t{r.RequestedDate:O}\t{r.StartDate:O}\t{r.EndDate:O}\t{r.Type.ToString("G").PadRight(10)}\t{r.Status}");
}
}
else if (listType.Equals("local-sessions", StringComparison.OrdinalIgnoreCase))
{
using (var db = OpenDatabase(database))
using (var sessions = GetSessions(db))
{
Console.Out.WriteLine("SessionId \tRequested Date \tName");
while (sessions.Read())
{
Console.WriteLine($"{Guid.Parse(sessions.GetString(0)):D}\t{sessions.GetDateTime(2):O}\t{sessions.GetString(1)}");
}
}
}
}
public void CanGiveKeyWhenConstructing()
{
var target = new NexosisClient("asdfasdfasdf");
Assert.Equal("asdfasdfasdf", target.ApiKey);
}
public void AddsTrailingSlashWhenNeeded()
{
var target = new NexosisClient("alpha-bravo-delta-charlie", "https://should.have.a.slash", new ApiConnection.HttpClientFactory());
Assert.Equal("https://should.have.a.slash/", target.ConfiguredUrl);
}
