flipper 0.16.0 → 1.4.0

data/spec/flipper/feature_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/feature'
 require 'flipper/instrumenters/memory'
 
@@ -33,6 +32,72 @@ RSpec.describe Flipper::Feature do
     end
   end
 
+  describe "#enabled?" do
+    context "for an actor" do
+      let(:actor) { Flipper::Actor.new("User;1") }
+
+      it 'returns true if feature is enabled' do
+        subject.enable
+        expect(subject.enabled?(actor)).to be(true)
+      end
+
+      it 'returns false if feature is disabled' do
+        subject.disable
+        expect(subject.enabled?(actor)).to be(false)
+      end
+    end
+
+    context "for multiple actors" do
+      let(:actors) {
+        [
+          Flipper::Actor.new("User;1"),
+          Flipper::Actor.new("User;2"),
+          Flipper::Actor.new("User;3"),
+        ]
+      }
+
+      it 'returns true if feature is enabled' do
+        subject.enable
+        expect(subject.enabled?(actors)).to be(true)
+      end
+
+      it 'returns true if feature is enabled for any actor' do
+        subject.enable_actor actors.first
+        expect(subject.enabled?(actors)).to be(true)
+      end
+
+      it 'returns true if feature is enabled for any actor with multiple arguments' do
+        subject.enable_actor actors.last
+        expect(subject.enabled?(*actors)).to be(true)
+      end
+
+      it 'returns false if feature is disabled for all actors' do
+        subject.disable
+        expect(subject.enabled?(actors)).to be(false)
+      end
+    end
+
+    context "for an object that implements .nil? == true" do
+      let(:actor) { Flipper::Actor.new("User;1") }
+
+      before do
+        def actor.nil?
+          true
+        end
+      end
+
+      it 'returns true if feature is enabled' do
+        subject.enable
+        expect(subject.enabled?(actor)).to be(true)
+      end
+
+      it 'returns false if feature is disabled' do
+        subject.disable
+        expect(subject.enabled?(actor)).to be(false)
+      end
+    end
+  end
+
   describe '#to_s' do
     it 'returns name as string' do
       feature = described_class.new(:search, adapter)
@@ -64,7 +129,7 @@ RSpec.describe Flipper::Feature do
       instance.gates.each do |gate|
         expect(gate).to be_a(Flipper::Gate)
       end
-      expect(instance.gates.size).to be(5)
+      expect(instance.gates.size).to be(6)
     end
   end
 
@@ -149,34 +214,33 @@ RSpec.describe Flipper::Feature do
     end
 
     it 'is recorded for enable' do
-      thing = Flipper::Types::Actor.new(Flipper::Actor.new('1'))
-      gate = subject.gate_for(thing)
+      actor = Flipper::Types::Actor.new(Flipper::Actor.new('1'))
+      subject.gate_for(actor)
 
-      subject.enable(thing)
+      subject.enable(actor)
 
       event = instrumenter.events.last
       expect(event).not_to be_nil
       expect(event.name).to eq('feature_operation.flipper')
       expect(event.payload[:feature_name]).to eq(:search)
       expect(event.payload[:operation]).to eq(:enable)
-      expect(event.payload[:thing]).to eq(thing)
+      expect(event.payload[:thing]).to eq(actor)
       expect(event.payload[:result]).not_to be_nil
     end
 
     it 'always instruments flipper type instance for enable' do
-      thing = Flipper::Actor.new('1')
-      gate = subject.gate_for(thing)
+      actor = Flipper::Actor.new('1')
+      subject.gate_for(actor)
 
-      subject.enable(thing)
+      subject.enable(actor)
 
       event = instrumenter.events.last
       expect(event).not_to be_nil
-      expect(event.payload[:thing]).to eq(Flipper::Types::Actor.new(thing))
+      expect(event.payload[:thing]).to eq(Flipper::Types::Actor.new(actor))
     end
 
     it 'is recorded for disable' do
       thing = Flipper::Types::Boolean.new
-      gate = subject.gate_for(thing)
 
       subject.disable(thing)
 
@@ -220,15 +284,14 @@ RSpec.describe Flipper::Feature do
     end
 
     it 'always instruments flipper type instance for disable' do
-      thing = Flipper::Actor.new('1')
-      gate = subject.gate_for(thing)
+      actor = Flipper::Actor.new('1')
 
-      subject.disable(thing)
+      subject.disable(actor)
 
       event = instrumenter.events.last
       expect(event).not_to be_nil
       expect(event.payload[:operation]).to eq(:disable)
