flipper 0.10.2 → 0.11.0.beta1

data/spec/integration_spec.rb

@@ -4,7 +4,7 @@ require 'flipper/adapters/memory'
 
 RSpec.describe Flipper do
   let(:adapter)     { Flipper::Adapters::Memory.new }
-  let(:flipper)     { Flipper.new(adapter) }
+  let(:flipper)     { described_class.new(adapter) }
   let(:feature)     { flipper[:search] }
 
   let(:actor_class) { Struct.new(:flipper_id) }
@@ -12,11 +12,19 @@ RSpec.describe Flipper do
   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 }
+  let(:admin_thing) do
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: true, dev?: false
+  end
+  let(:dev_thing) do
+    double 'Non Flipper Thing', flipper_id: 10, admin?: false, dev?: true
+  end
 
-  let(:admin_truthy_thing) { double 'Non Flipper Thing', :flipper_id => 1,  :admin? => "true-ish", :dev? => false }
-  let(:admin_falsey_thing) { double 'Non Flipper Thing', :flipper_id => 1,  :admin? => nil, :dev? => false }
+  let(:admin_truthy_thing) do
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: 'true-ish', dev?: false
+  end
+  let(:admin_falsey_thing) do
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: nil, dev?: false
+  end
 
   let(:pitt)        { actor_class.new(1) }
   let(:clooney)     { actor_class.new(10) }
@@ -25,149 +33,149 @@ RSpec.describe Flipper do
   let(:five_percent_of_time) { flipper.time(5) }
 
   before do
-    Flipper.register(:admins) { |thing| thing.admin? }
-    Flipper.register(:devs)   { |thing| thing.dev? }
+    described_class.register(:admins, &:admin?)
+    described_class.register(:devs, &:dev?)
   end
 
-  describe "#enable" do
-    context "with no arguments" do
+  describe '#enable' do
+    context 'with no arguments' do
       before do
         @result = feature.enable
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(@result).to eq(true)
       end
 
-      it "enables feature for all" do
+      it 'enables feature for all' do
         expect(feature.enabled?).to eq(true)
       end
 
-      it "adds feature to set of features" do
+      it 'adds feature to set of features' do
         expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
-    context "with a group" do
+    context 'with a group' do
       before do
         @result = feature.enable(admin_group)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(@result).to eq(true)
       end
 
-      it "enables feature for non flipper thing in group" do
+      it 'enables feature for non flipper thing in group' do
         expect(feature.enabled?(admin_thing)).to eq(true)
       end
 
-      it "does not enable feature for non flipper thing in other group" do
+      it 'does not enable feature for non flipper thing in other group' do
         expect(feature.enabled?(dev_thing)).to eq(false)
       end
 
-      it "enables feature for flipper actor in group" do
+      it 'enables feature for flipper actor in group' do
         expect(feature.enabled?(flipper.actor(admin_thing))).to eq(true)
       end
 
-      it "does not enable for flipper actor not in group" do
+      it 'does not enable for flipper actor not in group' do
         expect(feature.enabled?(flipper.actor(dev_thing))).to eq(false)
       end
 
-      it "does not enable feature for all" do
+      it 'does not enable feature for all' do
         expect(feature.enabled?).to eq(false)
       end
 
-      it "adds feature to set of features" do
+      it 'adds feature to set of features' do
         expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
-    context "with an actor" do
+    context 'with an actor' do
       before do
         @result = feature.enable(pitt)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(@result).to eq(true)
       end
 
-      it "enables feature for actor" do
+      it 'enables feature for actor' do
         expect(feature.enabled?(pitt)).to eq(true)
       end
 
-      it "does not enable feature for other actors" do
+      it 'does not enable feature for other actors' do
         expect(feature.enabled?(clooney)).to eq(false)
       end
 
-      it "adds feature to set of features" do
+      it 'adds feature to set of features' do
         expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
-    context "with a percentage of actors" do
+    context 'with a percentage of actors' do
       before do
         @result = feature.enable(five_percent_of_actors)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(@result).to eq(true)
       end
 
-      it "enables feature for actor within percentage" do
-        enabled = (1..100).select { |i|
+      it 'enables feature for actor within percentage' do
+        enabled = (1..100).select do |i|
           thing = actor_class.new(i)
           feature.enabled?(thing)
-        }.size
+        end.size
 
         expect(enabled).to be_within(2).of(5)
       end
 
-      it "adds feature to set of features" do
+      it 'adds feature to set of features' do
         expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
-    context "with a percentage of time" do
+    context 'with a percentage of time' do
       before do
         @gate = feature.gate(:percentage_of_time)
         @result = feature.enable(five_percent_of_time)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(@result).to eq(true)
       end
 
-      it "enables feature for time within percentage" do
-        allow(@gate).to receive_messages(:rand => 0.04)
+      it 'enables feature for time within percentage' do
+        allow(@gate).to receive_messages(rand: 0.04)
         expect(feature.enabled?).to eq(true)
       end
 
-      it "does not enable feature for time not within percentage" do
-        allow(@gate).to receive_messages(:rand => 0.10)
+      it 'does not enable feature for time not within percentage' do
+        allow(@gate).to receive_messages(rand: 0.10)
         expect(feature.enabled?).to eq(false)
       end
 
