blackbeard 0.0.2.0 → 0.0.3.1

data/spec/metric_spec.rb

@@ -1,50 +1,58 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe Blackbeard::Metric do
-
-  describe "hour_keys" do
-    before :each do
-      @total_metric = Blackbeard::Metric::Total.new("one-total")
-    end
-
-    it "should return an empty array if no metrics" do
-      @total_metric.send(:hour_keys).should == []
-    end
-
-    it "should return an array for each hour" do
-      @total_metric.add('user1', 1)
-      key = @total_metric.send(:key_for_hour, Blackbeard.tz.now)
-      @total_metric.send(:hour_keys).should == [key]
+module Blackbeard
+  describe Metric do
+    let(:metric) { Metric.new(:total, "one-total") }
+    let(:group) { Group.new(:example) }
+    let(:metric_data) { metric.metric_data }
+    let(:group_metric_data) { metric.metric_data(group) }
+
+    describe "self.all" do
+      before :each do
+        Metric.new(:total, "one-total")
+        Metric.new(:total, "two-total")
+        Metric.new(:unique, "one-unique")
+      end
+      it "should return a Metric Object for each Metric created" do
+        Metric.all.should have(3).metrics
+      end
+    end
+
+    describe "add" do
+      let(:context) { double(:unique_identifier => 'uid', :controller => double, :user => double) }
+      before :each do
+        metric.stub(:groups).and_return([group])
+      end
+
+      it "should increment metric data" do
+        metric_data.should_receive(:add).with("uid",1)
+        metric.add(context, 1)
+      end
+
+      it "should increment metric data for each group" do
+        group.stub(:segment_for).and_return("segment")
+        group_metric_data.should_receive(:add).with("uid", 1, "segment" )
+        metric.add(context, 1)
+      end
+
+      it "should not increment nil segments" do
+        group.stub(:segment_for).and_return(nil)
+        group_metric_data.should_not_receive(:add)
+        metric.add(context, 1)
+      end
+    end
+
+    describe "addable_groups" do
+      it "should include the groups not added" do
+        group # to initialize it
+        metric.addable_groups.map{|g| g.id }.should include(group.id)
+      end
+
+      it "should not include the group added" do
+        metric.add_group(group)
+        metric.addable_groups.map{|g| g.id }.should_not include(group.id)
+      end
     end
 
   end
-
-  describe "hours" do
-    before :each do
-      @total_metric = Blackbeard::Metric::Total.new("one-total")
-    end
-
-    it "should return an array of hashes" do
-      @total_metric.add('user1', 1)
-      @total_metric.hours.should be_an(Array)
-      @total_metric.hours.first.should be_a(Hash)
-    end
-  end
-
-  describe "self.all" do
-    before :each do
-      Blackbeard::Metric::Total.new("one-total")
-      Blackbeard::Metric::Total.new("two-total")
-      Blackbeard::Metric::Unique.new("one-unique")
-    end
-    it "should return a Metric Object for each Metric created" do
-      Blackbeard::Metric.all.should have(3).metrics
-    end
-
-    it "should instantiate each metric with the correct class" do
-      Blackbeard::Metric.all.select{|m| m.name == "two-total"}.should have(1).metric
-      Blackbeard::Metric.all.select{|m| m.name == "two-total"}.first.should be_a(Blackbeard::Metric::Total)
-    end
-  end
-
 end

data/spec/pirate_spec.rb

@@ -6,20 +6,16 @@ describe Blackbeard::Pirate do
   describe "memoization" do
     let(:name){ "bond" }
 
-    it "should get features once" do
-      Blackbeard::Feature.should_receive(:new).with(name).once.and_return(true)
-      4.times{ pirate.feature(name) }
+    it "should get metrics once" do
+      Blackbeard::Metric.should_receive(:new).with(:total, name).once.and_return(double)
+      4.times{ pirate.metric(:total, name) }
     end
 
