influxdb-client 1.7.0.pre.1015 → 1.8.0.pre.1240

data/test/influxdb/client_test.rb

@@ -30,41 +30,41 @@ class ClientTest < Minitest::Test
   end
 
   def test_client_new
-    refute_nil InfluxDB2::Client.new('http://localhost:9999', 'my-token')
+    refute_nil InfluxDB2::Client.new('http://localhost:8086', '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')
+    client1 = InfluxDB2::Client.new('http://localhost:8086', 'my-token')
+    client2 = InfluxDB2::Client.new('http://localhost:8086', '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')
+    client1 = InfluxDB2::Client.new('http://localhost:8086', 'my-token')
+    client2 = InfluxDB2::Client.new('http://localhost:8086', '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')
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token')
 
-    assert_equal 'http://localhost:9999', client.options[:url]
+    assert_equal 'http://localhost:8086', client.options[:url]
     assert_equal 'my-token', client.options[:token]
   end
 
   def test_close
-    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token')
+    client = InfluxDB2::Client.new('http://localhost:8086', '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')
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token')
 
     write_api = client.create_write_api
 
@@ -73,7 +73,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_health
-    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token', use_ssl: false)
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token', use_ssl: false)
 
     health = client.health
     assert_equal 'ready for queries and writes', health.message

data/test/influxdb/delete_api_integration_test.rb

@@ -24,7 +24,7 @@ class DeleteApiIntegrationTest < MiniTest::Test
   def setup
     WebMock.allow_net_connect!
 
-    @client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    @client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                     bucket: 'my-bucket',
                                     org: 'my-org',
                                     precision: InfluxDB2::WritePrecision::NANOSECOND,
@@ -56,6 +56,8 @@ class DeleteApiIntegrationTest < MiniTest::Test
   end
 
   def test_delete
+    # TODO: https://github.com/influxdata/influxdb/issues/19545
+    skip
     @client.create_delete_api.delete(Time.utc(2015, 10, 16, 8, 20, 15), Time.utc(2020, 10, 16, 8, 20, 15),
                                      predicate: 'location="europe"')
 
@@ -63,6 +65,8 @@ class DeleteApiIntegrationTest < MiniTest::Test
   end
 
   def test_delete_without_predicate
+    # TODO: https://github.com/influxdata/influxdb/issues/19545
+    skip
     @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

data/test/influxdb/delete_api_test.rb

@@ -26,9 +26,9 @@ class DeleteApiTest < MiniTest::Test
   end
 
   def test_delete
-    stub_request(:any, 'http://localhost:9999/api/v2/delete?bucket=my-bucket&org=my-org')
+    stub_request(:any, 'http://localhost:8086/api/v2/delete?bucket=my-bucket&org=my-org')
       .to_return(status: 204)
-    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                    bucket: 'my-bucket',
                                    org: 'my-org',
                                    precision: InfluxDB2::WritePrecision::NANOSECOND,
@@ -40,13 +40,13 @@ class DeleteApiTest < MiniTest::Test
     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)
+    assert_requested(:post, 'http://localhost:8086/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')
+    stub_request(:any, 'http://localhost:8086/api/v2/delete?bucket=my-bucket&org=my-org')
       .to_return(status: 204)
-    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                    bucket: 'my-bucket',
                                    org: 'my-org',
                                    precision: InfluxDB2::WritePrecision::NANOSECOND,
@@ -59,13 +59,13 @@ class DeleteApiTest < MiniTest::Test
     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)
+    assert_requested(:post, 'http://localhost:8086/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')
+    stub_request(:any, 'http://localhost:8086/api/v2/delete?bucket=my-bucket&org=my-org')
       .to_return(status: 204)
-    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                    bucket: 'my-bucket',
                                    org: 'my-org',
                                    precision: InfluxDB2::WritePrecision::NANOSECOND,
@@ -77,13 +77,13 @@ class DeleteApiTest < MiniTest::Test
     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)
+    assert_requested(:post, 'http://localhost:8086/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')
+    stub_request(:any, 'http://localhost:8086/api/v2/delete?bucket=my-bucket&org=my-org')
       .to_return(status: 204)
-    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                    bucket: 'my-bucket',
                                    org: 'my-org',
                                    precision: InfluxDB2::WritePrecision::NANOSECOND,
@@ -94,13 +94,13 @@ class DeleteApiTest < MiniTest::Test
 
     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)