-      it "adds feature to set of features" do
+      it 'adds feature to set of features' do
         expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
-    context "with argument that has no gate" do
-      it "raises error" do
+    context 'with argument that has no gate' do
+      it 'raises error' do
         thing = Object.new
-        expect {
+        expect do
           feature.enable(thing)
-        }.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
+        end.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
       end
     end
   end
 
-  describe "#disable" do
-    context "with no arguments" do
+  describe '#disable' do
+    context 'with no arguments' do
       before do
         # ensures that time gate is stubbed with result that would be true for pitt
         @gate = feature.gate(:percentage_of_time)
-        allow(@gate).to receive_messages(:rand => 0.04)
+        allow(@gate).to receive_messages(rand: 0.04)
 
         feature.enable admin_group
         feature.enable pitt
@@ -176,229 +184,229 @@ RSpec.describe Flipper do
         @result = feature.disable
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(@result).to be(true)
       end
 
-      it "disables feature" do
+      it 'disables feature' do
         expect(feature.enabled?).to eq(false)
       end
 
-      it "disables for individual actor" do
+      it 'disables for individual actor' do
         expect(feature.enabled?(pitt)).to eq(false)
       end
 
-      it "disables actor in group" do
+      it 'disables actor in group' do
         expect(feature.enabled?(admin_thing)).to eq(false)
       end
 
-      it "disables actor in percentage of actors" do
-        enabled = (1..100).select { |i|
+      it 'disables actor in percentage of actors' do
+        enabled = (1..100).select do |i|
           thing = actor_class.new(i)
           feature.enabled?(thing)
-        }.size
+        end.size
 
         expect(enabled).to be(0)
       end
 
-      it "disables percentage of time" do
+      it 'disables percentage of time' do
         expect(feature.enabled?(pitt)).to eq(false)
       end
 
-      it "adds feature to set of features" do
+      it 'adds feature to set of features' do
         expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
-    context "with a group" do
+    context 'with a group' do
       before do
         feature.enable dev_group
         feature.enable admin_group
         @result = feature.disable(admin_group)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(@result).to eq(true)
       end
 
-      it "disables the feature for non flipper thing in the group" do
+      it 'disables the feature for non flipper thing in the group' do
         expect(feature.enabled?(admin_thing)).to eq(false)
       end
 
-      it "does not disable feature for non flipper thing in other groups" do
+      it 'does not disable feature for non flipper thing in other groups' do
         expect(feature.enabled?(dev_thing)).to eq(true)
       end
 
-      it "disables feature for flipper actor in group" do
+      it 'disables feature for flipper actor in group' do
         expect(feature.enabled?(flipper.actor(admin_thing))).to eq(false)
       end
 
-      it "does not disable feature for flipper actor in other groups" do
+      it 'does not disable feature for flipper actor in other groups' do
         expect(feature.enabled?(flipper.actor(dev_thing))).to eq(true)
       end
 
-      it "adds feature to set of features" do
+      it 'adds feature to set of features' do
         expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
-    context "with an actor" do
+    context 'with an actor' do
       before do
         feature.enable pitt
         feature.enable clooney
         @result = feature.disable(pitt)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(@result).to eq(true)
       end
 
-      it "disables feature for actor" do
+      it 'disables feature for actor' do
         expect(feature.enabled?(pitt)).to eq(false)
       end
 
-      it "does not disable feature for other actors" do
+      it 'does not disable feature for other actors' do
         expect(feature.enabled?(clooney)).to eq(true)
       end
 
-      it "adds feature to set of features" do
+      it 'adds feature to set of features' do
         expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
-    context "with a percentage of actors" do
+    context 'with a percentage of actors' do
       before do
         @result = feature.disable(flipper.actors(0))
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(@result).to eq(true)
       end
 
-      it "disables feature" do
-        enabled = (1..100).select { |i|
+      it 'disables feature' do
+        enabled = (1..100).select do |i|
           thing = actor_class.new(i)
           feature.enabled?(thing)
-        }.size
+        end.size
 
         expect(enabled).to be(0)
       end
 
-      it "adds feature to set of features" do
+      it 'adds feature to set of features' do
         expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
-    context "with a percentage of time" do
+    context 'with a percentage of time' do
       before do
         @gate = feature.gate(:percentage_of_time)
         @result = feature.disable(flipper.time(0))
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(@result).to eq(true)
       end
 
-      it "disables feature for time within percentage" do
-        allow(@gate).to receive_messages(:rand => 0.04)
+      it 'disables feature for time within percentage' do
+        allow(@gate).to receive_messages(rand: 0.04)
         expect(feature.enabled?).to eq(false)
       end
 
-      it "disables feature for time not within percentage" do
-        allow(@gate).to receive_messages(:rand => 0.10)
+      it 'disables feature for time not within percentage' do
+        allow(@gate).to receive_messages(rand: 0.10)
         expect(feature.enabled?).to eq(false)
       end
 
-      it "adds feature to set of features" do
+      it 'adds feature to set of features' do
         expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
