tabs 0.9.1 → 1.0.0

data/spec/lib/tabs/config_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+require File.expand_path("../../../support/custom_resolutions", __FILE__)
+
+describe Tabs::Config do
+  context "#decimal_precision" do
+
+  	before do
+  		@precision = Tabs::Config.decimal_precision
+  	end
+
+  	after do
+  		Tabs::Config.decimal_precision = @precision
+  	end
+
+  	it "should set/get the decimal precision" do
+  	  Tabs::Config.decimal_precision = 4
+  	  expect(Tabs::Config.decimal_precision).to eq(4)
+  	end
+  end
+
+  context "#register_resolution" do
+  	it "should register a resolution" do
+	  	Tabs::Resolution.register(WellFormedResolution)
+	  	expect(Tabs::Resolution.all).to include(:seconds)
+  	end
+  end
+
+  context "#unregister_resolution" do
+  	it "should unregister a resolution" do
+  		Tabs::Resolution.unregister(:minute)
+  		expect(Tabs::Resolution.all).to_not include(:minute)
+  	end
+  end
+
+  context "#set_expirations" do
+
+    after do
+      Tabs::Config.reset_expirations
+    end
+
+    it "should allow multiple resolutions to be expired" do
+      Tabs::Config.set_expirations({ minute: 1.day, hour: 1.week })
+      expect(Tabs::Config.expiration_settings[:minute]).to eq(1.day)
+      expect(Tabs::Config.expiration_settings[:hour]).to eq(1.week)
+    end
+
+    it "should raise ResolutionMissingError if expiration passed in for invalid resolution" do
+      expect{ Tabs::Config.set_expirations({ missing_resolution: 1.day }) }
+        .to raise_error(Tabs::ResolutionMissingError)
+    end
+
+  end
+
+  context "#prefix" do
+    it "should allow custom prefix for tabs keys" do
+      Tabs::Config.prefix = "rspec"
+      expect(Tabs::Config.prefix).to eq("rspec")
+    end
+  end
+end

data/spec/lib/tabs/metrics/counter_spec.rb

@@ -25,6 +25,13 @@ describe Tabs::Metrics::Counter do
       expect(stats).to include({ "timestamp" => time, "count" => 1 })
     end
 
+    it "raises ResolutionMissingError if unregistered resolution requested" do
+      time = Time.utc(now.year, now.month, now.day, now.hour) - 2.hours
+      metric.increment(time)
+      Tabs::Resolution.unregister(:hour)
+      expect { metric.stats(((now - 3.hours)..now), :hour) }.to raise_error(Tabs::ResolutionMissingError)
+    end
+
   end
 
   describe "total count" do
@@ -47,6 +54,8 @@ describe Tabs::Metrics::Counter do
     end
 
     def create_span(time_unit)
+      metric.increment
+      Timecop.freeze(now + 1.send(time_unit))
       metric.increment
       Timecop.freeze(now + 3.send(time_unit))
       metric.increment
@@ -94,7 +103,7 @@ describe Tabs::Metrics::Counter do
     it "returns zeros for time periods which do not have any events" do
       create_span(:days)
       stats = metric.stats(now..(now + 7.days), :day)
-      expect(stats).to include({ "timestamp" => (now + 1.day), "count" => 0 })
+      expect(stats.detect{|s| s["timestamp"] == (now + 2.day)}["count"]).to eq(0)
     end
 
     context "for weekly metrics" do
@@ -106,6 +115,7 @@ describe Tabs::Metrics::Counter do
       it "returns the expected results for a weekly metric" do
         create_span(:weeks)
         stats = metric.stats(period, :week)
+        expect(stats.detect{|s| s["timestamp"] == (now + 1.week).beginning_of_week}["count"]).to eq(1)
         expect(stats).to include({ "timestamp" => (now + 3.weeks).beginning_of_week, "count" => 1 })
         expect(stats).to include({ "timestamp" => (now + 6.weeks).beginning_of_week, "count" => 2 })
       end
@@ -150,4 +160,37 @@ describe Tabs::Metrics::Counter do
 
   end
 
