flipper 0.4.0 → 0.5.0

data/spec/flipper/instrumentation/metriks_subscriber_spec.rb

@@ -38,16 +38,13 @@ describe Flipper::Instrumentation::MetriksSubscriber do
 
   it "updates adapter metrics when calls happen" do
     flipper[:stats].enable(user)
-    # one for features and one for actors
-    Metriks.timer("flipper.adapter.memory.set_add").count.should be(2)
+    Metriks.timer("flipper.adapter.memory.enable").count.should be(1)
 
     flipper[:stats].enabled?(user)
-    Metriks.timer("flipper.adapter.memory.read").count.should be(1)
-    # one for actors and one for groups
-    Metriks.timer("flipper.adapter.memory.set_members").count.should be(2)
+    Metriks.timer("flipper.adapter.memory.get").count.should be(1)
 
     flipper[:stats].disable(user)
-    Metriks.timer("flipper.adapter.memory.set_delete").count.should be(1)
+    Metriks.timer("flipper.adapter.memory.disable").count.should be(1)
   end
 
   it "updates gate metrics when calls happen" do

data/spec/flipper/middleware/{local_cache_spec.rb → memoizer_spec.rb}

@@ -1,18 +1,12 @@
 require 'helper'
 require 'rack/test'
-require 'flipper/middleware/local_cache'
+require 'flipper/middleware/memoizer'
 require 'flipper/adapters/operation_logger'
 require 'flipper/adapters/memory'
 
-describe Flipper::Middleware::LocalCache do
+describe Flipper::Middleware::Memoizer do
   include Rack::Test::Methods
 
-  class Enum < Struct.new(:iter)
-    def each(&block)
-      iter.call(&block)
-    end
-  end
-
   let(:source)         { {} }
   let(:memory_adapter) { Flipper::Adapters::Memory.new(source) }
   let(:adapter)        { Flipper::Adapters::OperationLogger.new(memory_adapter) }
@@ -36,8 +30,8 @@ describe Flipper::Middleware::LocalCache do
     end.to_app
   }
 
-  before do
-    adapter.reset
+  after do
+    flipper.adapter.memoize = nil
   end
 
   it "delegates" do
@@ -51,50 +45,42 @@ describe Flipper::Middleware::LocalCache do
     called.should be_true
   end
 
-  it "enables memoization during delegation" do
-    app = lambda { |env|
-      flipper.adapter.using_local_cache?.should be_true
-      [200, {}, nil]
-    }
-    middleware = described_class.new app, flipper
-    middleware.call({})
-  end
-
-  it "enables local cache for body each" do
-    app = lambda { |env|
-      [200, {}, Enum.new(lambda { |&block|
-        flipper.adapter.using_local_cache?.should be_true
-        block.call "hello"
-      })]
-    }
-    middleware = described_class.new app, flipper
-    body = middleware.call({}).last
-    body.each { |x| x.should eql('hello') }
-  end
-
   it "disables local cache after body close" do
     app = lambda { |env| [200, {}, []] }
     middleware = described_class.new app, flipper
     body = middleware.call({}).last
 
-    flipper.adapter.using_local_cache?.should be_true
+    flipper.adapter.memoizing?.should be_true
     body.close
-    flipper.adapter.using_local_cache?.should be_false
+    flipper.adapter.memoizing?.should be_false
   end
 
   it "clears local cache after body close" do
     app = lambda { |env| [200, {}, []] }
     middleware = described_class.new app, flipper
     body = middleware.call({}).last
-    flipper.adapter.local_cache['hello'] = 'world'
 
-    flipper.adapter.local_cache.should_not be_empty
+    flipper.adapter.cache['hello'] = 'world'
     body.close
-    flipper.adapter.local_cache.should be_empty
+    flipper.adapter.cache.should be_empty
+  end
+
+  it "clears the local cache with a successful request" do
+    flipper.adapter.cache['hello'] = 'world'
+    get '/'
+    flipper.adapter.cache.should be_empty
   end
 
-  it "really does cache" do
+  it "clears the local cache even when the request raises an error" do
+    flipper.adapter.cache['hello'] = 'world'
+    get '/fail' rescue nil
+    flipper.adapter.cache.should be_empty
+  end
+
+  it "caches getting a feature for duration of request" do
     flipper[:stats].enable