+    assert_requested(:post, 'http://localhost:8086/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')
+    stub_request(:any, 'http://localhost:8086/api/v2/delete?bucket=my-bucket&org=my-org')
       .to_return(status: 204)
-    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                    bucket: 'my-bucket',
                                    org: 'my-org',
                                    precision: InfluxDB2::WritePrecision::NANOSECOND,
@@ -115,7 +115,7 @@ class DeleteApiTest < MiniTest::Test
       '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',
+    assert_requested(:post, 'http://localhost:8086/api/v2/delete?bucket=my-bucket&org=my-org',
                      times: 1, body: body, headers: headers)
   end
 end

data/test/influxdb/query_api_integration_test.rb

@@ -24,7 +24,7 @@ class QueryApiIntegrationTest < MiniTest::Test
   def setup
     WebMock.allow_net_connect!
 
-    @client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    @client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                     bucket: 'my-bucket',
                                     org: 'my-org',
                                     precision: InfluxDB2::WritePrecision::NANOSECOND,

data/test/influxdb/query_api_stream_test.rb

@@ -24,7 +24,7 @@ class QueryApiStreamTest < MiniTest::Test
   def setup
     WebMock.allow_net_connect!
 
-    @client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    @client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                     bucket: 'my-bucket',
                                     org: 'my-org',
                                     precision: InfluxDB2::WritePrecision::NANOSECOND,

data/test/influxdb/query_api_test.rb

@@ -35,9 +35,9 @@ class QueryApiTest < MiniTest::Test
     ',,0,1970-01-01T00:00:20Z,1970-01-01T00:00:30Z,1970-01-01T00:00:20Z,22,free,mem,B,west'
 
   def test_query_raw
-    stub_request(:post, 'http://localhost:9999/api/v2/query?org=my-org')
+    stub_request(:post, 'http://localhost:8086/api/v2/query?org=my-org')
       .to_return(body: SUCCESS_DATA)
-    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                    bucket: 'my-bucket',
                                    org: 'my-org',
                                    use_ssl: false)
@@ -50,10 +50,10 @@ class QueryApiTest < MiniTest::Test
   end
 
   def test_query
-    stub_request(:post, 'http://localhost:9999/api/v2/query?org=my-org')
+    stub_request(:post, 'http://localhost:8086/api/v2/query?org=my-org')
       .to_return(body: SUCCESS_DATA)
 
-    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                    bucket: 'my-bucket',
                                    org: 'my-org',
                                    use_ssl: false)
@@ -74,10 +74,10 @@ class QueryApiTest < MiniTest::Test
   end
 
   def test_headers
-    stub_request(:post, 'http://localhost:9999/api/v2/query?org=my-org')
+    stub_request(:post, 'http://localhost:8086/api/v2/query?org=my-org')
       .to_return(body: SUCCESS_DATA)
 
-    client = InfluxDB2::Client.new('http://localhost:9999', 'my-token',
+    client = InfluxDB2::Client.new('http://localhost:8086', 'my-token',
                                    bucket: 'my-bucket',
                                    org: 'my-org',
                                    use_ssl: false)
@@ -90,7 +90,7 @@ class QueryApiTest < MiniTest::Test
       'User-Agent' => "influxdb-client-ruby/#{InfluxDB2::VERSION}",
       'Content-Type' => 'application/json'
     }
-    assert_requested(:post, 'http://localhost:9999/api/v2/query?org=my-org',
+    assert_requested(:post, 'http://localhost:8086/api/v2/query?org=my-org',
                      times: 1, headers: headers)
   end
 end

data/test/influxdb/write_api_batching_test.rb

@@ -26,7 +26,7 @@ class WriteApiBatchingTest < MiniTest::Test
 
     @write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
                                                  batch_size: 2, flush_interval: 5_000, retry_interval: 2_000)
