von 0.1.0 → 0.2.0

data/test/counters/best_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+describe Von::Counters::Best do
+  BestCounter = Von::Counters::Best
+
+  before :each do
+    Timecop.freeze(Time.local(2013, 01, 01, 06))
+    Von.config.init!
+    @redis = Redis.new
+    @redis.flushall
+  end
+
+  it "increments the best counter for a period" do
+    counter = BestCounter.new('foo', [ Von::Period.new(:day) ])
+
+    counter.increment
+
+    Timecop.freeze(Time.local(2013, 01, 02))
+    4.times { counter.increment }
+    Timecop.freeze(Time.local(2013, 01, 03))
+    3.times { counter.increment }
+
+    @redis.hget('von:counters:bests:foo:day:current', 'timestamp').must_equal '2013-01-03'
+    @redis.hget('von:counters:bests:foo:day:current', 'total').must_equal '3'
+    @redis.hget('von:counters:bests:foo:day:best', 'timestamp').must_equal '2013-01-02'
+    @redis.hget('von:counters:bests:foo:day:best', 'total').must_equal '4'
+  end
+
+  it "increments the best counter for multiple periods" do
+    counter = BestCounter.new('foo', [
+      Von::Period.new(:minute),
+      Von::Period.new(:week),
+    ])
+
+    counter.increment
+
+    Timecop.freeze(Time.local(2013, 01, 13, 06, 05))
+    4.times { counter.increment }
+    Timecop.freeze(Time.local(2013, 01, 20, 06, 10))
+    3.times { counter.increment }
+
+    @redis.hget('von:counters:bests:foo:minute:current', 'timestamp').must_equal '2013-01-20 06:10'
+    @redis.hget('von:counters:bests:foo:minute:current', 'total').must_equal '3'
+    @redis.hget('von:counters:bests:foo:minute:best', 'timestamp').must_equal '2013-01-13 06:05'
+    @redis.hget('von:counters:bests:foo:minute:best', 'total').must_equal '4'
+
+    @redis.hget('von:counters:bests:foo:week:current', 'timestamp').must_equal '2013-01-14'
+    @redis.hget('von:counters:bests:foo:week:current', 'total').must_equal '3'
+    @redis.hget('von:counters:bests:foo:week:best', 'timestamp').must_equal '2013-01-07'
+    @redis.hget('von:counters:bests:foo:week:best', 'total').must_equal '4'
+  end
+
+end

data/test/counters/current_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+describe Von::Counters::Current do
+  CurrentCounter = Von::Counters::Current
+
+  before :each do
+    Timecop.freeze(Time.local(2013, 01, 01, 06))
+    Von.config.init!
+    @redis = Redis.new
+    @redis.flushall
+  end
+
+  it "increments the current counter for a period" do
+    counter = CurrentCounter.new('foo', [ Von::Period.new(:day) ])
+
+    4.times { counter.increment }
+    Timecop.freeze(Time.local(2013, 01, 02))
+    3.times { counter.increment }
+
+    @redis.hget('von:counters:currents:foo:day', 'timestamp').must_equal '2013-01-02'
+    @redis.hget('von:counters:currents:foo:day', 'total').must_equal '3'
+  end
+
+  it "increments the current counter for multiple periods" do
+    counter = CurrentCounter.new('foo', [
+      Von::Period.new(:minute),
+      Von::Period.new(:week),
+    ])
+
+    4.times { counter.increment }
+    Timecop.freeze(Time.local(2013, 01, 20, 06, 10))
+    3.times { counter.increment }
+
+    @redis.hget('von:counters:currents:foo:minute', 'timestamp').must_equal '2013-01-20 06:10'
+    @redis.hget('von:counters:currents:foo:minute', 'total').must_equal '3'
+
+    @redis.hget('von:counters:currents:foo:week', 'timestamp').must_equal '2013-01-14'
+    @redis.hget('von:counters:currents:foo:week', 'total').must_equal '3'
+  end
+
+  it "counts acurrent counter for a period" do
+    counter = CurrentCounter.new('foo', [
+      Von::Period.new(:minute),
+      Von::Period.new(:day),
+    ])
+
+    4.times { counter.increment }
+    Timecop.freeze(Time.local(2013, 01, 01, 06, 10))
+    3.times { counter.increment }
+
+    counter.count(:minute).must_equal 3
+    counter.count(:day).must_equal 7
+  end
+
+end

