redisrank 0.1.0

data/spec/model_spec.rb

@@ -0,0 +1,191 @@
+require "spec_helper"
+require "model_helper"
+
+describe Redisrank::Model do
+  include Redisrank::Database
+
+  before(:each) do
+    @time = Time.utc(2010, 8, 28, 12, 0, 0)
+    ModelHelper1.redis.flushdb
+    ModelHelper2.redis.flushdb
+    ModelHelper3.redis.flushdb
+    ModelHelper4.redis.flushdb
+  end
+
+  it "should should name itself correctly" do
+    ModelHelper1.send(:name).should == "ModelHelper1"
+    ModelHelper2.send(:name).should == "ModelHelper2"
+  end
+
+  it "should return a Finder" do
+    two_hours_ago = 2.hours.ago
+    one_hour_ago  = 1.hour.ago
+    finder = ModelHelper1.find('label', two_hours_ago, one_hour_ago)
+    finder.should be_a(Redisrank::Finder)
+    finder.options[:scope].to_s.should == 'ModelHelper1'
+    finder.options[:label].to_s.should == 'label'
+    finder.options[:from].should  == two_hours_ago
+    finder.options[:till].should  == one_hour_ago
+  end
+
+  it "should #find_event" do
+    Redisrank::Event.should_receive(:find).with('ModelHelper1', 1)
+    ModelHelper1.find_event(1)
+  end
+
+  it "should listen to model-defined options" do
+    ModelHelper2.depth.should == :day
+    ModelHelper2.store_event.should == true
+    ModelHelper2.hashed_label.should == true
+    ModelHelper2.scope.should be_nil
+    ModelHelper2.expire.should be_nil
+
+    ModelHelper1.depth.should == nil
+    ModelHelper1.store_event.should == nil
+    ModelHelper1.hashed_label.should == nil
+    ModelHelper1.depth(:hour)
+    ModelHelper1.depth.should == :hour
+    ModelHelper1.store_event(true)
+    ModelHelper1.store_event.should == true
+    ModelHelper1.hashed_label(true)
+    ModelHelper1.hashed_label.should == true
+    ModelHelper1.options[:depth] = nil
+    ModelHelper1.options[:store_event] = nil
+    ModelHelper1.options[:hashed_label] = nil
+    ModelHelper1.depth.should == nil
+    ModelHelper1.store_event.should == nil
+    ModelHelper1.hashed_label.should == nil
+
+    ModelHelper4.scope.should == "FancyHelper"
+    ModelHelper4.send(:name).should == "FancyHelper"
+    ModelHelper4.expire.should == {:hour => 24*3600}
+  end
+
+  it "should store and fetch stats" do
+    ModelHelper1.store("sheep.black", {:count => 6, :weight => 461}, @time.hours_ago(4))
+    ModelHelper1.store("sheep.black", {:count => 2, :weight => 156}, @time)
+
+    stats = ModelHelper1.fetch("sheep.black", @time.hours_ago(2), @time.hours_since(1))
+    stats.rank["count"].should == 2
+    stats.rank["weight"].should == 156
+    
+    stats = ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1))
+    stats.rank[:count].should == 6
+    stats.rank[:weight].should == 461
+    
+    ModelHelper1.store("sheep.white", {:count => 5, :weight => 50}, @time.hours_ago(4))
+    ModelHelper1.store("sheep.white", {:count => 4, :weight => 500}, @time)
+
+    stats = ModelHelper1.fetch("sheep.white", @time.hours_ago(2), @time.hours_since(1))
+    stats.rank[:count].should == 4
+    stats.rank[:weight].should == 500
+    
+    stats = ModelHelper1.fetch("sheep.white", @time.hours_ago(5), @time.hours_since(1))
+    stats.rank[:count].should == 5
+    stats.rank[:weight].should == 500
+      end
+
+  it "should store and fetch grouping enabled stats" do
+    ModelHelper1.store("sheep/black", {:count => 6, :weight => 461}, @time.hours_ago(4))
+    ModelHelper1.store("sheep/black", {:count => 2, :weight => 156}, @time)
+    ModelHelper1.store("sheep/white", {:count => 5, :weight => 393}, @time.hours_ago(4))
+    ModelHelper1.store("sheep/white", {:count => 4, :weight => 100}, @time)
+
+    stats = ModelHelper1.fetch("sheep/black", @time.hours_ago(2), @time.hours_since(1))
+    stats.rank["count"].should == 2
+    stats.rank["weight"].should == 156
+    
+    stats = ModelHelper1.fetch("sheep/black", @time.hours_ago(5), @time.hours_since(1))
+    stats.rank[:count].should == 6
+    stats.rank[:weight].should == 461
+    
+    stats = ModelHelper1.fetch("sheep/white", @time.hours_ago(2), @time.hours_since(1))
+    stats.rank[:count].should == 4
+    stats.rank[:weight].should == 100
+    
+    stats = ModelHelper1.fetch("sheep/white", @time.hours_ago(5), @time.hours_since(1))
+    stats.rank[:count].should == 5
+    stats.rank[:weight].should == 393
+    
+    stats = ModelHelper1.fetch("sheep", @time.hours_ago(2), @time.hours_since(1))
+    stats.rank[:count].should == 4
+    stats.rank[:weight].should == 156
+    
+    stats = ModelHelper1.fetch("sheep", @time.hours_ago(5), @time.hours_since(1))
+    stats.rank[:count].should == 6
+    stats.rank[:weight].should == 461
+  end
+
+  it "should connect to different Redis servers on a per-model basis" do
+    ModelHelper3.redis.client.db.should == 14
+
+    ModelHelper3.store("sheep.black", {:count => 6, :weight => 461}, @time.hours_ago(4), :label_indexing => false)
+    ModelHelper3.store("sheep.black", {:count => 2, :weight => 156}, @time, :label_indexing => false)
+
+    db.keys("*").should be_empty
+    ModelHelper1.redis.keys("*").should be_empty
+    db("ModelHelper3").keys("*").count.should be(5)
+    ModelHelper3.redis.keys("*").count.should be(5)
+
+    stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(2), @time.hours_since(1), :label_indexing => false)
+    stats.rank["count"].should == 2
+    stats.rank["weight"].should == 156
+    stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1), :label_indexing => false)
+    stats.rank[:count].should == 6
+    stats.rank[:weight].should == 461
+
+    ModelHelper3.connect_to(:port => 8379, :db => 13)
+    ModelHelper3.redis.client.db.should == 13
+
+    stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1), :label_indexing => false)
+    stats.rank.should == {}
+
+    ModelHelper3.connect_to(:port => 8379, :db => 14)
+    ModelHelper3.redis.client.db.should == 14
+
+    stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1), :label_indexing => false)
+    stats.rank[:count].should == 6
+    stats.rank[:weight].should == 461
+  end
+
+  describe "Write Buffer" do
+    before(:each) do
+      Redisrank.buffer_size = 20
+    end
+
+    after(:each) do
+      Redisrank.buffer_size = 0
+    end
+
+    it "should buffer calls in memory before committing to Redis" do
+      14.times do
+        ModelHelper1.store("sheep.black", {:count => 1, :weight => 461}, @time.hours_ago(4))
+      end
+      ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1)).rank.should == {}
+
+      5.times do
+        ModelHelper1.store("sheep.black", {:count => 1, :weight => 156}, @time)
+      end
+      ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1)).rank.should == {}
+
+      ModelHelper1.store("sheep.black", {:count => 1, :weight => 156}, @time)
+      stats = ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1))
+      stats.rank["count"].should == 1
+      stats.rank["weight"].should == 461
+    end
+
+    it "should force flush buffer when #flush(true) is called" do
+      ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1)).rank.should == {}
+      14.times do
+        ModelHelper1.store("sheep.black", {:count => 1, :weight => 461}, @time.hours_ago(4))
+      end
+      ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1)).rank.should == {}
+      Redisrank.buffer.flush(true)
+
+      stats = ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1))
+      stats.rank["count"].should == 1
+      stats.rank["weight"].should == 461
+    end
+  end
+
+end