+  describe ".drop_by_resolution!" do
+    before do
+      Timecop.freeze(now)
+      2.times { metric.increment }
+      metric.drop_by_resolution!(:minute)
+    end
+
+    it "deletes all metrics for a resolution" do
+      stats = metric.stats((now - 1.minute)..(now + 1.minute), :minute)
+      expect(stats.total).to eq(0)
+    end
+  end
+
+  describe "expiration of counter metrics" do
+    let(:expires_setting){ 6.hours }
+    let(:now){ Time.utc(2050, 1, 1, 0, 0) }
+
+    before do
+      Tabs::Config.set_expirations({ minute: expires_setting })
+    end
+
+    after do
+      Tabs::Config.reset_expirations
+    end
+
+    it "sets an expiration when recording a value" do
+      metric.increment(now)
+      redis_expire_date = Time.now + Tabs::Storage.ttl(metric.storage_key(:minute, now))
+      expire_date = now + expires_setting + Tabs::Resolutions::Minute.to_seconds
+      expect(redis_expire_date).to be_within(2.seconds).of(expire_date)
+    end
+  end
+
 end

data/spec/lib/tabs/{task_spec.rb → metrics/task_spec.rb}

@@ -10,7 +10,7 @@ describe Tabs::Metrics::Task do
 
   describe ".start" do
 
-    let(:token) { stub(:token) }
+    let(:token) { double(:token) }
     let(:time) { Time.now }
 
     it "calls start on the given token" do
@@ -29,11 +29,10 @@ describe Tabs::Metrics::Task do
 
   describe ".complete" do
 
-    let(:token) { stub(:token) }
+    let(:token) { double(:token) }
     let(:time) { Time.now }
 
     it "calls complete on the given token" do
-      token = stub(:token)
       Tabs::Metrics::Task::Token.should_receive(:new).with(token_1, "foo").and_return(token)
       token.should_receive(:complete)
       metric.complete(token_1)
@@ -53,6 +52,16 @@ describe Tabs::Metrics::Task do
 
   describe ".stats" do
 
+    it "returns zeroes across the board for no stats" do
+      stats = metric.stats((now - 5.minutes)..(now + 5.minutes), :minute)
+
+      expect(stats.started_within_period).to eq 0
+      expect(stats.completed_within_period).to eq 0
+      expect(stats.started_and_completed_within_period).to eq 0
+      expect(stats.completion_rate).to eq 0.0
+      expect(stats.average_completion_time).to eq 0.0
+    end
+
     it "returns the expected value" do
       Timecop.freeze(now)
       metric.start(token_1)
@@ -63,6 +72,25 @@ describe Tabs::Metrics::Task do
       Timecop.freeze(now + 3.minutes)
       metric.complete(token_3)
       stats = metric.stats((now - 5.minutes)..(now + 5.minutes), :minute)
+
+      expect(stats.started_within_period).to eq 3
+      expect(stats.completed_within_period).to eq 2
+      expect(stats.started_and_completed_within_period).to eq 2
+      expect(stats.completion_rate).to eq 0.18182
+      expect(stats.average_completion_time).to eq 1.5
+    end
+
+    it "returns the expected value for a week" do
+      Timecop.freeze(now)
+      metric.start(token_1)
+      metric.start(token_2)
+      Timecop.freeze(now + 1.week)
+      metric.complete(token_1)
+      metric.start(token_3)
+      Timecop.freeze(now + 3.weeks)
+      metric.complete(token_3)
+      stats = metric.stats((now - 5.weeks)..(now + 5.weeks), :week)
+
       expect(stats.started_within_period).to eq 3
       expect(stats.completed_within_period).to eq 2
       expect(stats.started_and_completed_within_period).to eq 2

data/spec/lib/tabs/metrics/value_spec.rb

@@ -40,6 +40,8 @@ describe Tabs::Metrics::Value do
 
     def create_span(time_unit)
       metric.record(5)
+      Timecop.freeze(now + 1.send(time_unit))
+      metric.record(25)
       Timecop.freeze(now + 3.send(time_unit))
       metric.record(10)
       Timecop.freeze(now + 6.send(time_unit))
