blackbeard 0.0.2.0 → 0.0.3.1

data/spec/context_spec.rb

@@ -1,26 +1,101 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe Blackbeard::Context do
-  let(:pirate) { Blackbeard::Pirate.new }
-  let(:context) { Blackbeard::Context.new(pirate, :user_id => 9) }
-  let(:uid) { context.unique_identifier }
-  let(:total_metric) { Blackbeard::Metric::Total.new(:total_things) }
-  let(:unique_metric) { Blackbeard::Metric::Unique.new(:unique_things) }
-
-  describe "#add_total" do
-    it "should call add on the total metric" do
-      pirate.should_receive(:total_metric).with(total_metric.name){ total_metric }
-      total_metric.should_receive(:add).with(uid, 3)
-      context.add_total( total_metric.name, 3 )
+module Blackbeard
+  describe Context do
+    let(:pirate) { Pirate.new }
+    let(:user) { double(:id => 1) }
+    let(:context) { Context.new(pirate, user) }
+    let(:uid) { context.unique_identifier }
+    let(:total_metric) { Metric.new(:total, :things) }
+    let(:unique_metric) { Metric.new(:unique, :things) }
+    let(:test) { Test.new(:example_test) }
+
+    describe "#add_total" do
+      it "should call add on the total metric" do
+        pirate.should_receive(:metric).with(:total, total_metric.id){ total_metric }
+        total_metric.should_receive(:add).with(context, 3)
+        context.add_total( total_metric.id, 3 )
+      end
     end
-  end
 
-  describe "#add_unique" do
-    it "should call add on the unique metric" do
-      pirate.should_receive(:unique_metric).with(unique_metric.name){ unique_metric }
-      unique_metric.should_receive(:add).with(uid)
-      context.add_unique( unique_metric.name )
+    describe "#add_unique" do
+      it "should call add on the unique metric" do
+        pirate.should_receive(:metric).with(:unique, unique_metric.id){ unique_metric }
+        unique_metric.should_receive(:add).with(context, 1)
+        context.add_unique( unique_metric.id )
+      end
     end
-  end
 
+    describe "#ab_test" do
+      before :each do
+        pirate.should_receive(:test).with(test.id).and_return(test)
+      end
+
+      it "should call select_variation on the test" do
+        test.should_receive(:add_variations).with([:on, :off]).and_return(test)
+        test.should_receive(:select_variation).and_return(:off)
+        context.ab_test(:example_test, :on => 1, :off => 2)
+      end
+
+      context "when passed options" do
+        before :each do
+          test.should_receive(:select_variation).and_return('double')
+        end
+
+        it "should return the value of selected option" do
+          context.ab_test(:example_test, :on => 1, :off => 2, :double => 'trouble').should == 'trouble'
+        end
+
+        it "should return nil when the selected variation is not an option" do
+          context.ab_test(:example_test, :on => 1, :off => 2).should be_nil
+        end
+      end
+
+      context "when not passed options" do
+        before :each do
+          test.should_receive(:select_variation).and_return('double')
+        end
+
+        it "should return a select_variation obj equal to the selected variation" do
+          test_result = context.ab_test(:example_test)
+          test_result.should be_a(Blackbeard::SelectedVariation)
+          test_result.should == :double
+        end
+      end
+
+    end
+
+    describe "unique_identifier" do
+      it "should work with users" do
+        Context.new(pirate, user, nil).unique_identifier.should == "a1"
+      end
+      it "should work without users" do
+        request = double(:cookies => {})
+        controller = double(:request => request)
+        Context.new(pirate, nil, controller).unique_identifier.should == "b1"
+      end
+    end
+
+    describe "#active?" do
+      let(:inactive_test) { Blackbeard::Test.new(:inactive_test) }
+      let(:active_test) { Blackbeard::Test.new(:active_test) }
+
+      before :each do
+        pirate.stub(:test).with(active_test.id).and_return(active_test)
+        pirate.stub(:test).with(inactive_test.id).and_return(inactive_test)
+      end
+
+      it "should return true when active" do
+        active_test.should_receive(:select_variation).and_return('active')
+        context.active?(:active_test).should be_true
+      end
+
+      it "should return true when active" do
+        inactive_test.should_receive(:select_variation).and_return('inactive')
+        context.active?(:inactive_test).should be_false
+      end
+
+    end
+
+  end
 end

