flipper 0.2.1 → 0.3.0

data/spec/flipper/key_spec.rb

@@ -0,0 +1,17 @@
+require 'helper'
+require 'flipper/key'
+
+describe Flipper::Key do
+  subject { described_class.new(:foo, :bar) }
+
+  it "initializes with prefix and suffix" do
+    key = described_class.new(:foo, :bar)
+    key.should be_instance_of(described_class)
+  end
+
+  describe "#to_s" do
+    it "returns prefix and suffix joined by separator" do
+      subject.to_s.should eq("foo#{subject.separator}bar")
+    end
+  end
+end

data/spec/flipper/middleware/local_cache_spec.rb

@@ -1,41 +1,22 @@
 require 'helper'
 require 'rack/test'
 require 'flipper/middleware/local_cache'
+require 'flipper/adapters/operation_logger'
+require 'flipper/adapters/memory'
 
 describe Flipper::Middleware::LocalCache do
   include Rack::Test::Methods
 
-  class LoggedHash < Hash
-    attr_reader :reads, :writes
-
-    Read  = Struct.new(:key)
-    Write = Struct.new(:key, :value)
-
-    def initialize(*args)
-      @reads, @writes = [], []
-      super
-    end
-
-    def [](key)
-      @reads << Read.new(key)
-      super
-    end
-
-    def []=(key, value)
-      @writes << Write.new(key, value)
-      super
-    end
-  end
-
   class Enum < Struct.new(:iter)
-    def each(&b)
-      iter.call(&b)
+    def each(&block)
+      iter.call(&block)
     end
   end
 
-  let(:source)  { LoggedHash.new }
-  let(:adapter) { Flipper::Adapters::Memory.new(source) }
-  let(:flipper) { Flipper.new(adapter) }
+  let(:source)         { {} }
+  let(:memory_adapter) { Flipper::Adapters::Memory.new(source) }
+  let(:adapter)        { Flipper::Adapters::OperationLogger.new(memory_adapter) }
+  let(:flipper)        { Flipper.new(adapter) }
 
   let(:app) {
     # ensure scoped for builder block, annoying...
@@ -55,6 +36,10 @@ describe Flipper::Middleware::LocalCache do
     end.to_app
   }
 
