flipper 0.3.0 → 0.4.0

data/spec/flipper/adapters/memoized_spec.rb

@@ -34,13 +34,13 @@ describe Flipper::Adapters::Memoized do
 
   describe "#set_members" do
     before do
-      source['foo'] = Set[1, 2]
+      source['foo'] = Set['1', '2']
       subject.set_members('foo')
     end
 
     it "memoizes key" do
       cache['foo'].should eq(source['foo'])
-      cache['foo'].should eq(Set[1, 2])
+      cache['foo'].should eq(Set['1', '2'])
     end
   end
 
@@ -70,9 +70,9 @@ describe Flipper::Adapters::Memoized do
 
   describe "#set_add" do
     before do
-      source['foo'] = Set[1, 2]
+      source['foo'] = Set['1', '2']
       @result = subject.set_members('foo')
-      subject.set_add('foo', 3)
+      subject.set_add('foo', '3')
     end
 
     it "unmemoizes key" do
@@ -82,8 +82,8 @@ describe Flipper::Adapters::Memoized do
 
   describe "#set_delete" do
     before do
-      source['foo'] = Set[1, 2]
-      subject.set_delete('foo', 2)
+      source['foo'] = Set['1', '2']
+      subject.set_delete('foo', '2')
     end
 
     it "unmemoizes key" do

data/spec/flipper/dsl_spec.rb

@@ -1,5 +1,6 @@
 require 'helper'
 require 'flipper/dsl'
+require 'flipper/adapters/memory'
 
 describe Flipper::DSL do
   subject { Flipper::DSL.new(adapter) }
@@ -7,16 +8,33 @@ describe Flipper::DSL do
   let(:source)  { {} }
   let(:adapter) { Flipper::Adapters::Memory.new(source) }
 
-  let(:admins_feature) { feature(:admins) }
+  let(:admins_feature) { Flipper::Feature.new(:admins, adapter) }
 
-  def feature(name)
-    Flipper::Feature.new(name, adapter)
-  end
+  describe "#initialize" do
+    it "wraps adapter" do
+      dsl = described_class.new(adapter)
+      dsl.adapter.should be_instance_of(Flipper::Adapter)
+      dsl.adapter.adapter.should eq(adapter)
+    end
+
+    it "defaults instrumenter to noop" do
+      dsl = described_class.new(adapter)
+      dsl.instrumenter.should be(Flipper::Instrumenters::Noop)
+    end
 
-  it "wraps adapter when initializing" do
-    dsl = described_class.new(adapter)
-    dsl.adapter.should be_instance_of(Flipper::Adapter)
-    dsl.adapter.adapter.should eq(adapter)
+    context "with overriden instrumenter" do
+      let(:instrumenter) { double('Instrumentor', :instrument => nil) }
+
+      it "overrides default instrumenter" do
+        dsl = described_class.new(adapter, :instrumenter => instrumenter)
+        dsl.instrumenter.should be(instrumenter)
+      end
+
+      it "passes overridden instrumenter to adapter wrapping" do
+        dsl = described_class.new(adapter, :instrumenter => instrumenter)
+        dsl.adapter.instrumenter.should be(instrumenter)
+      end
+    end
   end
 
   describe "#enabled?" do
@@ -31,13 +49,6 @@ describe Flipper::DSL do
     end
   end
 
-  describe "#disabled?" do
-    it "passes all args to enabled? and returns the opposite" do
-      subject.should_receive(:enabled?).with(:stats, :foo).and_return(true)
-      subject.disabled?(:stats, :foo).should be_false
-    end
-  end
-
   describe "#enable" do
     before do
       subject.stub(:feature => admins_feature)
@@ -63,34 +74,18 @@ describe Flipper::DSL do
   end
 
   describe "#feature" do
-    before do
-      @result = subject.feature(:stats)
-    end
-
-    it "returns instance of feature with correct name and adapter" do
-      @result.should be_instance_of(Flipper::Feature)
-      @result.name.should eq(:stats)
-      @result.adapter.should eq(subject.adapter)
-    end
-
-    it "memoizes the feature" do
-      subject.feature(:stats).should equal(@result)
+    it_should_behave_like "a DSL feature" do
+      let(:instrumenter) { double('Instrumentor', :instrument => nil) }
+      let(:feature) { dsl.feature(:stats) }
+      let(:dsl) { Flipper::DSL.new(adapter, :instrumenter => instrumenter) }
     end
   end
 
   describe "#[]" do
-    before do
-      @result = subject[:stats]
-    end
-
-    it "returns instance of feature with correct name and adapter" do
-      @result.should be_instance_of(Flipper::Feature)
-      @result.name.should eq(:stats)
-      @result.adapter.should eq(subject.adapter)
-    end
-
-    it "memoizes the feature" do
-      subject[:stats].should equal(@result)
+    it_should_behave_like "a DSL feature" do
+      let(:instrumenter) { double('Instrumentor', :instrument => nil) }
+      let(:feature) { dsl[:stats] }
+      let(:dsl) { Flipper::DSL.new(adapter, :instrumenter => instrumenter) }
     end
   end
 
