flipper 0.26.0 → 1.1.0

data/spec/flipper/expression_spec.rb

@@ -0,0 +1,188 @@
+require 'flipper/expression'
+
+RSpec.describe Flipper::Expression do
+  describe "#build" do
+    it "can build Equal" do
+      expression = described_class.build({
+        "Equal" => [
+          "basic",
+          "basic",
+        ]
+      })
+
+      expect(expression).to be_instance_of(Flipper::Expression)
+      expect(expression.function).to be(Flipper::Expressions::Equal)
+      expect(expression.args).to eq([
+        Flipper.constant("basic"),
+        Flipper.constant("basic"),
+      ])
+    end
+
+    it "can build GreaterThanOrEqualTo" do
+      expression = described_class.build({
+        "GreaterThanOrEqualTo" => [
+          2,
+          1,
+        ]
+      })
+
+      expect(expression).to be_instance_of(Flipper::Expression)
+      expect(expression.function).to be(Flipper::Expressions::GreaterThanOrEqualTo)
+      expect(expression.args).to eq([
+        Flipper.constant(2),
+        Flipper.constant(1),
+      ])
+    end
+
+    it "can build GreaterThan" do
+      expression = described_class.build({
+        "GreaterThan" => [
+          2,
+          1,
+        ]
+      })
+
+      expect(expression).to be_instance_of(Flipper::Expression)
+      expect(expression.function).to be(Flipper::Expressions::GreaterThan)
+      expect(expression.args).to eq([
+        Flipper.constant(2),
+        Flipper.constant(1),
+      ])
+    end
+
+    it "can build LessThanOrEqualTo" do
+      expression = described_class.build({
+        "LessThanOrEqualTo" => [
+          2,
+          1,
+        ]
+      })
+
+      expect(expression).to be_instance_of(Flipper::Expression)
+      expect(expression.function).to be(Flipper::Expressions::LessThanOrEqualTo)
+      expect(expression.args).to eq([
+        Flipper.constant(2),
+        Flipper.constant(1),
+      ])
+    end
+
+    it "can build LessThan" do
+      expression = described_class.build({
+        "LessThan" => [2, 1]
+      })
+
+      expect(expression).to be_instance_of(Flipper::Expression)
+      expect(expression.function).to be(Flipper::Expressions::LessThan)
+      expect(expression.args).to eq([
+        Flipper.constant(2),
+        Flipper.constant(1),
+      ])
+    end
+
+    it "can build NotEqual" do
+      expression = described_class.build({
+        "NotEqual" => [
+          "basic",
+          "plus",
+        ]
+      })
+
+      expect(expression).to be_instance_of(Flipper::Expression)
+      expect(expression.function).to be(Flipper::Expressions::NotEqual)
+      expect(expression.args).to eq([
+        Flipper.constant("basic"),
+        Flipper.constant("plus"),
+      ])
+    end
+
+    it "can build Number" do
+      expression = described_class.build(1)
+
+      expect(expression).to be_instance_of(Flipper::Expression::Constant)
+      expect(expression.value).to eq(1)
+    end
+
+    it "can build Percentage" do
+      expression = described_class.build({
+        "Percentage" => [1]
+      })
+
+      expect(expression).to be_instance_of(Flipper::Expression)
+      expect(expression.function).to be(Flipper::Expressions::Percentage)
+      expect(expression.args).to eq([Flipper.constant(1)])
+    end
+
+    it "can build PercentageOfActors" do
+      expression = described_class.build({
+        "PercentageOfActors" => [
+          "User;1",
+          40,
+        ]
+      })
+
+      expect(expression).to be_instance_of(Flipper::Expression)
+      expect(expression.function).to be(Flipper::Expressions::PercentageOfActors)
+      expect(expression.args).to eq([
+        Flipper.constant("User;1"),
+        Flipper.constant(40),
+      ])
+    end
+
+    it "can build String" do
+      expression = described_class.build("basic")
+
+      expect(expression).to be_instance_of(Flipper::Expression::Constant)
+      expect(expression.value).to eq("basic")
+    end
+
+    it "can build Property" do
+      expression = described_class.build({
+        "Property" => ["flipper_id"]
+      })
+
+      expect(expression).to be_instance_of(Flipper::Expression)
+      expect(expression.function).to be(Flipper::Expressions::Property)
+      expect(expression.args).to eq([Flipper.constant("flipper_id")])
+    end
+  end
+
+  describe "#eql?" do
+    it "returns true for same class and args" do
+      expression = described_class.build("foo")
+      other = described_class.build("foo")
+      expect(expression.eql?(other)).to be(true)
+    end
+
+    it "returns false for different class" do
+      expression = described_class.build("foo")
+      other = Object.new
+      expect(expression.eql?(other)).to be(false)
+    end
+
+    it "returns false for different args" do
+      expression = described_class.build("foo")
+      other = described_class.build("bar")
+      expect(expression.eql?(other)).to be(false)
+    end
+  end
+
+  describe "#==" do
+    it "returns true for same class and args" do
+      expression = described_class.build("foo")
+      other = described_class.build("foo")
+      expect(expression == other).to be(true)
+    end
+
+    it "returns false for different class" do
+      expression = described_class.build("foo")
+      other = Object.new
+      expect(expression == other).to be(false)
+    end
+
+    it "returns false for different args" do
+      expression = described_class.build("foo")
+      other = described_class.build("bar")
+      expect(expression == other).to be(false)
+    end
+  end
+end

