flipper 1.0.0 → 1.1.1

data/spec/flipper/expressions/equal_spec.rb

@@ -0,0 +1,24 @@
+RSpec.describe Flipper::Expressions::Equal do
+  describe "#call" do
+    it "returns true when equal" do
+      expect(described_class.call("basic", "basic")).to be(true)
+    end
+
+    it "returns false when not equal" do
+      expect(described_class.call("basic", "plus")).to be(false)
+    end
+
+    it "returns false when value evaluates to nil" do
+      expect(described_class.call(nil, 1)).to be(false)
+      expect(described_class.call(1, nil)).to be(false)
+    end
+
+    it "raises ArgumentError with no arguments" do
+      expect { described_class.call }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError with one argument" do
+      expect { described_class.call(10) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/flipper/expressions/greater_than_or_equal_to_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Flipper::Expressions::GreaterThanOrEqualTo do
+  describe "#call" do
+    it "returns true when equal" do
+      expect(described_class.call(2, 2)).to be(true)
+    end
+
+    it "returns true when greater" do
+      expect(described_class.call(2, 1)).to be(true)
+    end
+
+    it "returns false when less" do
+      expect(described_class.call(1, 2)).to be(false)
+    end
+
+    it "returns false when value evaluates to nil" do
+      expect(described_class.call(nil, 1)).to be(false)
+      expect(described_class.call(1, nil)).to be(false)
+    end
+
+    it "raises ArgumentError with no arguments" do
+      expect { described_class.call }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError with one argument" do
+      expect { described_class.call(10) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/flipper/expressions/greater_than_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Flipper::Expressions::GreaterThan do
+  describe "#call" do
+    it "returns false when equal" do
+      expect(described_class.call(2, 2)).to be(false)
+    end
+
+    it "returns true when greater" do
+      expect(described_class.call(2, 1)).to be(true)
+    end
+
+    it "returns false when less" do
+      expect(described_class.call(1, 2)).to be(false)
+    end
+
+    it "returns false when value evaluates to nil" do
+      expect(described_class.call(nil, 1)).to be(false)
+      expect(described_class.call(1, nil)).to be(false)
+    end
+
+    it "raises ArgumentError with no arguments" do
+      expect { described_class.call }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError with one argument" do
+      expect { described_class.call(10) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/flipper/expressions/less_than_or_equal_to_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Flipper::Expressions::LessThanOrEqualTo do
+  describe "#call" do
+    it "returns true when equal" do
+      expect(described_class.call(2, 2)).to be(true)
+    end
+
+    it "returns true when less" do
+      expect(described_class.call(1, 2)).to be(true)
+    end
+
+    it "returns false when greater" do
+      expect(described_class.call(2, 1)).to be(false)
+    end
+
+    it "returns false when value evaluates to nil" do
+      expect(described_class.call(nil, 1)).to be(false)
+      expect(described_class.call(1, nil)).to be(false)
+    end
+
+    it "raises ArgumentError with no arguments" do
+      expect { described_class.call }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError with one argument" do
+      expect { described_class.call(10) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/flipper/expressions/less_than_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Flipper::Expressions::LessThan do
+  describe "#call" do
+    it "returns false when equal" do
+      expect(described_class.call(2, 2)).to be(false)
+    end
+
+    it "returns true when less" do
+      expect(described_class.call(1, 2)).to be(true)
+    end
+
+    it "returns true when less with args that need evaluation" do
+      expect(described_class.call(1, 2)).to be(true)
+    end
+
+    it "returns false when greater" do
+      expect(described_class.call(2, 1)).to be(false)
+    end
+
+    it "returns false when value evaluates to nil" do
+      expect(described_class.call(nil, 1)).to be(false)
+      expect(described_class.call(1, nil)).to be(false)
+    end
+
+    it "raises ArgumentError with no arguments" do
+      expect { described_class.call }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError with one argument" do
+      expect { described_class.call(10) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/flipper/expressions/not_equal_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Flipper::Expressions::NotEqual do
+  describe "#call" do
+    it "returns true when not equal" do
+      expect(described_class.call("basic", "plus")).to be(true)
+    end
+
+    it "returns false when equal" do
+      expect(described_class.call("basic", "basic")).to be(false)
+    end
+
+    it "raises ArgumentError for more arguments" do
+      expect { described_class.call(20, 10, 20).evaluate }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/flipper/expressions/now_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Flipper::Expressions::Now do
+  describe "#call" do
+    it "returns current time" do
+      expect(described_class.call).to be_within(2).of(Time.now.utc)
+    end
+
+    it "defaults to UTC" do
+      expect(described_class.call.zone).to eq("UTC")
+    end
+  end
+end

data/spec/flipper/expressions/number_spec.rb

@@ -0,0 +1,21 @@
+RSpec.describe Flipper::Expressions::Number do
+  describe "#call" do
+    it "returns Integer for Integer" do
+      expect(described_class.call(10)).to be(10)
+    end
+
+    it "returns Float for Float" do
+      expect(described_class.call(10.1)).to be(10.1)
+      expect(described_class.call(10.0)).to be(10.0)
+    end
+
+    it "returns Integer for String" do
+      expect(described_class.call('10')).to be(10)
+    end
+
+    it "returns Float for String" do
+      expect(described_class.call('10.0')).to be(10.0)
+      expect(described_class.call('10.1')).to be(10.1)
+    end
+  end
+end

data/spec/flipper/expressions/percentage_of_actors_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe Flipper::Expressions::PercentageOfActors do
+  describe "#call" do
+    it "returns true when string in percentage enabled" do
+      expect(described_class.call("User;1", 42)).to be(true)
+    end
+
+    it "returns true when string in fractional percentage enabled" do
+      expect(described_class.call("User;1", 41.687)).to be(true)
+    end
+
+    it "returns false when string in percentage enabled" do
+      expect(described_class.call("User;1", 0)).to be(false)
+    end
+
+    it "changes value based on feature_name so not all actors get all features first" do
+      expect(described_class.call("User;1", 70, context: {feature_name: "a"})).to be(true)
+      expect(described_class.call("User;1", 70, context: {feature_name: "b"})).to be(false)
+    end
+  end
+end

data/spec/flipper/expressions/percentage_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Flipper::Expressions::Percentage do
+  describe "#call" do
+    it "returns numeric" do
+      expect(described_class.call(10)).to be(10.0)
+    end
+
+    it "returns 0 if less than 0" do
+      expect(described_class.call(-1)).to be(0)
+    end
+
+    it "returns 100 if greater than 100" do
+      expect(described_class.call(101)).to be(100)
+    end
+  end
+end

data/spec/flipper/expressions/property_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe Flipper::Expressions::Property do
+  describe "#call" do
+    it "returns value for property key" do
+      context = { properties: { "flipper_id" => "User;1" } }
+      expect(described_class.call("flipper_id", context: context)).to eq("User;1")
+    end
+
+    it "returns nil if key not found in properties" do
+      context = { properties: { } }
+      expect(described_class.call("flipper_id", context: context)).to be(nil)
+    end
+  end
+end

data/spec/flipper/expressions/random_spec.rb

@@ -0,0 +1,9 @@
+RSpec.describe Flipper::Expressions::Random do
+  describe "#call" do
+    it "returns random number based on max" do
+      100.times do
+        expect(described_class.call(10)).to be_between(0, 10)
+      end
+    end
+  end
+end

data/spec/flipper/expressions/string_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Flipper::Expressions::String do
+  describe "#call" do
+    it "returns String for Numeric" do
+      expect(described_class.call(10)).to eq("10")
+    end
+
+    it "returns String" do
+      expect(described_class.call("test")).to eq("test")
+    end
+  end
+end

data/spec/flipper/expressions/time_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe Flipper::Expressions::Time do
+  let(:time) { Time.now.round }
+
+  describe "#call" do
+    it "returns time for #to_s format" do
+      expect(described_class.call(time.to_s)).to eq(time)
+    end
+
+    it "returns time for #iso8601 format" do
+      expect(described_class.call(time.iso8601)).to eq(time)
+    end
+  end
+end

data/spec/flipper/feature_spec.rb

@@ -109,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
 
@@ -693,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
@@ -845,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