-      expect(event.payload[:thing]).to eq(Flipper::Types::Actor.new(thing))
+      expect(event.payload[:thing]).to eq(Flipper::Types::Actor.new(actor))
     end
 
     it 'is recorded for add' do
@@ -276,17 +339,15 @@ RSpec.describe Flipper::Feature do
     end
 
     it 'is recorded for enabled?' do
-      thing = Flipper::Types::Actor.new(Flipper::Actor.new('1'))
-      gate = subject.gate_for(thing)
-
-      subject.enabled?(thing)
+      actor = Flipper::Types::Actor.new(Flipper::Actor.new('1'))
+      subject.enabled?(actor)
 
       event = instrumenter.events.last
       expect(event).not_to be_nil
       expect(event.name).to eq('feature_operation.flipper')
       expect(event.payload[:feature_name]).to eq(:search)
       expect(event.payload[:operation]).to eq(:enabled?)
-      expect(event.payload[:thing]).to eq(thing)
+      expect(event.payload[:actors]).to eq([actor])
       expect(event.payload[:result]).to eq(false)
     end
 
@@ -294,8 +355,8 @@ RSpec.describe Flipper::Feature do
     actor = Flipper::Types::Actor.new(user)
     {
       nil => nil,
-      user => actor,
-      actor => actor,
+      user => [actor],
+      actor => [actor],
     }.each do |thing, wrapped_thing|
       it "always instruments #{thing.inspect} as #{wrapped_thing.class} for enabled?" do
         subject.enabled?(thing)
@@ -303,7 +364,7 @@ RSpec.describe Flipper::Feature do
         event = instrumenter.events.last
         expect(event).not_to be_nil
         expect(event.payload[:operation]).to eq(:enabled?)
-        expect(event.payload[:thing]).to eq(wrapped_thing)
+        expect(event.payload[:actors]).to eq(wrapped_thing)
       end
     end
   end
@@ -359,19 +420,19 @@ RSpec.describe Flipper::Feature do
       end
 
       it 'returns :on' do
-        expect(subject.state).to be(:on)
+        expect(subject.state).to be(:conditional)
       end
 
-      it 'returns true for on?' do
-        expect(subject.on?).to be(true)
+      it 'returns false for on?' do
+        expect(subject.on?).to be(false)
       end
 
       it 'returns false for off?' do
         expect(subject.off?).to be(false)
       end
 
-      it 'returns false for conditional?' do
-        expect(subject.conditional?).to be(false)
+      it 'returns true for conditional?' do
+        expect(subject.conditional?).to be(true)
       end
     end
 
@@ -429,10 +490,10 @@ RSpec.describe Flipper::Feature do
 
     context 'when one or more groups enabled' do
       before do
-        @staff = Flipper.register(:staff) { |_thing| true }
-        @preview_features = Flipper.register(:preview_features) { |_thing| true }
-        @not_enabled = Flipper.register(:not_enabled) { |_thing| true }
-        @disabled = Flipper.register(:disabled) { |_thing| true }
+        @staff = Flipper.register(:staff) { |actor| true }
+        @preview_features = Flipper.register(:preview_features) { |actor| true }
+        @not_enabled = Flipper.register(:not_enabled) { |actor| true }
+        @disabled = Flipper.register(:disabled) { |actor| true }
         subject.enable @staff
         subject.enable @preview_features
         subject.disable @disabled
@@ -468,10 +529,10 @@ RSpec.describe Flipper::Feature do
 
     context 'when one or more groups enabled' do
       before do
-        @staff = Flipper.register(:staff) { |_thing| true }
-        @preview_features = Flipper.register(:preview_features) { |_thing| true }
-        @not_enabled = Flipper.register(:not_enabled) { |_thing| true }
-        @disabled = Flipper.register(:disabled) { |_thing| true }
+        @staff = Flipper.register(:staff) { |actor| true }
+        @preview_features = Flipper.register(:preview_features) { |actor| true }
+        @not_enabled = Flipper.register(:not_enabled) { |actor| true }
+        @disabled = Flipper.register(:disabled) { |actor| true }
         subject.enable @staff
         subject.enable @preview_features
         subject.disable @disabled
@@ -495,10 +556,10 @@ RSpec.describe Flipper::Feature do
 
     context 'when one or more groups enabled' do
       before do
