fluent-plugin-kinesis 0.3.1

data/Rakefile

@@ -0,0 +1,23 @@
+# Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+    test.libs << 'lib' << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+end
+
+task :default => :test

data/fluent-plugin-kinesis.gemspec

@@ -0,0 +1,41 @@
+# Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "fluent/plugin/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "fluent-plugin-kinesis"
+  spec.version       = FluentPluginKinesis::VERSION
+  spec.author        = 'Amazon Web Services'
+  spec.summary       = %q{Fluentd output plugin that sends events to Amazon Kinesis.}
+  spec.homepage      = "https://github.com/awslabs/aws-kinesis-fluent-plugin"
+  spec.license       = "Apache License, Version 2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "test-unit-rr", "~> 1.0"
+
+  spec.add_dependency "fluentd", ">= 0.10.53", "< 0.13"
+  spec.add_dependency "aws-sdk-core", "~> 2.0.12"
+  spec.add_dependency "multi_json", "~> 1.0"
+  spec.add_dependency "msgpack", ">= 0.5.8"
+end

data/lib/fluent/plugin/out_kinesis.rb

@@ -0,0 +1,277 @@
+# Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'aws-sdk-core'
+require 'multi_json'
+require 'logger'
+require 'securerandom'
+require 'fluent/plugin/version'
+
+module FluentPluginKinesis
+  class OutputFilter < Fluent::BufferedOutput
+
+    include Fluent::DetachMultiProcessMixin
+    include Fluent::SetTimeKeyMixin
+    include Fluent::SetTagKeyMixin
+
+    USER_AGENT_NAME = 'fluent-plugin-kinesis-output-filter'
+    PROC_BASE_STR = 'proc {|record| %s }'
+    PUT_RECORDS_MAX_COUNT = 500
+    PUT_RECORD_MAX_DATA_SIZE = 1024 * 50
+    PUT_RECORDS_MAX_DATA_SIZE = 1024 * 1024 * 5
+
+    Fluent::Plugin.register_output('kinesis',self)
+
+    config_set_default :include_time_key, true
+    config_set_default :include_tag_key,  true
+
+    config_param :aws_key_id,  :string, default: nil
+    config_param :aws_sec_key, :string, default: nil
+    # The 'region' parameter is optional because
+    # it may be set as an environment variable.
+    config_param :region,      :string, default: nil
+
+    config_param :stream_name,            :string
+    config_param :random_partition_key,   :bool,   default: false
+    config_param :partition_key,          :string, default: nil
+    config_param :partition_key_expr,     :string, default: nil
+    config_param :explicit_hash_key,      :string, default: nil
+    config_param :explicit_hash_key_expr, :string, default: nil
+    config_param :order_events,           :bool,   default: false
+    config_param :retries_on_putrecords,  :integer, default: 3
+
+    config_param :debug, :bool, default: false
+
+    def configure(conf)
+      super
+      validate_params
+
+      if @detach_process or (@num_threads > 1)
+        @parallel_mode = true
+        if @detach_process
+          @use_detach_multi_process_mixin = true
+        end
+      else
+        @parallel_mode = false
+      end
+
+      if @parallel_mode
+        if @order_events
+          log.warn 'You have set "order_events" to true, however this configuration will be ignored due to "detach_process" and/or "num_threads".'
+        end
+        @order_events = false
+      end
+
+      if @partition_key_expr
+        partition_key_proc_str = sprintf(
+          PROC_BASE_STR, @partition_key_expr
+        )
+        @partition_key_proc = eval(partition_key_proc_str)
+      end
+
+      if @explicit_hash_key_expr
+        explicit_hash_key_proc_str = sprintf(
+          PROC_BASE_STR, @explicit_hash_key_expr
+        )
+        @explicit_hash_key_proc = eval(explicit_hash_key_proc_str)
+      end
+    end
+
+    def start
+      detach_multi_process do
+        super
+        load_client
+        check_connection_to_stream
+      end
+    end
+
+    def format(tag, time, record)
+      data = {
+        data: record.to_json,
+        partition_key: get_key(:partition_key,record)
+      }
+
+      if @explicit_hash_key or @explicit_hash_key_proc
+        data[:explicit_hash_key] = get_key(:explicit_hash_key,record)
+      end
+
+      data.to_msgpack
+    end
+
+    def write(chunk)
+      data_list = chunk.to_enum(:msgpack_each).find_all{|record|
+        unless record_exceeds_max_size?(record['data'])
+          true
+        else
+          log.error sprintf('Record exceeds the 50KB per-record size limit and will not be delivered: %s', record['data'])
+          false
+        end
+      }.map{|record|
+        build_data_to_put(record)
+      }
+
+      if @order_events
+        put_record_for_order_events(data_list)
+      else
+        records_array = build_records_array_to_put(data_list)
+        records_array.each{|records|
+          put_records_with_retry(records)
+        }
+      end
+    end
+
+    private
+    def validate_params
+      unless @random_partition_key or @partition_key or @partition_key_expr
+        raise Fluent::ConfigError, "'random_partition_key' or 'partition_key' or 'partition_key_expr' is required"
+      end
+    end
+
+    def load_client
+
+      user_agent_suffix = "#{USER_AGENT_NAME}/#{FluentPluginKinesis::VERSION}"
+
+      options = {
+        user_agent_suffix: user_agent_suffix
+      }
+
+      if @region
+        options[:region] = @region
+      end
+
+      if @aws_key_id && @aws_sec_key
+        options.update(
+          access_key_id: @aws_key_id,
+          secret_access_key: @aws_sec_key,
+        )
+      end
+
+      if @debug
+        options.update(
+          logger: Logger.new(log.out),
+          log_level: :debug
+        )
+        # XXX: Add the following options, if necessary
+        # :http_wire_trace => true
+      end
+
+      @client = Aws::Kinesis::Client.new(options)
+
+    end
+
+    def check_connection_to_stream
+      @client.describe_stream(stream_name: @stream_name)
+    end
+
+    def get_key(name, record)
+      if @random_partition_key
+        SecureRandom.uuid
+      else
+        key = instance_variable_get("@#{name}")
+        key_proc = instance_variable_get("@#{name}_proc")
+
+        value = key ? record[key] : record
+
+        if key_proc
+          value = key_proc.call(value)
+        end
+
+        value.to_s
+      end
+    end
+
+    def build_data_to_put(data)
+      Hash[data.map{|k, v| [k.to_sym, v] }]
+    end
+
+    def put_record_for_order_events(data_list)
+      sequence_number_for_ordering = nil
+      data_list.each do |data_to_put|
+        if sequence_number_for_ordering
+          data_to_put.update(
+            sequence_number_for_ordering: sequence_number_for_ordering
+          )
+        end
+        data_to_put.update(
+          stream_name: @stream_name
+        )
+        result = @client.put_record(data_to_put)
+        sequence_number_for_ordering = result[:sequence_number]
+      end
+    end
+
+    def build_records_array_to_put(data_list)
+      records_array = []
+      records = []
+      records_payload_length = 0
+      data_list.each{|data_to_put|
+        payload = data_to_put[:data]
+        if records.length >= PUT_RECORDS_MAX_COUNT or (records_payload_length + payload.length) >= PUT_RECORDS_MAX_DATA_SIZE
+          records_array.push(records)
+          records = []
+          records_payload_length = 0
+        end
+        records.push(data_to_put)
+        records_payload_length += payload.length
+      }
+      records_array.push(records)
+      records_array
+    end
+
+    def put_records_with_retry(records,retry_count=0)
+      response = @client.put_records(
+        records: records,
+        stream_name: @stream_name
+      )
+
+      if response[:failed_record_count] && response[:failed_record_count] > 0
+        failed_records = []
+        response[:records].each_with_index{|record,index|
+          if record[:error_code]
+            failed_records.push({body: records[index], error_code: record[:error_code]})
+          end
+        }
+
+        if(retry_count < @retries_on_putrecords)
+          sleep(calculate_sleep_duration(retry_count))
+          retry_count += 1
+          log.warn sprintf('Retrying to put records. Retry count: %d', retry_count)
+          put_records_with_retry(
+            failed_records.map{|record| record[:body]},
+            retry_count
+          )
+        else
+          failed_records.each{|record|
+            log.error sprintf(
+              'Could not put record, Error: %s, Record: %s',
+              record[:error_code],
+              record[:body].to_json
+            )
+          }
+        end
+      end
+    end
+
+    def calculate_sleep_duration(current_retry)
+      Array.new(@retries_on_putrecords){|n| ((2 ** n) * scaling_factor)}[current_retry]
+    end
+
+    def scaling_factor
+      0.5 + Kernel.rand * 0.1
+    end
+
+    def record_exceeds_max_size?(record_string)
+      return record_string.length > PUT_RECORD_MAX_DATA_SIZE
+    end
+  end
+end

