public async Task Healthy()
{
MockServer.Given(Request.Create().WithPath("/ping").UsingGet())
.RespondWith(Response.Create().WithStatusCode(204));
Assert.IsTrue(await FluxClient.PingAsync());
}
public async Task VersionUnknown()
{
MockServer.Given(Request.Create().WithPath("/ping").UsingGet())
.RespondWith(Response.Create().WithStatusCode(204));
Assert.AreEqual("unknown", await FluxClient.Version());
}
private RestClient GetRestClient(FluxClient fluxClient)
{
var restClientInfo = fluxClient.GetType().GetField("RestClient", BindingFlags.NonPublic | BindingFlags.Instance);
var restClient = (RestClient)restClientInfo?.GetValue(fluxClient);
return(restClient);
}
public async Task QueryToPoco()
{
MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost())
.RespondWith(CreateResponse());
var result = await FluxClient.QueryAsync <Free>("from(bucket:\"telegraf\")");
Assert.That(result.Count == 4);
// 1
Assert.AreEqual("A", result[0].Host);
Assert.AreEqual("west", result[0].Region);
Assert.AreEqual(10L, result[0].Mem);
// 2
Assert.AreEqual("B", result[1].Host);
Assert.AreEqual("west", result[1].Region);
Assert.AreEqual(20L, result[1].Mem);
// 3
Assert.AreEqual("A", result[2].Host);
Assert.AreEqual("west", result[2].Region);
Assert.AreEqual(11L, result[2].Mem);
// 4
Assert.AreEqual("B", result[3].Host);
Assert.AreEqual("west", result[3].Region);
Assert.AreEqual(22L, result[3].Mem);
}
public async Task ServerError()
{
MockServer.Given(Request.Create().WithPath("/ping").UsingGet())
.RespondWith(CreateErrorResponse(""));
Assert.IsFalse(await FluxClient.PingAsync());
}
public async Task Version()
{
MockServer.Given(Request.Create().WithPath("/ping").UsingGet())
.RespondWith(Response.Create().WithStatusCode(204)
.WithHeader("X-Influxdb-Version", "1.7.0"));
Assert.AreEqual("1.7.0", await FluxClient.Version());
}
public async Task Query()
{
MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost())
.RespondWith(CreateResponse());
var result = await FluxClient.QueryAsync("from(bucket:\"telegraf\")");
AssertSuccessResult(result);
}
public async Task QueryRawCallbackOnError()
{
MockServer.Stop();
await FluxClient.QueryRaw("from(bucket:\"telegraf\")",
(cancellable, result) => Assert.Fail("Unreachable"),
error => CountdownEvent.Signal());
WaitToCallback();
}
async Task SetUpAsync()
{
var influxUrl = GetInfluxDbUrl();
var options = new FluxConnectionOptions(influxUrl);
FluxClient = FluxClientFactory.Create(options);
await InfluxDbQuery("CREATE DATABASE " + DatabaseName, DatabaseName);
}
public async Task QueryCallbackError()
{
MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost())
.RespondWith(CreateErrorResponse("Flux query is not valid"));
await FluxClient.QueryAsync("from(bucket:\"telegraf\")",
(cancellable, result) => Assert.Fail("Unreachable"),
error => CountdownEvent.Signal());
WaitToCallback();
}
public async Task UserAgentHeader()
{
MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost())
.RespondWith(CreateResponse());
await FluxClient.QueryAsync("from(bucket:\"telegraf\")");
var request = MockServer.LogEntries.Last();
StringAssert.StartsWith("influxdb-client-csharp/1.", request.RequestMessage.Headers["User-Agent"].First());
StringAssert.EndsWith(".0.0", request.RequestMessage.Headers["User-Agent"].First());
}
public async Task WithAuthentication()
{
FluxClient = FluxClientFactory.Create(new FluxConnectionOptions(MockServerUrl, "my-user", "my-password".ToCharArray()));
MockServer.Given(Request.Create()
.WithPath("/ping")
.WithParam("u", new ExactMatcher("my-user"))
.WithParam("p", new ExactMatcher("my-password"))
.UsingGet())
.RespondWith(Response.Create().WithStatusCode(204));
Assert.IsTrue(await FluxClient.PingAsync());
}
public async Task Error()
{
MockServer.Stop();
try
{
await FluxClient.Version();
Assert.Fail();
}
catch (InfluxException e)
{
Assert.IsNotEmpty(e.Message);
}
}
public async Task WithAuthentication()
{
FluxClient = FluxClientFactory.Create(new FluxConnectionOptions(MockServerUrl, "my-user", "my-password".ToCharArray()));
MockServer.Given(Request.Create()
.WithPath("/api/v2/query")
.WithParam("u", new ExactMatcher("my-user"))
.WithParam("p", new ExactMatcher("my-password"))
.UsingPost())
.RespondWith(CreateResponse());
var result = await FluxClient.QueryAsync("from(bucket:\"telegraf\")");
AssertSuccessResult(result);
}
public async Task QueryError()
{
MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost())
.RespondWith(CreateErrorResponse("Flux query is not valid"));
try
{
await FluxClient.QueryRawAsync("from(bucket:\"telegraf\")");
Assert.Fail();
}
catch (InfluxException e)
{
Assert.That(e.Message.Equals("Flux query is not valid"));
}
}
public async Task WithBasicAuthentication()
{
FluxClient = FluxClientFactory.Create(new FluxConnectionOptions(MockServerUrl, "my-user",
"my-password".ToCharArray(), FluxConnectionOptions.AuthenticationType.BasicAuthentication));
var auth = System.Text.Encoding.UTF8.GetBytes("my-user:my-password");
MockServer.Given(Request.Create()
.WithPath("/ping")
.WithHeader("Authorization",
new ExactMatcher("Basic " + Convert.ToBase64String(auth)))
.UsingGet())
.RespondWith(Response.Create().WithStatusCode(204));
Assert.IsTrue(await FluxClient.PingAsync());
}
public async Task QueryRawCallbackOnComplete()
{
CountdownEvent = new CountdownEvent(1);
MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost())
.RespondWith(CreateResponse());
var results = new List <string>();
await FluxClient.QueryRaw("from(bucket:\"telegraf\")", null,
(cancellable, result) => results.Add(result),
error => Assert.Fail("Unreachable"),
() => CountdownEvent.Signal());
WaitToCallback();
AssertSuccessResult(string.Join("\n", results));
}
public async Task ChunkedOneTable()
{
await PrepareChunkRecords();
var flux = FromFluxDatabase + "\n"
+ "\t|> filter(fn: (r) => r[\"_measurement\"] == \"chunked\")\n"
+ "\t|> range(start: 1970-01-01T00:00:00.000000000Z)";
await FluxClient.Query(flux, (cancellable, fluxRecord) =>
{
// +1 record
CountdownEvent.Signal();
if (CountdownEvent.CurrentCount % 100_000 == 0)
{
Trace.WriteLine($"Remaining parsed: {CountdownEvent.CurrentCount} records");
}
});
public async Task WithBasicAuthentication()
{
FluxClient = FluxClientFactory.Create(new FluxConnectionOptions(MockServerUrl, "my-user",
"my-password".ToCharArray(), FluxConnectionOptions.AuthenticationType.BasicAuthentication));
var auth = System.Text.Encoding.UTF8.GetBytes("my-user:my-password");
MockServer.Given(Request.Create()
.WithPath("/api/v2/query")
.WithHeader("Authorization",
new ExactMatcher("Basic " + Convert.ToBase64String(auth)))
.UsingPost())
.RespondWith(CreateResponse());
var result = await FluxClient.QueryAsync("from(bucket:\"telegraf\")");
AssertSuccessResult(result);
}
public async Task QueryRawCallback()
{
CountdownEvent = new CountdownEvent(8);
MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost())
.RespondWith(CreateResponse());
var results = new List <string>();
await FluxClient.QueryRaw("from(bucket:\"telegraf\")",
(cancellable, result) =>
{
results.Add(result);
CountdownEvent.Signal();
});
WaitToCallback();
Assert.That(results.Count == 8);
AssertSuccessResult(string.Join("\n", results));
}
public async Task QueryCallback()
{
CountdownEvent = new CountdownEvent(4);
MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost())
.RespondWith(CreateResponse());
var records = new List <FluxRecord>();
await FluxClient.QueryAsync("from(bucket:\"telegraf\")",
(cancellable, result) =>
{
records.Add(result);
CountdownEvent.Signal();
});
WaitToCallback();
AssertRecords(records);
}
public async Task ErrorAsStream()
{
var response = Response.Create()
.WithStatusCode(403)
.WithBody("Flux query service disabled. Verify flux-enabled=true in the [http] section of the InfluxDB config.");
MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost())
.RespondWith(response);
try
{
await FluxClient.QueryAsync("from(bucket:\"telegraf\")");
Assert.Fail();
}
catch (InfluxException e)
{
Assert.AreEqual(e.Status, 403);
Assert.AreEqual(e.Message,
"Flux query service disabled. Verify flux-enabled=true in the [http] section of the InfluxDB config.");
}
}
public async Task QueryErrorSuccessResponseWithoutReference()
{
var error = "#datatype,string,string\n"
+ "#group,true,true\n"
+ "#default,,\n"
+ ",error,reference\n"
+ ",failed to create physical plan: invalid time bounds from procedure from: bounds contain zero time,";
MockServer.Given(Request.Create().WithPath("/api/v2/query").UsingPost())
.RespondWith(CreateResponse(error));
try
{
await FluxClient.QueryAsync("from(bucket:\"telegraf\")");
Assert.Fail();
}
catch (InfluxException e)
{
Assert.That(e.Message.Equals("failed to create physical plan: invalid time bounds from procedure from: bounds contain zero time"));
}
}
public new void SetUp()
{
FluxClient = FluxClientFactory.Create(MockServerUrl);
}
public async Task NotRunningServer()
{
MockServer.Stop();
Assert.IsFalse(await FluxClient.PingAsync());
}
public void SetUp()
{
_fluxClient = FluxClientFactory.Create("http://localhost:8093");
}