-        @staff = Flipper.register(:staff) { |_thing| true }
-        @preview_features = Flipper.register(:preview_features) { |_thing| true }
-        @not_enabled = Flipper.register(:not_enabled) { |_thing| true }
-        @disabled = Flipper.register(:disabled) { |_thing| true }
+        @staff = Flipper.register(:staff) { |actor| true }
+        @preview_features = Flipper.register(:preview_features) { |actor| true }
+        @not_enabled = Flipper.register(:not_enabled) { |actor| true }
+        @disabled = Flipper.register(:disabled) { |actor| true }
         subject.enable @staff
         subject.enable @preview_features
         subject.disable @disabled
@@ -530,12 +591,12 @@ RSpec.describe Flipper::Feature do
 
     context 'when one or more actors are enabled' do
       before do
-        subject.enable Flipper::Types::Actor.new(Flipper::Actor.new('User:5'))
-        subject.enable Flipper::Types::Actor.new(Flipper::Actor.new('User:22'))
+        subject.enable Flipper::Types::Actor.new(Flipper::Actor.new('User;5'))
+        subject.enable Flipper::Types::Actor.new(Flipper::Actor.new('User;22'))
       end
 
       it 'returns set of actor ids' do
-        expect(subject.actors_value).to eq(Set.new(['User:5', 'User:22']))
+        expect(subject.actors_value).to eq(Set.new(['User;5', 'User;22']))
       end
     end
   end
@@ -650,6 +711,361 @@ RSpec.describe Flipper::Feature do
     end
   end
 
