flipper 1.0.0 → 1.1.0

data/spec/flipper/engine_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Flipper::Engine do
     Class.new(Rails::Application) do
       config.eager_load = false
       config.logger = ActiveSupport::Logger.new($stdout)
-    end
+    end.instance
   end
 
   before do
@@ -15,11 +15,70 @@ RSpec.describe Flipper::Engine do
     ActiveSupport::Dependencies.autoload_once_paths = ActiveSupport::Dependencies.autoload_once_paths.dup
   end
 
+  # Reset Rails.env around each example
+  around do |example|
+    begin
+      env = Rails.env.to_s
+      example.run
+    ensure
+      Rails.env = env
+    end
+  end
+
   let(:config) { application.config.flipper }
 
   subject { application.initialize! }
 
+  shared_examples 'config.strict' do
+    let(:adapter) { Flipper.adapter.adapter }
+
+    it 'can set strict=true from ENV' do
+      with_env 'FLIPPER_STRICT' => 'true' do
+        subject
+        expect(config.strict).to eq(:raise)
+        expect(adapter).to be_instance_of(Flipper::Adapters::Strict)
+      end
+    end
+
+    it 'can set strict=warn from ENV' do
+      with_env 'FLIPPER_STRICT' => 'warn' do
+        subject
+        expect(config.strict).to eq(:warn)
+        expect(adapter).to be_instance_of(Flipper::Adapters::Strict)
+        expect(adapter.handler).to be(Flipper::Adapters::Strict::HANDLERS.fetch(:warn))
+      end
+    end
+
+    it 'can set strict=false from ENV' do
+      with_env 'FLIPPER_STRICT' => 'false' do
+        subject
+        expect(config.strict).to eq(false)
+        expect(adapter).to be_instance_of(Flipper::Adapters::Memory)
+      end
+    end
+
+    it "defaults to strict=false in RAILS_ENV=production" do
+        Rails.env = "production"
+        subject
+        expect(config.strict).to eq(false)
+        expect(adapter).to be_instance_of(Flipper::Adapters::Memory)
+    end
+
+    %w(development test).each do |env|
+      it "defaults to strict=warn in RAILS_ENV=#{env}" do
+        Rails.env = env
+        expect(Rails.env).to eq(env)
+        subject
+        expect(config.strict).to eq(:warn)
+        expect(adapter).to be_instance_of(Flipper::Adapters::Strict)
+        expect(adapter.handler).to be(Flipper::Adapters::Strict::HANDLERS.fetch(:warn))
+      end
+    end
+  end
+
   context 'cloudless' do
+    it_behaves_like 'config.strict'
+
     it 'can set env_key from ENV' do
       with_env 'FLIPPER_ENV_KEY' => 'flopper' do
         subject
@@ -94,12 +153,6 @@ RSpec.describe Flipper::Engine do
         if: nil
       })
     end
-
-    it "defines #flipper_id on AR::Base" do
-      subject
-      require 'active_record'
-      expect(ActiveRecord::Base.ancestors).to include(Flipper::Identifier)
-    end
   end
 
   context 'with cloud' do
@@ -112,6 +165,14 @@ RSpec.describe Flipper::Engine do
     # App for Rack::Test
     let(:app) { application.routes }
 
+    it_behaves_like 'config.strict' do
+      let(:adapter) do
+        dual_write = Flipper.adapter.adapter
+        poll = dual_write.local
+        poll.adapter
+      end
+    end
+
     it "initializes cloud configuration" do
       stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
 
@@ -181,6 +242,46 @@ RSpec.describe Flipper::Engine do
     end
   end
 
+  context 'with cloud secrets in Rails.credentials' do
+    around do |example|
+      # Create temporary directory for Rails.root to write credentials to
+      # Once Rails 5.2 support is dropped, this can all be replaced with
+      # `config.credentials.content_path = Tempfile.new.path`
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          Dir.mkdir("#{dir}/config")
+
+          example.run
+        end
+      end
+    end
+
+    before do
+      # Set master key which is needed to write credentials
+      ENV["RAILS_MASTER_KEY"] = "a" * 32
+
+      application.credentials.write(YAML.dump({
+        flipper: {
+          cloud_token: "credentials-token",
+          cloud_sync_secret: "credentials-secret",
+        }
+      }))
+    end
+
+    it "enables cloud" do
+      application.initialize!
+      expect(ENV["FLIPPER_CLOUD_TOKEN"]).to eq("credentials-token")
+      expect(ENV["FLIPPER_CLOUD_SYNC_SECRET"]).to eq("credentials-secret")
+      expect(Flipper.instance).to be_a(Flipper::Cloud::DSL)
+    end
+  end
+
+  it "includes model methods" do
+    subject
+    require 'active_record'
+    expect(ActiveRecord::Base.ancestors).to include(Flipper::Model::ActiveRecord)
+  end
+
   # Add app initializer in the same order as config/initializers/*
   def initializer(&block)
     application.initializer 'spec', before: :load_config_initializers do

data/spec/flipper/exporters/json/v1_spec.rb

@@ -25,9 +25,9 @@ RSpec.describe Flipper::Exporters::Json::V1 do
     export = subject.call(adapter)
 
     expect(export.features).to eq({
-      "google_analytics" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "plausible" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
-      "search" => {actors: Set["User;1", "User;100"], boolean: nil, groups: Set["admins", "employees"], percentage_of_actors: "10", percentage_of_time: "15"},
+      "google_analytics" => {actors: Set.new, boolean: nil, expression: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "plausible" => {actors: Set.new, boolean: "true", expression: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "search" => {actors: Set["User;1", "User;100"], boolean: nil, expression: nil, groups: Set["admins", "employees"], percentage_of_actors: "10", percentage_of_time: "15"},
     })
   end
 end

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