influxdb-client 1.2.0

data/test/influxdb/client_test.rb

@@ -0,0 +1,70 @@
+# The MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'test_helper'
+
+class ClientTest < Minitest::Test
+  def test_defined_version_number
+    refute_nil ::InfluxDB2::VERSION
+  end
+
+  def test_client_new
+    refute_nil InfluxDB2::Client.new('http://localhost:9999', 'my-token')
+  end
+
+  def test_client_hash
+    client1 = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
+    client2 = InfluxDB2::Client.new('http://localhost:9999', 'my-token-diff')
+
+    refute_equal client1.hash, client2.hash
+    assert_equal client1.hash, client1.hash
+  end
+
+  def test_client_eq
+    client1 = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
+    client2 = InfluxDB2::Client.new('http://localhost:9999', 'my-token-diff')
+
+    refute_equal client1, client2
+    assert_equal client1, client1
+  end
+
+  def test_client_options
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
+
+    assert_equal 'http://localhost:9999', client.options[:url]
+    assert_equal 'my-token', client.options[:token]
+  end
+
+  def test_close
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
+
+    assert_equal true, client.close!
+    assert_equal true, client.close!
+  end
+
+  def test_get_write_api
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
+
+    write_api = client.create_write_api
+
+    refute_nil write_api
+    assert_instance_of InfluxDB2::WriteApi, write_api
+  end
+end

data/test/influxdb/delete_api_integration_test.rb

@@ -0,0 +1,100 @@
+# The MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'test_helper'
+
+class DeleteApiIntegrationTest < MiniTest::Test
+  def setup
+    WebMock.allow_net_connect!
+
+    @client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                    bucket: 'my-bucket',
+                                    org: 'my-org',
+                                    precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                    use_ssl: false)
+
+    now = Time.now.utc
+    @measurement = 'h2o_delete_' + now.to_i.to_s + +now.nsec.to_s
+
+    data = [InfluxDB2::Point.new(name: @measurement)
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
+                            .time(Time.utc(2015, 10, 15, 8, 20, 15), InfluxDB2::WritePrecision::MILLISECOND),
+            InfluxDB2::Point.new(name: @measurement)
+                            .add_tag('location', 'us')
+                            .add_field('level', 2)
+                            .time(Time.utc(2016, 10, 15, 8, 20, 15), InfluxDB2::WritePrecision::MILLISECOND),
+            InfluxDB2::Point.new(name: @measurement)
+                            .add_tag('location', 'india')
+                            .add_field('level', 2)
+                            .time(Time.utc(2017, 10, 15, 8, 20, 15), InfluxDB2::WritePrecision::MILLISECOND),
+            InfluxDB2::Point.new(name: @measurement)
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2)
+                            .time(Time.utc(2018, 10, 15, 8, 20, 15), InfluxDB2::WritePrecision::MILLISECOND)]
+
+    @client.create_write_api.write(data: data, precision: InfluxDB2::WritePrecision::MILLISECOND)
+
+    assert_equal 4, _query_count
+  end
+
+  def test_delete
+    @client.create_delete_api.delete(Time.utc(2015, 10, 16, 8, 20, 15), Time.utc(2020, 10, 16, 8, 20, 15),
+                                     predicate: 'location="europe"')
+
+    assert_equal 3, _query_count
+  end
+
+  def test_delete_without_predicate
+    @client.create_delete_api.delete(Time.utc(2016, 10, 15, 7, 20, 15), Time.utc(2018, 10, 14, 8, 20, 15))
+
+    assert_equal 2, _query_count
+  end
+
+  def test_delete_all
+    @client.create_delete_api.delete(Time.utc(2010, 10, 15, 7, 20, 15), Time.utc(2020, 10, 14, 8, 20, 15))
+
+    assert_equal 0, _query_count
+  end
+
+  def test_delete_without_interval
+    error = assert_raises InfluxDB2::InfluxError do
+      @client.create_delete_api.delete(nil, nil)
+    end
+
+    assert error.message.include?('invalid request'),
+           "Error message: '#{error.message}' doesn't contains 'invalid request'"
+  end
+
+  private
+
+  def _query_count
+    query = 'from(bucket: "my-bucket") |> range(start: 0) |> ' \
+           "filter(fn: (r) => r._measurement == \"#{@measurement}\") " \
+           '|> drop(columns: ["location"]) |> count()'
+
+    table = @client.create_query_api.query(query: InfluxDB2::Query.new(query: query,
+                                                                       dialect: InfluxDB2::QueryApi::DEFAULT_DIALECT,
+                                                                       type: nil))[0]
+    return 0 if table.nil?
+
+    table.records[0].value
+  end
+end