+  describe '#expression' do
+    it "returns nil if feature has no expression" do
+      expect(subject.expression).to be(nil)
+    end
+
+    it "returns expression if feature has expression" do
+      expression = Flipper.property(:plan).eq("basic")
+      subject.enable_expression expression
+      expect(subject.expression).to eq(expression)
+    end
+  end
+
+  describe '#enable_expression/disable_expression' do
+    context "with expression instance" do
+      it "updates gate values to equal expression or clears expression" do
+        expression = Flipper.property(:plan).eq("basic")
+        expect(subject.gate_values.expression).to be(nil)
+        subject.enable_expression(expression)
+        expect(subject.gate_values.expression).to eq(expression.value)
+        subject.disable_expression
+        expect(subject.gate_values.expression).to be(nil)
+      end
+    end
+
+    context "with Hash" do
+      it "updates gate values to equal expression or clears expression" do
+        expression = Flipper.property(:plan).eq("basic")
+        expect(subject.gate_values.expression).to be(nil)
+        subject.enable_expression(expression.value)
+        expect(subject.gate_values.expression).to eq(expression.value)
+        subject.disable_expression
+        expect(subject.gate_values.expression).to be(nil)
+      end
+    end
+  end
+
+  describe "#add_expression" do
+    context "when nothing enabled" do
+      context "with Expression instance" do
+        it "sets expression to Expression" do
+          expression = Flipper.property(:plan).eq("basic")
+          subject.add_expression(expression)
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression).to eq(expression)
+        end
+      end
+
+      context "with Any instance" do
+        it "sets expression to Any" do
+          expression = Flipper.any(Flipper.property(:plan).eq("basic"))
+          subject.add_expression(expression)
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression).to eq(expression)
+        end
+      end
+
+      context "with All instance" do
+        it "sets expression to All" do
+          expression = Flipper.all(Flipper.property(:plan).eq("basic"))
+          subject.add_expression(expression)
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression).to eq(expression)
+        end
+      end
+    end
+
+    context "when Expression enabled" do
+      let(:expression) { Flipper.property(:plan).eq("basic") }
+
+      before do
+        subject.enable_expression expression
+      end
+
+      context "with Expression instance" do
+        it "changes expression to Any and adds new Expression" do
+          new_expression = Flipper.property(:age).gte(21)
+          subject.add_expression(new_expression)
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression.args).to include(expression)
+          expect(subject.expression.args).to include(new_expression)
+        end
+      end
+
+      context "with Any instance" do
+        it "changes expression to Any and adds new Any" do
+          new_expression = Flipper.any(Flipper.property(:age).eq(21))
+          subject.add_expression new_expression
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression.args).to include(expression)
+          expect(subject.expression.args).to include(new_expression)
+        end
+      end
+
+      context "with All instance" do
+        it "changes expression to Any and adds new All" do
+          new_expression = Flipper.all(Flipper.property(:plan).eq("basic"))
+          subject.add_expression new_expression
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression.args).to include(expression)
+          expect(subject.expression.args).to include(new_expression)
+        end
+      end
+    end
+
+    context "when Any enabled" do
+      let(:condition) { Flipper.property(:plan).eq("basic") }
+      let(:expression) { Flipper.any(condition) }
+
+      before do
+        subject.enable_expression expression
+      end
+
+      context "with Expression instance" do
+        it "adds Expression to Any" do
+          new_expression = Flipper.property(:age).gte(21)
+          subject.add_expression(new_expression)
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression.args).to include(condition)
+          expect(subject.expression.args).to include(new_expression)
+        end
+      end
+
+      context "with Any instance" do
+        it "adds Any to Any" do
+          new_expression = Flipper.any(Flipper.property(:age).gte(21))
+          subject.add_expression(new_expression)
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression.args).to include(condition)
+          expect(subject.expression.args).to include(new_expression)
+        end
+      end
+
+      context "with All instance" do
+        it "adds All to Any" do
+          new_expression = Flipper.all(Flipper.property(:age).gte(21))
+          subject.add_expression(new_expression)
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression.args).to include(condition)
+          expect(subject.expression.args).to include(new_expression)
+        end
+      end
+    end
+
+    context "when All enabled" do
+      let(:condition) { Flipper.property(:plan).eq("basic") }
+      let(:expression) { Flipper.all(condition) }
+
+      before do
+        subject.enable_expression expression
+      end
+
+      context "with Expression instance" do
+        it "adds Expression to All" do
+          new_expression = Flipper.property(:age).gte(21)
+          subject.add_expression(new_expression)
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression.args).to include(condition)
+          expect(subject.expression.args).to include(new_expression)
+        end
+      end
+
+      context "with Any instance" do
+        it "adds Any to All" do
+          new_expression = Flipper.any(Flipper.property(:age).gte(21))
+          subject.add_expression(new_expression)
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression.args).to include(condition)
+          expect(subject.expression.args).to include(new_expression)
+        end
+      end
+
+      context "with All instance" do
+        it "adds All to All" do
+          new_expression = Flipper.all(Flipper.property(:age).gte(21))
+          subject.add_expression(new_expression)
+          expect(subject.expression).to be_instance_of(Flipper::Expression)
+          expect(subject.expression.args).to include(condition)
+          expect(subject.expression.args).to include(new_expression)
+        end
+      end
+    end
+  end
+
+  describe '#remove_expression' do
+    context "when nothing enabled" do
+      context "with Expression instance" do
+        it "does nothing" do
+          expression = Flipper.property(:plan).eq("basic")
+          subject.remove_expression(expression)
+          expect(subject.expression).to be(nil)
+        end
+      end
+
+      context "with Any instance" do
+        it "does nothing" do
+          expression = Flipper.any(Flipper.property(:plan).eq("basic"))
+          subject.remove_expression expression
+          expect(subject.expression).to be(nil)
+        end
+      end
+
+      context "with All instance" do
+        it "does nothing" do
+          expression = Flipper.all(Flipper.property(:plan).eq("basic"))
+          subject.remove_expression expression
+          expect(subject.expression).to be(nil)
+        end
+      end
+    end
+
+    context "when Expression enabled" do
+      let(:expression) { Flipper.property(:plan).eq("basic") }
+
+      before do
+        subject.enable_expression expression
+      end
+
+      context "with Expression instance" do
+        it "changes expression to Any and removes Expression if it matches" do
+          new_expression = Flipper.property(:plan).eq("basic")
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(Flipper.any)
+        end
+
+        it "changes expression to Any if Expression doesn't match" do
+          new_expression = Flipper.property(:plan).eq("premium")
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(Flipper.any(expression))
+        end
+      end
+
+      context "with Any instance" do
+        it "changes expression to Any and does nothing" do
+          new_expression = Flipper.any(Flipper.property(:plan).eq("basic"))
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(Flipper.any(expression))
+        end
+      end
+
+      context "with All instance" do
+        it "changes expression to Any and does nothing" do
+          new_expression = Flipper.all(Flipper.property(:plan).eq("basic"))
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(Flipper.any(expression))
+        end
+      end
+    end
+
+    context "when Any enabled" do
+      let(:condition) { Flipper.property(:plan).eq("basic") }
+      let(:expression) { Flipper.any condition }
+
+      before do
+        subject.enable_expression expression
+      end
+
+      context "with Expression instance" do
+        it "removes Expression if it matches" do
+          subject.remove_expression condition
+          expect(subject.expression).to eq(Flipper.any)
+        end
+
+        it "does nothing if Expression does not match" do
+          subject.remove_expression Flipper.property(:plan).eq("premium")
+          expect(subject.expression).to eq(expression)
+        end
+      end
+
+      context "with Any instance" do
+        it "removes Any if it matches" do
+          new_expression = Flipper.any(Flipper.property(:plan).eq("premium"))
+          subject.add_expression new_expression
+          expect(subject.expression.args.size).to be(2)
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(expression)
+        end
+
+        it "does nothing if Any does not match" do
+          new_expression = Flipper.any(Flipper.property(:plan).eq("premium"))
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(expression)
+        end
+      end
+
+      context "with All instance" do
+        it "removes All if it matches" do
+          new_expression = Flipper.all(Flipper.property(:plan).eq("premium"))
+          subject.add_expression new_expression
+          expect(subject.expression.args.size).to be(2)
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(expression)
+        end
+
+        it "does nothing if All does not match" do
+          new_expression = Flipper.all(Flipper.property(:plan).eq("premium"))
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(expression)
+        end
+      end
+    end
+
+    context "when All enabled" do
+      let(:condition) { Flipper.property(:plan).eq("basic") }
+      let(:expression) { Flipper.all condition }
+
+      before do
+        subject.enable_expression expression
+      end
+
+      context "with Expression instance" do
+        it "removes Expression if it matches" do
+          subject.remove_expression condition
+          expect(subject.expression).to eq(Flipper.all)
+        end
+
+        it "does nothing if Expression does not match" do
+          subject.remove_expression Flipper.property(:plan).eq("premium")
+          expect(subject.expression).to eq(expression)
+        end
+      end
+
+      context "with Any instance" do
+        it "removes Any if it matches" do
+          new_expression = Flipper.any(Flipper.property(:plan).eq("premium"))
+          subject.add_expression new_expression
+          expect(subject.expression.args.size).to be(2)
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(expression)
+        end
+
+        it "does nothing if Any does not match" do
+          new_expression = Flipper.any(Flipper.property(:plan).eq("premium"))
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(expression)
+        end
+      end
+
+      context "with All instance" do
+        it "removes All if it matches" do
+          new_expression = Flipper.all(Flipper.property(:plan).eq("premium"))
+          subject.add_expression new_expression
+          expect(subject.expression.args.size).to be(2)
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(expression)
+        end
+
+        it "does nothing if All does not match" do
+          new_expression = Flipper.all(Flipper.property(:plan).eq("premium"))
+          subject.remove_expression new_expression
+          expect(subject.expression).to eq(expression)
+        end
+      end
+    end
+  end
+
   describe '#enable_actor/disable_actor' do
     context 'with object that responds to flipper_id' do
       it 'updates the gate values to include the actor' do