@@ -78,6 +80,8 @@ describe Tabs::Metrics::Value do
     it "returns the expected results for a weekly metric" do
       create_span(:weeks)
       stats = metric.stats(now..(now + 7.weeks), :week)
+      second_week_stats = stats.detect{|s| s["timestamp"] == (now + 1.week).beginning_of_week }
+      expect(second_week_stats["count"]).to eq(1)
       expect(stats).to include({ "timestamp" => (now + 3.weeks).beginning_of_week, "count"=>1, "min"=>10, "max"=>10, "sum"=>10, "avg"=>10})
       expect(stats).to include({ "timestamp" => (now + 6.weeks).beginning_of_week, "count"=>2, "min"=>15, "max"=>20, "sum"=>35, "avg"=>17.5})
     end
@@ -121,4 +125,36 @@ describe Tabs::Metrics::Value do
 
   end
 
+  describe ".drop_by_resolution!" do
+    before do
+      Timecop.freeze(now)
+      2.times { metric.record(rand(30)) }
+      metric.drop_by_resolution!(:minute)
+    end
+
+    it "deletes all metrics for a resolution" do
+      stats = metric.stats((now - 1.minute)..(now + 1.minute), :minute)
+      expect(stats.sum).to eq(0)
+    end
+  end
+
+  describe "expiration of value metrics" do
+    let(:expires_setting){ 6.hours }
+    let(:now){ Time.utc(2050, 1, 1, 0, 0) }
+
+    before do
+      Tabs::Config.set_expirations({ minute: expires_setting })
+    end
+
+    after do
+      Tabs::Config.reset_expirations
+    end
+
+    it "sets an expiration when recording a value" do
+      metric.record(17, now)
+      redis_expire_date = Time.now + Tabs::Storage.ttl(metric.storage_key(:minute, now))
+      expire_date = now + expires_setting + Tabs::Resolutions::Minute.to_seconds
+      expect(redis_expire_date).to be_within(2.seconds).of(expire_date)
+    end
+  end
 end

data/spec/lib/tabs/resolution_spec.rb

@@ -2,10 +2,11 @@ require "spec_helper"
 require File.expand_path("../../../support/custom_resolutions", __FILE__)
 
 describe Tabs::Resolution do
+
   describe "#register" do
     it "registers a new resolution" do
-      Tabs::Resolution.register(:test, Tabs::Resolutions::Minute)
-      expect(Tabs::Resolution.all).to include :test
+      Tabs::Resolution.register(WellFormedResolution)
+      expect(Tabs::Resolution.all).to include WellFormedResolution.name
     end
 
     context "with a custom resolution" do
@@ -14,7 +15,7 @@ describe Tabs::Resolution do
       end
 
       it "gets stats for custom resolution" do
-        Tabs::Resolution.register(:seconds, WellFormedResolution)
+        Tabs::Resolution.register(WellFormedResolution)
         Timecop.freeze(Time.now)
 
         Tabs.increment_counter("foo")
@@ -24,6 +25,28 @@ describe Tabs::Resolution do
       it "raises an error when method not implemented" do
         expect{BadlyFormedResolution.normalize}.to raise_error
       end
+
+      it "disregards already registered resolutions" do
+        expect { Tabs::Resolution.register(Tabs::Resolutions::Minute) }.to_not raise_error
+      end
     end
   end
+
+  describe "#unregister" do
+    it "unregisters a single resolution" do
+      Tabs::Resolution.unregister(:minute)
+      expect(Tabs::Resolution.all).to_not include(:minute)
+    end
+
+    it "unregisters an array of resolutions" do
+      Tabs::Resolution.unregister([:minute, :hour])
+      expect(Tabs::Resolution.all).to_not include(:hour)
+      expect(Tabs::Resolution.all).to_not include(:minute)
+    end
+
+    it "disregards passing in an unrecognized resolution" do
+      expect { Tabs::Resolution.unregister(:invalid_resolution) }.to_not raise_error
+    end
+  end
+
 end