@@ -110,34 +105,36 @@ describe Flipper::DSL do
     end
 
     context "for unregistered group" do
-      it "returns nil" do
-        subject.group(:admins).should be_nil
+      it "raises error" do
+        expect {
+          subject.group(:admins)
+        }.to raise_error(Flipper::GroupNotRegistered)
       end
     end
   end
 
   describe "#actor" do
-    context "for something that responds to identifier" do
-      it "returns actor instance with identifier set to id" do
-        user = Struct.new(:identifier).new(45)
-        actor = subject.actor(user)
+    context "for a thing" do
+      it "returns actor instance" do
+        thing = Struct.new(:flipper_id).new(33)
+        actor = subject.actor(thing)
         actor.should be_instance_of(Flipper::Types::Actor)
-        actor.identifier.should eq(45)
+        actor.value.should eq('33')
       end
     end
 
-    context "for a number" do
-      it "returns actor instance with identifer set to number" do
-        actor = subject.actor(33)
-        actor.should be_instance_of(Flipper::Types::Actor)
-        actor.identifier.should eq(33)
+    context "for nil" do
+      it "raises argument error" do
+        expect {
+          subject.actor(nil)
+        }.to raise_error(ArgumentError)
       end
     end
 
-    context "for nil" do
-      it "raises error" do
+    context "for something that is not actor wrappable" do
+      it "raises argument error" do
         expect {
-          subject.actor(nil)
+          subject.actor(Object.new)
         }.to raise_error(ArgumentError)
       end
     end

data/spec/flipper/feature_spec.rb

@@ -1,36 +1,198 @@
 require 'helper'
 require 'flipper/feature'
 require 'flipper/adapters/memory'
+require 'flipper/instrumenters/memory'
 
 describe Flipper::Feature do
-  subject           { described_class.new(:search, adapter) }
+  subject { described_class.new(:search, adapter) }
 
-  let(:source)      { {} }
-  let(:adapter)     { Flipper::Adapters::Memory.new(source) }
+  let(:source) { {} }
+  let(:adapter) { Flipper::Adapters::Memory.new(source) }
 
-  it "initializes with name and adapter" do
-    feature = described_class.new(:search, adapter)
-    feature.name.should eq(:search)
-    feature.adapter.should eq(Flipper::Adapter.wrap(adapter))
+  describe "#initialize" do
+    it "sets name" do
+      feature = described_class.new(:search, adapter)
+      feature.name.should eq(:search)
+    end
+
+    it "sets adapter" do
+      feature = described_class.new(:search, adapter)
+      feature.adapter.should eq(Flipper::Adapter.wrap(adapter))
+    end
+
+    it "defaults instrumenter" do
+      feature = described_class.new(:search, adapter)
+      feature.instrumenter.should be(Flipper::Instrumenters::Noop)
+    end
+
+    context "with overriden instrumenter" do
+      let(:instrumenter) { double('Instrumentor', :instrument => nil) }
+
+      it "overrides default instrumenter" do
+        feature = described_class.new(:search, adapter, {
+          :instrumenter => instrumenter,
+        })
+        feature.instrumenter.should be(instrumenter)
+      end
+
+      it "passes overridden instrumenter to adapter wrapping" do
+        feature = described_class.new(:search, adapter, {
+          :instrumenter => instrumenter,
+        })
+        feature.adapter.instrumenter.should be(instrumenter)
+      end
+    end
+  end
+
+  describe "#gate_for" do
+    context "with percentage of actors" do
+      it "returns percentage of actors gate" do
+        percentage = Flipper::Types::PercentageOfActors.new(10)
+        gate = subject.gate_for(percentage)
+        gate.should be_instance_of(Flipper::Gates::PercentageOfActors)
+      end
+    end
   end
 
   describe "#gates" do
-    it "returns array of gates" do
-      subject.gates.should be_instance_of(Array)
-      subject.gates.each do |gate|
+    it "returns array of gates with each gate's instrumenter set" do
+      instrumenter = double('Instrumenter')
+      instance = described_class.new(:search, adapter, :instrumenter => instrumenter)
+      instance.gates.should be_instance_of(Array)
+      instance.gates.each do |gate|
         gate.should be_a(Flipper::Gate)
+        gate.instrumenter.should be(instrumenter)
       end
-      subject.gates.size.should be(5)
+      instance.gates.size.should be(5)
     end
   end
 
