logster 2.20.1 → 3.0.0

data/test/logster/test_message.rb

@@ -1,269 +0,0 @@
-# frozen_string_literal: true
-
-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_equal(msg1.env_buffer, [msg2.env])
-  end
-
-  def test_populate_from_env_will_add_time_to_env_unless_it_already_exists
-    t = (Time.now.to_f * 1000).to_i
-    msg = Logster::Message.new(0, "", "test", t)
-    msg.populate_from_env({})
-    assert_equal(t, msg.env["time"])
-
-    msg = Logster::Message.new(0, "", "test", t)
-    msg.populate_from_env(time: 5)
-    assert_nil(msg.env["time"])
-    assert_equal(5, msg.env[:time])
-
-    msg = Logster::Message.new(0, "", "test", t)
-    msg.populate_from_env("time" => 6)
-    assert_equal(6, msg.env["time"])
-    assert_nil(msg.env[:time])
-
-    msg = Logster::Message.new(0, "", "test", t)
-    msg.populate_from_env([{ "time" => 6 }, { "time" => 8 }])
-    assert_equal([6, 8], msg.env.map { |e| e["time"] })
-    assert_equal([nil, nil], msg.env.map { |e| e[:time] })
-
-    msg = Logster::Message.new(0, "", "test", t)
-    msg.populate_from_env([{ dsd: 6 }, { dsd: 8 }])
-    assert_equal([t, t], msg.env.map { |e| e["time"] })
-  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)
-    assert_equal(msg2.env, msg1.env_buffer)
-  end
-
-  def test_merge_messages_one_with_array_envs
-    msg1 = Logster::Message.new(0, "", "test", 10)
-    msg1.env = { e: "ee", f: "ff" }
-
-    msg2 = Logster::Message.new(0, "", "test", 20)
-    msg2.env = [{ a: "aa", b: "bb" }, { c: "cc", d: "dd" }]
-
-    msg1.merge_similar_message(msg2)
-    assert_equal(msg2.env, msg1.env_buffer)
-  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_use_full_hostname
-    Logster::Message.instance_variable_set(:@hostname, nil)
-    Logster.config.use_full_hostname = true
-    msg = Logster::Message.new(0, "", "test", 10)
-    msg.populate_from_env({})
-
-    assert_equal(`hostname -f`.strip!, msg.env["hostname"])
-  ensure
-    Logster.config.use_full_hostname = nil
-    Logster::Message.instance_variable_set(:@hostname, 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)
-
-    msg1.merge_similar_message(msg2)
-    assert_equal(msg1.count, 15 + 13)
-  end
-
-  def test_messages_with_bad_encoding_dont_break_logster
-    hash = {
-      severity: 0,
-      progname: "test",
-      message: "invalid encoding",
-      env: {
-        a: "bad_value",
-        b: ["bad_value"],
-      },
-    }
-    json = hash.to_json.gsub("bad_value", "45\xC0\xBE")
-    message = Logster::Message.from_json(json)
-    message.to_json # test failure would be this raising exception
-
-    message.env = JSON.parse(json)["env"]
-    message.to_json
-  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_merging_envs_add_new_envs_to_buffer
-    msg1 = Logster::Message.new(0, "", "test", 10, count: 50)
-    msg1.env = 50.times.map { |n| { a: n } }
-    msg2 = Logster::Message.new(0, "", "test", 20, count: 13)
-    msg2.env = 13.times.map { |n| { b: n } }
-
-    assert_equal(msg1.grouping_key, msg2.grouping_key)
-
-    msg1.merge_similar_message(msg2)
-    assert_equal(63, msg1.count) # update count
-    assert_equal(msg2.env, msg1.env_buffer)
-  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
-
-  def test_drop_redundant_envs
-    message = Logster::Message.new(Logger::WARN, "", "message")
-    message.env = [{ a: 4 }] * 10
-    assert_equal(10, message.env.size)
-    message.drop_redundant_envs(5)
-    assert_equal(5, message.env.size)
-
-    env = { f: 5, g: 4 }
-    message.env = env.dup
-    message.drop_redundant_envs(1)
-    assert_equal(env, message.env)
-  end
-
-  def test_apply_env_size_limit_keeps_as_many_keys_as_possible
-    message = Logster::Message.new(Logger::WARN, "", "message", 1)
-    env = { a: 1, bb: 22, ccc: 333 }
-    message.env = env.dup
-    message.apply_env_size_limit(24)
-    assert_operator(message.env.to_json.bytesize, :<=, 24)
-    assert_equal({ a: 1, bb: 22 }.to_json.bytesize, message.env.to_json.bytesize)
-
-    message.env = [env.dup] * 5
-    message.apply_env_size_limit(24)
-    assert_equal(5, message.env.size)
-    message.env.each do |e|
-      assert_operator(e.to_json.bytesize, :<=, 24)
-      assert_equal({ a: 1, bb: 22 }.to_json.bytesize, e.to_json.bytesize)
-    end
-
-    message.env = env.dup
-    message.apply_env_size_limit(25)
-    assert_operator(message.env.to_json.bytesize, :<=, 25)
-    assert_equal({ a: 1, bb: 22, ccc: 333 }.to_json.bytesize, message.env.to_json.bytesize)
-  end
-
-  def test_apply_message_size_limit_removes_gems_dir_from_backtrace_to_keep_total_message_size_below_limit
-    backtrace = <<~TEXT
-      /var/www/discourse/vendor/bundle/ruby/2.6.0/gems/rails_multisite-2.0.7/lib/rails_multisite/connection_management.rb:220:in `with_connection'
-      /var/www/discourse/vendor/bundle/ruby/2.6.0/gems/rails_multisite-2.0.7/lib/rails_multisite/connection_management.rb:60:in `with_connection'
-      /var/www/discourse/lib/scheduler/defer.rb:89:in `do_work'
-      /var/www/discourse/lib/scheduler/defer.rb:79:in `block (2 levels) in start_thread'
-    TEXT
-    without_gems_dir = <<~TEXT
-      rails_multisite-2.0.7/lib/rails_multisite/connection_management.rb:220:in `with_connection'
-      rails_multisite-2.0.7/lib/rails_multisite/connection_management.rb:60:in `with_connection'
-      /var/www/discourse/lib/scheduler/defer.rb:89:in `do_work'
-      /var/www/discourse/lib/scheduler/defer.rb:79:in `block (2 levels) in start_thread'
-    TEXT
-    gems_dir = "/var/www/discourse/vendor/bundle/ruby/2.6.0/gems/"
-    message = Logster::Message.new(Logger::WARN, "", "message", 1)
-
-    message.backtrace = backtrace.dup
-    assert_operator(message.to_json(exclude_env: true).bytesize, :>=, 500)
-    message.apply_message_size_limit(500, gems_dir: gems_dir)
-    assert_operator(message.to_json(exclude_env: true).bytesize, :<=, 500)
-    assert_equal(without_gems_dir.strip, message.backtrace.strip)
-  end
-
-  def test_apply_message_size_limit_removes_lines_from_backtrace_to_keep_total_size_below_limit
-    backtrace = <<~TEXT
-      rails_multisite-2.0.7/lib/rails_multisite/connection_management.rb:220:in `with_connection'
-      rails_multisite-2.0.7/lib/rails_multisite/connection_management.rb:60:in `with_connection'
-      /var/www/discourse/lib/scheduler/defer.rb:89:in `do_work'
-      /var/www/discourse/lib/scheduler/defer.rb:79:in `block (2 levels) in start_thread'
-    TEXT
-
-    expected = <<~TEXT
-      rails_multisite-2.0.7/lib/rails_multisite/connection_management.rb:220:in `with_connection'
-      rails_multisite-2.0.7/lib/rails_multisite/connection_management.rb:60:in `with_connection'
-      /var/www/discourse
-    TEXT
-    message = Logster::Message.new(Logger::WARN, "", "message", 1)
-    message.backtrace = backtrace.dup
-    assert_operator(message.to_json(exclude_env: true).bytesize, :>=, 350)
-    message.apply_message_size_limit(350)
-    assert_operator(message.to_json(exclude_env: true).bytesize, :<=, 350)
-    assert_equal(expected.strip, message.backtrace.strip)
-  end
-
-  def test_truncate_backtrace_shouldnt_corrupt_backtrace_when_it_contains_multibytes_characters
-    backtrace = "aहa"
-    message = Logster::Message.new(Logger::WARN, "", "message", 1)
-    message.backtrace = backtrace.dup
-    message.truncate_backtrace(3)
-    assert_equal("a", message.backtrace)
-
-    message.backtrace = backtrace.dup
-    message.truncate_backtrace(4)
-    assert_equal("aह", message.backtrace)
-
-    message.backtrace = backtrace.dup
-    message.truncate_backtrace(5)
-    assert_equal(backtrace, message.backtrace)
-  end
-
-  def test_apply_message_size_limit_doesnt_remove_backtrace_entirely
-    message = Logster::Message.new(Logger::WARN, "", "message", 1)
-    message.backtrace = "a" * 1000
-    assert_operator(message.to_json(exclude_env: true).bytesize, :>=, 500)
-    message.apply_message_size_limit(500)
-    assert_operator(message.to_json(exclude_env: true).bytesize, :<=, 500)
-    assert_equal(("a" * 354).size, message.backtrace.size)
-  end
-
-  def test_apply_message_size_limit_doesnt_hang_forever_and_doesnt_remove_backtrace_entirely
-    message = Logster::Message.new(Logger::WARN, "", "message", 1)
-    message.backtrace = "aa" * 100
-    message.apply_message_size_limit(10)
-    assert_equal(("aa" * 100).size, message.backtrace.size)
-  end
-end