@@ -678,8 +1094,6 @@ RSpec.describe Flipper::Feature do
   describe '#enable_group/disable_group' do
     context 'with symbol group name' do
       it 'updates the gate values to include the group' do
-        actor = Flipper::Actor.new(5)
-        group = Flipper.register(:five_only) { |actor| actor.flipper_id == 5 }
         expect(subject.gate_values.groups).to be_empty
         subject.enable_group(:five_only)
         expect(subject.gate_values.groups).to eq(Set['five_only'])
@@ -690,8 +1104,6 @@ RSpec.describe Flipper::Feature do
 
     context 'with string group name' do
       it 'updates the gate values to include the group' do
-        actor = Flipper::Actor.new(5)
-        group = Flipper.register(:five_only) { |actor| actor.flipper_id == 5 }
         expect(subject.gate_values.groups).to be_empty
         subject.enable_group('five_only')
         expect(subject.gate_values.groups).to eq(Set['five_only'])
@@ -702,7 +1114,6 @@ RSpec.describe Flipper::Feature do
 
     context 'with group instance' do
       it 'updates the gate values for the group' do
-        actor = Flipper::Actor.new(5)
         group = Flipper.register(:five_only) { |actor| actor.flipper_id == 5 }
         expect(subject.gate_values.groups).to be_empty
         subject.enable_group(group)
@@ -802,12 +1213,14 @@ RSpec.describe Flipper::Feature do
               :actor,
               :boolean,
               :group,
+              :expression,
             ])
 
       expect(subject.disabled_gate_names.to_set).to eq(Set[
               :actor,
               :boolean,
               :group,
+              :expression,
             ])
     end
   end

data/spec/flipper/gate_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::Gate do
   let(:feature_name) { :stats }