+
+    # clear the log of operations
     adapter.reset
 
     app = lambda { |env|
@@ -104,28 +90,12 @@ describe Flipper::Middleware::LocalCache do
       flipper[:stats].enabled?
       flipper[:stats].enabled?
       flipper[:stats].enabled?
-
       [200, {}, []]
     }
+
     middleware = described_class.new app, flipper
     middleware.call({})
 
-    adapter.operations.should eq([
-      Flipper::Adapters::OperationLogger::Read.new("stats/boolean"),
-    ])
-  end
-
-  context "with a successful request" do
-    it "clears the local cache" do
-      flipper.adapter.local_cache.should_receive(:clear).twice
-      get '/'
-    end
-  end
-
-  context "when the request raises an error" do
-    it "clears the local cache" do
-      flipper.adapter.local_cache.should_receive(:clear).once
-      get '/fail' rescue nil
-    end
+    adapter.count(:get).should be(1)
   end
 end

data/spec/flipper/types/boolean_spec.rb

@@ -2,8 +2,18 @@ require 'helper'
 require 'flipper/types/boolean'
 
 describe Flipper::Types::Boolean do
-  it "initializes with nothing" do
-    switch = Flipper::Types::Boolean.new
-    switch.should be_instance_of(Flipper::Types::Boolean)
+  it "defaults value to true" do
+    boolean = Flipper::Types::Boolean.new
+    boolean.value.should be(true)
+  end
+
+  it "allows overriding default value" do
+    boolean = Flipper::Types::Boolean.new(false)
+    boolean.value.should be(false)
+  end
+
+  it "returns true for nil value" do
+    boolean = Flipper::Types::Boolean.new(nil)
+    boolean.value.should be(true)
   end
 end

data/spec/flipper_spec.rb

@@ -46,6 +46,13 @@ describe Flipper do
     end
   end
 
+  describe ".unregister_groups" do
+    it "clear group registry" do
+      Flipper.groups.should_receive(:clear)
+      Flipper.unregister_groups
+    end
+  end
+
   describe ".group" do
     context "for registered group" do
       before do

data/spec/helper.rb

@@ -24,7 +24,7 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
 
   config.before(:each) do
-    Flipper.groups = nil
+    Flipper.unregister_groups
   end
 end
 
@@ -67,7 +67,7 @@ shared_examples_for 'a DSL feature' do
   end
 
   it "sets adapter" do
-    feature.adapter.should eq(dsl.adapter)
+    feature.adapter.name.should eq(dsl.adapter.name)
   end
 
   it "sets instrumenter" do
@@ -75,6 +75,24 @@ shared_examples_for 'a DSL feature' do
   end
 
   it "memoizes the feature" do
-    dsl.feature(:stats).should equal(feature)
+    dsl.send(method_name, :stats).should equal(feature)
+  end
+
+  it "raises argument error if not string or symbol" do
+    expect {
+      dsl.send(method_name, Object.new)
+    }.to raise_error(ArgumentError, /must be a String or Symbol/)
+  end
+end
+
+shared_examples_for "a DSL boolean method" do
+  it "returns boolean with value set" do
+    result = subject.send(method_name, true)
+    result.should be_instance_of(Flipper::Types::Boolean)
+    result.value.should be(true)
+
+    result = subject.send(method_name, false)
+    result.should be_instance_of(Flipper::Types::Boolean)
+    result.value.should be(false)
   end
 end

data/spec/integration_spec.rb

@@ -2,16 +2,17 @@ require 'helper'
 require 'flipper/feature'
 require 'flipper/adapters/memory'
 
-describe Flipper::Feature do
-  subject           { described_class.new(:search, adapter) }
-
-  let(:actor_class) { Struct.new(:flipper_id) }
-
+describe Flipper do
   let(:source)      { {} }
   let(:adapter)     { Flipper::Adapters::Memory.new(source) }
 
-  let(:admin_group) { Flipper.group(:admins) }
-  let(:dev_group)   { Flipper.group(:devs) }
+  let(:flipper)     { Flipper.new(adapter) }
+  let(:feature)     { flipper[:search] }
+
+  let(:actor_class) { Struct.new(:flipper_id) }
+
+  let(:admin_group) { flipper.group(:admins) }
+  let(:dev_group)   { flipper.group(:devs) }
 
   let(:admin_thing) { double 'Non Flipper Thing', :flipper_id => 1,  :admin? => true, :dev? => false }
   let(:dev_thing)   { double 'Non Flipper Thing', :flipper_id => 10, :admin? => false, :dev? => true }