data/test/logster/test_pattern.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../test_helper"
-require "logster/redis_store"
-require "logster/pattern"
-
-class TestPattern < Minitest::Test
-  class FakePattern < Logster::Pattern
-    def self.set_name
-      "__LOGSTER__fake_patterns_set".freeze
-    end
-  end
-
-  class TestRedisStore < Logster::BaseStore
-    def get_patterns(set_name)
-      ["/differentstore/"]
-    end
-  end
-
-  def setup
-    Logster.store = Logster::RedisStore.new
-    Logster.store.clear_all
-  end
-
-  def teardown
-    Logster.store.clear_all
-    Logster.store = nil
-  end
-
-  def test_parse_pattern_works_correctly
-    assert_equal(/osama/i, klass.parse_pattern(/osama/i))
-    assert_equal(/osama/i, klass.parse_pattern("/osama/i"))
-    assert_equal(/osama/, klass.parse_pattern("/osama/"))
-    assert_equal(/osama/, klass.parse_pattern("osama"))
-    assert_equal(/[a-zA-Z]/, klass.parse_pattern("[a-zA-Z]"))
-    assert_equal(/[a-zA-Z]/, klass.parse_pattern("/[a-zA-Z]/"))
-
-    assert_nil(klass.parse_pattern("/osama"))
-    assert_nil(klass.parse_pattern("["))
-    assert_nil(klass.parse_pattern("/[/"))
-  end
-
-  def test_validity_checks_are_correct
-    assert(klass.valid?(/osama/))
-    refute(klass.valid?(//))
-    refute(klass.valid?(//i))
-    refute(klass.valid?(/ /))
-  end
-
-  def test_find_all_works_correctly
-    patterns = ["/test/i", "tttt", "[d-y].*"]
-    patterns.each { |p| FakePattern.new(p).save }
-
-    results = FakePattern.find_all
-    assert_equal(3, results.size)
-    assert_includes(results, /test/i)
-    assert_includes(results, /tttt/)
-    assert_includes(results, /[d-y].*/)
-
-    results = FakePattern.find_all(raw: true)
-    assert_equal(3, results.size)
-    assert_includes(results, "/test/i")
-    assert_includes(results, "/tttt/")
-    assert_includes(results, "/[d-y].*/")
-  end
-
-  def test_find_all_can_take_an_instance_of_store
-    results = FakePattern.find_all(store: TestRedisStore.new)
-    assert_equal(1, results.size)
-    assert_equal(/differentstore/, results.first)
-  end
-
-  def test_find_works_correctly
-    FakePattern.new("/wwwlll/").save
-
-    record = FakePattern.find("wwwlll")
-    assert_equal(/wwwlll/, record.pattern)
-    record = FakePattern.find(/wwwlll/)
-    assert_equal(/wwwlll/, record.pattern)
-
-    assert_nil(FakePattern.find("dfsdfsdf"))
-    assert_nil(FakePattern.find(nil))
-  end
-
-  def test_patterns_get_parsed_on_initialize
-    assert_equal(/mypattern/, FakePattern.new("mypattern").pattern)
-    assert_equal(/111333/, FakePattern.new(/111333/).pattern)
-  end
-
-  def test_save_works_correctly
-    bad_patterns = ["/bruken", nil, "[a-z", "/(osa|sss{1/"]
-    bad_patterns.each do |p|
-      assert_raises(Logster::Pattern::PatternError) { FakePattern.new(p).save }
-    end
-    assert_equal(0, FakePattern.find_all.size)
-
-    good_patterns = ["/logster/i", /logster/, "sssd", "(ccx|tqe){1,5}", "logster"]
-    good_patterns.each { |p| FakePattern.new(p).save }
-    results = FakePattern.find_all
-    assert_equal(4, results.size) # 4 because /logster/ and logster are the same
-    good_patterns_regex = [/logster/i, /logster/, /sssd/, /(ccx|tqe){1,5}/]
-    results.each { |p| assert_includes(good_patterns_regex, p) }
-  end
-
-  def test_modify_works_correctly
-    record = FakePattern.new(/logster/)
-    record.save
-
-    record.modify("/LoGsTEr/")
-    all_patterns = FakePattern.find_all
-    assert_equal(1, all_patterns.size)
-    assert_equal(/LoGsTEr/, all_patterns.first)
-    assert_equal(/LoGsTEr/, record.pattern)
-  end
-
-  def test_modify_doesnt_remove_old_pattern_when_new_is_bad
-    record = FakePattern.new(/LoGsTEr/)
-    record.save
-
-    assert_raises(Logster::Pattern::PatternError) { record.modify("/badReg") }
-    all_patterns = FakePattern.find_all
-    assert_equal(1, all_patterns.size)
-    assert_equal(/LoGsTEr/, all_patterns.first)
-    assert_equal(/LoGsTEr/, record.pattern)
-  end
-
-  def test_destroy_works_correctly
-    record = FakePattern.new(/somepattern/)
-    record.save
-
-    patterns = FakePattern.find_all
-    assert_equal(1, patterns.size)
-    assert_equal(/somepattern/, patterns.first)
-
-    record.destroy
-    assert_equal(0, FakePattern.find_all.size)
-  end
-
-  private
-
-  def klass
-    Logster::Pattern
-  end
-end

data/test/logster/test_railtie.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-ENV["RAILS_ENV"] = "test"
-
-require "redis"
-require_relative "../dummy/config/environment"
-ActiveRecord::Migrator.migrations_paths = [File.expand_path("dummy/db/migrate", __dir__)]
-
-require_relative "../test_helper"
-
-class TestRailtie < Minitest::Test
-  def test_sets_logger
-    refute_nil Logster.logger
-
-    if Rails.version >= "7.1"
-      assert_includes Rails.logger.broadcasts, Logster.logger
-    else
-      assert_equal Rails.logger, Logster.logger
-    end
-  end
-end

data/test/logster/test_redis_rate_limiter.rb

@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-
-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 { @rate_limiter.check(Logger::WARN) }
-
-    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