-    context "with argument that has no gate" do
-      it "raises error" do
+    context 'with argument that has no gate' do
+      it 'raises error' do
         thing = Object.new
-        expect {
+        expect do
           feature.disable(thing)
-        }.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
+        end.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
+  describe '#enabled?' do
+    context 'with no arguments' do
+      it 'defaults to false' do
         expect(feature.enabled?).to eq(false)
       end
     end
 
-    context "with no arguments, but boolean enabled" do
+    context 'with no arguments, but boolean enabled' do
       before do
         feature.enable
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(feature.enabled?).to eq(true)
       end
     end
 
-    context "for actor in enabled group" do
+    context 'for actor in enabled group' do
       before do
         feature.enable admin_group
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(feature.enabled?(flipper.actor(admin_thing))).to eq(true)
         expect(feature.enabled?(admin_thing)).to eq(true)
       end
 
-      it "returns true for truthy block values" do
+      it 'returns true for truthy block values' do
         expect(feature.enabled?(flipper.actor(admin_truthy_thing))).to eq(true)
       end
     end
 
-    context "for actor in disabled group" do
-      it "returns false" do
+    context 'for actor in disabled group' do
+      it 'returns false' do
         expect(feature.enabled?(flipper.actor(dev_thing))).to eq(false)
         expect(feature.enabled?(dev_thing)).to eq(false)
       end
 
-      it "returns false for falsey block values" do
+      it 'returns false for falsey block values' do
         expect(feature.enabled?(flipper.actor(admin_falsey_thing))).to eq(false)
       end
     end
 
-    context "for enabled actor" do
+    context 'for enabled actor' do
       before do
         feature.enable pitt
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(feature.enabled?(pitt)).to eq(true)
       end
     end
 
-    context "for not enabled actor" do
-      it "returns false" do
+    context 'for not enabled actor' do
+      it 'returns false' do
         expect(feature.enabled?(clooney)).to eq(false)
       end
 
-      it "returns true if boolean enabled" do
+      it 'returns true if boolean enabled' do
         feature.enable
         expect(feature.enabled?(clooney)).to eq(true)
       end
     end
 
-    context "for enabled percentage of time" do
+    context 'for enabled percentage of time' do
       before do
         # ensure percentage of time returns percentage that makes five percent
         # of time true
         @gate = feature.gate(:percentage_of_time)
-        allow(@gate).to receive_messages(:rand => 0.04)
+        allow(@gate).to receive_messages(rand: 0.04)
 
         feature.enable five_percent_of_time
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(feature.enabled?).to eq(true)
         expect(feature.enabled?(nil)).to eq(true)
         expect(feature.enabled?(pitt)).to eq(true)
@@ -406,24 +414,24 @@ RSpec.describe Flipper do
       end
     end
 
-    context "for not enabled percentage of time" do
+    context 'for not enabled percentage of time' do
       before do
         # ensure percentage of time returns percentage that makes five percent
         # of time false
         @gate = feature.gate(:percentage_of_time)
-        allow(@gate).to receive_messages(:rand => 0.10)
+        allow(@gate).to receive_messages(rand: 0.10)
 
         feature.enable five_percent_of_time
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(feature.enabled?).to eq(false)
         expect(feature.enabled?(nil)).to eq(false)
         expect(feature.enabled?(pitt)).to eq(false)
         expect(feature.enabled?(admin_thing)).to eq(false)
       end
 
-      it "returns true if boolean enabled" do
+      it 'returns true if boolean enabled' do
         feature.enable
         expect(feature.enabled?).to eq(true)
         expect(feature.enabled?(nil)).to eq(true)
@@ -432,20 +440,20 @@ RSpec.describe Flipper do
       end
     end
 
-    context "for a non flipper thing" do
+    context 'for a non flipper thing' do
       before do
         feature.enable admin_group
       end
 
-      it "returns true if in enabled group" do
+      it 'returns true if in enabled group' do
         expect(feature.enabled?(admin_thing)).to eq(true)
       end
 
-      it "returns false if not in enabled group" do
+      it 'returns false if not in enabled group' do
         expect(feature.enabled?(dev_thing)).to eq(false)
       end
 
-      it "returns true if boolean enabled" do
+      it 'returns true if boolean enabled' do
         feature.enable
         expect(feature.enabled?(admin_thing)).to eq(true)
         expect(feature.enabled?(dev_thing)).to eq(true)
@@ -453,7 +461,7 @@ RSpec.describe Flipper do
     end
   end
 
-  context "enabling multiple groups, disabling everything, then enabling one group" do
+  context 'enabling multiple groups, disabling everything, then enabling one group' do
     before do
       feature.enable(admin_group)
       feature.enable(dev_group)
@@ -461,11 +469,11 @@ RSpec.describe Flipper do
       feature.enable(admin_group)
     end
 
-    it "enables feature for object in enabled group" do
+    it 'enables feature for object in enabled group' do
       expect(feature.enabled?(admin_thing)).to eq(true)
     end
 
-    it "does not enable feature for object in not enabled group" do
+    it 'does not enable feature for object in not enabled group' do
       expect(feature.enabled?(dev_thing)).to eq(false)
     end
   end