data/spec/lib/tabs/resolutionable_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Tabs::Resolutionable do
+
+  module TestResolution
+    include Tabs::Resolutionable
+    extend self
+
+    def name
+      :test
+    end
+
+    def to_seconds
+      1000
+    end
+
+  end
+
+  describe "interface exceptions" do
+
+    ["serialize", "deserialize", "from_seconds", "add", "normalize"].each do |method|
+      it "are raised when the #{method} method is not implemented" do
+        expect { TestResolution.send(method) }.to raise_error
+      end
+    end
+
+  end
+
+  describe "#expire" do
+    let(:expires_setting){ 1.day }
+
+    before do
+      Tabs::Config.register_resolution(TestResolution)
+      Tabs::Config.set_expirations(test: expires_setting)
+    end
+
+    after do
+      Tabs::Config.reset_expirations
+      Tabs::Config.unregister_resolutions(:test)
+    end
+
+    it "sets the expiration for the given key" do
+      now = Time.utc(2050, 1, 1, 0, 0, 0)
+      Tabs::Storage.set("foo", "bar")
+      TestResolution.expire("foo", now)
+      redis_expire_date = Time.now + Tabs::Storage.ttl("foo")
+      expire_date = now + expires_setting + TestResolution.to_seconds
+      expect(redis_expire_date).to be_within(2.seconds).of(expire_date)
+    end
+
+  end
+
+end

data/spec/lib/tabs/resolutions/day_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Tabs::Resolutions::Day do
+  let(:timestamp){ Time.new(2000, 1, 1, 12, 15) }
+
+  context "#normalize" do
+    it "should normalize the date to year, month, day" do
+      expect(subject.normalize(timestamp)).to eq(timestamp.utc.change(hour: 0))
+    end
+  end
+
+  context "#serialize" do
+    it "should return YYYY-MM-DD" do
+      expect(subject.serialize(timestamp)).to eq("2000-01-01")
+    end
+  end
+
+  context "#deserialize" do
+    it "should convert string into date" do
+      expect(subject.deserialize("2000-01-01")).to eq(timestamp.utc.change(hour: 0))
+    end
+  end
+end

data/spec/lib/tabs/resolutions/hour_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Tabs::Resolutions::Hour do
+  let(:timestamp){ Time.utc(2000, 1, 1, 14, 12) }
+
+  context "#normalize" do
+    it "should normalize the date to year, month, day, hour" do
+      expect(subject.normalize(timestamp)).to eq(timestamp.change(min: 0))
+    end
+  end
+
+  context "#serialize" do
+    it "should return YYYY-MM-DD-HH" do
+      expect(subject.serialize(timestamp)).to eq("2000-01-01-14")
+    end
+  end
+
+  context "#deserialize" do
+    it "should convert string into date" do
+      expect(subject.deserialize("2000-01-01-14")).to eq(timestamp.change(min: 0))
+    end
+  end
+end

data/spec/lib/tabs/resolutions/minute_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Tabs::Resolutions::Minute do
+  let(:timestamp){ Time.utc(2000, 1, 1, 14, 12, 44) }
+
+  context "#normalize" do
+    it "should normalize the date to year, month, day, hour, minute" do
+      expect(subject.normalize(timestamp)).to eq(timestamp.change(sec: 0))
+    end
+  end
+
+  context "#serialize" do
+    it "should return YYYY-MM-DD-HH-MM" do
+      expect(subject.serialize(timestamp)).to eq("2000-01-01-14-12")
+    end
+  end
+
+  context "#deserialize" do
+    it "should convert string into date" do
+      expect(subject.deserialize("2000-01-01-14-12")).to eq(timestamp.change(sec: 0))
+    end
+  end
+end

data/spec/lib/tabs/resolutions/month_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Tabs::Resolutions::Month do
+  let(:timestamp){ Time.utc(2000, 1, 15) }
+
+  context "#normalize" do
+    it "should normalize the date to year, month" do
+      expect(subject.normalize(timestamp)).to eq(timestamp.change(day: 1))
+    end
+  end
+
+  context "#serialize" do
+    it "should return YYYY-MM" do
+      expect(subject.serialize(timestamp)).to eq("2000-01")
+    end
+  end
+
+  context "#deserialize" do
+    it "should convert string into date" do
+      expect(subject.deserialize("2000-01")).to eq(timestamp.change(day: 1))
+    end
+  end
+end