-    it "should get unique metrics once" do
-      Blackbeard::Metric::Unique.should_receive(:new).with(name).once.and_return(true)
-      4.times{ pirate.unique_metric(name) }
+    it "should get test once" do
+      Blackbeard::Test.should_receive(:new).with(name).once.and_return(double)
+      4.times{ pirate.test(name) }
     end
 
-    it "should get total metrics once" do
-      Blackbeard::Metric::Total.should_receive(:new).with(name).once.and_return(true)
-      4.times{ pirate.total_metric(name) }
-    end
 
   end
 
@@ -33,15 +29,26 @@ describe Blackbeard::Pirate do
 
   describe "set context delegations" do
     context "with no set context" do
-      it "should raise Blackbeard::MissingContextError" do
-        expect{ pirate.add_unique(:exmaple) }.to raise_error( Blackbeard::MissingContextError )
+      it "add_unique should raise Blackbeard::MissingContextError" do
+        expect{ pirate.add_unique(:example) }.to_not raise_error
+      end
+
+      it "add_total should raise Blackbeard::MissingContextError" do
+        expect{ pirate.add_total(:example, 1) }.to_not raise_error
       end
-      it "should raise Blackbeard::MissingContextError" do
-        expect{ pirate.add_total(:exmaple, 1) }.to raise_error( Blackbeard::MissingContextError )
+
+      it "ab_test should raise Blackbeard::MissingContextError" do
+        expect{ pirate.ab_test(:example, :on => 1, :off => 2) }.to_not raise_error
+      end
+
+      it "active? should raise Blackbeard::MissingContextError" do
+        expect{ pirate.active?(:example) }.to_not raise_error
       end
+
     end
     context "with context set" do
-      let!(:set_context){ pirate.set_context(:user_id => 1) }
+      let(:user){ double }
+      let!(:set_context){ pirate.set_context(user) }
 
       it "should delegate #add_unique" do
         set_context.should_receive(:add_unique).with(:example_metric).and_return(set_context)
@@ -52,6 +59,16 @@ describe Blackbeard::Pirate do
         set_context.should_receive(:add_total).with(:example_metric, 1).and_return(set_context)
         pirate.add_total(:example_metric, 1)
       end
+
+      it "should delegate #ab_test" do
+        set_context.should_receive(:ab_test).with(:example_metric, :on => 1, :off => 2).and_return(set_context)
+        pirate.ab_test(:example_metric, :on => 1, :off => 2)
+      end
+
+      it "should delegate #active?" do
+        set_context.should_receive(:active?).with(:example_metric).and_return(false)
+        pirate.active?(:example_metric)
+      end
     end
   end
 