data/spec/dashboard/groups_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + './../spec_helper')
+
+require 'rack/test'
+require 'blackbeard/dashboard'
+
+module Blackbeard
+  describe Dashboard do
+    include Rack::Test::Methods
+
+    let(:app) { Dashboard }
+
+    describe "get /" do
+      it "should redirect" do
+        get "/"
+        last_response.should be_ok
+      end
+    end
+
+    describe "get /groups" do
+      it "should list all the groups" do
+        Group.new("jostling")
+        get "/groups"
+
+        last_response.should be_ok
+        last_response.body.should include('jostling')
+      end
+    end
+
+    describe "get /groups/:id" do
+      it "should show a metric" do
+        group = Group.new("jostling")
+        get "/groups/#{group.id}"
+
+        last_response.should be_ok
+        last_response.body.should include("jostling")
+      end
+    end
+
+    describe "post /groups/:id" do
+      it "should update the group" do
+        group = Group.new("jostling")
+        post "/groups/#{group.id}", :name => 'hello'
+
+        last_response.should be_ok
+        Group.new("jostling").name.should == 'hello'
+      end
+    end
+
+  end
+end

data/spec/dashboard/home_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + './../spec_helper')
+
+require 'rack/test'
+require 'blackbeard/dashboard'
+
+module Blackbeard
+  describe Dashboard do
+    include Rack::Test::Methods
+
+    let(:app) { Dashboard }
+
+    describe "get /" do
+      it "should redirect" do
+        get "/"
+        last_response.should be_ok
+      end
+    end
+
+  end
+end

data/spec/dashboard/metrics_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + './../spec_helper')
+
+require 'rack/test'
+require 'blackbeard/dashboard'
+
+module Blackbeard
+  describe Dashboard do
+    include Rack::Test::Methods
+
+    let(:app) { Dashboard }
+
+    describe "get /metrics" do
+      it "should list all the metrics" do
+        Metric.new("total", "jostling")
+        get "/metrics"
+
+        last_response.should be_ok
+        last_response.body.should include('jostling')
+      end
+    end
+
+    describe "get /metrics/:type/:type_id" do
+      it "should show a metric" do
+        metric = Metric.new("total", "jostling")
+        get "/metrics/#{metric.type}/#{metric.type_id}"
+
+        last_response.should be_ok
+        last_response.body.should include("jostling")
+      end
+    end
+
+    describe "post /metrics/:type/:type_id" do
+      it "should update the metric" do
+        metric = Metric.new("total", "jostling")
+        post "/metrics/#{metric.type}/#{metric.type_id}", :name => 'hello'
+
+        last_response.should be_ok
+        Metric.new(:total, "jostling").name.should == 'hello'
+      end
+    end
+
+    describe "post /metrics/:type/:type_id/groups" do
+      it "should add a group to the metric" do
+        metric = Metric.new("total", "jostling")
+        group = Group.new("admin")
+        post "/metrics/#{metric.type}/#{metric.type_id}/groups", :group_id => group.id
+
+        last_response.should be_redirect
+        follow_redirect!
+        last_request.url.should == "http://example.org/metrics/#{metric.type}/#{metric.type_id}?group_id=#{group.id}"
+        metric.has_group?(group).should be_true
+      end
+    end
+
+
+  end
+end

data/spec/dashboard/tests_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + './../spec_helper')
+
+require 'rack/test'
+require 'blackbeard/dashboard'
+
+module Blackbeard
+  describe Dashboard do
+    include Rack::Test::Methods
+
+    let(:app) { Dashboard }
+
+    describe "get /tests" do
+      it "should list all the test" do
+        Test.new("jostling")
+        get "/tests"
+
+        last_response.should be_ok
+        last_response.body.should include('jostling')
+      end
+    end
+
+    describe "get /tests/:id" do
+      it "should show a test" do
+        test = Test.new("jostling")
+        get "/tests/#{test.id}"
+
+        last_response.should be_ok
+        last_response.body.should include("jostling")
+      end
+    end
+
+    describe "post /tests/:id" do
+      it "should update the test" do
+        test = Test.new("jostling")
+        post "/tests/#{test.id}", :name => 'hello'
+
+        last_response.should be_ok
+        Test.new("jostling").name.should == 'hello'
+      end
+    end
+
+  end
+end