data/spec/options_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Redisrank::Options do
+
+  before(:each) do
+    @helper = OptionsHelper.new
+    @helper.parse_options(:wtf => 'dude', :foo => 'booze')
+  end
+
+  it "should #parse_options" do
+    @helper.options[:hello].should == 'world'
+    @helper.options[:foo].should == 'booze'
+    @helper.options[:wtf].should == 'dude'
+    @helper.raw_options.should_not have_key(:hello)
+  end
+
+  it "should create option_accessors" do
+    @helper.hello.should == 'world'
+    @helper.hello('woooo')
+    @helper.hello.should == 'woooo'
+  end
+
+end
+
+class OptionsHelper
+  include Redisrank::Options
+
+  option_accessor :hello
+
+  def default_options
+    { :hello => 'world',
+      :foo => 'bar' }
+  end
+
+
+end

data/spec/redis-test.conf

@@ -0,0 +1,9 @@
+daemonize yes
+dir ./spec/db
+pidfile ./redis.pid
+port 8379
+bind 127.0.0.1
+timeout 300
+loglevel debug
+logfile stdout
+databases 16

data/spec/result_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Redisrank::Result do
+
+  it "should should initialize properly" do
+    options = {:from => "from", :till => "till"}
+    result = Redisrank::Result.new(options)
+    result.from.should == "from"
+    result.till.should == "till"
+  end
+
+  it "should have merge_to_max method" do
+    result = Redisrank::Result.new
+    result[:world].should be_nil
+    result.merge_to_max(:world, 3)
+    result[:world].should == 3
+    result.merge_to_max(:world, 8)
+    result[:world].should == 8
+    result.merge_to_max(:world, 3)
+    result[:world].should == 8
+  end
+
+end