data/test/counters/period_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+describe Von::Counters::Period do
+  PeriodCounter = Von::Counters::Period
+
+  before :each do
+    Timecop.freeze(Time.local(2013, 01, 01, 01, 01))
+    Von.config.init!
+    @redis = Redis.new
+    @redis.flushall
+  end
+
+  it "increments a month counter" do
+    counter = PeriodCounter.new('foo', [
+      Von::Period.new(:monthly, 1)
+    ])
+
+    counter.increment
+    counter.increment
+
+    @redis.hget('von:counters:foo:month', '2013-01').must_equal '2'
+    @redis.lrange('von:lists:foo:month', 0, -1).size.must_equal 1
+    @redis.lrange('von:lists:foo:month', 0, -1).first.must_equal '2013-01'
+  end
+
+  it 'increments a minute counter' do
+    counter = PeriodCounter.new('foo', [
+      Von::Period.new(:minutely, 60)
+    ])
+
+    counter.increment
+    counter.increment
+
+    @redis.hget('von:counters:foo:minute', '2013-01-01 01:01').must_equal '2'
+    @redis.lrange('von:lists:foo:minute', 0, -1).size.must_equal 1
+    @redis.lrange('von:lists:foo:minute', 0, -1).first.must_equal '2013-01-01 01:01'
+  end
+
+  it "expires counters past the limit" do
+    counter = PeriodCounter.new('foo', [
+      Von::Period.new(:monthly, 1)
+    ])
+
+    counter.increment
+    Timecop.freeze(Time.local(2013, 02))
+    counter.increment
+
+    @redis.hget('von:counters:foo:month', '2013-02').must_equal '1'
+    @redis.lrange('von:lists:foo:month', 0, -1).size.must_equal 1
+    @redis.lrange('von:lists:foo:month', 0, -1).first.must_equal '2013-02'
+  end
+
+
+  it "gets a count for a time period and 0s missing entries" do
+    counter = PeriodCounter.new('foo', [
+      Von::Period.new(:monthly, 1),
+      Von::Period.new(:hourly, 6)
+    ])
+
+    counter.increment
+    counter.increment
+    Timecop.freeze(Time.local(2013, 02, 01, 7))
+    counter.increment
+    Timecop.freeze(Time.local(2013, 02, 01, 9))
+    counter.increment
+
+    counter.count(:month).must_equal [{:timestamp => "2013-02", :count => 2}]
+    counter.count(:hour).must_equal [
+      { :timestamp => "2013-02-01 04:00", :count => 0 },
+      { :timestamp => "2013-02-01 05:00", :count => 0 },
+      { :timestamp => "2013-02-01 06:00", :count => 0 },
+      { :timestamp => "2013-02-01 07:00", :count => 1 },
+      { :timestamp => "2013-02-01 08:00", :count => 0 },
+      { :timestamp => "2013-02-01 09:00", :count => 1 }
+    ]
+  end
+
+end

data/test/counters/total_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+describe Von::Counters::Total do
+  TotalCounter = Von::Counters::Total
+
+  before :each do
+    Timecop.freeze(Time.local(2013, 01, 01, 01, 01))
+    Von.config.init!
+    @redis = Redis.new
+    @redis.flushall
+  end
+
+  it "increments the total counter if given a single key" do
+    counter = TotalCounter.new('foo')
+
+    counter.increment
+    @redis.hget('von:counters:foo', 'total').must_equal '1'
+
+    counter.increment
+    @redis.hget('von:counters:foo', 'total').must_equal '2'
+  end
+
+  it "gets a total count for a counter" do
+    counter = TotalCounter.new('foo')
+    counter.increment
+    counter.increment
+    counter.increment
+
+    counter.count.must_equal 3
+  end
+
+
+end

data/test/period_test.rb

@@ -1,65 +1,87 @@
+require 'test_helper'
+
 describe Von::Period do
   Period = Von::Period
 
   before :each do
     @config = Von::Config
     @config.init!
+    Timecop.freeze(Time.local(2013, 01, 02, 03, 04))
   end
 
-  it "intiializes given a counter, period, and length" do
-    period = Period.new('foo', :monthly, 6)
-    period.counter_key.must_equal 'foo'
-    period.length.must_equal 6
+  it "intiializes given a period" do
+    period = Period.new(:monthly)
+    period.name.must_equal :monthly
+    period.length.must_be_nil
     period.format.must_equal '%Y-%m'
   end
 
