public async Task Should_Write_Read_And_Delete_Typed_Data_With_Timezones()
{
for (int i = 0; i < 2; i++)
{
var start = new DateTime(2011, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 250, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "otherData1", infos);
var from = start;
var to = from.AddSeconds(250);
var resultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM otherData1 WHERE '{from.ToIso8601()}' <= time AND time < '{to.ToIso8601()}' tz('Europe/Copenhagen')");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(250, series.Rows.Count);
// attempt deletion
await _client.DeleteRangeAsync(InfluxClientFixture.DatabaseName, "otherData1", from, to);
resultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM otherData1 WHERE '{from.ToIso8601()}' <= time AND time < '{to.ToIso8601()}' tz('Europe/Copenhagen')");
Assert.Equal(1, resultSet.Results.Count);
result = resultSet.Results[0];
Assert.Equal(0, result.Series.Count);
}
}
public async Task Should_Write_And_Query_Typed_Data()
{
var start = new DateTime(2013, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 500, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "computerInfo5", infos);
var from = start;
var to = from.AddSeconds(250);
var resultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM computerInfo5 WHERE '{from.ToIso8601()}' <= time AND time < '{to.ToIso8601()}'");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(250, series.Rows.Count);
// attempt deletion
await _client.DeleteRangeAsync(InfluxClientFixture.DatabaseName, "computerInfo5", from, to);
resultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM computerInfo5 WHERE '{from.ToIso8601()}' <= time AND time < '{to.ToIso8601()}'");
Assert.Equal(1, resultSet.Results.Count);
result = resultSet.Results[0];
Assert.Equal(0, result.Series.Count);
}
public async Task Should_Write_Named_Dynamic_Rows_To_Database()
{
var infos = InfluxClientFixture.CreateNamedDynamicRowsStartingAt("namedComputerInfo", new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc), 500);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, infos);
var resultSet = await _client.ReadAsync <NamedDynamicInfluxRow>(InfluxClientFixture.DatabaseName, "SELECT * FROM namedComputerInfo");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(500, series.Rows.Count);
foreach (var row in series.Rows)
{
Assert.Equal("namedComputerInfo", row.MeasurementName);
Assert.Equal(typeof(double), row.GetField("cpu").GetType());
Assert.Equal(typeof(long), row.GetField("ram").GetType());
Assert.Equal(typeof(double), row.GetField("cpuAsDecimal").GetType());
Assert.Equal(typeof(string), row.GetField("timez").GetType());
}
}
public async Task Should_Write_Query_With_String_Binding(int rows, int startYear, string tableName)
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(startYear, 1, 1, 1, 1, 1, DateTimeKind.Utc), rows, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, tableName, infos);
var secondResultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"select * from {tableName} where host = $host", new { host = InfluxClientFixture.Hosts[0] });
var result = secondResultSet.Results[0];
Assert.Equal(1, result.Series.Count);
}
public async Task Should_Write_And_Read_Data_From_Non_Default_RP_With_ShardGroupDuration()
{
_client.CreateRetentionPolicyAsync(InfluxClientFixture.DatabaseName, RpWithShardGroupName, "1d", 1, "1h", false).Wait();
var rps = await _client.ShowRetentionPoliciesAsync(InfluxClientFixture.DatabaseName);
Assert.True(rps.Succeeded);
Assert.Equal(1, rps.Series.Count);
var rpSeries = rps.Series[0];
Assert.Equal(2, rpSeries.Rows.Count);
var policy = rpSeries.Rows.FirstOrDefault(row => row.Name == RpWithShardGroupName);
Assert.NotNull(policy);
if (!(policy.Duration == "1d" || policy.Duration == "24h0m0s"))
{
Assert.True(false);
}
//Assert.Equal( "1d", policy.Duration );
if (!(policy.ShardGroupDuration == "1h" || policy.ShardGroupDuration == "1h0m0s"))
{
Assert.True(false);
}
//Assert.Equal( "1h", policy.ShardGroupDuration );
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(DateTime.UtcNow.AddHours(-2), 2 * 60 * 60, false);
var options = new InfluxWriteOptions
{
RetentionPolicy = RpWithShardGroupName
};
_client.WriteAsync(InfluxClientFixture.DatabaseName, MeasurementName, infos, options).Wait();
var resultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM {RpWithShardGroupName}.{MeasurementName}");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(2 * 60 * 60, series.Rows.Count);
await _client.DropRetentionPolicyAsync(InfluxClientFixture.DatabaseName, RpWithShardGroupName);
}
public async Task Should_Show_Series()
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(2010, 1, 1, 1, 1, 1, DateTimeKind.Utc), 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "set1Measurement", infos);
var result = await _client.ShowSeriesAsync <ComputerInfoMeta>(InfluxClientFixture.DatabaseName, "set1Measurement");
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(10, series.Rows.Count);
}
public async Task Should_Show_Measurements()
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc), 200, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "set2Measurement", infos);
var result = await _client.ShowMeasurementsAsync(InfluxClientFixture.DatabaseName);
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Contains(series.Rows, x => x.Name == "set2Measurement");
}
public async Task Should_Show_Tag_Keys()
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(2012, 1, 1, 1, 1, 1, DateTimeKind.Utc), 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "set3Measurement", infos);
var result = await _client.ShowTagKeysAsync(InfluxClientFixture.DatabaseName, "set3Measurement");
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Contains(series.Rows, x => x.TagKey == "host");
Assert.Contains(series.Rows, x => x.TagKey == "region");
}
public async Task Should_Write_Typed_Rows_To_Database(int rows, int startYear, string tableName)
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(startYear, 1, 1, 1, 1, 1, DateTimeKind.Utc), rows, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, tableName, infos);
var secondResultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"select * from {tableName}");
var result = secondResultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(rows, series.Rows.Count);
}
public async Task Should_Show_Tag_Values()
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(2014, 1, 1, 1, 1, 1, DateTimeKind.Utc), 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "set5Measurement", infos);
var result = await _client.ShowTagValuesAsync <RegionRow>(InfluxClientFixture.DatabaseName, "region", "set5Measurement");
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
foreach (var region in InfluxClientFixture.Regions)
{
Assert.Contains(series.Rows, x => x.Region == region);
}
}
public async Task Should_Show_Series()
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(2010, 1, 1, 1, 1, 1, DateTimeKind.Utc), 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "set1Measurement", infos);
var result = await _client.ShowSeriesAsync(InfluxClientFixture.DatabaseName, "set1Measurement");
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
foreach (var key in InfluxClientFixture.GenerateShowSeriesKeysFor("set1Measurement"))
{
Assert.Contains(key, series.Rows.Select(x => x.Key));
}
}
public async Task Should_Write_Read_And_Delete_Dynamic_Typed_Data_With_Timezones_And_Offset()
{
HashSet <TimeSpan> validOffsets = new HashSet <TimeSpan> {
TimeSpan.FromHours(1), TimeSpan.FromHours(2)
}; // valid offsets in 'Europe/Copenhagen'
var start = new DateTime(2011, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified);
var infos = InfluxClientFixture.CreateDynamicRowsStartingAtWithOffset(start, TimeSpan.FromHours(5), 250);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "otherData3", infos);
var from = start + TimeSpan.FromHours(5);
var to = from.AddSeconds(250);
var resultSet = await _client.ReadAsync <LocalizedComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM otherData3 WHERE '{from.ToIso8601()}' <= time AND time < '{to.ToIso8601()}' tz('Europe/Copenhagen')");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(250, series.Rows.Count);
// iterate all check timestamps to UTC timestamps
var current = DateTime.SpecifyKind(from, DateTimeKind.Utc);
for (int i = 0; i < 250; i++)
{
var row = series.Rows[i];
Assert.Equal(current, row.Timestamp.ToUniversalTime());
Assert.True(validOffsets.Contains(row.Timestamp.Offset));
current = current.AddSeconds(1);
}
// attempt deletion
await _client.DeleteRangeAsync(InfluxClientFixture.DatabaseName, "otherData3", from, to);
resultSet = await _client.ReadAsync <LocalizedComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM otherData3 WHERE '{from.ToIso8601()}' <= time AND time < '{to.ToIso8601()}' tz('Europe/Copenhagen')");
Assert.Equal(1, resultSet.Results.Count);
result = resultSet.Results[0];
Assert.Equal(0, result.Series.Count);
}
public async Task Should_Write_And_Query_Deferred_Grouped_Data_With_Multi_Query(int count, char c, bool useDefaultOptions)
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, count, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, $"groupedComputerInfo4{c}", infos);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, $"groupedComputerInfo5{c}", infos);
InfluxChunkedResultSet <ComputerInfo> chunkedResultSet;
if (useDefaultOptions)
{
chunkedResultSet = await _client.ReadChunkedAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo4{c} GROUP BY region;SELECT * FROM groupedComputerInfo5{c} GROUP BY region");
}
else
{
chunkedResultSet = await _client.ReadChunkedAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo4{c} GROUP BY region;SELECT * FROM groupedComputerInfo5{c} GROUP BY region", new InfluxQueryOptions { ChunkSize = 200 });
}
InfluxChunkedResult <ComputerInfo> currentResult;
InfluxChunkedSeries <ComputerInfo> currentSerie;
InfluxChunk <ComputerInfo> currentChunk;
int resultCount = 0;
int serieCount = 0;
int rowCount = 0;
using ( chunkedResultSet )
{
while ((currentResult = await chunkedResultSet.GetNextResultAsync()) != null)
{
while ((currentSerie = await currentResult.GetNextSeriesAsync()) != null)
{
while ((currentChunk = await currentSerie.GetNextChunkAsync()) != null)
{
rowCount += currentChunk.Rows.Count;
}
serieCount++;
}
resultCount++;
}
}
Assert.Equal(1 * 2, resultCount);
Assert.Equal(InfluxClientFixture.Regions.Length * 2, serieCount);
Assert.Equal(count * 2, rowCount);
}
public async Task Should_Write_Typed_Rows_To_Database_With_Chunking()
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(2010, 1, 1, 1, 1, 1, DateTimeKind.Utc), 20000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "computerInfo1", infos);
var resultSet = await _client.ReadAsync <ComputerInfo>(
InfluxClientFixture.DatabaseName,
"select * from computerInfo1",
new InfluxQueryOptions { ChunkSize = 1000 });
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(20000, series.Rows.Count);
}
public async Task Should_Write_And_Query_Grouped_On_Enumerated_Data()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateEnumeratedRowsStartingAt(start, 5000);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedEnumeratedRows", infos);
var resultSet = await _client.ReadAsync <EnumeratedRow>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedEnumeratedRows GROUP BY type");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
foreach (var type in InfluxClientFixture.TestEnums)
{
var kvp = new KeyValuePair <string, object>("type", type);
var group = result.FindGroup("groupedEnumeratedRows", new[] { kvp });
Assert.NotNull(group);
}
}
public async Task Should_Write_And_Query_Grouped_Data()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo1", infos);
var resultSet = await _client.ReadAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo1 GROUP BY region");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
foreach (var region in InfluxClientFixture.Regions)
{
var kvp = new KeyValuePair <string, object>("region", region);
var group = result.FindGroup("groupedComputerInfo1", new[] { kvp });
Assert.NotNull(group);
}
}
public async Task Should_Write_And_Query_Deferred_Grouped_Data_Breaking_2()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo9", infos);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo10", infos);
var chunkedResultSet = await _client.ReadChunkedAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo9 GROUP BY region;SELECT * FROM groupedComputerInfo10 GROUP BY region", new InfluxQueryOptions { ChunkSize = 200 });
InfluxChunkedResult <ComputerInfo> currentResult;
InfluxChunkedSeries <ComputerInfo> currentSerie;
InfluxChunk <ComputerInfo> currentChunk;
int resultCount = 0;
int serieCount = 0;
int rowCount = 0;
HashSet <string> measurements = new HashSet <string>();
using ( chunkedResultSet )
{
while ((currentResult = await chunkedResultSet.GetNextResultAsync()) != null)
{
while ((currentSerie = await currentResult.GetNextSeriesAsync()) != null)
{
while ((currentChunk = await currentSerie.GetNextChunkAsync()) != null)
{
rowCount += currentChunk.Rows.Count;
break;
}
measurements.Add(currentSerie.Name);
serieCount++;
break;
}
resultCount++;
}
}
Assert.Equal(2, resultCount);
Assert.Equal(2, serieCount);
Assert.Equal(400, rowCount);
Assert.True(measurements.Contains("groupedComputerInfo9"));
Assert.True(measurements.Contains("groupedComputerInfo10"));
}
public async Task Should_Write_And_Query_Deferred_Data()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo7", infos);
var chunkedResultSet = await _client.ReadChunkedAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo7", new InfluxQueryOptions { ChunkSize = 200 });
InfluxChunkedResult <ComputerInfo> currentResult;
InfluxChunkedSeries <ComputerInfo> currentSerie;
InfluxChunk <ComputerInfo> currentChunk;
int resultCount = 0;
int serieCount = 0;
int rowCount = 0;
HashSet <DateTime> times = new HashSet <DateTime>();
using ( chunkedResultSet )
{
while ((currentResult = await chunkedResultSet.GetNextResultAsync()) != null)
{
while ((currentSerie = await currentResult.GetNextSeriesAsync()) != null)
{
while ((currentChunk = await currentSerie.GetNextChunkAsync()) != null)
{
foreach (var row in currentChunk.Rows)
{
Assert.False(times.Contains(row.Timestamp));
times.Add(row.Timestamp);
}
rowCount += currentChunk.Rows.Count;
}
serieCount++;
}
resultCount++;
}
}
Assert.Equal(1, resultCount);
Assert.Equal(1, serieCount);
Assert.Equal(5000, rowCount);
}
public async Task Should_Write_Different_Types_Of_Rows_To_Database(int rows, int startYear, string tableName)
{
var start1 = new DateTime(startYear, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var typedInfos = InfluxClientFixture.CreateTypedRowsStartingAt(start1, rows, false);
var start2 = start1.AddYears(1);
var dynamicInfos = InfluxClientFixture.CreateDynamicRowsStartingAt(start1, rows);
List <object> items = new List <object>();
foreach (var t in typedInfos)
{
items.Add(t);
}
foreach (var d in dynamicInfos)
{
items.Add(d);
}
await _client.WriteAsync(InfluxClientFixture.DatabaseName, tableName, items);
}
public async Task Should_Write_And_Query_Grouped_Data_Using_Computed_Columns()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 5000, false);
var end = infos.Last().Timestamp;
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo3", infos);
var resultSet = await _client.ReadAsync <ComputedComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT MEAN(cpu) AS cpu, COUNT(ram) AS ram FROM groupedComputerInfo3 WHERE time >= '{start.ToIso8601()}' AND time <= '{end.ToIso8601()}' GROUP BY time(1ms), region fill(none)");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
foreach (var region in InfluxClientFixture.Regions)
{
var kvp = new KeyValuePair <string, object>("region", region);
var group = result.FindGroup("groupedComputerInfo3", new[] { kvp });
Assert.NotNull(group);
}
}
public async Task Should_Write_Named_Typed_Rows_To_Database()
{
var infos = InfluxClientFixture.CreateNamedTypedRowsStartingAt("namedComputerInfo1", new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc), 500);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, infos);
var resultSet = await _client.ReadAsync <NamedComputerInfo>(InfluxClientFixture.DatabaseName, "SELECT * FROM namedComputerInfo1");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(500, series.Rows.Count);
foreach (var row in series.Rows)
{
Assert.Equal("namedComputerInfo1", row.MeasurementName);
}
}
public async Task Should_Write_And_Query_Deferred_Grouped_Data_Breaking()
{
var start = new DateTime(2011, 1, 1, 1, 1, 1, DateTimeKind.Utc);
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(start, 5000, false);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "groupedComputerInfo8", infos);
var chunkedResultSet = await _client.ReadChunkedAsync <ComputerInfo>(InfluxClientFixture.DatabaseName, $"SELECT * FROM groupedComputerInfo8 GROUP BY region", new InfluxQueryOptions { ChunkSize = 200 });
InfluxChunkedResult <ComputerInfo> currentResult;
InfluxChunkedSeries <ComputerInfo> currentSerie;
InfluxChunk <ComputerInfo> currentChunk;
int resultCount = 0;
int serieCount = 0;
int rowCount = 0;
using ( chunkedResultSet )
{
while ((currentResult = await chunkedResultSet.GetNextResultAsync()) != null)
{
while ((currentSerie = await currentResult.GetNextSeriesAsync()) != null)
{
while ((currentChunk = await currentSerie.GetNextChunkAsync()) != null)
{
rowCount += currentChunk.Rows.Count;
break;
}
serieCount++;
}
resultCount++;
}
}
Assert.Equal(1, resultCount);
Assert.Equal(InfluxClientFixture.Regions.Length, serieCount);
Assert.Equal(1000, rowCount);
}
public DatabaseManagementTests(InfluxClientFixture fixture)
{
_client = fixture.Client;
}
public RawTests(InfluxClientFixture fixture)
{
_client = fixture.Client;
}
public async Task Should_Write_Dynamic_Rows_To_Database(int rows)
{
var infos = InfluxClientFixture.CreateDynamicRowsStartingAt(new DateTime(2012, 1, 1, 1, 1, 1, DateTimeKind.Utc), rows);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "computerInfo", infos);
}
public DateTimeTests(InfluxClientFixture fixture)
{
_client = fixture.Client;
}
public SchemaExplorationTests(InfluxClientFixture fixture)
{
_client = fixture.Client;
}
public ReadWriteTests(InfluxClientFixture fixture)
{
_client = fixture.Client;
}
public async Task Should_Write_Special_Dynamic_Rows_To_Database(int rows, int startYear)
{
var infos = InfluxClientFixture.CreateSpecialTypedDynamicRowsStartingAt(new DateTime(startYear, 1, 1, 1, 1, 1, DateTimeKind.Utc), rows);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "specialComputerInfo1", infos);
}
public async Task Should_Write_Typed_Rows_With_Nulls_To_Database(int rows, int startYear)
{
var infos = InfluxClientFixture.CreateTypedRowsStartingAt(new DateTime(startYear, 1, 1, 1, 1, 1, DateTimeKind.Utc), rows, true);
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "computerInfo3", infos);
}
