logster 2.1.0 → 2.1.1

data/test/logster/test_message.rb

@@ -1,119 +1,119 @@
-require_relative '../test_helper'
-require 'logster/message'
-
-class TestMessage < MiniTest::Test
-
-  def test_merge_similar
-    msg1 = Logster::Message.new(0, '', 'test', 10)
-    msg1.populate_from_env(a: "1", b: "2")
-
-    msg2 = Logster::Message.new(0, '', 'test', 20)
-    msg2.populate_from_env(a: "2", c: "3")
-
-    assert_equal(msg2.grouping_key, msg1.grouping_key)
-
-    msg1.merge_similar_message(msg2)
-
-    assert_equal(20, msg1.timestamp)
-    assert_equal(10, msg1.first_timestamp)
-
-    assert Array === msg1.env
-    assert_equal(msg1.env.size, 2)
-    assert({ a: "1", b: "2" } <= msg1.env[0])
-    assert({ "a" => "2", "c" => "3" } <= msg1.env[1])
-  end
-
-  def test_merge_messages_both_with_array_envs
-    msg1 = Logster::Message.new(0, '', 'test', 10)
-    msg1.env = [{ a: "aa", b: "bb" }, { c: "cc", d: "dd" }]
-
-    msg2 = Logster::Message.new(0, '', 'test', 20)
-    msg2.env = [{ e: "ee", f: "ff" }, { g: "gg", h: "hh" }]
-
-    msg1.merge_similar_message(msg2)
-
-    # new env should be an array, but it should never have
-    # another array of envs within itself (hence flatten(1))
-    assert_equal(msg1.env.size, 4)
-    assert_equal(msg1.env.map(&:keys).flatten(1).map(&:to_s), %w{a b c d e f g h})
-    assert_equal(msg1.env.map(&:values).flatten(1).map(&:to_s), %w{aa bb cc dd ee ff gg hh})
-  end
-
-  def test_merge_messages_one_with_array_envs
-    msg1 = Logster::Message.new(0, '', 'test', 10)
-    msg1.env = [{ a: "aa", b: "bb" }, { c: "cc", d: "dd" }]
-
-    msg2 = Logster::Message.new(0, '', 'test', 20)
-    msg2.env = { e: "ee", f: "ff" }
-
-    msg1.merge_similar_message(msg2)
-
-    assert_equal(msg1.env.size, 3)
-    assert_equal(msg1.env.map(&:keys).flatten(1).map(&:to_s), %w{a b c d e f})
-    assert_equal(msg1.env.map(&:values).flatten(1).map(&:to_s), %w{aa bb cc dd ee ff})
-  end
-
-  def test_adds_application_version
-    Logster.config.application_version = "abc"
-    msg = Logster::Message.new(0, '', 'test', 10)
-    msg.populate_from_env({})
-
-    assert_equal("abc", msg.env["application_version"])
-
-  ensure
-    Logster.config.application_version = nil
-  end
-
-  def test_merging_sums_count_for_both_messages
-    msg1 = Logster::Message.new(0, '', 'test', 10, count: 15)
-    msg2 = Logster::Message.new(0, '', 'test', 20, count: 13)
-    msg2.env = {}
-
-    assert_equal(msg1.grouping_key, msg2.grouping_key)
-
-    save_env = msg1.merge_similar_message(msg2)
-    assert(save_env)
-    assert_equal(msg1.count, 15 + 13)
-  end
-
-  def test_populate_from_env_works_on_array
-    msg = Logster::Message.new(0, '', 'test', 10)
-    hash = { "custom_key" => "key" }
-    msg.populate_from_env([hash])
-
-    assert Array === msg.env
-    assert_equal(msg.env.size, 1)
-    assert hash <= msg.env[0]
-  end
-
-  def test_ensure_env_samples_dont_exceed_50
-    msg1 = Logster::Message.new(0, '', 'test', 10, count: 50)
-    msg1.env = [{ a: 1 }]
-    msg2 = Logster::Message.new(0, '', 'test', 20, count: 13)
-    msg2.env = { b: 2 }
-
-    assert_equal(msg1.grouping_key, msg2.grouping_key)
-
-    save_env = msg1.merge_similar_message(msg2)
-
-    refute(save_env)
-    assert_equal(63, msg1.count) # update count
-    assert_equal([{ a: 1 }], msg1.env) # but don't merge msg2's env into msg1's
-  end
-
-  def test_message_to_h_respects_params
-    msg = Logster::Message.new(0, "", "test")
-    test_hash = { test_key: "this is a test" }
-    msg.env = test_hash
-    assert_equal(test_hash, msg.to_h[:env])
-    assert_nil(msg.to_h(exclude_env: true)[:env])
-  end
-
-  def test_message_to_json_respects_params
-    msg = Logster::Message.new(0, "", "test")
-    test_hash = { test_key: "this is a test" }
-    msg.env = test_hash
-    assert_includes(msg.to_json, test_hash.to_json)
-    refute_includes(msg.to_json(exclude_env: true), test_hash.to_json)
-  end
-end
+require_relative '../test_helper'
+require 'logster/message'
+
+class TestMessage < MiniTest::Test
+
+  def test_merge_similar
+    msg1 = Logster::Message.new(0, '', 'test', 10)
+    msg1.populate_from_env(a: "1", b: "2")
+
+    msg2 = Logster::Message.new(0, '', 'test', 20)
+    msg2.populate_from_env(a: "2", c: "3")
+
+    assert_equal(msg2.grouping_key, msg1.grouping_key)
+
+    msg1.merge_similar_message(msg2)
+
+    assert_equal(20, msg1.timestamp)
+    assert_equal(10, msg1.first_timestamp)
+
+    assert Array === msg1.env
+    assert_equal(msg1.env.size, 2)
+    assert({ a: "1", b: "2" } <= msg1.env[0])
+    assert({ "a" => "2", "c" => "3" } <= msg1.env[1])
+  end
+
+  def test_merge_messages_both_with_array_envs
+    msg1 = Logster::Message.new(0, '', 'test', 10)
+    msg1.env = [{ a: "aa", b: "bb" }, { c: "cc", d: "dd" }]
+
+    msg2 = Logster::Message.new(0, '', 'test', 20)
+    msg2.env = [{ e: "ee", f: "ff" }, { g: "gg", h: "hh" }]
+
+    msg1.merge_similar_message(msg2)
+
+    # new env should be an array, but it should never have
+    # another array of envs within itself (hence flatten(1))
+    assert_equal(msg1.env.size, 4)
+    assert_equal(msg1.env.map(&:keys).flatten(1).map(&:to_s), %w{a b c d e f g h})
+    assert_equal(msg1.env.map(&:values).flatten(1).map(&:to_s), %w{aa bb cc dd ee ff gg hh})
+  end
+
+  def test_merge_messages_one_with_array_envs
+    msg1 = Logster::Message.new(0, '', 'test', 10)
+    msg1.env = [{ a: "aa", b: "bb" }, { c: "cc", d: "dd" }]
+
+    msg2 = Logster::Message.new(0, '', 'test', 20)
+    msg2.env = { e: "ee", f: "ff" }
+
+    msg1.merge_similar_message(msg2)
+
+    assert_equal(msg1.env.size, 3)
+    assert_equal(msg1.env.map(&:keys).flatten(1).map(&:to_s), %w{a b c d e f})
+    assert_equal(msg1.env.map(&:values).flatten(1).map(&:to_s), %w{aa bb cc dd ee ff})
+  end
+
+  def test_adds_application_version
+    Logster.config.application_version = "abc"
+    msg = Logster::Message.new(0, '', 'test', 10)
+    msg.populate_from_env({})
+
+    assert_equal("abc", msg.env["application_version"])
+
+  ensure
+    Logster.config.application_version = nil
+  end
+
+  def test_merging_sums_count_for_both_messages
+    msg1 = Logster::Message.new(0, '', 'test', 10, count: 15)
+    msg2 = Logster::Message.new(0, '', 'test', 20, count: 13)
+    msg2.env = {}
+
+    assert_equal(msg1.grouping_key, msg2.grouping_key)
+
+    save_env = msg1.merge_similar_message(msg2)
+    assert(save_env)
+    assert_equal(msg1.count, 15 + 13)
+  end
+
+  def test_populate_from_env_works_on_array
+    msg = Logster::Message.new(0, '', 'test', 10)
+    hash = { "custom_key" => "key" }
+    msg.populate_from_env([hash])
+
+    assert Array === msg.env
+    assert_equal(msg.env.size, 1)
+    assert hash <= msg.env[0]
+  end
+
+  def test_ensure_env_samples_dont_exceed_50
+    msg1 = Logster::Message.new(0, '', 'test', 10, count: 50)
+    msg1.env = [{ a: 1 }]
+    msg2 = Logster::Message.new(0, '', 'test', 20, count: 13)
+    msg2.env = { b: 2 }
+
+    assert_equal(msg1.grouping_key, msg2.grouping_key)
+
+    save_env = msg1.merge_similar_message(msg2)
+
+    refute(save_env)
+    assert_equal(63, msg1.count) # update count
+    assert_equal([{ a: 1 }], msg1.env) # but don't merge msg2's env into msg1's
+  end
+
+  def test_message_to_h_respects_params
+    msg = Logster::Message.new(0, "", "test")
+    test_hash = { test_key: "this is a test" }
+    msg.env = test_hash
+    assert_equal(test_hash, msg.to_h[:env])
+    assert_nil(msg.to_h(exclude_env: true)[:env])
+  end
+
+  def test_message_to_json_respects_params
+    msg = Logster::Message.new(0, "", "test")
+    test_hash = { test_key: "this is a test" }
+    msg.env = test_hash
+    assert_includes(msg.to_json, test_hash.to_json)
+    refute_includes(msg.to_json(exclude_env: true), test_hash.to_json)
+  end
+end