-  it "checks if the period is an hourly period" do
-    Period.new('foo', :hourly, 6).must_be :hours?
-    Period.new('foo', :daily, 6).wont_be :hours?
-    Period.new('foo', :weekly, 6).wont_be :hours?
-    Period.new('foo', :monthly, 6).wont_be :hours?
-    Period.new('foo', :yearly, 6).wont_be :hours?
+  it "intiializes given a time unit" do
+    period = Period.new(:month)
+    period.name.must_equal :monthly
+    period.length.must_be_nil
+    period.format.must_equal '%Y-%m'
   end
 
-  it "knows what time unit it is" do
-    Period.new('foo', :hourly, 6).time_unit.must_equal :hour
-    Period.new('foo', :daily, 6).time_unit.must_equal :day
-    Period.new('foo', :weekly, 6).time_unit.must_equal :week
-    Period.new('foo', :monthly, 6).time_unit.must_equal :month
-    Period.new('foo', :yearly, 6).time_unit.must_equal :year
+  it "intiializes given a period and length" do
+    period = Period.new(:monthly, 3)
+    period.name.must_equal :monthly
+    period.length.must_equal 3
+    period.format.must_equal '%Y-%m'
   end
 
-  it "pulls a time format from config options" do
-    Period.new('foo', :hourly, 6).format.must_equal Von.config.hourly_format
-    Period.new('foo', :daily, 6).format.must_equal Von.config.daily_format
-    Period.new('foo', :weekly, 6).format.must_equal Von.config.weekly_format
-    Period.new('foo', :monthly, 6).format.must_equal Von.config.monthly_format
-    Period.new('foo', :yearly, 6).format.must_equal Von.config.yearly_format
+  it "generates a timestamp for now" do
+    Period.new(:minutely).timestamp.must_equal '2013-01-02 03:04'
+    Period.new(:hourly).timestamp.must_equal '2013-01-02 03:00'
+    Period.new(:daily).timestamp.must_equal '2013-01-02'
+    Period.new(:weekly).timestamp.must_equal '2012-12-31'
+    Period.new(:monthly).timestamp.must_equal '2013-01'
+    Period.new(:yearly).timestamp.must_equal '2013'
   end
 
-  it "builds a redis hash key string" do
-    field  = 'foo'
-    period = :hourly
-    period_obj = Period.new(field, period, 6)
+  it "knows the prev time period" do
+    Period.new(:minutely).prev.must_equal '2013-01-02 03:03'
+    Period.new(:hourly).prev.must_equal '2013-01-02 02:00'
+    Period.new(:daily).prev.must_equal '2013-01-01'
+    Period.new(:weekly).prev.must_equal '2012-12-24'
+    Period.new(:monthly).prev.must_equal '2012-12'
+    Period.new(:yearly).prev.must_equal '2012'
+  end
 
-    period_obj.hash_key.must_equal "#{@config.namespace}:counters:#{field}:#{period}"
+  it "checks if the period is an hourly period" do
+    Period.new(:minutely).wont_be :hours?
+    Period.new(:hourly).must_be :hours?
+    Period.new(:daily).wont_be :hours?
+    Period.new(:weekly).wont_be :hours?
+    Period.new(:monthly).wont_be :hours?
+    Period.new(:yearly).wont_be :hours?
   end
 
-  it "builds a redis list key string" do
-    field  = 'foo'
-    period = :hourly
-    period_obj = Period.new(field, period, 6)
+  it "checks if the period is an hourly period" do
+    Period.new(:minutely).must_be :minutes?
+    Period.new(:hourly).wont_be :minutes?
+    Period.new(:daily).wont_be :minutes?
+    Period.new(:weekly).wont_be :minutes?
+    Period.new(:monthly).wont_be :minutes?
+    Period.new(:yearly).wont_be :minutes?
+  end
 
-    period_obj.list_key.must_equal "#{@config.namespace}:lists:#{field}:#{period}"
+  it "knows what time unit it is" do
+    Period.new(:minutely).time_unit.must_equal :minute
+    Period.new(:hourly).time_unit.must_equal :hour
+    Period.new(:daily).time_unit.must_equal :day
+    Period.new(:weekly).time_unit.must_equal :week
+    Period.new(:monthly).time_unit.must_equal :month
+    Period.new(:yearly).time_unit.must_equal :year
   end
 