-    @client = InfluxDB2::Client.new('http://localhost:9999',
+    @client = InfluxDB2::Client.new('http://localhost:8086',
                                     'my-token',
                                     bucket: 'my-bucket',
                                     org: 'my-org',
@@ -68,7 +68,7 @@ class WriteApiBatchingTest < MiniTest::Test
   end
 
   def test_batch_size
-    stub_request(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
 
     @write_client.write(data: 'h2o_feet,location=coyote_creek level\\ water_level=1.0 1')
@@ -83,20 +83,20 @@ class WriteApiBatchingTest < MiniTest::Test
     request2 = "h2o_feet,location=coyote_creek level\\ water_level=3.0 3\n" \
                'h2o_feet,location=coyote_creek level\\ water_level=4.0 4'
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: request1)
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: request2)
   end
 
   def test_batch_size_group_by
-    stub_request(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
-    stub_request(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=s')
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=s')
       .to_return(status: 204)
-    stub_request(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org-a&precision=ns')
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org-a&precision=ns')
       .to_return(status: 204)
-    stub_request(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket2&org=my-org-a&precision=ns')
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket2&org=my-org-a&precision=ns')
       .to_return(status: 204)
 
     bucket = 'my-bucket'
@@ -113,21 +113,21 @@ class WriteApiBatchingTest < MiniTest::Test
 
     sleep(1)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: 'h2o_feet,location=coyote_creek level\\ water_level=1.0 1')
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=s',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=s',
                      times: 1, body: 'h2o_feet,location=coyote_creek level\\ water_level=2.0 2')
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org-a&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org-a&precision=ns',
                      times: 1, body: "h2o_feet,location=coyote_creek level\\ water_level=3.0 3\n" \
                     'h2o_feet,location=coyote_creek level\\ water_level=4.0 4')
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket2&org=my-org-a&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket2&org=my-org-a&precision=ns',
                      times: 1, body: 'h2o_feet,location=coyote_creek level\\ water_level=5.0 5')
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org-a&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org-a&precision=ns',
                      times: 1, body: 'h2o_feet,location=coyote_creek level\\ water_level=6.0 6')
   end
 
   def test_flush_interval
-    stub_request(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
 
     request1 = "h2o_feet,location=coyote_creek level\\ water_level=1.0 1\n" \
@@ -139,31 +139,31 @@ class WriteApiBatchingTest < MiniTest::Test
 
     sleep(1)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: request1)
 
     @write_client.write(data: 'h2o_feet,location=coyote_creek level\\ water_level=3.0 3')
 
     sleep(2)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 0, body: request2)
 
     sleep(3)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: request2)
   end
 
   def test_flush_all_by_close_client
-    stub_request(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 204)
 
     @client.close!
 
     @write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
                                                  batch_size: 10, flush_interval: 5_000)
-    @client = InfluxDB2::Client.new('http://localhost:9999',
+    @client = InfluxDB2::Client.new('http://localhost:8086',
                                     'my-token',
                                     bucket: 'my-bucket',
                                     org: 'my-org',
@@ -176,22 +176,81 @@ class WriteApiBatchingTest < MiniTest::Test
     @write_client.write(data: 'h2o_feet,location=coyote_creek level\\ water_level=2.0 2')
     @write_client.write(data: 'h2o_feet,location=coyote_creek level\\ water_level=3.0 3')
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 0, body: 'h2o_feet,location=coyote_creek level\\ water_level=3.0 3')
 
     @client.close!
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: "h2o_feet,location=coyote_creek level\\ water_level=1.0 1\n" \
                      "h2o_feet,location=coyote_creek level\\ water_level=2.0 2\n" \
                      'h2o_feet,location=coyote_creek level\\ water_level=3.0 3')
   end
 
+  def test_jitter_interval
+    @client.close!
+
+    @client = InfluxDB2::Client.new('http://localhost:8086',
+                                    'my-token',
+                                    bucket: 'my-bucket',
+                                    org: 'my-org',
+                                    precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                    use_ssl: false)
+
+    @write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
+                                                 batch_size: 2, flush_interval: 5_000, jitter_interval: 2_000)
+    @write_client = @client.create_write_api(write_options: @write_options)
+
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 204)
+
+    request = "h2o_feet,location=coyote_creek water_level=1.0 1\n" \
+               'h2o_feet,location=coyote_creek water_level=2.0 2'
+
+    @write_client.write(data: ['h2o_feet,location=coyote_creek water_level=1.0 1',
+                               'h2o_feet,location=coyote_creek water_level=2.0 2'])
+
+    sleep(0.05)
+
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 0, body: request)
+
+    sleep(2)
+
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 1, body: request)
+  end
+end
+
+class WriteApiRetryStrategyTest < MiniTest::Test
+  def setup
+    WebMock.disable_net_connect!
+
+    @write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
+                                                 batch_size: 2, flush_interval: 5_000, retry_interval: 2_000)
+    @client = InfluxDB2::Client.new('http://localhost:8086',
+                                    'my-token',
+                                    bucket: 'my-bucket',
+                                    org: 'my-org',
+                                    precision: InfluxDB2::WritePrecision::NANOSECOND,
+                                    use_ssl: false)
+
+    @write_client = @client.create_write_api(write_options: @write_options)
+  end
+
+  def teardown
+    @client.close!
+
+    assert_equal true, @write_client.closed
+
+    WebMock.reset!
+  end
+
   def test_retry_interval_by_config
     error_body = '{"code":"temporarily unavailable","message":"Token is temporarily over quota. '\
                  'The Retry-After header describes when to try the write again."}'
 