data/spec/group_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Blackbeard::Group do
+  let(:group){ Blackbeard::Group.new('example') }
+  let(:context){ double(:controller => double, :user => double) }
+  describe "segment" do
+    context "with no code defined" do
+      it "should return nil" do
+        group.segment_for(context).should be(nil)
+      end
+    end
+    context "with code defined" do
+      it "return nil for nil" do
+        Blackbeard.config.define_group(:example){ |r,u| nil }
+        group.segment_for(context).should be(nil)
+      end
+      it "return nil for false" do
+        Blackbeard.config.define_group(:example){ |r,u| false }
+        group.segment_for(context).should be(nil)
+      end
+      it "return string for true" do
+        Blackbeard.config.define_group(:example){ |r,u| true }
+        group.segment_for(context).should eq('example')
+      end
+      it "return string for string" do
+        Blackbeard.config.define_group(:example){ |r,u| 'foo' }
+        group.segment_for(context).should eq('foo')
+      end
+      it "return string for int" do
+        Blackbeard.config.define_group(:example){ |r,u| 12 }
+        group.segment_for(context).should eq('12')
+      end
+    end
+  end
+
+end

data/spec/metric_data/base_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Blackbeard
+  module MetricData
+    describe Base do
+      let(:metric) { Blackbeard::Metric.new(:total, "one-total") }
+      let(:metric2) { Blackbeard::Metric.new(:total, "two-total") }
+      let(:metric_data) { metric.metric_data }
+
+      describe "key" do
+        it "should auto increment" do
+          metric_data.key.should == "data::1"
+          metric2.metric_data.key.should == "data::2"
+        end
+      end
+
+      describe "hour_keys" do
+
+        it "should return an empty array if no metrics" do
+          metric_data.send(:hour_keys).should == []
+        end
+
+        it "should return an array for each hour" do
+          metric_data.add('user1', 1)
+          key = metric_data.send(:key_for_hour, tz.now)
+          metric_data.send(:hour_keys).should have(1).key
+        end
+      end
+
+      describe "recent_hours" do
+        let(:start_at) { Time.new(2014,1,1,12,0,0) }
+
+        it "should return results for recent hours" do
+          metric_data.recent_hours(3, start_at).should have(3).metric_hours
+        end
+      end
+
+      describe "recent_days" do
+        let(:start_on) { Date.new(2014,1,3) }
+
+        it "should return results for recent days" do
+          metric_data.recent_days(3, start_on).should have(3).metric_days
+        end
+      end
+
+      describe "hour_keys_for_day" do
+        it "should return 1 key for every hour from morning to night" do
+            keys_for_day = metric_data.hour_keys_for_day(Date.new(2014,1,1))
+            keys_for_day.should have(24).keys
+            keys_for_day.first.should == metric_data.send(:key_for_hour, Time.new(2014,1,1,0,0,0))
+            keys_for_day.last.should == metric_data.send(:key_for_hour, Time.new(2014,1,1,23,0,0))
+        end
+      end
+
+    end
+  end
+end

data/spec/metric_data/total_spec.rb

@@ -0,0 +1,116 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Blackbeard
+  module MetricData
+
+    describe Total do
+
+      let(:metric) { Blackbeard::Metric.new(:total, "page views") }
+      let(:metric_data) { metric.metric_data }
+      let(:uid) { "unique identifier" }
+      let(:ouid) { "other unique identifier" }
+
+      describe "add" do
+        it "should increment the metric by the amount" do
+          expect{
+            metric_data.add(uid, 2)
+          }.to change{ metric_data.result_for_hour(tz.now)["total"] }.from(nil).to(2)
+        end
+
+        it "should increment an existing amount" do
+          metric_data.add(uid, 1)
+          expect{
+            metric_data.add(uid, 2)
+          }.to change{ metric_data.result_for_hour(tz.now)["total"] }.from(1).to(3)
+        end
+
+        it "should handle negatives ok" do
+          metric_data.add(uid, 2)
+          expect{
+            metric_data.add(uid, -1)
+          }.to change{ metric_data.result_for_hour(tz.now)["total"] }.from(2).to(1)
+        end
+
+        it "should handle floats" do
+          metric_data.add(uid, 2.5)
+          expect{
+            metric_data.add(uid, 1.25)
+          }.to change{ metric_data.result_for_hour(tz.now)["total"] }.to(3.75)
+        end
+
+        context "with segment" do
+          it "should increment the segment" do
+            expect{
+              metric_data.add(uid, 1, "segment")
+            }.to change{ metric_data.result_for_hour(tz.now)["segment"] }.from(nil).to(1)
+          end
+        end
+
+
+      end
+
+
+
+      describe "result_for_hour" do
+        it "should return 0 if no metric has been recorded" do
+          metric_data.result_for_hour(tz.now).should be_empty
+        end
+
+        it "should return sum if metric called more than once" do
+          metric_data.add(uid, 2)
+          metric_data.add(uid, 4)
+          metric_data.result_for_hour(tz.now).should == {"total"=>6.0}
+        end
+      end
+
+      describe "result_for_day" do
+        let(:date) { Date.new(2014,1,1) }
+        context "result in db" do
+          before :each do
+            day_key = metric_data.send(:key_for_date, date)
+            db.hash_set(day_key, "total", 4)
+          end
+          it "should return the result from db" do
+            metric_data.result_for_day(date).should == {"total"=>4.0}
+          end
+          it "should not remerge the results" do
+            metric_data.should_not_receive(:generate_result_for_day).with(date)
+            metric_data.result_for_day(date)
+          end
+        end
+
+        context "result not in db" do
+          it "should merge hours" do
+            metric_data.should_receive(:generate_result_for_day).with(date).and_return({"total" => "2"})
+            metric_data.result_for_day(date).should == {"total" => 2.0 }
+          end
+        end
+      end
+
+
+      describe "generate_result_for_day" do
+        let(:date) { Date.new(2014,1,1) }
+        before :each do
+          at_1am = Time.new(2014,1,1,1)
+          metric_data.add_at(at_1am, '1' )
+          metric_data.add_at(at_1am, '2' )
+          at_2pm = Time.new(2014,1,1,14)
+          metric_data.add_at(at_2pm, '2' )
+          metric_data.add_at(at_2pm, '3' )
+          metric_data.add_at(at_2pm, '4' )
+        end
+
+        it "should sum the hours" do
+          metric_data.send(:generate_result_for_day, date).should == {"total" => 5.0}
+        end
+
+        it "should store the result if it's not today's result" do
+          day_key = metric_data.send(:key_for_date, date)
+          db.should_receive(:hash_multi_set).with(day_key, {"total" => 5})
+          metric_data.send(:generate_result_for_day, date)
+        end
+
+      end
+    end
+  end
+end