data/spec/scope_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Redisrank::Scope do
+  include Redisrank::Database
+
+  before(:all) do
+    db.flushdb
+  end
+
+  before(:each) do
+    @name = "PageViews"
+    @scope = Redisrank::Scope.new(@name)
+  end
+
+  it "should initialize properly" do
+    @scope.to_s.should == @name
+  end
+
+  it "should increment next_id" do
+    scope = Redisrank::Scope.new("Visitors")
+    @scope.next_id.should == 1
+    scope.next_id.should == 1
+    @scope.next_id.should == 2
+    scope.next_id.should == 2
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# add project-relative load paths
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec'
+  add_filter '/vendor'
+end
+
+# require stuff
+require 'redisrank'
+require 'rspec'
+require 'rspec/autorun'
+
+# use the test Redisrank instance
+Redisrank.connect(:port => 8379, :db => 15, :thread_safe => true)
+Redisrank.redis.flushdb

data/spec/summary_spec.rb

@@ -0,0 +1,177 @@
+require "spec_helper"
+
+describe Redisrank::Summary do
+  include Redisrank::Database
+
+  before(:each) do
+    db.flushdb
+    @scope = "PageViews"
+    @label = "about_us"
+    @date = Time.now
+    @key = Redisrank::Key.new(@scope, @label, @date, {:depth => :day})
+    @stats = {"views" => 3, "visitors" => 2}
+    @expire = {:hour => 24*3600}
+  end
+
+  it "should update a single summary properly" do
+    Redisrank::Summary.send(:update_fields, @key, @stats, :hour)
+    summary = db.zrevrange(@key.to_s(:hour), 0, -1, :with_scores => true)
+    expect(summary.count).to be 2
+    views = summary.first 
+    expect(views.first).to eq('views')
+    expect(views.last).to be 3.0
+    visitors = summary.last
+    expect(visitors.first).to eq('visitors')
+    expect(visitors.last).to be 2.0
+
+    Redisrank::Summary.send(:update_fields, @key, @stats, :hour)
+    summary = db.zrevrange(@key.to_s(:hour), 0, -1, :with_scores => true)
+    expect(summary.count).to be 2
+    views = summary.first 
+    expect(views.first).to eq('views')
+    expect(views.last).to be 3.0
+    visitors = summary.last
+    expect(visitors.first).to eq('visitors')
+    expect(visitors.last).to be 2.0
+  end
+
+  it "should set key expiry properly" do
+    Redisrank::Summary.update_all(@key, @stats, :hour,{:expire => @expire})
+    ((24*3600)-1..(24*3600)+1).should include(db.ttl(@key.to_s(:hour)))
+    [:day, :month, :year].each do |depth|
+      db.ttl(@key.to_s(depth)).should == -1
+    end
+
+    db.flushdb
+    Redisrank::Summary.update_all(@key, @stats, :hour, {:expire => {}})
+    [:hour, :day, :month, :year].each do |depth|
+      db.ttl(@key.to_s(depth)).should == -1
+    end
+  end
+
+  it "should update all summaries properly" do
+    Redisrank::Summary.update_all(@key, @stats, :sec)
+    [:year, :month, :day, :hour, :min, :sec, :usec].each do |depth|
+      summary = db.zrevrange(@key.to_s(depth), 0, -1, :with_scores => true)
+      if depth != :usec
+        summary.count.should eq(2)
+        views = summary.first 
+        expect(views.first).to eq('views')
+        expect(views.last).to be 3.0
+        visitors = summary.last
+        expect(visitors.first).to eq('visitors')
+        expect(visitors.last).to be 2.0
+      else
+        summary.count.should eq(0)
+      end
+    end
+  end
+
+  it "should update summaries even if no label is set" do
+    key = Redisrank::Key.new(@scope, nil, @date, {:depth => :day})
+    Redisrank::Summary.send(:update_fields, key, @stats, :hour)
+    summary = db.zrevrange(key.to_s(:hour), 0, -1, :with_scores => true)
+    views = summary.first 
+    expect(views.first).to eq('views')
+    expect(views.last).to be 3.0
+    visitors = summary.last
+    expect(visitors.first).to eq('visitors')
+    expect(visitors.last).to be 2.0
+  end
+
+  it "should inject stats key grouping summaries" do
+    hash = { "count/hello" => 3, "count/world"   => 7,
+             "death/bomb"  => 4, "death/unicorn" => 3,
+             :"od/sugar"   => 7, :"od/meth"      => 8 }
+    res = Redisrank::Summary.send(:inject_group_summaries, hash)
+    res.should == { "count" => 10, "count/hello" => 3, "count/world"   => 7,
+                    "death" => 7,  "death/bomb"  => 4, "death/unicorn" => 3,
+                    "od"    => 15, :"od/sugar"   => 7, :"od/meth"      => 8 }
+  end
+
+  it "should properly store key group summaries" do
+    stats = {"views" => 3, "visitors/eu" => 2, "visitors/us" => 4}
+    Redisrank::Summary.update_all(@key, stats, :hour)
+    summary = db.zrevrange(@key.to_s(:hour), 0, -1, :with_scores => true)
+    summary.count.should eq(4)
+    
+    views = summary.select{|s| s.first == 'views'}.first
+    visitors = summary.select{|s| s.first == 'visitors'}.first
+    eu = summary.select{|s| s.first == 'visitors/eu'}.first
+    us = summary.select{|s| s.first == 'visitors/us'}.first
+    
+    views.last.should == 3.0
+    visitors.last.should == 6.0
+    eu.last.should == 2.0
+    us.last.should == 4.0
+  end
+
+  it "should not store key group summaries when option is disabled" do
+    stats = {"views" => 3, "visitors/eu" => 2, "visitors/us" => 4}
+    Redisrank::Summary.update_all(@key, stats, :hour, {:enable_grouping => false})
+    summary = db.zrevrange(@key.to_s(:hour), 0, -1, :with_scores => true)
+    summary.count.should eq(3)
+    
+    views = summary.select{|s| s.first == 'views'}.first
+    eu = summary.select{|s| s.first == 'visitors/eu'}.first
+    us = summary.select{|s| s.first == 'visitors/us'}.first
+
+    views.last.should == 3.0
+    eu.last.should == 2.0
+    us.last.should == 4.0
+  end
+
+  it "should store label-based grouping enabled stats" do
+    stats = {"views" => 3, "visitors/eu" => 2, "visitors/us" => 4}
+    label = "views/about_us"
+    key = Redisrank::Key.new(@scope, label, @date)
+    Redisrank::Summary.update_all(key, stats, :hour)
+
+    key.groups[0].label.to_s.should == "views/about_us"
+    key.groups[1].label.to_s.should == "views"
+    child1 = key.groups[0]
+    parent = key.groups[1]
+
+    label = "views/contact"
+    key = Redisrank::Key.new(@scope, label, @date)
+    Redisrank::Summary.update_all(key, stats, :hour)
+
+    key.groups[0].label.to_s.should == "views/contact"
+    key.groups[1].label.to_s.should == "views"
+    child2 = key.groups[0]
+
+    summary = db.zrevrange(child1.to_s(:hour), 0, -1, :with_scores => true)
+    summary.count.should eq(4)
+    
+    views = summary.select{|s| s.first == 'views'}.first
+    eu = summary.select{|s| s.first == 'visitors/eu'}.first
+    us = summary.select{|s| s.first == 'visitors/us'}.first
+
+    views.last.should == 3.0
+    eu.last.should == 2.0
+    us.last.should == 4.0
+
+    summary = db.zrevrange(child2.to_s(:hour), 0, -1, :with_scores => true)
+    summary.count.should eq(4)
+    
+    views = summary.select{|s| s.first == 'views'}.first
+    eu = summary.select{|s| s.first == 'visitors/eu'}.first
+    us = summary.select{|s| s.first == 'visitors/us'}.first
+
+    views.last.should == 3.0
+    eu.last.should == 2.0
+    us.last.should == 4.0
+
+    summary = db.zrevrange(parent.to_s(:hour), 0, -1, :with_scores => true)
+    summary.count.should eq(4)
+    
+    views = summary.select{|s| s.first == 'views'}.first
+    eu = summary.select{|s| s.first == 'visitors/eu'}.first
+    us = summary.select{|s| s.first == 'visitors/us'}.first
+
+    views.last.should == 3.0
+    eu.last.should == 2.0
+    us.last.should == 4.0
+  end
+
+end