-    stub_request(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 429, headers: { 'X-Platform-Error-Code' => 'temporarily unavailable' }, body: error_body).then
       .to_return(status: 204)
 
@@ -203,17 +262,17 @@ class WriteApiBatchingTest < MiniTest::Test
 
     sleep(0.5)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: request)
 
     sleep(1)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: request)
 
-    sleep(1)
+    sleep(5)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 2, body: request)
   end
 
@@ -221,7 +280,7 @@ class WriteApiBatchingTest < MiniTest::Test
     error_body = '{"code":"temporarily unavailable","message":"Server is temporarily unavailable to accept writes. '\
                  'The Retry-After header describes when to try the write again."}'
 
-    stub_request(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
       .to_return(status: 503, headers: { 'X-Platform-Error-Code' => 'temporarily unavailable', 'Retry-After' => '3' },
                  body: error_body).then
       .to_return(status: 204)
@@ -237,56 +296,253 @@ class WriteApiBatchingTest < MiniTest::Test
 
     sleep(0.5)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: request)
 
     sleep(1)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: request)
 
     sleep(1)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: request)
 
     sleep(1)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 2, body: request)
   end
 
-  def test_jitter_interval
-    @client.close!
+  def test_max_retries
+    error_body = '{"code":"temporarily unavailable","message":"Server is temporarily unavailable to accept writes. '\
+                 'The Retry-After header describes when to try the write again."}'
 
-    @client = InfluxDB2::Client.new('http://localhost:9999',
-                                    'my-token',
-                                    bucket: 'my-bucket',
-                                    org: 'my-org',
-                                    precision: InfluxDB2::WritePrecision::NANOSECOND,
-                                    use_ssl: false)
+    headers = { 'X-Platform-Error-Code' => 'temporarily unavailable' }
 
-    @write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
-                                                 batch_size: 2, flush_interval: 5_000, jitter_interval: 2_000)
-    @write_client = @client.create_write_api(write_options: @write_options)
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 429, headers: headers, body: error_body).then # retry
+      .to_return(status: 429, headers: headers, body: error_body).then # retry
+      .to_return(status: 429, headers: headers, body: error_body).then # retry
+      .to_return(status: 429, headers: headers, body: error_body).then # retry
+      .to_return(status: 429, headers: headers, body: error_body) # not called
+
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2.0)
+
+    request = 'h2o,location=europe level=2.0'
+
+    write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
+                                                batch_size: 1, retry_interval: 2_000, max_retries: 3,
+                                                max_retry_delay: 5_000, exponential_base: 2)
+
+    error = assert_raises InfluxDB2::InfluxError do
+      @client.create_write_api(write_options: write_options).write(data: point)
+
+      sleep(0.5)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 1, body: request)
+
+      sleep(2)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 2, body: request)
+
+      sleep(4)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 3, body: request)
 
