redisrank 0.1.0

data/spec/buffer_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+
+describe Redisrank::Buffer do
+
+  before(:each) do
+    @class  = Redisrank::Buffer
+    @buffer = Redisrank::Buffer.instance
+    @key = double("Key", :to_s => "Scope/label:2011")
+    @stats = {:count => 1, :views => 3}
+    @depth_limit = :hour
+    @opts = {:enable_grouping => true}
+  end
+
+  # let's cleanup after ourselves for the other specs
+  after(:each) do
+    @class.instance_variable_set("@instance", nil)
+    @buffer.size = 0
+  end
+
+  it "should provide instance of itself" do
+    @buffer.should be_a(@class)
+  end
+
+  it "should only buffer if buffer size setting is greater than 1" do
+    @buffer.size.should == 0
+    expect(@buffer.send(:should_buffer?)).to be false
+    @buffer.size = 1
+    @buffer.size.should == 1
+    expect(@buffer.send(:should_buffer?)).to be false
+    @buffer.size = 2
+    @buffer.size.should == 2
+    expect(@buffer.send(:should_buffer?)).to be true
+  end
+
+  it "should only flush buffer if buffer size is greater than or equal to buffer size setting" do
+    @buffer.size.should == 0
+    @buffer.send(:queue).size.should == 0
+    expect(@buffer.send(:should_flush?)).to be false
+    @buffer.send(:queue)[:hello] = 'world'
+    @buffer.send(:incr_count)
+    expect(@buffer.send(:should_flush?)).to be true
+    @buffer.size = 5
+    expect(@buffer.send(:should_flush?)).to be false
+    3.times { |i|
+      @buffer.send(:queue)[i] = i.to_s
+      @buffer.send(:incr_count)
+    }
+    expect(@buffer.send(:should_flush?)).to be false
+    @buffer.send(:queue)[4] = '4'
+    @buffer.send(:incr_count)
+    expect(@buffer.send(:should_flush?)).to be true
+  end
+
+  it "should force flush queue irregardless of result of #should_flush? when #reset_queue is called with true" do
+    @buffer.send(:queue)[:hello] = 'world'
+    @buffer.send(:incr_count)
+    expect(@buffer.send(:should_flush?)).to be true
+    @buffer.size = 2
+    expect(@buffer.send(:should_flush?)).to be false
+    @buffer.send(:reset_queue).should == {}
+    @buffer.instance_variable_get("@count").should == 1
+    @buffer.send(:reset_queue, true).should == {:hello => 'world'}
+    @buffer.instance_variable_get("@count").should == 0
+  end
+
+  it "should #flush_data into Summary.update properly" do
+    # the root level key value doesn't actually matter, but it's something like this...
+    data = {'ScopeName/label/goes/here:2011::true:true' => {
+      :key => @key,
+      :stats => @stats,
+      :depth_limit => @depth_limit,
+      :opts => @opts
+    }}
+    item = data.first[1]
+    Redisrank::Summary.should_receive(:update).with(@key, @stats, @depth_limit, @opts)
+    @buffer.send(:flush_data, data)
+  end
+
+  it "should build #buffer_key correctly" do
+    opts = {:enable_grouping => true, :label_indexing => false, :connection_ref => nil}
+    @buffer.send(:buffer_key, @key, opts).should ==
+      "#{@key.to_s}:connection_ref::enable_grouping:true:label_indexing:false"
+    opts = {:enable_grouping => false, :label_indexing => true, :connection_ref => :omg}
+    @buffer.send(:buffer_key, @key, opts).should ==
+      "#{@key.to_s}:connection_ref:omg:enable_grouping:false:label_indexing:true"
+  end
+
+  describe "Buffering" do
+    it "should store items on buffer queue" do
+      expect(@buffer.store(@key, @stats, @depth_limit, @opts)).to be false
+      @buffer.size = 5
+      expect(@buffer.store(@key, @stats, @depth_limit, @opts)).to be true
+      expect(@buffer.send(:queue).count).to eq(1)
+      @buffer.send(:queue)[@buffer.send(:queue).keys.first][:stats][:count].should == 1
+      @buffer.send(:queue)[@buffer.send(:queue).keys.first][:stats][:views].should == 3
+      expect(@buffer.store(@key, @stats, @depth_limit, @opts)).to be true
+      expect(@buffer.send(:queue).count).to eq(1)
+      @buffer.send(:queue)[@buffer.send(:queue).keys.first][:stats][:count].should == 1
+      @buffer.send(:queue)[@buffer.send(:queue).keys.first][:stats][:views].should == 3
+    end
+    
+  end
+
+end