-  it "builds a redis field for the given period and current time" do
-    Timecop.freeze(Time.local(2013, 02, 01, 05))
-    Period.new('foo', :hourly, 6).field.must_equal '2013-02-01 05:00'
-    Period.new('foo', :daily, 6).field.must_equal '2013-02-01'
-    Period.new('foo', :weekly, 6).field.must_equal '2013-02-01'
-    Period.new('foo', :monthly, 6).field.must_equal '2013-02'
-    Period.new('foo', :yearly, 6).field.must_equal '2013'
+  it "gets a time format from config" do
+    Period.new(:minutely).format.must_equal Von.config.minutely_format
+    Period.new(:hourly).format.must_equal Von.config.hourly_format
+    Period.new(:daily).format.must_equal Von.config.daily_format
+    Period.new(:weekly).format.must_equal Von.config.weekly_format
+    Period.new(:monthly).format.must_equal Von.config.monthly_format
+    Period.new(:yearly).format.must_equal Von.config.yearly_format
   end
 
-end
+end

data/test/test_helper.rb

@@ -6,68 +6,8 @@ Bundler.setup
 
 require 'minitest/autorun'
 require 'minitest/pride'
+require 'fakeredis'
 require 'mocha'
 require 'timecop'
 
-require 'von'
-
-module Von
-  class TestConnection
-    attr_reader :store
-
-    def initialize
-      @store = {}
-    end
-
-    def hincrby(hash, key, counter)
-      @store[hash] ||= {}
-
-      if @store[hash].has_key?(key)
-        @store[hash][key] += counter
-      else
-        @store[hash][key] = counter
-      end
-
-       @store[hash][key]
-    end
-
-    def hget(hash, key)
-      @store[hash][key]
-    end
-
-    def hgetall(hash)
-      @store.fetch(hash, {})
-    end
-
-    def hdel(hash, key)
-      @store[hash].delete(key)
-    end
-
-    def rpush(list, member)
-      @store[list] ||= []
-      @store[list] << member
-    end
-
-    def lpop(list)
-      @store[list].shift
-    end
-
-    def lrange(list, start, stop)
-      @store[list] ||= []
-      @store[list][start..stop]
-    end
-
-    def llen(list)
-      @store[list].length
-    end
-
-  end
-end
-
-module MiniTest::Expectations
-  def mock_connection!
-    connection = Von::TestConnection.new
-    @store     = connection.store
-    Von.expects(:connection).returns(connection).at_least_once
-  end
-end
+require 'von'

data/test/von_test.rb

@@ -3,20 +3,42 @@ require 'test_helper'
 describe Von do
 
   before :each do
+    Timecop.freeze(Time.local(2013, 01, 01, 01, 01))
     Von.config.init!
+    @redis = Redis.new
+    @redis.flushall
   end
 
   it "increments a counter and counts it" do
-    mock_connection!
+    3.times { Von.increment('foo') }
+    Von.count('foo').total.must_equal 3
+  end
+
+  it "increments a counter and parent counters and counts them" do
+    3.times { Von.increment('foo:bar') }
+    Von.count('foo').total.must_equal 3
+    Von.count('foo:bar').total.must_equal 3
+  end
+
+  it "increments period/best counters and counts them" do
+    Von.configure do |config|
+      config.counter 'foo', :monthly => 2, :best => :day
+    end
 
     Von.increment('foo')
+    Timecop.freeze(Time.local(2013, 02, 03))
     Von.increment('foo')
-    Von.count('foo').must_equal 2
+    Von.increment('foo')
+    Timecop.freeze(Time.local(2013, 03, 04))
+    Von.increment('foo')
+
+    Von.count('foo').best(:day).must_equal({:timestamp => "2013-02-03", :count => 2})
+    Von.count('foo').per(:month).must_equal [{:timestamp => "2013-02", :count => 2}, {:timestamp => "2013-03", :count => 1}]
   end
 
   it "raises a Redis connection errors if raise_connection_errors is true" do
     Von.config.raise_connection_errors = true
-    Redis.expects(:new).raises(Redis::CannotConnectError)
+    Von.expects(:increment).raises(Redis::CannotConnectError)
 
     lambda { Von.increment('foo') }.must_raise Redis::CannotConnectError
   end