influxdb-client 1.1.0 → 1.2.0

data/lib/influxdb2/client/query_api.rb

@@ -73,7 +73,7 @@ module InfluxDB2
       uri = URI.parse(File.join(@options[:url], '/api/v2/query'))
       uri.query = URI.encode_www_form(org: org_param)
 
-      _post(payload.to_body.to_json, uri)
+      _post_json(payload.to_body.to_json, uri)
     end
 
     def _generate_payload(query, dialect)

data/lib/influxdb2/client/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module InfluxDB2
-  VERSION = '1.1.0'.freeze
+  VERSION = '1.2.0'.freeze
 end

data/lib/influxdb2/client/worker.rb

@@ -33,24 +33,36 @@ module InfluxDB2
 
       @thread_flush = Thread.new do
         until api_client.closed
-          sleep @write_options.flush_interval / 1_000
-          check_background_queue
+          sleep @write_options.flush_interval.to_f / 1_000
+          _check_background_queue
         end
       end
 
       @thread_size = Thread.new do
         until api_client.closed
-          check_background_queue(size: true) if @queue.length >= @write_options.batch_size
+          _check_background_queue(size: true) if @queue.length >= @write_options.batch_size
           sleep 0.01
         end
       end
     end
 
     def push(payload)
-      @queue.push(payload)
+      if payload.respond_to? :each
+        payload.each do |item|
+          push(item)
+        end
+      else
+        @queue.push(payload)
+      end
     end
 
-    def check_background_queue(size: false, flush_all: false)
+    def flush_all
+      _check_background_queue until @queue.empty?
+    end
+
+    private
+
+    def _check_background_queue(size: false)
       @queue_event.pop
       data = {}
       points = 0
@@ -60,7 +72,7 @@ module InfluxDB2
         return
       end
 
-      while (flush_all || points < @write_options.batch_size) && !@queue.empty?
+      while (points < @write_options.batch_size) && !@queue.empty?
         begin
           item = @queue.pop(true)
           key = item.key
@@ -68,22 +80,36 @@ module InfluxDB2
           data[key] << item.data
           points += 1
         rescue ThreadError
+          @queue_event.push(true)
           return
         end
       end
 
-      write(data) unless data.values.flatten.empty?
-      @queue_event.push(true)
+      begin
+        _write(data) unless data.values.flatten.empty?
+      ensure
+        @queue_event.push(true)
+      end
     end
 
-    def flush_all
-      check_background_queue(flush_all: true) unless @queue.empty?
+    def _write(data)
+      data.each do |key, points|
+        _write_raw(key, points)
+      end
     end
 
-    def write(data)
-      data.each do |key, points|
-        @api_client.write_raw(points.join("\n"), precision: key.precision, bucket: key.bucket, org: key.org)
+    def _write_raw(key, points)
+      if @write_options.jitter_interval.positive?
+        jitter_delay = (@write_options.jitter_interval.to_f / 1_000) * rand
+        sleep jitter_delay
       end
+      @api_client.write_raw(points.join("\n"), precision: key.precision, bucket: key.bucket, org: key.org)
+    rescue InfluxError => e
+      raise e if e.code.nil? || !(%w[429 503].include? e.code)
+
+      timeout = e.retry_after.empty? ? @write_options.retry_interval.to_f / 1_000 : e.retry_after.to_f
+      sleep timeout
+      _write_raw(key, points)
     end
   end
 end

data/lib/influxdb2/client/write_api.rb

@@ -27,17 +27,36 @@ module InfluxDB2
 
   # Creates write api configuration.
   #
-  # @param write_type: methods of write (batching, asynchronous, synchronous)
-  # @param batch_size: the number of data point to collect in batch
-  # @param flush_interval: flush data at least in this interval
   class WriteOptions
-    def initialize(write_type: WriteType::SYNCHRONOUS, batch_size: 1_000, flush_interval: 1_000)
+    # @param [WriteType] write_type: methods of write (batching, synchronous)
+    # @param [Integer] batch_size: the number of data point to collect in batch
+    # @param [Integer] flush_interval: flush data at least in this interval
+    # @param [Integer] retry_interval: number of milliseconds to retry unsuccessful write.
+    #   The retry interval is used when the InfluxDB server does not specify "Retry-After" header.
+    # @param [Integer] jitter_interval: the number of milliseconds to increase the batch flush interval
+    #   by a random amount
+    def initialize(write_type: WriteType::SYNCHRONOUS, batch_size: 1_000, flush_interval: 1_000, retry_interval: 1_000,
+                   jitter_interval: 0)
+      _check_not_negative('batch_size', batch_size)
+      _check_not_negative('flush_interval', flush_interval)
+      _check_not_negative('retry_interval', retry_interval)
+      _check_positive('jitter_interval', jitter_interval)
       @write_type = write_type
       @batch_size = batch_size
       @flush_interval = flush_interval
+      @retry_interval = retry_interval
+      @jitter_interval = jitter_interval
     end
 
-    attr_reader :write_type, :batch_size, :flush_interval
+    attr_reader :write_type, :batch_size, :flush_interval, :retry_interval, :jitter_interval
+
+    def _check_not_negative(key, value)
+      raise ArgumentError, "The '#{key}' should be positive or zero, but is: #{value}" if value <= 0
+    end
+
+    def _check_positive(key, value)
+      raise ArgumentError, "The '#{key}' should be positive number, but is: #{value}" if value < 0
+    end
   end
 
   SYNCHRONOUS = InfluxDB2::WriteOptions.new(write_type: WriteType::SYNCHRONOUS)
@@ -144,7 +163,7 @@ module InfluxDB2
       uri = URI.parse(File.join(@options[:url], '/api/v2/write'))
       uri.query = URI.encode_www_form(bucket: bucket_param, org: org_param, precision: precision_param.to_s)
 
-      _post(payload, uri)
+      _post_text(payload, uri)
     end
 
     # Item for batching queue
@@ -210,9 +229,14 @@ module InfluxDB2
       elsif data.is_a?(Hash)
         _generate_payload(Point.from_hash(data), bucket: bucket, org: org, precision: precision)
       elsif data.respond_to? :map
-        data.map do |item|
+        payloads = data.map do |item|
           _generate_payload(item, bucket: bucket, org: org, precision: precision)
-        end.reject(&:nil?).join("\n".freeze)
+        end.reject(&:nil?)
+        if @write_options.write_type == WriteType::BATCHING
+          payloads
+        else
+          payloads.join("\n".freeze)
+        end
       end
     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

@@ -323,4 +323,79 @@ class FluxCsvParserErrorTest < MiniTest::Test
 
     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