data/spec/collection_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe Redisrank::Collection do
+
+  it "should initialize properly" do
+    options = {:from => "from", :till => "till", :depth => "depth"}
+    result = Redisrank::Collection.new(options)
+    result.from.should == options[:from]
+    result.till.should == options[:till]
+    result.depth.should == options[:depth]
+  end
+
+  it "should have a rank property" do
+    col = Redisrank::Collection.new()
+    col.rank.should == {}
+    col.rank = {:foo => "bar"}
+    col.rank.should == {:foo => "bar"}
+  end
+
+end

data/spec/connection_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+include Redisrank
+
+describe Redisrank::Connection do
+
+  before(:each) do
+    @redis = Redisrank.redis
+  end
+
+  it "should have a valid Redis client instance" do
+    Redisrank.redis.should_not be_nil
+  end
+
+  it "should have initialized custom testing connection" do
+    @redis.client.host.should == '127.0.0.1'
+    @redis.client.port.should == 8379
+    @redis.client.db.should == 15
+  end
+
+  it "should be able to set and get data" do
+    @redis.set("hello", "world")
+    expect(@redis.get("hello")).to eq("world")
+    expect(@redis.del("hello")).to be 1
+  end
+
+  it "should be able to store hashes to Redis" do
+    @redis.hset("hash", "field", "1")
+    @redis.hget("hash", "field").should == "1"
+    @redis.hincrby("hash", "field", 1)
+    @redis.hget("hash", "field").should == "2"
+    @redis.hincrby("hash", "field", -1)
+    @redis.hget("hash", "field").should == "1"
+    @redis.del("hash")
+  end
+
+  it "should be accessible from Redisrank module" do
+    Redisrank.redis.should == Connection.get
+    Redisrank.redis.should == Redisrank.connection
+  end
+
+  it "should handle multiple connections with refs" do
+    Redisrank.redis.client.db.should == 15
+    Redisrank.connect(:port => 8379, :db => 14, :ref => "Custom")
+    Redisrank.redis.client.db.should == 15
+    Redisrank.redis("Custom").client.db.should == 14
+  end
+
+  it "should be able to overwrite default and custom refs" do
+    Redisrank.redis.client.db.should == 15
+    Redisrank.connect(:port => 8379, :db => 14)
+    Redisrank.redis.client.db.should == 14
+
+    Redisrank.redis("Custom").client.db.should == 14
+    Redisrank.connect(:port => 8379, :db => 15, :ref => "Custom")
+    Redisrank.redis("Custom").client.db.should == 15
+
+    # Reset the default connection to the testing server or all hell
+    # might brake loose from the rest of the specs
+    Redisrank.connect(:port => 8379, :db => 15)
+  end
+
+  # TODO: Test thread-safety
+  it "should be thread-safe" do
+    pending("need to figure out a way to test thread-safety")
+  end
+
+end

data/spec/core_ext/hash_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe Hash do
+
+  it "should #merge_to_max values" do
+    hash = {:count => 1}
+    expect(hash.merge_to_max(:sum, 3)).to be true
+    expect(hash).to eq({:count => 1, :sum => 3})
+    expect(hash.merge_to_max(:count, 4)).to be true
+    expect(hash).to eq({:count => 4, :sum => 3})
+    expect(hash.merge_to_max(:count, 3)).to be false
+    expect(hash.merge_to_max(:count, 'test')).to be false
+    expect(hash.merge_to_max(:view, 'test')).to be false
+    expect(hash).to eq({:count => 4, :sum => 3})
+    hash[:view] = 'test'
+    expect(hash.merge_to_max(:view, 3)).to be false
+  end
+
+  it "should #merge_to_max! hashes" do
+    hash = { :count => 1, :sum => 2}
+
+    expect(hash.clone.merge_to_max!({:mult => 3, :sum => 2, :count => 2})).to eq({:count => 2, :sum => 2, :mult => 3})
+    expect(hash.clone.merge_to_max!({:mult => 3, :sum => 3, :count => 2})).to eq({:count => 2, :sum => 3, :mult => 3})
+  end
+
+end