data/spec/redis_store_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Blackbeard
+  describe RedisStore do
+
+    it "should keep keys" do
+      db.set("hello", "world")
+      db.keys.should == ["hello"]
+    end
+
+    describe "hashes" do
+      it "should set and get" do
+        db.hash_set('a_hash', 'hello', 'world')
+        db.hash_get('a_hash', 'hello').should == 'world'
+      end
+
+      it "should multi set" do
+        db.hash_multi_set('a_hash', {:one => 'two', :three => 'four'})
+        db.hash_get('a_hash','three').should == 'four'
+      end
+
+      it "should not raise error on multi set with empty hash" do
+        expect{
+          db.hash_multi_set('a_hash', {})
+        }.to_not raise_error
+      end
+
+      it "should set if field does not exist" do
+        db.hash_set('a_hash', 'hello', 'world')
+        db.hash_key_set_if_not_exists('a_hash', 'hello', 'bar')
+        db.hash_get('a_hash', 'hello').should == 'world'
+        db.hash_key_set_if_not_exists('a_hash', 'foo', 'bar')
+        db.hash_get('a_hash', 'foo').should == 'bar'
+      end
+
+      it "should return lenth and keys" do
+        db.hash_set('a_hash', 'foo', 'bar')
+        db.hash_set('a_hash', 'hello', 'world')
+        db.hash_length('a_hash').should eq(2)
+        db.hash_keys('a_hash').should include('foo', 'hello')
+      end
+
+      it "should get all" do
+        db.hash_set('a_hash', 'foo', 'bar')
+        db.hash_set('a_hash', 'hello', 'world')
+        db.hash_get_all('a_hash').should include('foo' => 'bar', 'hello' => 'world')
+      end
+
+      it "should increment by float" do
+        db.hash_increment_by_float('a_hash', 'field', 1)
+        db.hash_increment_by_float('a_hash', 'field', 2.5)
+        db.hash_get('a_hash', 'field').should == "3.5"
+      end
+    end
+
+    describe "sets" do
+      it "should add and remove" do
+        db.set_add_member('a_set', 'foo')
+        db.set_add_member('a_set', 'bar')
+        db.set_members('a_set').should include('foo', 'bar')
+        db.set_remove_member('a_set', 'bar')
+        db.set_members('a_set').should_not include('bar')
+      end
+
+      it "should return true if added" do
+        db.set_add_member('a_set', 'foo').should be(true)
+        db.set_add_member('a_set', 'foo').should be(false)
+      end
+
+      it "should return all the members" do
+        db.set_add_member('a_set', 'foo')
+        db.set_add_member('a_set', 'bar')
+        db.set_members('a_set').should include('foo', 'bar')
+      end
+
+      it "should set multiple members at once" do
+        db.set_add_members('a_set', 'foo', ['bar', 'shag'])
+        db.set_members('a_set').should include('foo', 'bar', 'shag')
+      end
+
+      it "should count the members" do
+        db.set_add_members('a_set', 'foo', 'bar')
+        db.set_count('a_set').should eq(2)
+      end
+
+      it "should count the union" do
+        db.set_add_members('a_set', 'foo', 'bar')
+        db.set_add_members('x_set', 'bar', 'world')
+        db.set_union_count('a_set','x_set').should eq(3)
+      end
+
+    end
+
+    describe "strings" do
+      it "should get and set" do
+        db.set('hello','world')
+        db.get('hello').should eq('world')
+      end
+
+      it "should delete" do
+        db.set('hello','world')
+        expect{
+          db.del('hello')
+        }.to change{ db.get('hello') }.from('world').to(nil)
+      end
+
+      it "should get many at once" do
+        db.set('hello','world')
+        db.set('foo','bar')
+        db.multi_get('hello','herp', 'foo').should == ['world',nil,'bar']
+      end
+
+      it "should increment" do
+        db.increment('count')
+        db.get('count').should eq('1')
+        db.increment('count')
+        db.get('count').should eq('2')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,10 +1,22 @@
 require 'blackbeard'
 require 'redis'
+require "codeclimate-test-reporter"
+
+CodeClimate::TestReporter.start
 
 RSpec.configure do |config|
   config.before do
-    redis = Blackbeard.db
+    redis = Blackbeard.config.db
+    namespace = "BlackbeardTests"
     keys = redis.keys
     redis.del(keys) if keys.any?
   end
 end
+
+def tz
+  Blackbeard.config.tz
+end
+
+def db
+  Blackbeard.config.db
+end

data/spec/storable_attributes_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Blackbeard::Storable do
+  class ExampleStorableAttrBase < Blackbeard::Storable
+    string_attributes :name
+  end
+
+  class ExampleStorableAttr < ExampleStorableAttrBase
+    set_master_key :example
+  end
+
+  describe "string_attributes" do
+    it "should be read and write" do
+      example = ExampleStorableAttr.new("id")
+      example.name = "Some name"
+      example.name.should == "Some name"
+    end
+
+    it "should persist" do
+      example = ExampleStorableAttr.new("id")
+      example.name = "Some name"
+
+      example_reloaded = ExampleStorableAttr.new("id")
+      example_reloaded.name.should == "Some name"
+    end
+  end
+
+  describe "update_attributes" do
+    let(:storable){ ExampleStorableAttr.new("id") }
+    it "should not raise raise_error with non-attributes" do
+      expect{
+        storable.update_attributes(:name => 'hello')
+      }.to_not  raise_error
+    end
+    it "should update the attribute for known attributes" do
+      expect{
+        storable.update_attributes(:name => 'hello')
+      }.to change{ storable.name }.from(nil).to('hello')
+    end
+
+    it "should update the attribute for known attributes even when strings" do
+      expect{
+        storable.update_attributes("name" => 'hello')
+      }.to change{ storable.name }.from(nil).to('hello')
+    end
+  end
+end