-    stub_request(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      sleep(5)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 4, body: request)
+
+      sleep(5)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 4, body: request)
+
+      sleep(5)
+    end
+
+    assert_equal('429', error.code)
+
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 4, body: request)
+  end
+
+  def test_influx_exception
+    error_body = '{"code":"invalid","message":"unable to parse '\
+                 '\'h2o_feet, location=coyote_creek water_level=1.0 1\': missing tag key"}'
+
+    stub_request(:any, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 400, headers: { 'X-Platform-Error-Code' => 'invalid' }, body: error_body)
+
+    write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
+                                                batch_size: 1, retry_interval: 2_000, max_retries: 3,
+                                                max_retry_delay: 5_000, exponential_base: 2)
+
+    error = assert_raises InfluxDB2::InfluxError do
+      @client.create_write_api(write_options: write_options).write(data: 'h2o,location=west value=33i 15')
+
+      sleep(1)
+    end
+
+    assert_equal '400', error.code
+    assert_equal 'invalid', error.reference
+    assert_equal "unable to parse 'h2o_feet, location=coyote_creek water_level=1.0 1': missing tag key", error.message
+  end
+
+  def test_max_retries_by_header
+    error_body = '{"code":"temporarily unavailable","message":"Server is temporarily unavailable to accept writes. '\
+                 'The Retry-After header describes when to try the write again."}'
+
+    headers = { 'X-Platform-Error-Code' => 'temporarily unavailable', 'Retry-After' => '3' }
+
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_return(status: 429, headers: headers, body: error_body).then # retry
+      .to_return(status: 429, headers: headers, body: error_body).then # retry
+      .to_return(status: 429, headers: headers, body: error_body).then # retry
+      .to_return(status: 429, headers: headers, body: error_body).then # retry
+      .to_return(status: 429, headers: headers, body: error_body) # not called
+
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2.0)
+
+    request = 'h2o,location=europe level=2.0'
+
+    write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
+                                                batch_size: 1, retry_interval: 2_000, max_retries: 3,
+                                                max_retry_delay: 5_000, exponential_base: 2)
+
+    error = assert_raises InfluxDB2::InfluxError do
+      @client.create_write_api(write_options: write_options).write(data: point)
+
+      sleep(0.5)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 1, body: request)
+
+      sleep(3)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 2, body: request)
+
+      sleep(3)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 3, body: request)
+
+      sleep(3)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 4, body: request)
+
+      sleep(3)
+    end
+
+    assert_equal('429', error.code)
+
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 4, body: request)
+  end
+
+  def test_connection_error
+    error_message = 'Failed to open TCP connection to localhost:8086' \
+        '(Connection refused - connect(2) for "localhost" port 8086)'
+
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_raise(Errno::ECONNREFUSED.new(error_message))
+      .to_raise(Errno::ECONNREFUSED.new(error_message))
+      .to_raise(Errno::ECONNREFUSED.new(error_message))
+      .to_raise(Errno::ECONNREFUSED.new(error_message))
+      .to_raise(Errno::ECONNREFUSED.new(error_message))
+
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2.0)
+
+    request = 'h2o,location=europe level=2.0'
+
+    write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
+                                                batch_size: 1, retry_interval: 2_000, max_retries: 3,
+                                                max_retry_delay: 5_000, exponential_base: 2)
+
+    error = assert_raises InfluxDB2::InfluxError do
+      @client.create_write_api(write_options: write_options).write(data: point)
+
+      sleep(0.5)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 1, body: request)
+
+      sleep(2)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 2, body: request)
+
+      sleep(4)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 3, body: request)
+
+      sleep(5)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 4, body: request)
+
+      sleep(5)
+
+      assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                       times: 4, body: request)
+
+      sleep(5)
+    end
+
+    assert_equal('Connection refused - ' + error_message, error.message)
+  end
+
+  def test_write_connection_error
+    stub_request(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns')
+      .to_raise(Errno::ECONNREFUSED.new(''))
+      .to_raise(Errno::ECONNREFUSED.new(''))
       .to_return(status: 204)
 
-    request = "h2o_feet,location=coyote_creek water_level=1.0 1\n" \
-               'h2o_feet,location=coyote_creek water_level=2.0 2'
+    point = InfluxDB2::Point.new(name: 'h2o')
+                            .add_tag('location', 'europe')
+                            .add_field('level', 2.0)
 
-    @write_client.write(data: ['h2o_feet,location=coyote_creek water_level=1.0 1',
-                               'h2o_feet,location=coyote_creek water_level=2.0 2'])
+    request = 'h2o,location=europe level=2.0'
 
-    sleep(0.05)
+    write_options = InfluxDB2::WriteOptions.new(write_type: InfluxDB2::WriteType::BATCHING,
+                                                batch_size: 1, retry_interval: 2_000, max_retries: 3,
+                                                max_retry_delay: 5_000, exponential_base: 2)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
-                     times: 0, body: request)
+    @client.create_write_api(write_options: write_options).write(data: point)
 
-    sleep(2)
+    sleep(0.5)
 
-    assert_requested(:post, 'http://localhost:9999/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
                      times: 1, body: request)
+
+    sleep(2)
+
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 2, body: request)
+
+    sleep(4)
+
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 3, body: request)
+
+    sleep(5)
+
+    assert_requested(:post, 'http://localhost:8086/api/v2/write?bucket=my-bucket&org=my-org&precision=ns',
+                     times: 3, body: request)
   end
 end