flipper 0.26.0 → 1.1.0

data/spec/flipper/feature_spec.rb

@@ -32,6 +32,52 @@ 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
+  end
+
   describe '#to_s' do
     it 'returns name as string' do
       feature = described_class.new(:search, adapter)
@@ -63,7 +109,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
 
@@ -148,29 +194,29 @@ 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'))
+      gate = 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')
+      gate = 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
@@ -219,15 +265,15 @@ 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')
+      gate = subject.gate_for(actor)
 
-      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
@@ -275,17 +321,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
 
@@ -293,8 +337,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)
@@ -302,7 +346,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
@@ -428,10 +472,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
@@ -467,10 +511,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
@@ -494,10 +538,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
@@ -649,6 +693,363 @@ 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")
+        other_expression = Flipper.property(:age).gte(21)
+        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")
+        other_expression = Flipper.property(:age).gte(21)
+        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
@@ -801,12 +1202,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_values_spec.rb

@@ -80,13 +80,13 @@ RSpec.describe Flipper::GateValues do
   it 'raises argument error for percentage of time value that cannot be converted to an integer' do
     expect do
       described_class.new(percentage_of_time: ['asdf'])
-    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to an integer))
+    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to a number))
   end
 
   it 'raises argument error for percentage of actors value that cannot be converted to an int' do
     expect do
       described_class.new(percentage_of_actors: ['asdf'])
-    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to an integer))
+    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to a number))
   end
 
   it 'raises argument error for actors value that cannot be converted to a set' do
@@ -100,35 +100,4 @@ RSpec.describe Flipper::GateValues do
       described_class.new(groups: 'asdf')
     end.to raise_error(ArgumentError, %("asdf" cannot be converted to a set))
   end
-
-  describe '#[]' do
-    it 'can read the boolean value' do
-      expect(described_class.new(boolean: true)[:boolean]).to be(true)
-      expect(described_class.new(boolean: true)['boolean']).to be(true)
-    end
-
-    it 'can read the actors value' do
-      expect(described_class.new(actors: Set[1, 2])[:actors]).to eq(Set[1, 2])
-      expect(described_class.new(actors: Set[1, 2])['actors']).to eq(Set[1, 2])
-    end
-
-    it 'can read the groups value' do
-      expect(described_class.new(groups: Set[:admins])[:groups]).to eq(Set[:admins])
-      expect(described_class.new(groups: Set[:admins])['groups']).to eq(Set[:admins])
-    end
-
-    it 'can read the percentage of time value' do
-      expect(described_class.new(percentage_of_time: 15)[:percentage_of_time]).to eq(15)
-      expect(described_class.new(percentage_of_time: 15)['percentage_of_time']).to eq(15)
-    end
-
-    it 'can read the percentage of actors value' do
-      expect(described_class.new(percentage_of_actors: 15)[:percentage_of_actors]).to eq(15)
-      expect(described_class.new(percentage_of_actors: 15)['percentage_of_actors']).to eq(15)
-    end
-
-    it 'returns nil for value that is not present' do
-      expect(described_class.new({})['not legit']).to be(nil)
-    end
-  end
 end

data/spec/flipper/gates/boolean_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Flipper::Gates::Boolean do
     Flipper::FeatureCheckContext.new(
       feature_name: feature_name,
       values: Flipper::GateValues.new(boolean: bool),
-      thing: Flipper::Types::Actor.new(Flipper::Actor.new(1))
+      actors: [Flipper::Types::Actor.new(Flipper::Actor.new('1'))]
     )
   end