+  before do
+    adapter.reset
+  end
+
   it "delegates" do
     called = false
     app = lambda { |env|
@@ -77,9 +62,9 @@ describe Flipper::Middleware::LocalCache do
 
   it "enables local cache for body each" do
     app = lambda { |env|
-      [200, {}, Enum.new(lambda { |&b|
+      [200, {}, Enum.new(lambda { |&block|
         flipper.adapter.using_local_cache?.should be_true
-        b.call "hello"
+        block.call "hello"
       })]
     }
     middleware = described_class.new app, flipper
@@ -110,6 +95,7 @@ describe Flipper::Middleware::LocalCache do
 
   it "really does cache" do
     flipper[:stats].enable
+    adapter.reset
 
     app = lambda { |env|
       flipper[:stats].enabled?
@@ -124,7 +110,9 @@ describe Flipper::Middleware::LocalCache do
     middleware = described_class.new app, flipper
     middleware.call({})
 
-    source.reads.map(&:key).should eq(["stats/boolean"])
+    adapter.operations.should eq([
+      Flipper::Adapters::OperationLogger::Read.new("stats/boolean"),
+    ])
   end
 
   context "with a successful request" do

data/spec/flipper/registry_spec.rb

@@ -65,7 +65,7 @@ describe Flipper::Registry do
     end
 
     it "returns the keys" do
-      subject.keys.should eq([:admins, :devs])
+      subject.keys.map(&:to_s).sort.should eq(['admins', 'devs'])
     end
   end
 
@@ -76,7 +76,7 @@ describe Flipper::Registry do
     end
 
     it "returns the values" do
-      subject.values.should eq(['admins', 'devs'])
+      subject.values.map(&:to_s).sort.should eq(['admins', 'devs'])
     end
   end
 
@@ -95,8 +95,8 @@ describe Flipper::Registry do
         values << value
       end
 
-      keys.should eq([:admins, :devs])
-      values.should eq(['admins', 'devs'])
+      keys.map(&:to_s).sort.should eq(['admins', 'devs'])
+      values.sort.should eq(['admins', 'devs'])
     end
   end
 

data/spec/flipper/types/actor_spec.rb

@@ -31,17 +31,12 @@ describe Flipper::Types::Actor do
       described_class.wrappable?(thing).should be_true
     end
 
-    it "returns true if responds to id" do
-      thing = Struct.new(:id).new(10)
-      described_class.wrappable?(thing).should be_true
-    end
-
     it "returns true if responds to to_i" do
       described_class.wrappable?(1).should be_true
     end
 
-    it "returns false if not actor and does not respond to identifier, id, nor to_i" do
-      described_class.wrappable?(:nope).should be_false
+    it "returns false if not actor and does not respond to identifier or to_i" do
+      described_class.wrappable?(Object.new).should be_false
     end
   end
 
@@ -73,12 +68,6 @@ describe Flipper::Types::Actor do
     actor.identifier.should be(1)
   end
 
-  it "initializes with object that responds to id" do
-    thing = Struct.new(:id).new(13)
-    actor = described_class.new(thing)
-    actor.identifier.should be(13)
-  end
-
   it "raises error when initialized with nil" do
     expect {
       described_class.new(nil)
@@ -104,7 +93,7 @@ describe Flipper::Types::Actor do
   describe "#respond_to?" do
     it "returns true if responds to method" do
       actor = described_class.new(10)
-      actor.respond_to?(:enabled_value).should be_true
+      actor.respond_to?(:value).should be_true
     end
 
     it "returns true if thing responds to method" do

data/spec/flipper/types/percentage_spec.rb

@@ -2,5 +2,26 @@ require 'helper'
 require 'flipper/types/percentage_of_actors'
 
 describe Flipper::Types::Percentage do
+  subject {
+    described_class.new(5)
+  }
   it_should_behave_like 'a percentage'
+
+  describe "#eql?" do
+    it "returns true for same class and value" do
+      subject.eql?(described_class.new(subject.value)).should be_true
+    end
+
+    it "returns false for different value" do
+      subject.eql?(described_class.new(subject.value + 1)).should be_false
+    end
+
+    it "returns false for different class" do
+      subject.eql?(Object.new).should be_false
+    end
+
+    it "is aliased to ==" do
+      (subject == described_class.new(subject.value)).should be_true
+    end
+  end
 end

data/spec/integration_spec.rb

@@ -0,0 +1,455 @@
+require 'helper'
+require 'flipper/feature'
+require 'flipper/adapters/memory'
+
+describe Flipper::Feature do
+  subject           { described_class.new(:search, adapter) }
+
+  let(:source)      { {} }
+  let(:adapter)     { Flipper::Adapters::Memory.new(source) }
+
+  let(:admin_group) { Flipper.group(:admins) }
+  let(:dev_group)   { Flipper.group(:devs) }
+
+  let(:admin_thing) { double 'Non Flipper Thing', :identifier => 1,  :admin? => true, :dev? => false }
+  let(:dev_thing)   { double 'Non Flipper Thing', :identifier => 10, :admin? => false, :dev? => true }
+
+  let(:pitt)        { Flipper::Types::Actor.new(1) }
+  let(:clooney)     { Flipper::Types::Actor.new(10) }
+
+  let(:five_percent_of_actors) { Flipper::Types::PercentageOfActors.new(5) }
+  let(:five_percent_of_random) { Flipper::Types::PercentageOfRandom.new(5) }
+
+  before do
+    Flipper.register(:admins) { |thing| thing.admin? }
+    Flipper.register(:devs)   { |thing| thing.dev? }
+  end
+
+  def enable_feature(feature)
+    key = Flipper::Key.new(subject.name, Flipper::Gates::Boolean::Key)
+    adapter.write key, true
+  end
+
+  def enable_group(group)
+    key = Flipper::Key.new(subject.name, Flipper::Gates::Group::Key)
+    name = group.respond_to?(:name) ? group.name : group
+    adapter.set_add key, name
+  end
+
+  def enable_actor(actor)
+    key = Flipper::Key.new(subject.name, Flipper::Gates::Actor::Key)
+    adapter.set_add key, actor.identifier
+  end
+
+  def enable_percentage_of_actors(percentage)
+    key = Flipper::Key.new(subject.name, Flipper::Gates::PercentageOfActors::Key)
+    adapter.write key, percentage.value
+  end
+
+  def enable_percentage_of_random(percentage)
+    key = Flipper::Key.new(subject.name, Flipper::Gates::PercentageOfRandom::Key)
+    adapter.write key, percentage.value
+  end
+
+  describe "#enable" do
+    context "with no arguments" do
+      before do
+        subject.enable
+      end
+
+      it "enables feature for all" do
+        subject.enabled?.should be_true
+      end
+
+      it "adds feature to set of features" do
+        adapter.set_members('features').should include('search')
+      end
+    end
+
+    context "with a group" do
+      before do
+        subject.enable(admin_group)
+      end
+
+      it "enables feature for non flipper thing in group" do
+        subject.enabled?(admin_thing).should be_true
+      end
+
+      it "does not enable feature for non flipper thing in other group" do
+        subject.enabled?(dev_thing).should be_false
+      end
+
+      it "enables feature for flipper actor in group" do
+        subject.enabled?(Flipper::Types::Actor.new(admin_thing)).should be_true
+      end
+
+      it "does not enable for flipper actor not in group" do
+        subject.enabled?(Flipper::Types::Actor.new(dev_thing)).should be_false
+      end
+
+      it "does not enable feature for all" do
+        subject.enabled?.should be_false
+      end
+
+      it "adds feature to set of features" do
+        adapter.set_members('features').should include('search')
+      end
+    end
+
+    context "with an actor" do
+      before do
+        subject.enable(pitt)
+      end
+
+      it "enables feature for actor" do
+        subject.enabled?(pitt).should be_true
+      end
+
+      it "does not enable feature for other actors" do
+        subject.enabled?(clooney).should be_false
+      end
+
+      it "adds feature to set of features" do
+        adapter.set_members('features').should include('search')
+      end
+    end
+
+    context "with a percentage of actors" do
+      before do
+        subject.enable(five_percent_of_actors)
+      end
+
+      it "enables feature for actor within percentage" do
+        enabled = (1..100).select { |i| subject.enabled?(Flipper::Types::Actor.new(i)) }.length
+        enabled.should be_within(2).of(5)
+      end
+
+      it "adds feature to set of features" do
+        adapter.set_members('features').should include('search')
+      end
+    end
+
+    context "with a percentage of random" do
+      before do
+        @gate = Flipper::Gates::PercentageOfRandom.new(subject)
+        Flipper::Gates::PercentageOfRandom.should_receive(:new).and_return(@gate)
+        subject.enable(five_percent_of_random)
+      end
+
+      it "enables feature for time within percentage" do
+        @gate.stub(:rand => 0.04)
+        subject.enabled?.should be_true
+      end
+
+      it "does not enable feature for time not within percentage" do
+        @gate.stub(:rand => 0.10)
+        subject.enabled?.should be_false
+      end
+
+      it "adds feature to set of features" do
+        adapter.set_members('features').should include('search')
+      end
+    end
+
+    context "with argument that has no gate" do
+      it "raises error" do
+        thing = Object.new
+        expect {
+          subject.enable(thing)
+        }.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
+      end
+    end
+  end
+
+  describe "#disable" do
+    context "with no arguments" do
+      before do
+        # ensures that random gate is stubbed with result that would be true for pitt
+        @gate = Flipper::Gates::PercentageOfRandom.new(subject)
+        @gate.stub(:rand => 0.04)
+        Flipper::Gates::PercentageOfRandom.should_receive(:new).and_return(@gate)
+        enable_group admin_group
+        enable_actor pitt
+        enable_percentage_of_actors five_percent_of_actors
+        enable_percentage_of_random five_percent_of_random
+        subject.disable
+      end
+
+      it "disables feature" do
+        subject.enabled?.should be_false
+      end
+
+      it "disables for individual actor" do
+        subject.enabled?(pitt).should be_false
+      end
+
+      it "disables actor in group" do
+        subject.enabled?(admin_thing).should be_false
+      end
+
+      it "disables actor in percentage of actors" do
+        enabled = (1..100).select { |i| subject.enabled?(Flipper::Types::Actor.new(i)) }.length
+        enabled.should be(0)
+      end
+
+      it "disables percentage of random" do
+        subject.enabled?(pitt).should be_false
+      end
+
+      it "adds feature to set of features" do
+        adapter.set_members('features').should include('search')
+      end
+    end
+
+    context "with a group" do
+      before do
+        enable_group dev_group
+        enable_group admin_group
+        subject.disable(admin_group)
+      end
+
+      it "disables the feature for non flipper thing in the group" do
+        subject.enabled?(admin_thing).should be_false
+      end
+
+      it "does not disable feature for non flipper thing in other groups" do
+        subject.enabled?(dev_thing).should be_true
+      end
+
+      it "disables feature for flipper actor in group" do
+        subject.enabled?(Flipper::Types::Actor.new(admin_thing)).should be_false
+      end
+
+      it "does not disable feature for flipper actor in other groups" do
+        subject.enabled?(Flipper::Types::Actor.new(dev_thing)).should be_true
+      end
+
+      it "adds feature to set of features" do
+        adapter.set_members('features').should include('search')
+      end
+    end
+
+    context "with an actor" do
+      before do
+        enable_actor pitt
+        enable_actor clooney
+        subject.disable(pitt)
+      end
+
+      it "disables feature for actor" do
+        subject.enabled?(pitt).should be_false
+      end
+
+      it "does not disable feature for other actors" do
+        subject.enabled?(clooney).should be_true
+      end
+
+      it "adds feature to set of features" do
+        adapter.set_members('features').should include('search')
+      end
+    end
+
+    context "with a percentage of actors" do
+      before do
+        subject.disable(five_percent_of_actors)
+      end
+
+      it "disables feature" do
+        enabled = (1..100).select { |i| subject.enabled?(Flipper::Types::Actor.new(i)) }.length
+        enabled.should be(0)
+      end
+
+      it "adds feature to set of features" do
+        adapter.set_members('features').should include('search')
+      end
+    end
+
+    context "with a percentage of time" do
+      before do
+        @gate = Flipper::Gates::PercentageOfRandom.new(subject)
+        Flipper::Gates::PercentageOfRandom.should_receive(:new).and_return(@gate)
+        subject.disable(five_percent_of_random)
+      end
+
+      it "disables feature for time within percentage" do
+        @gate.stub(:rand => 0.04)
+        subject.enabled?.should be_false
+      end
+
+      it "disables feature for time not within percentage" do
+        @gate.stub(:rand => 0.10)
+        subject.enabled?.should be_false
+      end
+
+      it "adds feature to set of features" do
+        adapter.set_members('features').should include('search')
+      end
+    end
+
+    context "with argument that has no gate" do
+      it "raises error" do
+        thing = Object.new
+        expect {
+          subject.disable(thing)
+        }.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
+      end
+    end
+  end
+
+  describe "#enabled?" do
+    context "with no arguments" do
+      it "defaults to false" do
+        subject.enabled?.should be_false
+      end
+    end
+
+    context "with no arguments, but boolean enabled" do
+      before do
+        enable_feature subject
+      end
+
+      it "returns true" do
+        subject.enabled?.should be_true
+      end
+    end
+
+    context "for actor in enabled group" do
+      before do
+        enable_group admin_group
+      end
+
+      it "returns true" do
+        subject.enabled?(Flipper::Types::Actor.new(admin_thing)).should be_true
+      end
+    end
+
+    context "for actor in disabled group" do
+      it "returns false" do
+        subject.enabled?(Flipper::Types::Actor.new(dev_thing)).should be_false
+      end
+    end
+
+    context "for enabled actor" do
+      before do
+        enable_actor pitt
+      end
+
+      it "returns true" do
+        subject.enabled?(pitt).should be_true
+      end
+    end
+
+    context "for not enabled actor" do
+      it "returns false" do
+        subject.enabled?(clooney).should be_false
+      end
+
+      it "returns true if boolean enabled" do
+        enable_feature subject
+        subject.enabled?(clooney).should be_true
+      end
+    end
+
+    context "during enabled percentage of time" do
+      before do
+        @gate = Flipper::Gates::PercentageOfRandom.new(subject)
+        @gate.stub(:rand => 0.04)
+        Flipper::Gates::PercentageOfRandom.should_receive(:new).and_return(@gate)
+        enable_percentage_of_random five_percent_of_random
+      end
+
+      it "returns true" do
+        subject.enabled?.should be_true
+        subject.enabled?(nil).should be_true
+        subject.enabled?(pitt).should be_true
+        subject.enabled?(admin_thing).should be_true
+      end
+    end
+
+    context "during not enabled percentage of time" do
+      before do
+        @gate = Flipper::Gates::PercentageOfRandom.new(subject)
+        @gate.stub(:rand => 0.10)
+        Flipper::Gates::PercentageOfRandom.should_receive(:new).and_return(@gate)
+        enable_percentage_of_random five_percent_of_random
+      end
+
+      it "returns false" do
+        subject.enabled?.should be_false
+        subject.enabled?(nil).should be_false
+        subject.enabled?(pitt).should be_false
+        subject.enabled?(admin_thing).should be_false
+      end
+
+      it "returns true if boolean enabled" do
+        enable_feature subject
+        subject.enabled?.should be_true
+        subject.enabled?(nil).should be_true
+        subject.enabled?(pitt).should be_true
+        subject.enabled?(admin_thing).should be_true
+      end
+    end
+
+    context "for a non flipper thing" do
+      before do
+        enable_group admin_group
+      end
+
+      it "returns true if in enabled group" do
+        subject.enabled?(admin_thing).should be_true
+      end
+
+      it "returns false if not in enabled group" do
+        subject.enabled?(dev_thing).should be_false
+      end
+
+      it "returns true if boolean enabled" do
+        enable_feature subject
+        subject.enabled?(admin_thing).should be_true
+        subject.enabled?(dev_thing).should be_true
+      end
+    end
+
+    context "for a non flipper thing that does not respond to something in group block" do
+      let(:actor) { double('Actor') }
+
+      before do
+        boomboom = Flipper.register(:boomboom) { |actor| actor.boomboom? }
+        enable_group boomboom
+      end
+
+      it "returns false" do
+        expect { subject.enabled?(actor) }.to raise_error
+      end
+    end
+
+    context "for a non flipper thing when group in adapter, but not defined in code" do
+      let(:actor) { double('Actor') }
+
+      before do
+        enable_group :support
+      end
+
+      it "returns false" do
+        subject.enabled?(actor).should be_false
+      end
+    end
+  end
+
+  context "enabling multiple groups, disabling everything, then enabling one group" do
+    before do
+      subject.enable(admin_group)
+      subject.enable(dev_group)
+      subject.disable
+      subject.enable(admin_group)
+    end
+
+    it "enables feature for object in enabled group" do
+      subject.enabled?(admin_thing).should be_true
+    end
+
+    it "does not enable feature for object in not enabled group" do
+      subject.enabled?(dev_thing).should be_false
+    end
+  end
+end