data/spec/database_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+
+describe Redisrank::Database do
+  include Redisrank::Database
+
+  it "should make #db method available when included" do
+    db.should == Redisrank.redis
+  end
+
+end

data/spec/date_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+describe Redisrank::Date do
+
+  it "should initialize from Time object" do
+    now = Time.now
+    [Redisrank::Date.new(now), now.to_rs].each do |rdate|
+      Redisrank::Date::DEPTHS.each { |k| rdate.send(k).should == now.send(k) }
+    end
+  end
+
+  it "should initialize from Date object" do
+    today = Date.today
+    [Redisrank::Date.new(today), today.to_rs].each do |rdate|
+      [:year, :month, :day].each { |k| rdate.send(k).should == today.send(k) }
+      [:hour, :min, :sec, :usec].each { |k| rdate.send(k).should == 0 }
+    end
+  end
+
+  it "should initialize from Fixnum object (UNIX Timestamp)" do
+    now = Time.now.to_i
+    time = Time.at(now)
+    [Redisrank::Date.new(now), now.to_rs].each do |rdate|
+      [:year, :month, :day, :hour, :min, :sec].each { |k| rdate.send(k).should == time.send(k) }
+    end
+  end
+
+  it "should initialize from String object" do
+    now = Time.now
+    rdate = Redisrank::Date.new(now.to_s)
+    [:year, :month, :day, :hour, :min, :sec].each { |k| rdate.send(k).should == now.send(k) }
+  end
+
+  it "should initialize from Redisrank date String" do
+    now = Time.now
+    rdate = Redisrank::Date.new(now.to_s)
+    [:year, :month, :day, :hour, :min, :sec].each { |k|
+      rdate.to_s(k).should == Redisrank::Date.new(rdate.to_s(k)).to_s(k)
+    }
+  end
+
+  it "should convert to Time object" do
+    now = Time.now
+    rdate = Redisrank::Date.new(now)
+    rdate.to_time.to_s.should == now.to_s
+  end
+
+  it "should convert to Date object" do
+    today = Date.today
+    rdate = Redisrank::Date.new(today)
+    rdate.to_date.to_s.should == today.to_s
+  end
+
+  it "should convert to Fixnum object (UNIX Timestamp)" do
+    now = Time.now
+    rdate = Redisrank::Date.new(now)
+    rdate.to_i.should == now.to_i
+  end
+
+  it "should convert to string with correct depths" do
+    today = Date.today
+    now = Time.now
+    [[now, Redisrank::Date.new(now)], [today, Redisrank::Date.new(today)]].each do |current, rdate|
+      props = [:year, :month, :day, :hour, :min, :sec, nil]
+      if rdate.usec > 0
+        rdate.to_s(:usec).should == props.map { |k| current.send(k).to_s.rjust(2, '0') if !k.nil? }.join + "." + current.usec.to_s.rjust(6, '0')
+      end
+      props.clone.each do
+        rdate.to_s(props.last).should == props.map { |k| current.send(k).to_s.rjust(2, '0') if !k.nil? }.join
+        props.pop
+      end
+    end
+  end
+
+  it "should add helper methods to Date, Time and Fixnum classes" do
+    Date.today.to_time.should == Time.parse(Date.today.to_s)
+    Time.now.to_i.to_time.should == Time.at(Time.now.to_i)
+    Date.today.to_rs.to_date.should == Date.today
+  end
+
+  it "should have a depth property" do
+    now = Time.now
+
+    date = Redisrank::Date.new(now)
+    date.depth.should be_nil
+    date.to_s.should == now.to_rs(:sec).to_s
+    date.to_s.should == now.to_rs.to_s(:sec)
+
+    date = Redisrank::Date.new(now, :hour)
+    date.depth.should == :hour
+    date.to_s.should == now.to_rs(:hour).to_s
+    date.to_s.should == now.to_rs.to_s(:hour)
+  end
+
+end

