flipper 0.24.1 → 1.3.0

data/spec/flipper/expression/builder_spec.rb

@@ -0,0 +1,248 @@
+RSpec.describe Flipper::Expression::Builder do
+  def build(object)
+    Flipper::Expression.build(object)
+  end
+
+  describe "#add" do
+    it "converts to Any and adds new expressions" do
+      expression = build("something")
+      first = Flipper.boolean(true).eq(true)
+      second = Flipper.boolean(false).eq(false)
+      new_expression = expression.add(first, second)
+      expect(new_expression).to eq(build({ Any: ["something", first, second] }))
+    end
+  end
+
+  describe "#remove" do
+    it "converts to Any and removes any expressions that match" do
+      expression = build("something")
+      first = Flipper.boolean(true).eq(true)
+      second = Flipper.boolean(false).eq(false)
+      new_expression = expression.remove(build("something"), first, second)
+      expect(new_expression).to eq(build(Any: []))
+    end
+  end
+
+  it "can convert to Any" do
+    expression = build("something")
+    converted = expression.any
+    expect(converted).to be_instance_of(Flipper::Expression)
+    expect(converted.function).to be(Flipper::Expressions::Any)
+    expect(converted.args).to eq([expression])
+  end
+
+  it "can convert to All" do
+    expression = build("something")
+    converted = expression.all
+    expect(converted).to eq(build(All: ["something"]))
+  end
+
+  context "Any" do
+    describe "#any" do
+      it "returns self" do
+        expression = build(Any: [
+          Flipper.boolean(true),
+          Flipper.string("yep").eq("yep"),
+        ])
+        expect(expression.any).to be(expression)
+      end
+    end
+
+    describe "#add" do
+      it "returns new instance with expression added" do
+        expression = Flipper.boolean(true)
+        other = Flipper.string("yep").eq("yep")
+
+        result = expression.add(other)
+        expect(result.args).to eq([
+          Flipper.boolean(true),
+          Flipper.string("yep").eq("yep"),
+        ])
+      end
+
+      it "returns new instance with many expressions added" do
+        expression = Flipper.boolean(true)
+        second = Flipper.string("yep").eq("yep")
+        third = Flipper.number(1).lte(20)
+
+        result = expression.add(second, third)
+        expect(result.args).to eq([
+          Flipper.boolean(true),
+          Flipper.string("yep").eq("yep"),
+          Flipper.number(1).lte(20),
+        ])
+      end
+
+      it "returns new instance with array of expressions added" do
+        expression = Flipper.boolean(true)
+        second = Flipper.string("yep").eq("yep")
+        third = Flipper.number(1).lte(20)
+
+        result = expression.add([second, third])
+        expect(result.args).to eq([
+          Flipper.boolean(true),
+          Flipper.string("yep").eq("yep"),
+          Flipper.number(1).lte(20),
+        ])
+      end
+    end
+
+    describe "#remove" do
+      it "returns new instance with expression removed" do
+        first = Flipper.boolean(true)
+        second = Flipper.string("yep").eq("yep")
+        third = Flipper.number(1).lte(20)
+        expression = Flipper.any([first, second, third])
+
+        result = expression.remove(second)
+        expect(expression.args).to eq([first, second, third])
+        expect(result.args).to eq([first, third])
+      end
+
+      it "returns new instance with many expressions removed" do
+        first = Flipper.boolean(true)
+        second = Flipper.string("yep").eq("yep")
+        third = Flipper.number(1).lte(20)
+        expression = Flipper.any([first, second, third])
+
+        result = expression.remove(second, third)
+        expect(expression.args).to eq([first, second, third])
+        expect(result.args).to eq([first])
+      end
+
+      it "returns new instance with array of expressions removed" do
+        first = Flipper.boolean(true)
+        second = Flipper.string("yep").eq("yep")
+        third = Flipper.number(1).lte(20)
+        expression = Flipper.any([first, second, third])
+
+        result = expression.remove([second, third])
+        expect(expression.args).to eq([first, second, third])
+        expect(result.args).to eq([first])
+      end
+    end
+  end
+
+  [
+    [2, 3, "equal", "eq", :Equal],
+    [2, 3, "not_equal", "neq", :NotEqual],
+    [2, 3, "greater_than", "gt", :GreaterThan],
+    [2, 3, "greater_than_or_equal_to", "gte", :GreaterThanOrEqualTo],
+    [2, 3, "greater_than_or_equal_to", "greater_than_or_equal", :GreaterThanOrEqualTo],
+    [2, 3, "less_than", "lt", :LessThan],
+    [2, 3, "less_than_or_equal_to", "lte", :LessThanOrEqualTo],
+    [2, 3, "less_than_or_equal_to", "less_than_or_equal", :LessThanOrEqualTo],
+  ].each do |(left, right, method_name, shortcut_name, function)|
+    it "can convert to #{function}" do
+      expression = build(left)
+      other = build(right)
+      converted = expression.send(method_name, other)
+      expect(converted).to eq(build({ function => [ left, right] }))
+    end
+
+    it "can convert to #{function} using #{shortcut_name}" do
+      expression = build(left)
+      other = build(right)
+      converted = expression.send(shortcut_name, other)
+      expect(converted).to eq(build({ function => [ left, right] }))
+    end
+
+    it "builds args into expressions when converting to #{function}" do
+      expression = build(left)
+      other = Flipper.property(:age)
+      converted = expression.send(method_name, other.value)
+      expect(converted).to eq(build({ function => [ left, other.value] }))
+    end
+  end
+
+  it "can convert to PercentageOfActors" do
+    expression = Flipper.constant("User;1").percentage_of_actors(40)
+    expect(expression).to eq(build({ PercentageOfActors: [ "User;1", 40 ] }))
+  end
+
+  context "All" do
+    describe "#all" do
+      it "returns self" do
+        expression = Flipper.all([
+          Flipper.boolean(true),
+          Flipper.string("yep").eq("yep"),
+        ])
+        expect(expression.all).to be(expression)
+      end
+    end
+
+    describe "#add" do
+      it "returns new instance with expression added" do
+        expression = Flipper.all([Flipper.boolean(true)])
+        other = Flipper.string("yep").eq("yep")
+
+        result = expression.add(other)
+        expect(result.args).to eq([
+          Flipper.boolean(true),
+          Flipper.string("yep").eq("yep"),
+        ])
+      end
+
+      it "returns new instance with many expressions added" do
+        expression = Flipper.all([Flipper.boolean(true)])
+        second = Flipper.string("yep").eq("yep")
+        third = Flipper.number(1).lte(20)
+
+        result = expression.add(second, third)
+        expect(result.args).to eq([
+          Flipper.boolean(true),
+          Flipper.string("yep").eq("yep"),
+          Flipper.number(1).lte(20),
+        ])
+      end
+
+      it "returns new instance with array of expressions added" do
+        expression = Flipper.all([Flipper.boolean(true)])
+        second = Flipper.string("yep").eq("yep")
+        third = Flipper.number(1).lte(20)
+
+        result = expression.add([second, third])
+        expect(result.args).to eq([
+          Flipper.boolean(true),
+          Flipper.string("yep").eq("yep"),
+          Flipper.number(1).lte(20),
+        ])
+      end
+    end
+
+    describe "#remove" do
+      it "returns new instance with expression removed" do
+        first = Flipper.boolean(true)
+        second = Flipper.string("yep").eq("yep")
+        third = Flipper.number(1).lte(20)
+        expression = Flipper.all([first, second, third])
+
+        result = expression.remove(second)
+        expect(expression.args).to eq([first, second, third])
+        expect(result.args).to eq([first, third])
+      end
+
+      it "returns new instance with many expressions removed" do
+        first = Flipper.boolean(true)
+        second = Flipper.string("yep").eq("yep")
+        third = Flipper.number(1).lte(20)
+        expression = Flipper.all([first, second, third])
+
+        result = expression.remove(second, third)
+        expect(expression.args).to eq([first, second, third])
+        expect(result.args).to eq([first])
+      end
+
+      it "returns new instance with array of expressions removed" do
+        first = Flipper.boolean(true)
+        second = Flipper.string("yep").eq("yep")
+        third = Flipper.number(1).lte(20)
+        expression = Flipper.all([first, second, third])
+
+        result = expression.remove([second, third])
+        expect(expression.args).to eq([first, second, third])
+        expect(result.args).to eq([first])
+      end
+    end
+  end
+end

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