data/spec/flipper/expressions/all_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Flipper::Expressions::All do
+  describe "#call" do
+    it "returns true if all args evaluate as true" do
+      expect(described_class.call(true, true)).to be(true)
+    end
+
+    it "returns false if any args evaluate as false" do
+      expect(described_class.call(false, true)).to be(false)
+    end
+
+    it "returns true with empty args" do
+      expect(described_class.call).to be(true)
+    end
+  end
+end

data/spec/flipper/expressions/any_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Flipper::Expressions::Any do
+  describe "#call" do
+    it "returns true if any args evaluate as true" do
+      expect(described_class.call(true, false)).to be(true)
+    end
+
+    it "returns false if all args evaluate as false" do
+      expect(described_class.call(false, false)).to be(false)
+    end
+
+    it "returns false with empty args" do
+      expect(described_class.call).to be(false)
+    end
+  end
+end

data/spec/flipper/expressions/boolean_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Flipper::Expressions::Boolean do
+  describe "#call" do
+    [true, 'true', 1, '1'].each do |value|
+      it "returns a true for #{value.inspect}" do
+        expect(described_class.call(value)).to be(true)
+      end
+    end
+
+    [false, 'false', 0, '0', nil].each do |value|
+      it "returns a true for #{value.inspect}" do
+        expect(described_class.call(value)).to be(false)
+      end
+    end
+  end
+end

data/spec/flipper/expressions/duration_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe Flipper::Expressions::Duration do
+  describe "#call" do
+    it "raises error with invalid value" do
+      expect { described_class.call(false, 'minute') }.to raise_error(ArgumentError)
+    end
+
+    it "raises error with invalid unit" do
+      expect { described_class.call(4, 'score') }.to raise_error(ArgumentError)
+    end
+
+    it 'defaults unit to seconds' do
+      expect(described_class.call(10)).to eq(10)
+    end
+
+    it "evaluates seconds" do
+      expect(described_class.call(10, 'seconds')).to eq(10)
+    end
+
+    it "evaluates minutes" do
+      expect(described_class.call(2, 'minutes')).to eq(120)
+    end
+
+    it "evaluates hours" do
+      expect(described_class.call(2, 'hours')).to eq(7200)
+    end
+
+    it "evaluates days" do
+      expect(described_class.call(2, 'days')).to eq(172_800)
+    end
+
+    it "evaluates weeks" do
+      expect(described_class.call(2, 'weeks')).to eq(1_209_600)
+    end
+
+    it "evaluates months" do
+      expect(described_class.call(2, 'months')).to eq(5_259_492)
+    end
+
+    it "evaluates years" do
+      expect(described_class.call(2, 'years')).to eq(63_113_904)
+    end
+  end
+end

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_check_context_spec.rb

@@ -1,65 +1,65 @@
 RSpec.describe Flipper::FeatureCheckContext do
   let(:feature_name) { :new_profiles }
   let(:values) { Flipper::GateValues.new({}) }
-  let(:thing) { Flipper::Actor.new('5') }
+  let(:actor) { Flipper::Actor.new('5') }
   let(:options) do
     {
       feature_name: feature_name,
       values: values,
-      thing: thing,
+      actors: [actor],
     }
   end
 
   it 'initializes just fine' do
-    instance = described_class.new(options)
+    instance = described_class.new(**options)
     expect(instance.feature_name).to eq(feature_name)
     expect(instance.values).to eq(values)
-    expect(instance.thing).to eq(thing)
+    expect(instance.actors).to eq([actor])
   end
 
   it 'requires feature_name' do
     options.delete(:feature_name)
     expect do
-      described_class.new(options)
-    end.to raise_error(KeyError)
+      described_class.new(**options)
+    end.to raise_error(ArgumentError)
   end
 
   it 'requires values' do
     options.delete(:values)
     expect do
-      described_class.new(options)
-    end.to raise_error(KeyError)
+      described_class.new(**options)
+    end.to raise_error(ArgumentError)
   end
 
-  it 'requires thing' do
-    options.delete(:thing)
+  it 'requires actors' do
+    options.delete(:actors)
     expect do
-      described_class.new(options)
-    end.to raise_error(KeyError)
+      described_class.new(**options)
+    end.to raise_error(ArgumentError)
   end
 
   it 'knows actors_value' do
     args = options.merge(values: Flipper::GateValues.new(actors: Set['User;1']))
-    expect(described_class.new(args).actors_value).to eq(Set['User;1'])
+    expect(described_class.new(**args).actors_value).to eq(Set['User;1'])
   end
 
   it 'knows groups_value' do
     args = options.merge(values: Flipper::GateValues.new(groups: Set['admins']))
-    expect(described_class.new(args).groups_value).to eq(Set['admins'])
+    expect(described_class.new(**args).groups_value).to eq(Set['admins'])
   end
 
   it 'knows boolean_value' do
-    instance = described_class.new(options.merge(values: Flipper::GateValues.new(boolean: true)))
+    instance = described_class.new(**options.merge(values: Flipper::GateValues.new(boolean: true)))
     expect(instance.boolean_value).to eq(true)
   end
 
   it 'knows percentage_of_actors_value' do
     args = options.merge(values: Flipper::GateValues.new(percentage_of_actors: 14))
-    expect(described_class.new(args).percentage_of_actors_value).to eq(14)
+    expect(described_class.new(**args).percentage_of_actors_value).to eq(14)
   end
 
   it 'knows percentage_of_time_value' do
     args = options.merge(values: Flipper::GateValues.new(percentage_of_time: 41))
-    expect(described_class.new(args).percentage_of_time_value).to eq(41)
+    expect(described_class.new(**args).percentage_of_time_value).to eq(41)
   end
 end