data/test/logster/test_redis_rate_limiter.rb

@@ -1,230 +1,230 @@
-require_relative '../test_helper'
-require 'logster/redis_store'
-require 'rack'
-
-class TestRedisRateLimiter < Minitest::Test
-  def setup
-    @redis = Redis.new
-  end
-
-  def teardown
-    @redis.flushall
-    Timecop.return
-  end
-
-  def test_clear_all
-    called = 0
-
-    @redis.set("dont_nuke", "1")
-
-    @rate_limiter = Logster::RedisRateLimiter.new(
-      @redis, [Logger::WARN], 8, 60, Proc.new { "prefix" }, Proc.new { called += 1 }
-    )
-
-    9.times do
-      @rate_limiter.check(Logger::WARN)
-    end
-
-    assert_equal 10, @rate_limiter.check(Logger::WARN)
-
-    Logster::RedisRateLimiter.clear_all(@redis, Proc.new { "prefix" })
-
-    assert_equal 1, @rate_limiter.check(Logger::WARN)
-
-    # also clears when prefix missing
-    Logster::RedisRateLimiter.clear_all(@redis)
-
-    assert_equal 1, @rate_limiter.check(Logger::WARN)
-
-    assert_equal "1", @redis.get("dont_nuke")
-    @redis.del("dont_nuke")
-
-  end
-
-  def test_check
-    time = Time.new(2015, 1, 1, 1, 1)
-    Timecop.freeze(time)
-    called = 0
-
-    @rate_limiter = Logster::RedisRateLimiter.new(
-      @redis, [Logger::WARN], 8, 60, nil, Proc.new { called += 1 }
-    )
-
-    assert_equal(1, @rate_limiter.check(Logger::WARN))
-    assert_redis_key(60, 0)
-    assert_equal(1, number_of_buckets)
-
-    Timecop.freeze(time + 10) do
-      assert_equal(2, @rate_limiter.check(Logger::WARN))
-      assert_redis_key(60, 1)
-      assert_equal(3, @rate_limiter.check(Logger::WARN))
-      assert_equal(2, number_of_buckets)
-    end
-
-    Timecop.freeze(time + 20) do
-      assert_equal(4, @rate_limiter.check(Logger::WARN))
-      assert_redis_key(60, 2)
-      assert_equal(3, number_of_buckets)
-    end
-
-    Timecop.freeze(time + 30) do
-      assert_equal(5, @rate_limiter.check(Logger::WARN))
-      assert_redis_key(60, 3)
-      assert_equal(4, number_of_buckets)
-    end
-
-    Timecop.freeze(time + 40) do
-      assert_equal(6, @rate_limiter.check(Logger::WARN))
-      assert_redis_key(60, 4)
-      assert_equal(5, number_of_buckets)
-    end
-
-    Timecop.freeze(time + 50) do
-      assert_equal(7, @rate_limiter.check(Logger::WARN))
-      assert_redis_key(60, 5)
-      assert_equal(6, number_of_buckets)
-    end
-
-    Timecop.freeze(time + 60) do
-      @redis.del("#{key}:0")
-      assert_equal(5, number_of_buckets)
-
-      assert_equal(7, @rate_limiter.check(Logger::WARN))
-      assert_redis_key(60, 0)
-      assert_equal(6, number_of_buckets)
-
-      assert_equal(8, @rate_limiter.check(Logger::WARN))
-      assert_equal(1, called)
-      assert_equal(6, number_of_buckets)
-      assert_equal("1", @redis.get(@rate_limiter.callback_key))
-    end
-
-    Timecop.freeze(time + 70) do
-      @redis.del("#{key}:1")
-      assert_equal(7, @rate_limiter.check(Logger::WARN))
-      assert_nil(@redis.get(@rate_limiter.callback_key))
-    end
-  end
-
-  def test_check_with_multiple_severities
-    time = Time.new(2015, 1, 1, 1, 1)
-    Timecop.freeze(time)
-    called = 0
-
-    @rate_limiter = Logster::RedisRateLimiter.new(
-      @redis, [Logger::WARN, Logger::ERROR], 4, 60, nil, Proc.new { called += 1 }
-    )
-
-    assert_equal(1, @rate_limiter.check(Logger::WARN))
-    assert_equal(2, @rate_limiter.check(Logger::ERROR))
-
-    Timecop.freeze(time + 50) do
-      assert_equal(3, @rate_limiter.check(Logger::WARN))
-      assert_equal(4, @rate_limiter.check(Logger::ERROR))
-      assert_equal(2, number_of_buckets)
-    end
-
-    assert_equal(5, @rate_limiter.check(Logger::ERROR))
-    assert_equal(1, called)
-  end
-
-  def test_bucket_number_per_minute
-    time = Time.new(2015, 1, 1, 1, 1)
-    Timecop.freeze(time)
-    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60)
-
-    assert_bucket_number(0, time)
-    assert_bucket_number(0, time + 9)
-    assert_bucket_number(1, time + 11)
-    assert_bucket_number(5, time + 59)
-  end
-
-  def test_bucket_number_per_hour
-    time = Time.new(2015, 1, 1, 1, 0)
-    Timecop.freeze(time)
-    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 3600)
-
-    assert_bucket_number(0, time)
-    assert_bucket_number(1, time + 1199)
-    assert_bucket_number(2, time + 1200)
-    assert_bucket_number(5, time + 3599)
-  end
-
-  def test_bucket_expiry
-    time = Time.new(2015, 1, 1, 1, 1)
-    Timecop.freeze(time)
-    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60)
-
-    assert_bucket_expiry(60, time)
-    assert_bucket_expiry(55, time + 5)
-    assert_bucket_expiry(60, time + 10)
-    assert_bucket_expiry(58, time + 12)
-    assert_bucket_expiry(55, time + 15)
-    assert_bucket_expiry(51, time + 19)
-    assert_bucket_expiry(60, time + 20)
-    assert_bucket_expiry(55, time + 35)
-  end
-
-  def test_raw_connection
-    time = Time.new(2015, 1, 1, 1, 1)
-    Timecop.freeze(time)
-    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60, Proc.new { "lobster" })
-
-    assert_equal(1, @rate_limiter.check(Logger::WARN))
-    assert_redis_key(60, 0)
-
-    toggle = true
-
-    @rate_limiter = Logster::RedisRateLimiter.new(
-      @redis, [Logger::WARN], 1, 60, Proc.new { toggle ? 'lobster1' : 'lobster2' }
-    )
-
-    assert_includes(key, "lobster1")
-
-    toggle = false
-    assert_includes(key, "lobster2")
-  end
-
-  def test_retrieve_rate
-    time = Time.new(2015, 1, 1, 1 , 1)
-    Timecop.freeze(time)
-
-    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60)
-
-    @rate_limiter.check(Logger::WARN)
-    assert_equal(@rate_limiter.retrieve_rate, 1)
-
-    Timecop.freeze(time + 50) do
-      @rate_limiter.check(Logger::WARN)
-      assert_equal(@rate_limiter.retrieve_rate, 2)
-    end
-  end
-
-  private
-
-  def key
-    @rate_limiter.key
-  end
-
-  def number_of_buckets
-    @redis.keys("#{key}:[0-#{Logster::RedisRateLimiter::BUCKETS}]").size
-  end
-
-  def assert_bucket_number(expected, time)
-    Timecop.freeze(time) do
-      assert_equal(expected, @rate_limiter.send(:bucket_number, Time.now.to_i))
-    end
-  end
-
-  def assert_bucket_expiry(expected, time)
-    Timecop.freeze(time) do
-      assert_equal(expected, @rate_limiter.send(:bucket_expiry, Time.now.to_i))
-    end
-  end
-
-  def assert_redis_key(expected_ttl, expected_bucket_number)
-    redis_key = "#{key}:#{expected_bucket_number}"
-    assert(@redis.get(redis_key), "the right bucket should be created")
-    assert_equal(expected_ttl, @redis.ttl(redis_key))
-  end
-end
+require_relative '../test_helper'
+require 'logster/redis_store'
+require 'rack'
+
+class TestRedisRateLimiter < Minitest::Test
+  def setup
+    @redis = Redis.new
+  end
+
+  def teardown
+    @redis.flushall
+    Timecop.return
+  end
+
+  def test_clear_all
+    called = 0
+
+    @redis.set("dont_nuke", "1")
+
+    @rate_limiter = Logster::RedisRateLimiter.new(
+      @redis, [Logger::WARN], 8, 60, Proc.new { "prefix" }, Proc.new { called += 1 }
+    )
+
+    9.times do
+      @rate_limiter.check(Logger::WARN)
+    end
+
+    assert_equal 10, @rate_limiter.check(Logger::WARN)
+
+    Logster::RedisRateLimiter.clear_all(@redis, Proc.new { "prefix" })
+
+    assert_equal 1, @rate_limiter.check(Logger::WARN)
+
+    # also clears when prefix missing
+    Logster::RedisRateLimiter.clear_all(@redis)
+
+    assert_equal 1, @rate_limiter.check(Logger::WARN)
+
+    assert_equal "1", @redis.get("dont_nuke")
+    @redis.del("dont_nuke")
+
+  end
+
+  def test_check
+    time = Time.new(2015, 1, 1, 1, 1)
+    Timecop.freeze(time)
+    called = 0
+
+    @rate_limiter = Logster::RedisRateLimiter.new(
+      @redis, [Logger::WARN], 8, 60, nil, Proc.new { called += 1 }
+    )
+
+    assert_equal(1, @rate_limiter.check(Logger::WARN))
+    assert_redis_key(60, 0)
+    assert_equal(1, number_of_buckets)
+
+    Timecop.freeze(time + 10) do
+      assert_equal(2, @rate_limiter.check(Logger::WARN))
+      assert_redis_key(60, 1)
+      assert_equal(3, @rate_limiter.check(Logger::WARN))
+      assert_equal(2, number_of_buckets)
+    end
+
+    Timecop.freeze(time + 20) do
+      assert_equal(4, @rate_limiter.check(Logger::WARN))
+      assert_redis_key(60, 2)
+      assert_equal(3, number_of_buckets)
+    end
+
+    Timecop.freeze(time + 30) do
+      assert_equal(5, @rate_limiter.check(Logger::WARN))
+      assert_redis_key(60, 3)
+      assert_equal(4, number_of_buckets)
+    end
+
+    Timecop.freeze(time + 40) do
+      assert_equal(6, @rate_limiter.check(Logger::WARN))
+      assert_redis_key(60, 4)
+      assert_equal(5, number_of_buckets)
+    end
+
+    Timecop.freeze(time + 50) do
+      assert_equal(7, @rate_limiter.check(Logger::WARN))
+      assert_redis_key(60, 5)
+      assert_equal(6, number_of_buckets)
+    end
+
+    Timecop.freeze(time + 60) do
+      @redis.del("#{key}:0")
+      assert_equal(5, number_of_buckets)
+
+      assert_equal(7, @rate_limiter.check(Logger::WARN))
+      assert_redis_key(60, 0)
+      assert_equal(6, number_of_buckets)
+
+      assert_equal(8, @rate_limiter.check(Logger::WARN))
+      assert_equal(1, called)
+      assert_equal(6, number_of_buckets)
+      assert_equal("1", @redis.get(@rate_limiter.callback_key))
+    end
+
+    Timecop.freeze(time + 70) do
+      @redis.del("#{key}:1")
+      assert_equal(7, @rate_limiter.check(Logger::WARN))
+      assert_nil(@redis.get(@rate_limiter.callback_key))
+    end
+  end
+
+  def test_check_with_multiple_severities
+    time = Time.new(2015, 1, 1, 1, 1)
+    Timecop.freeze(time)
+    called = 0
+
+    @rate_limiter = Logster::RedisRateLimiter.new(
+      @redis, [Logger::WARN, Logger::ERROR], 4, 60, nil, Proc.new { called += 1 }
+    )
+
+    assert_equal(1, @rate_limiter.check(Logger::WARN))
+    assert_equal(2, @rate_limiter.check(Logger::ERROR))
+
+    Timecop.freeze(time + 50) do
+      assert_equal(3, @rate_limiter.check(Logger::WARN))
+      assert_equal(4, @rate_limiter.check(Logger::ERROR))
+      assert_equal(2, number_of_buckets)
+    end
+
+    assert_equal(5, @rate_limiter.check(Logger::ERROR))
+    assert_equal(1, called)
+  end
+
+  def test_bucket_number_per_minute
+    time = Time.new(2015, 1, 1, 1, 1)
+    Timecop.freeze(time)
+    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60)
+
+    assert_bucket_number(0, time)
+    assert_bucket_number(0, time + 9)
+    assert_bucket_number(1, time + 11)
+    assert_bucket_number(5, time + 59)
+  end
+
+  def test_bucket_number_per_hour
+    time = Time.new(2015, 1, 1, 1, 0)
+    Timecop.freeze(time)
+    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 3600)
+
+    assert_bucket_number(0, time)
+    assert_bucket_number(1, time + 1199)
+    assert_bucket_number(2, time + 1200)
+    assert_bucket_number(5, time + 3599)
+  end
+
+  def test_bucket_expiry
+    time = Time.new(2015, 1, 1, 1, 1)
+    Timecop.freeze(time)
+    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60)
+
+    assert_bucket_expiry(60, time)
+    assert_bucket_expiry(55, time + 5)
+    assert_bucket_expiry(60, time + 10)
+    assert_bucket_expiry(58, time + 12)
+    assert_bucket_expiry(55, time + 15)
+    assert_bucket_expiry(51, time + 19)
+    assert_bucket_expiry(60, time + 20)
+    assert_bucket_expiry(55, time + 35)
+  end
+
+  def test_raw_connection
+    time = Time.new(2015, 1, 1, 1, 1)
+    Timecop.freeze(time)
+    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60, Proc.new { "lobster" })
+
+    assert_equal(1, @rate_limiter.check(Logger::WARN))
+    assert_redis_key(60, 0)
+
+    toggle = true
+
+    @rate_limiter = Logster::RedisRateLimiter.new(
+      @redis, [Logger::WARN], 1, 60, Proc.new { toggle ? 'lobster1' : 'lobster2' }
+    )
+
+    assert_includes(key, "lobster1")
+
+    toggle = false
+    assert_includes(key, "lobster2")
+  end
+
+  def test_retrieve_rate
+    time = Time.new(2015, 1, 1, 1 , 1)
+    Timecop.freeze(time)
+
+    @rate_limiter = Logster::RedisRateLimiter.new(@redis, [Logger::WARN], 1, 60)
+
+    @rate_limiter.check(Logger::WARN)
+    assert_equal(@rate_limiter.retrieve_rate, 1)
+
+    Timecop.freeze(time + 50) do
+      @rate_limiter.check(Logger::WARN)
+      assert_equal(@rate_limiter.retrieve_rate, 2)
+    end
+  end
+
+  private
+
+  def key
+    @rate_limiter.key
+  end
+
+  def number_of_buckets
+    @redis.keys("#{key}:[0-#{Logster::RedisRateLimiter::BUCKETS}]").size
+  end
+
+  def assert_bucket_number(expected, time)
+    Timecop.freeze(time) do
+      assert_equal(expected, @rate_limiter.send(:bucket_number, Time.now.to_i))
+    end
+  end
+
+  def assert_bucket_expiry(expected, time)
+    Timecop.freeze(time) do
+      assert_equal(expected, @rate_limiter.send(:bucket_expiry, Time.now.to_i))
+    end
+  end
+
+  def assert_redis_key(expected_ttl, expected_bucket_number)
+    redis_key = "#{key}:#{expected_bucket_number}"
+    assert(@redis.get(redis_key), "the right bucket should be created")
+    assert_equal(expected_ttl, @redis.ttl(redis_key))
+  end
+end