data/spec/metric_data/unique_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Blackbeard
+  module MetricData
+    describe Unique do
+
+      let(:metric) { Blackbeard::Metric.new(:unique, "join") }
+      let(:metric_data) { metric.metric_data }
+      let(:uid) { "unique identifier" }
+      let(:ouid) { "other unique identifier" }
+
+      describe "add" do
+        it "should increment the metric for the uid" do
+          expect{
+            metric_data.add(uid)
+          }.to change{ metric_data.result_for_hour(tz.now)["uniques"] }.from(nil).to(1)
+        end
+
+        it "should not increment the metric for duplicate uids" do
+          metric_data.add(uid)
+          expect{
+            metric_data.add(uid)
+          }.to_not change{ metric_data.result_for_hour(tz.now) }
+        end
+
+        context "with segment" do
+          it "should increment the segment" do
+            expect{
+              metric_data.add(uid, 1, "segment")
+            }.to change{ metric_data.result_for_hour(tz.now)["segment"] }
+          end
+
+          it "should not increment the global" do
+            expect{
+              metric_data.add(uid, 1, "segment")
+            }.to_not change{ metric_data.result_for_hour(tz.now)["uniques"] }
+          end
+        end
+
+      end
+
+      describe "result_for_hour" do
+        it "should empty if no metric has been recorded" do
+          metric_data.result_for_hour(tz.now).should be_empty
+        end
+
+        it "should return 1 if metric called once" do
+          metric_data.add(uid)
+          metric_data.result_for_hour(tz.now).should == {"uniques" => 1}
+        end
+
+        it "should return 1 if metric called more than once" do
+          3.times{ metric_data.add(uid) }
+          metric_data.result_for_hour(tz.now).should == {"uniques" => 1}
+        end
+
+        it "should return 2 if metric was called with 2 uniques" do
+          metric_data.add(uid)
+          metric_data.add(ouid)
+          metric_data.result_for_hour(tz.now).should == {"uniques" => 2}
+        end
+
+      end
+
+      describe "generate_result_for_day" do
+        let(:date) { Date.new(2014,1,1) }
+        before :each do
+          at_1am = Time.new(2014,1,1,1)
+          metric_data.add_at(at_1am, '1' )
+          metric_data.add_at(at_1am, '2' )
+          at_2pm = Time.new(2014,1,1,14)
+          metric_data.add_at(at_2pm, '2' )
+          metric_data.add_at(at_2pm, '3' )
+          metric_data.add_at(at_2pm, '4' )
+        end
+
+        it "should sum the hours" do
+          metric_data.send(:generate_result_for_day, date).should == {"uniques" => 4}
+        end
+
+        it "should store the result if it's not today's result" do
+          day_key = metric_data.send(:key_for_date, date)
+          db.should_receive(:hash_multi_set).with(day_key, {"uniques" => 4})
+          metric_data.send(:generate_result_for_day, date)
+        end
+
+      end
+    end
+  end
+
+end