-  context "#disabled?" do
-    it "returns the opposite of enabled" do
-      subject.stub(:enabled? => true)
-      subject.disabled?.should be_false
+  describe "#inspect" do
+    it "returns easy to read string representation" do
+      string = subject.inspect
+      string.should include('Flipper::Feature')
+      string.should include('name=:search')
+      string.should include('state=:off')
+      string.should include("adapter=#{subject.adapter.name.inspect}")
+    end
+  end
+
+  describe "instrumentation" do
+    let(:instrumenter) { Flipper::Instrumenters::Memory.new }
+
+    subject {
+      described_class.new(:search, adapter, :instrumenter => instrumenter)
+    }
+
+    it "is recorded for enable" do
+      thing = Flipper::Types::Boolean.new
+      gate = subject.gate_for(thing)
+
+      subject.enable(thing)
+
+      event = instrumenter.events.last
+      event.should_not be_nil
+      event.name.should eq('feature_operation.flipper')
+      event.payload[:feature_name].should eq(:search)
+      event.payload[:operation].should eq(:enable)
+      event.payload[:thing].should eq(thing)
+      event.payload[:result].should_not be_nil
+    end
+
+    it "is recorded for disable" do
+      thing = Flipper::Types::Boolean.new
+      gate = subject.gate_for(thing)
 
-      subject.stub(:enabled? => false)
-      subject.disabled?.should be_true
+      subject.disable(thing)
+
+      event = instrumenter.events.last
+      event.should_not be_nil
+      event.name.should eq('feature_operation.flipper')
+      event.payload[:feature_name].should eq(:search)
+      event.payload[:operation].should eq(:disable)
+      event.payload[:thing].should eq(thing)
+      event.payload[:result].should_not be_nil
+    end
+
+    it "is recorded for enabled?" do
+      thing = Flipper::Types::Boolean.new
+      gate = subject.gate_for(thing)
+
+      subject.enabled?(thing)
+
+      event = instrumenter.events.last
+      event.should_not be_nil
+      event.name.should eq('feature_operation.flipper')
+      event.payload[:feature_name].should eq(:search)
+      event.payload[:operation].should eq(:enabled?)
+      event.payload[:thing].should eq(thing)
+      event.payload[:result].should be_false
+    end
+  end
+
+  describe "#state" do
+    context "fully on" do
+      before do
+        subject.enable
+      end
+
+      it "returns :on" do
+        subject.state.should be(:on)
+      end
+    end
+
+    context "fully off" do
+      before do
+        subject.disable
+      end
+
+      it "returns :off" do
+        subject.state.should be(:off)
+      end
+    end
+
+    context "partially on" do
+      before do
+        subject.enable Flipper::Types::PercentageOfRandom.new(5)
+      end
+
+      it "returns :conditional" do
+        subject.state.should be(:conditional)
+      end
+    end
+  end
+
+  describe "#description" do
+    context "fully on" do
+      before do
+        subject.enable
+      end
+
+      it "returns enabled" do
+        subject.description.should eq('Enabled')
+      end
+    end
+
+    context "fully off" do
+      before do
+        subject.disable
+      end
+
+      it "returns disabled" do
+        subject.description.should eq('Disabled')
+      end
+    end
+
+    context "partially on" do
+      before do
+        actor = Struct.new(:flipper_id).new(5)
+        subject.enable Flipper::Types::PercentageOfRandom.new(5)
+        subject.enable actor
+      end
+
+      it "returns text" do
+        subject.description.should eq('Enabled for actors (5), 5% of the time')
+      end
     end
   end
 end

data/spec/flipper/gate_spec.rb

@@ -0,0 +1,47 @@
+require 'helper'
+
+describe Flipper::Gate do
+  let(:adapter) { double('Adapter', :name => 'memory', :read => '22') }
+  let(:feature) { double('Feature', :name => :search, :adapter => adapter) }
+
+  subject {
+    gate = described_class.new(feature)
+    # implemented in subclass
+    gate.stub({
+      :key => :actors,
+      :description => 'enabled',
+    })
+    gate
+  }
+
+  describe "#initialize" do
+    it "sets feature" do
+      gate = described_class.new(feature)
+      gate.feature.should be(feature)
+    end
+
+    it "defaults instrumenter" do
+      gate = described_class.new(feature)
+      gate.instrumenter.should be(Flipper::Instrumenters::Noop)
+    end
+
+    it "allows overriding instrumenter" do
+      instrumenter = double('Instrumentor')
+      gate = described_class.new(feature, :instrumenter => instrumenter)
+      gate.instrumenter.should be(instrumenter)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns easy to read string representation" do
+      string = subject.inspect
+      string.should include('Flipper::Gate')
+      string.should include('feature=:search')
+      string.should include('description="enabled"')
+      string.should include("adapter=#{subject.adapter.name.inspect}")
+      string.should include('adapter_key=#<Flipper::Key:')
+      string.should include('toggle_class=Flipper::Toggles::Value')
+      string.should include('toggle_value="22"')
+    end
+  end
+end