@@ -19,22 +20,18 @@ describe Flipper::Feature do
   let(:pitt)        { actor_class.new(1) }
   let(:clooney)     { actor_class.new(10) }
 
-  let(:five_percent_of_actors) { Flipper::Types::PercentageOfActors.new(5) }
-  let(:five_percent_of_random) { Flipper::Types::PercentageOfRandom.new(5) }
+  let(:five_percent_of_actors) { flipper.actors(5) }
+  let(:five_percent_of_random) { flipper.random(5) }
 
   before do
     Flipper.register(:admins) { |thing| thing.admin? }
     Flipper.register(:devs)   { |thing| thing.dev? }
   end
 
-  after do
-    Flipper.groups = nil
-  end
-
   describe "#enable" do
     context "with no arguments" do
       before do
-        @result = subject.enable
+        @result = feature.enable
       end
 
       it "returns true" do
@@ -42,17 +39,17 @@ describe Flipper::Feature do
       end
 
       it "enables feature for all" do
-        subject.enabled?.should be_true
+        feature.enabled?.should be_true
       end
 
       it "adds feature to set of features" do
-        adapter.set_members('features').should include('search')
+        flipper.features.map(&:name).should include(:search)
       end
     end
 
     context "with a group" do
       before do
-        @result = subject.enable(admin_group)
+        @result = feature.enable(admin_group)
       end
 
       it "returns true" do
@@ -60,33 +57,33 @@ describe Flipper::Feature do
       end
 
       it "enables feature for non flipper thing in group" do