data/lib/fluent/plugin/version.rb

@@ -0,0 +1,16 @@
+# Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module FluentPluginKinesis
+  VERSION = '0.3.1'
+end

data/test/helper.rb

@@ -0,0 +1,31 @@
+# Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'rubygems'
+require 'bundler'
+require 'stringio'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'test/unit'
+require 'test/unit/rr'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'fluent/test'
+require 'fluent/plugin/out_kinesis'

data/test/plugin/test_out_kinesis.rb

@@ -0,0 +1,407 @@
+# Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'helper'
+
+class KinesisOutputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  CONFIG = %[
+    aws_key_id test_key_id
+    aws_sec_key test_sec_key
+    stream_name test_stream
+    region us-east-1
+    partition_key test_partition_key
+  ]
+
+  def create_driver(conf = CONFIG, tag='test')
+    Fluent::Test::BufferedOutputTestDriver
+      .new(FluentPluginKinesis::OutputFilter, tag).configure(conf)
+  end
+
+  def create_mock_client
+    client = mock(Object.new)
+    mock(Aws::Kinesis::Client).new({}) { client }
+    return client
+  end
+
+  def test_configure
+    d = create_driver
+    assert_equal 'test_key_id', d.instance.aws_key_id
+    assert_equal 'test_sec_key', d.instance.aws_sec_key
+    assert_equal 'test_stream', d.instance.stream_name
+    assert_equal 'us-east-1', d.instance.region
+    assert_equal 'test_partition_key', d.instance.partition_key
+  end
+
+  def test_configure_with_more_options
+
+    conf = %[
+      stream_name test_stream
+      region us-east-1
+      partition_key test_partition_key
+      partition_key_expr record
+      explicit_hash_key test_hash_key
+      explicit_hash_key_expr record
+      order_events true
+    ]
+    d = create_driver(conf)
+    assert_equal 'test_stream', d.instance.stream_name
+    assert_equal 'us-east-1', d.instance.region
+    assert_equal 'test_partition_key', d.instance.partition_key
+    assert_equal 'Proc',
+      d.instance.instance_variable_get(:@partition_key_proc).class.to_s
+    assert_equal 'test_hash_key', d.instance.explicit_hash_key
+    assert_equal 'Proc',
+      d.instance.instance_variable_get(:@explicit_hash_key_proc).class.to_s
+    assert_equal 'a',
+      d.instance.instance_variable_get(:@partition_key_proc).call('a')
+    assert_equal 'a',
+      d.instance.instance_variable_get(:@explicit_hash_key_proc).call('a')
+    assert_equal true, d.instance.order_events
+    assert_equal nil, d.instance.instance_variable_get(:@sequence_number_for_ordering)
+  end
+
+  def test_mode_configuration
+
+    conf = %[
+      stream_name test_stream
+      region us-east-1
+      partition_key test_partition_key
+    ]
+    d = create_driver(conf)
+    assert_equal(false, d.instance.order_events)
+    assert_equal(false, d.instance.instance_variable_get(:@parallel_mode))
+
+    conf = %[
+      stream_name test_stream
+      region us-east-1
+      partition_key test_partition_key
+      order_events true
+    ]
+    d = create_driver(conf)
+    assert_equal(true, d.instance.order_events)
+    assert_equal(false, d.instance.instance_variable_get(:@parallel_mode))
+
+    conf = %[
+      stream_name test_stream
+      region us-east-1
+      partition_key test_partition_key
+      num_threads 1
+    ]
+    d = create_driver(conf)
+    assert_equal(false, d.instance.order_events)
+    assert_equal(false, d.instance.instance_variable_get(:@parallel_mode))
+
+    conf = %[
+      stream_name test_stream
+      region us-east-1
+      partition_key test_partition_key
+      num_threads 2
+    ]
+    d = create_driver(conf)
+    assert_equal(false, d.instance.order_events)
+    assert_equal(true, d.instance.instance_variable_get(:@parallel_mode))
+
+    conf = %[
+      stream_name test_stream
+      region us-east-1
+      partition_key test_partition_key
+      detach_process 1
+    ]
+    d = create_driver(conf)
+    assert_equal(false, d.instance.order_events)
+    assert_equal(true, d.instance.instance_variable_get(:@parallel_mode))
+
+    conf = %[
+      stream_name test_stream
+      region us-east-1
+      partition_key test_partition_key
+      order_events true
+      detach_process 1
+      num_threads 2
+    ]
+    d = create_driver(conf)
+    assert_equal(false, d.instance.order_events)
+    assert_equal(true, d.instance.instance_variable_get(:@parallel_mode))
+
+  end
+
+  def test_format
+
+    d = create_driver
+
+    data1 = {"test_partition_key"=>"key1","a"=>1,"time"=>"2011-01-02T13:14:15Z","tag"=>"test"}
+    data2 = {"test_partition_key"=>"key2","a"=>2,"time"=>"2011-01-02T13:14:15Z","tag"=>"test"}
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    d.emit(data1, time)
+    d.emit(data2, time)
+
+    d.expect_format({
+      'data' => data1.to_json,
+      'partition_key' => 'key1' }.to_msgpack
+    )
+    d.expect_format({
+      'data' => data2.to_json,
+      'partition_key' => 'key2' }.to_msgpack
+    )
+
+    client = create_mock_client
+    client.describe_stream(stream_name: 'test_stream')
+    client.put_records(
+      stream_name: 'test_stream',
+      records: [
+        {
+          data: data1.to_json,
+          partition_key: 'key1'
+        },
+        {
+          data: data2.to_json,
+          partition_key: 'key2'
+        }
+      ]
+    ) { {} }
+
+    d.run
+  end
+
+  def test_order_events
+
+    d = create_driver(CONFIG + "\norder_events true")
+
+    data1 = {"test_partition_key"=>"key1","a"=>1,"time"=>"2011-01-02T13:14:15Z","tag"=>"test"}
+    data2 = {"test_partition_key"=>"key2","a"=>2,"time"=>"2011-01-02T13:14:15Z","tag"=>"test"}
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    d.emit(data1, time)
+    d.emit(data2, time)
+
+    d.expect_format({
+      'data' => data1.to_json,
+      'partition_key' => 'key1' }.to_msgpack
+    )
+    d.expect_format({
+      'data' => data2.to_json,
+      'partition_key' => 'key2' }.to_msgpack
+    )
+
+    client = create_mock_client
+    client.describe_stream(stream_name: 'test_stream')
+    client.put_record(
+      data: data1.to_json,
+      partition_key: 'key1',
+      stream_name: 'test_stream'
+    ) { {sequence_number: 1} }
+    client.put_record(
+      data: data2.to_json,
+      partition_key: 'key2',
+      sequence_number_for_ordering: 1,
+      stream_name: 'test_stream'
+    ) { {} }
+
+    d.run
+  end
+
+  def test_format_at_lowlevel
+    d = create_driver
+    data = {"test_partition_key"=>"key1","a"=>1}
+    assert_equal(
+        MessagePack.pack({
+            "data"              => data.to_json,
+            "partition_key"     => "key1"
+        }),
+        d.instance.format('test','test',data)
+    )
+  end
+
+  def test_format_at_lowlevel_with_more_options
+
+    conf = %[
+      stream_name test_stream
+      region us-east-1
+      partition_key test_partition_key
+      partition_key_expr record
+      explicit_hash_key test_hash_key
+      explicit_hash_key_expr record
+      order_events true
+    ]
+
+    d = create_driver(conf)
+    data = {"test_partition_key"=>"key1","test_hash_key"=>"hash1","a"=>1}
+    assert_equal(
+        MessagePack.pack({
+            "data"              => data.to_json,
+            "partition_key"     => "key1",
+            "explicit_hash_key" => "hash1"
+        }),
+        d.instance.format('test','test',data)
+    )
+  end
+
+  def test_get_key
+    d = create_driver
+    assert_equal(
+      "1",
+      d.instance.send(:get_key, "partition_key", {"test_partition_key" => 1})
+    )
+
+    assert_equal(
+      "abc",
+      d.instance.send(:get_key, "partition_key", {"test_partition_key" => "abc"})
+    )
+
+    d = create_driver(%[
+      random_partition_key true
+      stream_name test_stream
+      region us-east-1'
+    ])
+
+    assert_match(
+      /\A[\da-f-]{36}\z/,
+      d.instance.send(:get_key, 'foo', 'bar')
+    )
+
+    d = create_driver(%[
+      random_partition_key true
+      partition_key test_key
+      stream_name test_stream
+      region us-east-1'
+    ])
+
+    assert_match(
+      /\A[\da-f-]{36}\z/,
+      d.instance.send(
+        :get_key,
+        'partition_key',
+        {"test_key" => 'key1'}
+      )
+    )
+
+    d = create_driver(%[
+      random_partition_key true
+      partition_key test_key
+      explicit_hash_key explicit_key
+      stream_name test_stream
+      region us-east-1'
+    ])
+
+    assert_match(
+      /\A[\da-f-]{36}\z/,
+      d.instance.send(
+        :get_key,
+        'partition_key',
+        {"test_key" => 'key1', "explicit_key" => 'key2'}
+      )
+    )
+  end
+
+  def test_record_exceeds_max_size
+    d = create_driver
+    string = ''
+    (1..1024).each{ string = string + '1' }
+    assert_equal(
+      false,
+      d.instance.send(:record_exceeds_max_size?,string)
+    )
+
+    string = ''
+    (1..(1024*50)).each{ string = string + '1' }
+    assert_equal(
+      false,
+      d.instance.send(:record_exceeds_max_size?,string)
+    )
+
+    string = ''
+    (1..(1024*51)).each{ string = string + '1' }
+    assert_equal(
+      true,
+      d.instance.send(:record_exceeds_max_size?,string)
+    )
+  end
+
+  def test_build_records_array_to_put
+    d = create_driver
+
+    data_list = []
+    (0..500).each do |n|
+      data_list.push({data: n.to_s})
+    end
+    result = d.instance.send(:build_records_array_to_put,data_list)
+    assert_equal(2,result.length)
+    assert_equal(500,result[0].length)
+    assert_equal(1,result[1].length)
+
+    data_list = []
+    (0..1400).each do
+      data_list.push({data: '1'})
+    end
+    result = d.instance.send(:build_records_array_to_put,data_list)
+    assert_equal(3,result.length)
+    assert_equal(500,result[0].length)
+    assert_equal(500,result[1].length)
+    assert_equal(401,result[2].length)
+
+    data_list = []
+    data_string = ''
+    (0..(1024*30)).each do
+      data_string = data_string + '1'
+    end
+    (0..500).each do
+      data_list.push({data: data_string})
+    end
+    result = d.instance.send(:build_records_array_to_put,data_list)
+    assert_equal(3,result.length)
+    assert_equal(170,result[0].length)
+    assert_operator(
+      1024 * 1024 *5, :>,
+      result[0].reduce(0){|sum,i| sum + i[:data].length}
+    )
+    assert_equal(170,result[1].length)
+    assert_operator(
+      1024 * 1024 *5, :>,
+      result[1].reduce(0){|sum,i| sum + i[:data].length}
+    )
+    assert_equal(161,result[2].length)
+    assert_operator(
+      1024 * 1024 *5, :>,
+      result[2].reduce(0){|sum,i| sum + i[:data].length}
+    )
+  end
+
+  def test_build_data_to_put
+    d = create_driver
+    assert_equal(
+      {key: 1},
+      d.instance.send(:build_data_to_put,{"key"=>1})
+    )
+  end
+
+  def test_calculate_sleep_duration
+    d = create_driver
+    assert_operator(
+        1, :>,
+        d.instance.send(:calculate_sleep_duration,0)
+    )
+    assert_operator(
+        2, :>,
+        d.instance.send(:calculate_sleep_duration,1)
+    )
+    assert_operator(
+        4, :>,
+        d.instance.send(:calculate_sleep_duration,2)
+    )
+  end
+end