data/spec/event_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe Redisrank::Event do
+  include Redisrank::Database
+
+  before(:each) do
+    db.flushdb
+    @scope = "PageViews"
+    @label = "about_us"
+    @label_hash = Digest::SHA1.hexdigest(@label)
+    @stats = {'views' => 1}
+    @meta = {'user_id' => 239}
+    @options = {:depth => :hour}
+    @date = Time.now
+    @event = Redisrank::Event.new(@scope, @label, @date, @stats, @options, @meta)
+  end
+
+  it "should initialize properly" do
+    @event.id.should be_nil
+    @event.scope.to_s.should == @scope
+    @event.label.to_s.should == @label
+    @event.label_hash.should == @label_hash
+    @event.date.to_time.to_s.should == @date.to_s
+    @event.stats.should == @stats
+    @event.meta.should == @meta
+    @event.options.should == @event.default_options.merge(@options)
+  end
+
+  it "should allow changing attributes" do
+    # date
+    @event.date.to_time.to_s.should == @date.to_s
+    @date = Time.now
+    @event.date = @date
+    @event.date.to_time.to_s.should == @date.to_s
+    # label
+    @event.label.to_s.should == @label
+    @event.label_hash.should == @label_hash
+    @label = "contact_us"
+    @label_hash = Digest::SHA1.hexdigest(@label)
+    @event.label = @label
+    @event.label.to_s.should == @label
+    @event.label_hash.should == @label_hash
+  end
+
+  it "should increment next_id" do
+    event = Redisrank::Event.new("VisitorCount", @label, @date, @stats, @options, @meta)
+    @event.next_id.should == 1
+    event.next_id.should == 1
+    @event.next_id.should == 2
+    event.next_id.should == 2
+  end
+
+  it "should store event properly" do
+    @event = Redisrank::Event.new(@scope, @label, @date, @stats, @options.merge({:store_event => true}), @meta)
+    expect(@event.new?).to be true
+    @event.save
+    expect(@event.new?).to be false
+    keys = db.keys "*"
+    keys.should include("#{@event.scope}#{Redisrank::KEY_EVENT}#{@event.id}")
+    keys.should include("#{@event.scope}#{Redisrank::KEY_EVENT_IDS}")
+  end
+
+  it "should find event by id" do
+    @event = Redisrank::Event.new(@scope, @label, @date, @stats, @options.merge({:store_event => true}), @meta).save
+    fetched = Redisrank::Event.find(@scope, @event.id)
+    @event.scope.to_s.should == fetched.scope.to_s
+    @event.label.to_s.should == fetched.label.to_s
+    @event.date.to_s.should == fetched.date.to_s
+    @event.stats.should == fetched.stats
+    @event.meta.should == fetched.meta
+  end
+
+  it "should store summarized statistics" do
+    2.times do |i|
+      @event = Redisrank::Event.new(@scope, @label, @date, @stats, @options, @meta).save
+      Redisrank::Date::DEPTHS.each do |depth|
+        summary = db.zrevrange @event.key.to_s(depth), 0, -1, :with_scores => true
+        expect(summary.count).to be > 0
+        expect(summary.first.first).to eq("views")
+        expect(summary.first.last).to eq(1)
+        break if depth == :hour
+      end
+    end
+  end
+
+end

data/spec/finder/date_set_spec.rb