-        subject.enabled?(admin_thing).should be_true
+        feature.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
+        feature.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
+        feature.enabled?(flipper.actor(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
+        feature.enabled?(flipper.actor(dev_thing)).should be_false
       end
 
       it "does not enable feature for all" do
-        subject.enabled?.should be_false
+        feature.enabled?.should be_false
       end
 
       it "adds feature to set of features" do
-        adapter.set_members('features').should include('search')
+        flipper.features.map(&:name).should include(:search)
       end
     end
 
     context "with an actor" do
       before do
-        @result = subject.enable(pitt)
+        @result = feature.enable(pitt)
       end
 
       it "returns true" do
@@ -94,21 +91,21 @@ describe Flipper::Feature do
       end
 
       it "enables feature for actor" do
-        subject.enabled?(pitt).should be_true
+        feature.enabled?(pitt).should be_true
       end
 
       it "does not enable feature for other actors" do
-        subject.enabled?(clooney).should be_false
+        feature.enabled?(clooney).should be_false
       end
 
       it "adds feature to set of features" do
-        adapter.set_members('features').should include('search')
+        flipper.features.map(&:name).should include(:search)
       end
     end
 
     context "with a percentage of actors" do
       before do
-        @result = subject.enable(five_percent_of_actors)
+        @result = feature.enable(five_percent_of_actors)
       end
 
       it "returns true" do
@@ -118,22 +115,21 @@ describe Flipper::Feature do
       it "enables feature for actor within percentage" do
         enabled = (1..100).select { |i|
           thing = actor_class.new(i)
-          subject.enabled?(thing)
+          feature.enabled?(thing)
         }.size
 
         enabled.should be_within(2).of(5)
       end
 
       it "adds feature to set of features" do
-        adapter.set_members('features').should include('search')
+        flipper.features.map(&:name).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)
-        @result = subject.enable(five_percent_of_random)
+        @gate = feature.gate(:percentage_of_random)
+        @result = feature.enable(five_percent_of_random)
       end
 
       it "returns true" do
@@ -142,16 +138,16 @@ describe Flipper::Feature do
 
       it "enables feature for time within percentage" do
         @gate.stub(:rand => 0.04)
-        subject.enabled?.should be_true
+        feature.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
+        feature.enabled?.should be_false
       end
 
       it "adds feature to set of features" do
-        adapter.set_members('features').should include('search')
+        flipper.features.map(&:name).should include(:search)
       end
     end
 
@@ -159,7 +155,7 @@ describe Flipper::Feature do
       it "raises error" do
         thing = Object.new
         expect {
-          subject.enable(thing)
+          feature.enable(thing)
         }.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
       end
     end
@@ -169,14 +165,14 @@ describe Flipper::Feature 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 = feature.gate(:percentage_of_random)
         @gate.stub(:rand => 0.04)
-        Flipper::Gates::PercentageOfRandom.should_receive(:new).and_return(@gate)
-        subject.enable admin_group
-        subject.enable pitt
-        subject.enable five_percent_of_actors
-        subject.enable five_percent_of_random
-        @result = subject.disable
+
+        feature.enable admin_group
+        feature.enable pitt
+        feature.enable five_percent_of_actors
+        feature.enable five_percent_of_random
+        @result = feature.disable
       end
 
       it "returns true" do
@@ -184,40 +180,40 @@ describe Flipper::Feature do
       end
 
       it "disables feature" do
-        subject.enabled?.should be_false
+        feature.enabled?.should be_false
       end
 
       it "disables for individual actor" do
-        subject.enabled?(pitt).should be_false
+        feature.enabled?(pitt).should be_false
       end
 
       it "disables actor in group" do
-        subject.enabled?(admin_thing).should be_false
+        feature.enabled?(admin_thing).should be_false
       end
 
       it "disables actor in percentage of actors" do
         enabled = (1..100).select { |i|
           thing = actor_class.new(i)
-          subject.enabled?(thing)
+          feature.enabled?(thing)
         }.size
 
         enabled.should be(0)
       end
 
       it "disables percentage of random" do
-        subject.enabled?(pitt).should be_false
+        feature.enabled?(pitt).should be_false
       end
 
       it "adds feature to set of features" do
-        adapter.set_members('features').should include('search')
+        flipper.features.map(&:name).should include(:search)
       end
     end
 
     context "with a group" do
       before do
-        subject.enable dev_group
-        subject.enable admin_group
-        @result = subject.disable(admin_group)
+        feature.enable dev_group
+        feature.enable admin_group
+        @result = feature.disable(admin_group)
       end
 
       it "returns true" do
@@ -225,31 +221,31 @@ describe Flipper::Feature do
       end
 
       it "disables the feature for non flipper thing in the group" do
-        subject.enabled?(admin_thing).should be_false
+        feature.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
+        feature.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
+        feature.enabled?(flipper.actor(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
+        feature.enabled?(flipper.actor(dev_thing)).should be_true
       end
 
       it "adds feature to set of features" do
-        adapter.set_members('features').should include('search')
+        flipper.features.map(&:name).should include(:search)
       end
     end
 
     context "with an actor" do
       before do
-        subject.enable pitt
-        subject.enable clooney
-        @result = subject.disable(pitt)
+        feature.enable pitt
+        feature.enable clooney
+        @result = feature.disable(pitt)
       end
 
       it "returns true" do
@@ -257,21 +253,21 @@ describe Flipper::Feature do
       end
 
       it "disables feature for actor" do
-        subject.enabled?(pitt).should be_false
+        feature.enabled?(pitt).should be_false
       end
 
       it "does not disable feature for other actors" do
-        subject.enabled?(clooney).should be_true
+        feature.enabled?(clooney).should be_true
       end
 
       it "adds feature to set of features" do
-        adapter.set_members('features').should include('search')
+        flipper.features.map(&:name).should include(:search)
       end
     end
 
     context "with a percentage of actors" do
       before do
-        @result = subject.disable(five_percent_of_actors)
+        @result = feature.disable(flipper.actors(0))
       end
 
       it "returns true" do
@@ -281,22 +277,21 @@ describe Flipper::Feature do
       it "disables feature" do
         enabled = (1..100).select { |i|
           thing = actor_class.new(i)
-          subject.enabled?(thing)
+          feature.enabled?(thing)
         }.size
 
         enabled.should be(0)
       end
 
       it "adds feature to set of features" do
-        adapter.set_members('features').should include('search')
+        flipper.features.map(&:name).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)
-        @result = subject.disable(five_percent_of_random)
+        @gate = feature.gate(:percentage_of_random)
+        @result = feature.disable(flipper.random(0))
       end
 
       it "returns true" do
@@ -305,16 +300,16 @@ describe Flipper::Feature do
 
       it "disables feature for time within percentage" do
         @gate.stub(:rand => 0.04)
-        subject.enabled?.should be_false
+        feature.enabled?.should be_false
       end
 
       it "disables feature for time not within percentage" do
         @gate.stub(:rand => 0.10)
-        subject.enabled?.should be_false
+        feature.enabled?.should be_false
       end
 
       it "adds feature to set of features" do
-        adapter.set_members('features').should include('search')
+        flipper.features.map(&:name).should include(:search)
       end
     end
 
@@ -322,7 +317,7 @@ describe Flipper::Feature do
       it "raises error" do
         thing = Object.new
         expect {
-          subject.disable(thing)
+          feature.disable(thing)
         }.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
       end
     end
@@ -331,132 +326,136 @@ describe Flipper::Feature do
   describe "#enabled?" do
     context "with no arguments" do
       it "defaults to false" do
-        subject.enabled?.should be_false
+        feature.enabled?.should be_false
       end
     end
 
     context "with no arguments, but boolean enabled" do
       before do
-        subject.enable
+        feature.enable
       end
 
       it "returns true" do
-        subject.enabled?.should be_true
+        feature.enabled?.should be_true
       end
     end
 
     context "for actor in enabled group" do
       before do
-        subject.enable admin_group
+        feature.enable admin_group
       end
 
       it "returns true" do
-        subject.enabled?(Flipper::Types::Actor.new(admin_thing)).should be_true
+        feature.enabled?(flipper.actor(admin_thing)).should be_true
+        feature.enabled?(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
+        feature.enabled?(flipper.actor(dev_thing)).should be_false
+        feature.enabled?(dev_thing).should be_false
       end
     end
 
     context "for enabled actor" do
       before do
-        subject.enable pitt
+        feature.enable pitt
       end
 
       it "returns true" do
-        subject.enabled?(pitt).should be_true
+        feature.enabled?(pitt).should be_true
       end
     end
 
     context "for not enabled actor" do
       it "returns false" do
-        subject.enabled?(clooney).should be_false
+        feature.enabled?(clooney).should be_false
       end
 
       it "returns true if boolean enabled" do
-        subject.enable
-        subject.enabled?(clooney).should be_true
+        feature.enable
+        feature.enabled?(clooney).should be_true
       end
     end
 
     context "during enabled percentage of time" do
       before do
-        @gate = Flipper::Gates::PercentageOfRandom.new(subject)
+        # ensure percentage of random returns enabled percentage
+        @gate = feature.gate(:percentage_of_random)
         @gate.stub(:rand => 0.04)
-        Flipper::Gates::PercentageOfRandom.should_receive(:new).and_return(@gate)
-        subject.enable five_percent_of_random
+
+        feature.enable 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
+        feature.enabled?.should be_true
+        feature.enabled?(nil).should be_true
+        feature.enabled?(pitt).should be_true
+        feature.enabled?(admin_thing).should be_true
       end
     end
 
     context "during not enabled percentage of time" do
       before do
-        @gate = Flipper::Gates::PercentageOfRandom.new(subject)
+        # ensure percentage of random returns not enabled percentage
+        @gate = feature.gate(:percentage_of_random)
         @gate.stub(:rand => 0.10)
-        Flipper::Gates::PercentageOfRandom.should_receive(:new).and_return(@gate)
-        subject.enable five_percent_of_random
+
+        feature.enable 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
+        feature.enabled?.should be_false
+        feature.enabled?(nil).should be_false
+        feature.enabled?(pitt).should be_false
+        feature.enabled?(admin_thing).should be_false
       end
 
       it "returns true if boolean enabled" do
-        subject.enable
-        subject.enabled?.should be_true
-        subject.enabled?(nil).should be_true
-        subject.enabled?(pitt).should be_true
-        subject.enabled?(admin_thing).should be_true
+        feature.enable
+        feature.enabled?.should be_true
+        feature.enabled?(nil).should be_true
+        feature.enabled?(pitt).should be_true
+        feature.enabled?(admin_thing).should be_true
       end
     end
 
     context "for a non flipper thing" do
       before do
-        subject.enable admin_group
+        feature.enable admin_group
       end
 
       it "returns true if in enabled group" do
-        subject.enabled?(admin_thing).should be_true
+        feature.enabled?(admin_thing).should be_true
       end
 
       it "returns false if not in enabled group" do
-        subject.enabled?(dev_thing).should be_false
+        feature.enabled?(dev_thing).should be_false
       end
 
       it "returns true if boolean enabled" do
-        subject.enable
-        subject.enabled?(admin_thing).should be_true
-        subject.enabled?(dev_thing).should be_true
+        feature.enable
+        feature.enabled?(admin_thing).should be_true
+        feature.enabled?(dev_thing).should be_true
       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)
+      feature.enable(admin_group)
+      feature.enable(dev_group)
+      feature.disable
+      feature.enable(admin_group)
     end
 
     it "enables feature for object in enabled group" do
-      subject.enabled?(admin_thing).should be_true
+      feature.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
+      feature.enabled?(dev_thing).should be_false
     end
   end
 end