data/test/influxdb/delete_api_test.rb

@@ -0,0 +1,121 @@
+# The MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'test_helper'
+
+class DeleteApiTest < MiniTest::Test
+  def setup
+    WebMock.disable_net_connect!
+  end
+
+  def test_delete
+    stub_request(:any, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org')
+      .to_return(status: 204)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
+
+    client.create_delete_api.delete(Time.utc(2019, 10, 15, 8, 20, 15), Time.utc(2019, 11, 15, 8, 20, 15),
+                                    predicate: 'key1="value1" AND key2="value"', bucket: 'my-bucket', org: 'my-org')
+
+    body = '{"start":"2019-10-15T08:20:15+00:00","stop":"2019-11-15T08:20:15+00:00","predicate":"key1=\"value1\" ' \
+           'AND key2=\"value\""}'
+
+    assert_requested(:post, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org', times: 1, body: body)
+  end
+
+  def test_delete_time_as_date_time
+    stub_request(:any, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org')
+      .to_return(status: 204)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
+
+    client.create_delete_api.delete(DateTime.rfc3339('2019-02-03T04:05:06+07:00'),
+                                    DateTime.rfc3339('2019-03-03T04:05:06+07:00'),
+                                    predicate: 'key1="value1" AND key2="value"', bucket: 'my-bucket', org: 'my-org')
+
+    body = '{"start":"2019-02-03T04:05:06+07:00","stop":"2019-03-03T04:05:06+07:00","predicate":"key1=\"value1\" ' \
+           'AND key2=\"value\""}'
+
+    assert_requested(:post, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org', times: 1, body: body)
+  end
+
+  def test_delete_time_as_string
+    stub_request(:any, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org')
+      .to_return(status: 204)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
+
+    client.create_delete_api.delete('2019-02-03T04:05:06+07:00',  '2019-04-03T04:05:06+07:00',
+                                    predicate: 'key1="value1" AND key2="value"', bucket: 'my-bucket', org: 'my-org')
+
+    body = '{"start":"2019-02-03T04:05:06+07:00","stop":"2019-04-03T04:05:06+07:00","predicate":"key1=\"value1\" ' \
+           'AND key2=\"value\""}'
+
+    assert_requested(:post, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org', times: 1, body: body)
+  end
+
+  def test_without_predicate
+    stub_request(:any, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org')
+      .to_return(status: 204)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
+
+    client.create_delete_api.delete('2019-02-03T04:05:06+07:00', '2019-04-03T04:05:06+07:00',
+                                    bucket: 'my-bucket', org: 'my-org')
+
+    body = '{"start":"2019-02-03T04:05:06+07:00","stop":"2019-04-03T04:05:06+07:00"}'
+
+    assert_requested(:post, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org', times: 1, body: body)
+  end
+
+  def test_user_agent_header
+    stub_request(:any, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org')
+      .to_return(status: 204)
+    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+                                   bucket: 'my-bucket',
+                                   org: 'my-org',
+                                   precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                   use_ssl: false)
+
+    client.create_delete_api.delete('2019-02-03T04:05:06+07:00', '2019-04-03T04:05:06+07:00',
+                                    bucket: 'my-bucket', org: 'my-org')
+
+    body = '{"start":"2019-02-03T04:05:06+07:00","stop":"2019-04-03T04:05:06+07:00"}'
+    headers = {
+      'Authorization' => 'Token my-token',
+      'User-Agent' => "influxdb-client-ruby/#{InfluxDB2::VERSION}",
+      'Content-Type' => 'application/json'
+    }
+    assert_requested(:post, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org',
+                     times: 1, body: body, headers: headers)
+  end
+end

data/test/influxdb/flux_csv_parser_test.rb

@@ -0,0 +1,401 @@
+# The MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'test_helper'
+
+class FluxCsvParserTest < MiniTest::Test
+  def test_multiple_values
+    data = "#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,string,string,string,string,long,long,string\n" \
+      "#group,false,false,true,true,true,true,true,true,false,false,false\n" \
+      "#default,_result,,,,,,,,,,\n" \
+      ",result,table,_start,_stop,_field,_measurement,host,region,_value2,value1,value_str\n" \
+      ",,0,1677-09-21T00:12:43.145224192Z,2018-07-16T11:21:02.547596934Z,free,mem,A,west,121,11,test\n" \
+      ",,1,1677-09-21T00:12:43.145224192Z,2018-07-16T11:21:02.547596934Z,free,mem,B,west,484,22,test\n" \
+      ",,2,1677-09-21T00:12:43.145224192Z,2018-07-16T11:21:02.547596934Z,usage_system,cpu,A,west,1444,38,test\n" \
+      ',,3,1677-09-21T00:12:43.145224192Z,2018-07-16T11:21:02.547596934Z,user_usage,cpu,A,west,2401,49,test'
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+
+    column_headers = tables[0].columns
+    assert_equal 11, column_headers.size
+
+    values = [false, false, true, true, true, true, true, true, false, false, false]
+    _assert_columns(column_headers, values: values)
+    assert_equal 4, tables.size
+
+    _assert_multiple_record(tables)
+  end
+
+  def test_parse_shortcut
+    data = '#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,' \
+      "dateTime:RFC3339,long,string,string,string,boolean\n" \
+      "#group,false,false,false,false,false,false,false,false,false,true\n" \
+      "#default,_result,,,,,,,,,true\n" \
+      ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,true\n"
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+
+    assert_equal 1, tables.size
+    assert_equal 1, tables[0].records.size
+
+    record = tables[0].records[0]
+
+    assert_equal _parse_time('1970-01-01T00:00:10Z'), record.start
+    assert_equal _parse_time('1970-01-01T00:00:20Z'), record.stop
+    assert_equal _parse_time('1970-01-01T00:00:10Z'), record.time
+    assert_equal 10, record.value
+    assert_equal 'free', record.field
+    assert_equal 'mem', record.measurement
+  end
+
+  def test_mapping_boolean
+    data = '#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,' \
+      "dateTime:RFC3339,long,string,string,string,boolean\n" \
+      "#group,false,false,false,false,false,false,false,false,false,true\n" \
+      "#default,_result,,,,,,,,,true\n" \
+      ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,true\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,false\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,x\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,\n"
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+    records = tables[0].records
+
+    assert_equal true, records[0].values['value']
+    assert_equal false, records[1].values['value']
+    assert_equal false, records[2].values['value']
+    assert_equal true, records[3].values['value']
+  end
+
+  def test_mapping_unsigned_long
+    data = '#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,' \
+      "dateTime:RFC3339,long,string,string,string,unsignedLong\n" \
+      "#group,false,false,false,false,false,false,false,false,false,true\n" \
+      "#default,_result,,,,,,,,,\n" \
+      ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,17916881237904312345\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,\n"
+
+    expected = 17_916_881_237_904_312_345
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+    records = tables[0].records
+
+    assert_equal expected, records[0].values['value']
+    assert_nil records[1].values['value']
+  end
+
+  def test_mapping_double
+    data = '#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,' \
+      "dateTime:RFC3339,long,string,string,string,double\n" \
+      "#group,false,false,false,false,false,false,false,false,false,true\n" \
+      "#default,_result,,,,,,,,,\n" \
+      ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,12.25\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,\n" \
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+    records = tables[0].records
+
+    assert_equal 12.25, records[0].values['value']
+    assert_nil records[1].values['value']
+  end
+
+  def test_mapping_base64_binary
+    binary_data = 'test value'
+    encoded_data = Base64.encode64(binary_data)
+
+    data = '#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,' \
+      "dateTime:RFC3339,long,string,string,string,base64Binary\n" \
+      "#group,false,false,false,false,false,false,false,false,false,true\n" \
+      "#default,_result,,,,,,,,,\n" \
+      ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n" \
+      ',,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,' + encoded_data + "\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,\n"
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+    records = tables[0].records
+
+    value = records[0].values['value']
+
+    assert !value.nil?
+    assert_equal binary_data, value
+
+    assert_nil records[1].values['value']
+  end
+
+  def test_mapping_rfc3339
+    data = '#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,' \
+      "dateTime:RFC3339,long,string,string,string,dateTime:RFC3339\n" \
+      "#group,false,false,false,false,false,false,false,false,false,true\n" \
+      "#default,_result,,,,,,,,,\n" \
+      ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,1970-01-01T00:00:10Z\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,\n"
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+    records = tables[0].records
+
+    assert_equal Time.parse('1970-01-01T00:00:10Z').to_datetime.rfc3339, records[0].values['value']
+    assert_nil records[1].values['value']
+  end
+
+  def test_mapping_duration
+    data = '#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339' \
+      ",dateTime:RFC3339,long,string,string,string,duration\n" \
+      "#group,false,false,false,false,false,false,false,false,false,true\n" \
+      "#default,_result,,,,,,,,,\n" \
+      ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,125\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,\n"
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+    records = tables[0].records
+
+    assert_equal 125, records[0].values['value']
+    assert_nil records[1].values['value']
+  end
+
+  def test_group_key
+    data = '#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,' \
+      "dateTime:RFC3339,long,string,string,string,duration\n" \
+      "#group,false,false,false,false,true,false,false,false,false,true\n" \
+      "#default,_result,,,,,,,,,\n" \
+      ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,125\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,\n" \
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+
+    assert_equal 10, tables[0].columns.size
+    assert_equal 2, tables[0].group_key.size
+  end
+
+  def test_unknown_type_as_string
+    data = '#datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,' \
+      "dateTime:RFC3339,long,string,string,string,unknown\n" \
+      "#group,false,false,false,false,false,false,false,false,false,true\n" \
+      "#default,_result,,,,,,,,,\n" \
+      ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,12.25\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,\n"
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+    records = tables[0].records
+
+    assert_equal '12.25', records[0].values['value']
+    assert_nil records[1].values['value']
+  end
+
+  private
+
+  def _parse_time(time)
+    Time.parse(time).to_datetime.rfc3339
+  end
+
+  def _assert_record(flux_record, values: nil, size: 0, value: nil)
+    values.keys.each do |key|
+      assert_equal values[key], flux_record.values[key]
+    end
+
+    if value.nil?
+      assert_nil value
+    else
+      assert_equal value, flux_record.value
+    end
+
+    assert_equal size, flux_record.values.size
+  end
+
+  def _assert_columns(column_headers, values: nil)
+    i = 0
+    values.each do |value|
+      assert_equal value, column_headers[i].group
+      i += 1
+    end
+  end
+
+  def _assert_multiple_record(tables)
+    # Record 1
+    table_records = tables[0].records
+    assert_equal 1, table_records.size
+
+    values = { 'table' => 0, 'host' => 'A', 'region' => 'west', 'value1' => 11, '_value2' => 121,
+               'value_str' => 'test' }
+
+    _assert_record(table_records[0], values: values, size: 11)
+
+    # Record 2
+    table_records = tables[1].records
+    assert_equal 1, table_records.size
+
+    values = { 'table' => 1, 'host' => 'B', 'region' => 'west', 'value1' => 22, '_value2' => 484,
+               'value_str' => 'test' }
+
+    _assert_record(table_records[0], values: values, size: 11)
+
+    # Record 3
+    table_records = tables[2].records
+    assert_equal 1, table_records.size
+
+    values = { 'table' => 2, 'host' => 'A', 'region' => 'west', 'value1' => 38, '_value2' => 1444,
+               'value_str' => 'test' }
+
+    _assert_record(table_records[0], values: values, size: 11)
+
+    # Record 4
+    table_records = tables[3].records
+    assert_equal 1, table_records.size
+
+    values = { 'table' => 3, 'host' => 'A', 'region' => 'west', 'value1' => 49, '_value2' => 2401,
+               'value_str' => 'test' }
+
+    _assert_record(table_records[0], values: values, size: 11)
+  end
+end
+
+class FluxCsvParserErrorTest < MiniTest::Test
+  def test_error
+    data = "#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,897'
+
+    parser = InfluxDB2::FluxCsvParser.new(data)
+
+    error = assert_raises InfluxDB2::FluxQueryError do
+      parser.parse
+    end
+
+    assert_equal 'failed to create physical plan: invalid time bounds from procedure from: bounds contain zero time',
+                 error.message
+    assert_equal 897, error.reference
+  end
+
+  def test_error_without_reference
+    data = "#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,'
+
+    parser = InfluxDB2::FluxCsvParser.new(data)
+
+    error = assert_raises InfluxDB2::FluxQueryError do
+      parser.parse
+    end
+
+    assert_equal 'failed to create physical plan: invalid time bounds from procedure from: bounds contain zero time',
+                 error.message
+    assert_equal 0, error.reference
+  end
+
+  def test_without_table_definition
+    data = ",result,table,_start,_stop,_time,_value,_field,_measurement,host,value\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,12.25\n" \
+      ",,0,1970-01-01T00:00:10Z,1970-01-01T00:00:20Z,1970-01-01T00:00:10Z,10,free,mem,A,\n"
+
+    parser = InfluxDB2::FluxCsvParser.new(data)
+
+    error = assert_raises InfluxDB2::FluxCsvParserError do
+      parser.parse
+    end
+
+    assert_equal 'Unable to parse CSV response. FluxTable definition was not found.', error.message
+  end
+
+  def test_multiple_queries
+    data = "#datatype,string,long,string,string,dateTime:RFC3339,dateTime:RFC3339,dateTime:RFC3339,double,string\n" \
+      "#group,false,false,true,true,true,true,false,false,true\n" \
+       "#default,t1,,,,,,,,\n" \
+       ",result,table,_field,_measurement,_start,_stop,_time,_value,tag\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:20:00Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:21:40Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:23:20Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:25:00Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:26:40Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:28:20Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:30:00Z,2,test1\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:20:00Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:21:40Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:23:20Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:25:00Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:26:40Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:28:20Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:30:00Z,2,test2\n" \
+       "\n" \
+       "#datatype,string,long,string,string,dateTime:RFC3339,dateTime:RFC3339,dateTime:RFC3339,double,string\n" \
+       "#group,false,false,true,true,true,true,false,false,true\n" \
+       "#default,t2,,,,,,,,\n" \
+       ",result,table,_field,_measurement,_start,_stop,_time,_value,tag\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:20:00Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:21:40Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:23:20Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:25:00Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:26:40Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:28:20Z,2,test1\n" \
+       ",,0,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:30:00Z,2,test1\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:20:00Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:21:40Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:23:20Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:25:00Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:26:40Z,2,test2\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:28:20Z,2,test2\n" \
+       ',,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:30:00Z,2,test2'
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+
+    assert_equal 4, tables.size
+    assert_equal 7, tables[0].records.size
+    assert_equal 7, tables[1].records.size
+    assert_equal 7, tables[2].records.size
+    assert_equal 7, tables[3].records.size
+  end
+
+  def test_table_not_start_at_zero
+    data = "#datatype,string,long,string,string,dateTime:RFC3339,dateTime:RFC3339,dateTime:RFC3339,double,string\n" \
+       "#group,false,false,true,true,true,true,false,false,true\n" \
+       "#default,t1,,,,,,,,\n" \
+       ",result,table,_field,_measurement,_start,_stop,_time,_value,tag\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:20:00Z,2,test1\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:21:40Z,2,test1\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:23:20Z,2,test1\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:25:00Z,2,test1\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:26:40Z,2,test1\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:28:20Z,2,test1\n" \
+       ",,1,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:30:00Z,2,test1\n" \
+       ",,2,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:20:00Z,2,test2\n" \
+       ",,2,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:21:40Z,2,test2\n" \
+       ",,2,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:23:20Z,2,test2\n" \
+       ",,2,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:25:00Z,2,test2\n" \
+       ",,2,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:26:40Z,2,test2\n" \
+       ",,2,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:28:20Z,2,test2\n" \
+       ',,2,value,pct,2010-02-27T04:48:32.752600083Z,2020-02-27T16:48:32.752600083Z,2020-02-27T16:30:00Z,2,test2\n'
+
+    tables = InfluxDB2::FluxCsvParser.new(data).parse.tables
+
+    assert_equal 2, tables.size
+    assert_equal 7, tables[0].records.size
+    assert_equal 7, tables[1].records.size
+  end
+end