@@ -0,0 +1,527 @@
+require "spec_helper"
+
+describe Redisrank::Finder::DateSet do
+
+  before(:all) do
+    @finder = Redisrank::Finder::DateSet.new
+  end
+
+  it "should initialize properly" do
+    t_start = Time.utc(2010, 8, 28, 22, 54, 57)
+    t_end = Time.utc(2013, 12, 4, 22, 52, 3)
+    result = Redisrank::Finder::DateSet.new(t_start, t_end)
+    result.should == [
+      { :add => ["2010082822", "2010082823"],             :rem => []             },
+      { :add => ["20131204"],                             :rem => ["2013120423"] },
+      { :add => ["20100829", "20100830", "20100831"],     :rem => []             },
+      { :add => ["20131201", "20131202", "20131203"],     :rem => []             },
+      { :add => ["201009", "201010", "201011", "201012"], :rem => []             },
+      { :add => ["2013"],                                 :rem => ["201312"]     },
+      { :add => ["2011", "2012"],                         :rem => []             }
+    ]
+  end
+
+  it "should find date sets by interval" do
+    t_start = Time.utc(2010, 8, 28, 18, 54, 57)
+
+    t_end = t_start + 4.hours
+    result = Redisrank::Finder::DateSet.new.find_date_sets(t_start, t_end, :hour, true)
+    result[0][:add].should == ["2010082818", "2010082819", "2010082820", "2010082821", "2010082822"]
+    result[0][:rem].should == []
+    result.should == Redisrank::Finder::DateSet.new(t_start, t_end, nil, :hour)
+
+    t_end = t_start + 4.days
+    result = Redisrank::Finder::DateSet.new.find_date_sets(t_start, t_end, :day, true)
+    result[0][:add].should == ["20100828", "20100829", "20100830", "20100831", "20100901"]
+    result[0][:rem].should == []
+    result.should == Redisrank::Finder::DateSet.new(t_start, t_end, nil, :day)
+  end
+
+  it "should find start keys properly" do
+
+    #
+    # Simple fetching
+    # Dates: 22:54, 26th August, 2010 --> 22:52, 14th December, 2010
+    #
+
+    t_start = Time.utc(2010, 8, 26, 22, 54, 57)
+    t_end = Time.utc(2013, 12, 14, 22, 52, 3)
+
+    result = @finder.send(:find_start_keys_for, :sec, t_start, t_end)
+    result[:add].should == ["20100826225458", "20100826225459"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end)
+    result[:add].should == ["201008262255", "201008262256", "201008262257", "201008262258", "201008262259"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["2010082623"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :day, t_start, t_end)
+    result[:add].should == ["20100827", "20100828", "20100829", "20100830", "20100831"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :month, t_start, t_end)
+    result[:add].should == ["201009", "201010", "201011", "201012"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :year, t_start, t_end)
+    result[:add].should == ["2011", "2012"]
+    result[:rem].should == []
+
+    #
+    # Reverse / Inteligent fetching
+    # Dates: 5:06, 4th April, 2010 --> 22:52, 14th February, 2011
+    #
+
+    t_start = Time.utc(2010, 4, 4, 5, 6, 4)
+    t_end = Time.utc(2011, 2, 14, 22, 52, 3)
+
+    result = @finder.send(:find_start_keys_for, :sec, t_start, t_end)
+    result[:add].should == ["201004040506"]
+    result[:rem].should == ["20100404050600", "20100404050601", "20100404050602", "20100404050603", "20100404050604"]
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end)
+    result[:add].should == ["2010040405"]
+    result[:rem].should == ["201004040500", "201004040501", "201004040502", "201004040503", "201004040504", "201004040505", "201004040506"]
+
+    result = @finder.send(:find_start_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["20100404"]
+    result[:rem].should == ["2010040400", "2010040401", "2010040402", "2010040403", "2010040404", "2010040405"]
+
+    result = @finder.send(:find_start_keys_for, :day, t_start, t_end)
+    result[:add].should == ["201004"]
+    result[:rem].should == ["20100401", "20100402", "20100403", "20100404"]
+
+    result = @finder.send(:find_start_keys_for, :month, t_start, t_end)
+    result[:add].should == ["2010"]
+    result[:rem].should == ["201001", "201002", "201003", "201004"]
+
+    result = @finder.send(:find_start_keys_for, :year, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+  end
+
+  it "should find end keys properly" do
+
+    #
+    # Simple fetching
+    # Dates: 22:04, 26th December, 2007 --> 5:06, 7th May, 2010
+    #
+
+    t_start = Time.utc(2007, 12, 26, 22, 4, 4)
+    t_end = Time.utc(2010, 5, 7, 5, 6, 3)
+
+    result = @finder.send(:find_end_keys_for, :sec, t_start, t_end)
+    result[:add].should == ["20100507050600", "20100507050601", "20100507050602"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end)
+    result[:add].should == ["201005070500", "201005070501", "201005070502", "201005070503", "201005070504", "201005070505"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["2010050700", "2010050701", "2010050702", "2010050703", "2010050704"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :day, t_start, t_end)
+    result[:add].should == ["20100501", "20100502", "20100503", "20100504", "20100505", "20100506"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :month, t_start, t_end)
+    result[:add].should == ["201001", "201002", "201003", "201004"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :year, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    #
+    # Reverse / Inteligent fetching
+    # Dates: 22:04, 26th December, 2009 --> 22:56, 27th October, 2010
+    #
+
+    t_start = Time.utc(2009, 12, 26, 22, 4, 4)
+    t_end = Time.utc(2010, 10, 27, 22, 56, 57)
+
+    result = @finder.send(:find_end_keys_for, :sec, t_start, t_end)
+    result[:add].should == ["201010272256"]
+    result[:rem].should == ["20101027225657", "20101027225658", "20101027225659"]
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end)
+    result[:add].should == ["2010102722"]
+    result[:rem].should == ["201010272256", "201010272257", "201010272258", "201010272259"]
+
+    result = @finder.send(:find_end_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["20101027"]
+    result[:rem].should == ["2010102722", "2010102723"]
+
+    result = @finder.send(:find_end_keys_for, :day, t_start, t_end)
+    result[:add].should == ["201010"]
+    result[:rem].should == ["20101027", "20101028", "20101029", "20101030", "20101031"]
+
+    result = @finder.send(:find_end_keys_for, :month, t_start, t_end)
+    result[:add].should == ["2010"]
+    result[:rem].should == ["201010", "201011", "201012"]
+
+    result = @finder.send(:find_end_keys_for, :year, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+  end
+
+  it "should fetch start/end keys with limits" do
+
+    #
+    # Simple fetching with Limits
+    #
+
+    # seconds
+    t_start = Time.utc(2010, 8, 26, 20, 54, 45)
+    t_end = t_start + 4.seconds
+
+    result = @finder.send(:find_start_keys_for, :sec, t_start, t_end)
+    result[:add].should == ["20100826205446", "20100826205447", "20100826205448"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :sec, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    t_start = Time.utc(2010, 8, 26, 20, 54, 4)
+    t_end = t_start + 4.seconds
+
+    result = @finder.send(:find_start_keys_for, :sec, t_start, t_end)
+    result[:add].should == ["20100826205405", "20100826205406", "20100826205407"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :sec, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    # minutes
+    t_start = Time.utc(2010, 8, 26, 20, 54)
+    t_end = t_start + 4.minutes
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end)
+    result[:add].should == ["201008262055", "201008262056", "201008262057"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    t_start = Time.utc(2010, 8, 26, 20, 4)
+    t_end = t_start + 4.minutes
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end)
+    result[:add].should == ["201008262005", "201008262006", "201008262007"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    # hours
+    t_start = Time.utc(2010, 8, 26, 20, 54)
+    t_end = t_start + 2.hours
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end)
+    result[:add].should == ["201008262055", "201008262056", "201008262057", "201008262058", "201008262059"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["2010082621"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :hour, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end)
+    result[:add].should == ["2010082622"]
+    result[:rem].should == ["201008262254", "201008262255", "201008262256", "201008262257", "201008262258", "201008262259"]
+
+    t_start = Time.utc(2010, 8, 26, 4, 54)
+    t_end = t_start + 5.hours
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end)
+    result[:add].should == ["201008260455", "201008260456", "201008260457", "201008260458", "201008260459"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["2010082605", "2010082606", "2010082607", "2010082608"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :hour, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end)
+    result[:add].should == ["2010082609"]
+    result[:rem].should == ["201008260954", "201008260955", "201008260956", "201008260957", "201008260958", "201008260959"]
+
+    # days
+    t_start = Time.utc(2010, 8, 26, 20, 54)
+    t_end = t_start + 2.day
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end)
+    result[:add].should == ["201008262055", "201008262056", "201008262057", "201008262058", "201008262059"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["2010082621", "2010082622", "2010082623"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :day, t_start, t_end)
+    result[:add].should == ["20100827"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :day, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["20100828"]
+    result[:rem].should == ["2010082820", "2010082821", "2010082822", "2010082823"]
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end)
+    result[:add].should == ["2010082820"]
+    result[:rem].should == ["201008282054", "201008282055", "201008282056", "201008282057", "201008282058", "201008282059"]
+
+    t_start = Time.utc(2010, 8, 6, 20, 54)
+    t_end = t_start + 2.day
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end)
+    result[:add].should == ["201008062055", "201008062056", "201008062057", "201008062058", "201008062059"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["2010080621", "2010080622", "2010080623"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :day, t_start, t_end)
+    result[:add].should == ["20100807"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :day, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["20100808"]
+    result[:rem].should == ["2010080820", "2010080821", "2010080822", "2010080823"]
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end)
+    result[:add].should == ["2010080820"]
+    result[:rem].should == ["201008082054", "201008082055", "201008082056", "201008082057", "201008082058", "201008082059"]
+
+    # months
+    t_start = Time.utc(2010, 8, 26, 20, 54)
+    t_end = t_start + 3.months
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end)
+    result[:add].should == ["201008262055", "201008262056", "201008262057", "201008262058", "201008262059"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["2010082621", "2010082622", "2010082623"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :day, t_start, t_end)
+    result[:add].should == ["20100827", "20100828", "20100829", "20100830", "20100831"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :month, t_start, t_end)
+    result[:add].should == ["201009", "201010"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :month, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :day, t_start, t_end)
+    result[:add].should == ["201011"]
+    result[:rem].should == ["20101126", "20101127", "20101128", "20101129", "20101130"]
+
+    result = @finder.send(:find_end_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["20101126"]
+    result[:rem].should == ["2010112620", "2010112621", "2010112622", "2010112623"]
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end)
+    result[:add].should == ["2010112620"]
+    result[:rem].should == ["201011262054", "201011262055", "201011262056", "201011262057", "201011262058", "201011262059"]
+
+    t_start = Time.utc(2010, 4, 26, 20, 54)
+    t_end = t_start + 3.months
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end)
+    result[:add].should == ["201004262055", "201004262056", "201004262057", "201004262058", "201004262059"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["2010042621", "2010042622", "2010042623"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :day, t_start, t_end)
+    result[:add].should == ["20100427", "20100428", "20100429", "20100430"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :month, t_start, t_end)
+    result[:add].should == ["201005", "201006"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :month, t_start, t_end)
+    result[:add].should == []
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :day, t_start, t_end)
+    result[:add].should == ["201007"]
+    result[:rem].should == ["20100726", "20100727", "20100728", "20100729", "20100730", "20100731"]
+
+    result = @finder.send(:find_end_keys_for, :hour, t_start, t_end)
+    result[:add].should == ["20100726"]
+    result[:rem].should == ["2010072620", "2010072621", "2010072622", "2010072623"]
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end)
+    result[:add].should == ["2010072620"]
+    result[:rem].should == ["201007262054", "201007262055", "201007262056", "201007262057", "201007262058", "201007262059"]
+
+  end
+
+  it "should find inclusive keys on lowest depth" do
+
+    #
+    # Simple start fetching
+    # Dates: 22:54, 26th August, 2010 --> 22:52, 14th December, 2010
+    #
+
+    t_start = Time.utc(2010, 8, 26, 22, 54, 57)
+    t_end = Time.utc(2013, 12, 14, 22, 52, 3)
+
+    result = @finder.send(:find_start_keys_for, :sec, t_start, t_end, true)
+    result[:add].should == ["20100826225457", "20100826225458", "20100826225459"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end, true)
+    result[:add].should == ["201008262254", "201008262255", "201008262256", "201008262257", "201008262258", "201008262259"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :hour, t_start, t_end, true)
+    result[:add].should == ["2010082622", "2010082623"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :day, t_start, t_end, true)
+    result[:add].should == ["20100826", "20100827", "20100828", "20100829", "20100830", "20100831"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :month, t_start, t_end, true)
+    result[:add].should == ["201008", "201009", "201010", "201011", "201012"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_start_keys_for, :year, t_start, t_end, true)
+    result[:add].should == ["2011", "2012", "2013"]
+    result[:rem].should == []
+
+    #
+    # Reverse / Inteligent start fetching
+    # Dates: 5:06, 4th April, 2010 --> 22:52, 14th February, 2011
+    #
+
+    t_start = Time.utc(2010, 4, 4, 5, 6, 4)
+    t_end = Time.utc(2013, 2, 14, 22, 52, 3)
+
+    result = @finder.send(:find_start_keys_for, :sec, t_start, t_end, true)
+    result[:add].should == ["201004040506"]
+    result[:rem].should == ["20100404050600", "20100404050601", "20100404050602", "20100404050603"]
+
+    result = @finder.send(:find_start_keys_for, :min, t_start, t_end, true)
+    result[:add].should == ["2010040405"]
+    result[:rem].should == ["201004040500", "201004040501", "201004040502", "201004040503", "201004040504", "201004040505"]
+
+    result = @finder.send(:find_start_keys_for, :hour, t_start, t_end, true)
+    result[:add].should == ["20100404"]
+    result[:rem].should == ["2010040400", "2010040401", "2010040402", "2010040403", "2010040404"]
+
+    result = @finder.send(:find_start_keys_for, :day, t_start, t_end, true)
+    result[:add].should == ["201004"]
+    result[:rem].should == ["20100401", "20100402", "20100403"]
+
+    result = @finder.send(:find_start_keys_for, :month, t_start, t_end, true)
+    result[:add].should == ["2010"]
+    result[:rem].should == ["201001", "201002", "201003"]
+
+    result = @finder.send(:find_start_keys_for, :year, t_start, t_end, true)
+    result[:add].should == ["2011", "2012", "2013"]
+    result[:rem].should == []
+
+    #
+    # Simple fetching
+    # Dates: 22:04, 26th December, 2007 --> 5:06, 7th May, 2010
+    #
+
+    t_start = Time.utc(2007, 12, 26, 22, 4, 4)
+    t_end = Time.utc(2010, 5, 7, 5, 6, 3)
+
+    result = @finder.send(:find_end_keys_for, :sec, t_start, t_end, true)
+    result[:add].should == ["20100507050600", "20100507050601", "20100507050602", "20100507050603"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end, true)
+    result[:add].should == ["201005070500", "201005070501", "201005070502", "201005070503", "201005070504", "201005070505", "201005070506"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :hour, t_start, t_end, true)
+    result[:add].should == ["2010050700", "2010050701", "2010050702", "2010050703", "2010050704", "2010050705"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :day, t_start, t_end, true)
+    result[:add].should == ["20100501", "20100502", "20100503", "20100504", "20100505", "20100506", "20100507"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :month, t_start, t_end, true)
+    result[:add].should == ["201001", "201002", "201003", "201004", "201005"]
+    result[:rem].should == []
+
+    result = @finder.send(:find_end_keys_for, :year, t_start, t_end, true)
+    result[:add].should == ["2010"]
+    result[:rem].should == []
+
+    #
+    # Reverse / Inteligent fetching
+    # Dates: 22:04, 26th December, 2009 --> 22:56, 27th October, 2010
+    #
+
+    t_start = Time.utc(2009, 12, 26, 22, 4, 4)
+    t_end = Time.utc(2010, 10, 27, 22, 56, 57)
+
+    result = @finder.send(:find_end_keys_for, :sec, t_start, t_end, true)
+    result[:add].should == ["201010272256"]
+    result[:rem].should == ["20101027225658", "20101027225659"]
+
+    result = @finder.send(:find_end_keys_for, :min, t_start, t_end, true)
+    result[:add].should == ["2010102722"]
+    result[:rem].should == ["201010272257", "201010272258", "201010272259"]
+
+    result = @finder.send(:find_end_keys_for, :hour, t_start, t_end, true)
+    result[:add].should == ["20101027"]
+    result[:rem].should == ["2010102723"]
+
+    result = @finder.send(:find_end_keys_for, :day, t_start, t_end, true)
+    result[:add].should == ["201010"]
+    result[:rem].should == ["20101028", "20101029", "20101030", "20101031"]
+
+    result = @finder.send(:find_end_keys_for, :month, t_start, t_end, true)
+    result[:add].should == ["2010"]
+    result[:rem].should == ["201011", "201012"]
+
+    result = @finder.send(:find_end_keys_for, :year, t_start, t_end, true)
+    result[:add].should == ["2010"]
+    result[:rem].should == []
+
+  end
+
+end