data/spec/storable_has_many_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Blackbeard
+
+  class Thing < Storable
+    set_master_key :things
+  end
+
+  class HasManyExample < Storable
+    set_master_key :examples
+    has_many :things => Thing
+  end
+
+  describe StorableHasMany do
+    let(:example){ HasManyExample.new(:example) }
+    let(:thing){ Thing.new(:foo) }
+
+    it "should add and remove things" do
+      example.add_thing(thing)
+      expect{
+        example.remove_thing(thing)
+      }.to change{ example.has_thing?(thing) }.from(true).to(false)
+    end
+
+    it "should has_thing?" do
+      example.add_thing(thing)
+      example.has_thing?(thing).should be_true
+    end
+
+    it "should list things" do
+      expect{
+        example.add_thing(thing)
+      }.to change{ example.things.count}.from(0).to(1)
+    end
+
+    it "should list thing_ids" do
+      example.thing_ids.should == []
+      example.add_thing(thing)
+      example.thing_ids.should == [thing.id]
+    end
+
+    it "should list the keys" do
+      example.thing_keys.should == []
+      example.add_thing(thing)
+      example.thing_keys.should == [thing.key]
+    end
+  end
+
+end

data/spec/storable_has_set_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Blackbeard
+
+  class HasSetExample < Storable
+    set_master_key :examples
+    has_set :things => :thing
+  end
+
+  describe StorableHasMany do
+    let(:example){ HasSetExample.new(:example) }
+    let(:thing) { "foo" }
+
+    it "should add and remove things" do
+      example.add_thing(thing)
+      expect{
+        example.remove_thing(thing)
+      }.to change{ example.has_thing?(thing) }.from(true).to(false)
+    end
+
+    it "should add many things at once" do
+      expect{
+        example.add_things("thing1", "thing2")
+      }.to change{ example.things.count }.by(2)
+    end
+
+    it "should has_thing?" do
+      example.add_thing(thing)
+      example.has_thing?(thing).should be_true
+    end
+
+    it "should list things" do
+      expect{
+        example.add_thing(thing)
+      }.to change{ example.things.count}.from(0).to(1)
+    end
+  end
+
+end

data/spec/storable_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Blackbeard::Storable do
+  class ExampleStorable < Blackbeard::Storable
+    set_master_key :example
+  end
+
+  class AnotherStorable < Blackbeard::Storable
+    set_master_key :another
+  end
+
+  it "should be able to instantiate" do
+    expect{
+      ExampleStorable.new(:some_id)
+    }.to_not raise_error
+  end
+
+  describe "master_key" do
+    it "should be by class" do
+      ExampleStorable.master_key.should == 'example'
+      AnotherStorable.master_key.should == 'another'
+    end
+  end
+
+  describe "==" do
+    it "should match class and id" do
+      (ExampleStorable.new("thing") == ExampleStorable.new("thing")).should be_true
+      (ExampleStorable.new("thing") == ExampleStorable.new("thing2")).should be_false
+      (ExampleStorable.new("thing") == AnotherStorable.new("thing")).should be_false
+    end
+  end
+
+end

data/spec/test_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Blackbeard::Test do
+  let(:test){ Blackbeard::Test.new('example') }
+
+  describe "#select_variation" do
+    # '*' - experimenting
+    # :variation
+
+    context "feature is static variation" do
+      it "should return the static variation"
+    end
+
+    context "experimenting" do
+      context "unique_identifier has already seen the variation" do
+        it "should return the same variation"
+      end
+
+      context "unique_identifier has not already seen the variation" do
+        it "should employ a strategy to select a variation"
+      end
+    end
+
+  end
+end