flipper 0.26.0 → 1.1.0

data/spec/flipper/engine_spec.rb

@@ -0,0 +1,291 @@
+require 'rails'
+require 'flipper/engine'
+
+RSpec.describe Flipper::Engine do
+  let(:application) do
+    Class.new(Rails::Application) do
+      config.eager_load = false
+      config.logger = ActiveSupport::Logger.new($stdout)
+    end.instance
+  end
+
+  before do
+    Rails.application = nil
+    ActiveSupport::Dependencies.autoload_paths = ActiveSupport::Dependencies.autoload_paths.dup
+    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
+        expect(config.env_key).to eq('flopper')
+      end
+    end
+
+    it 'can set memoize from ENV' do
+      with_env 'FLIPPER_MEMOIZE' => 'false' do
+        subject
+        expect(config.memoize).to eq(false)
+      end
+    end
+
+    it 'can set preload from ENV' do
+      with_env 'FLIPPER_PRELOAD' => 'false' do
+        subject
+        expect(config.preload).to eq(false)
+      end
+    end
+
+    it 'can set instrumenter from ENV' do
+      stub_const('My::Cool::Instrumenter', Class.new)
+      with_env 'FLIPPER_INSTRUMENTER' => 'My::Cool::Instrumenter' do
+        subject
+        expect(config.instrumenter).to eq(My::Cool::Instrumenter)
+      end
+    end
+
+    it 'can set log from ENV' do
+      with_env 'FLIPPER_LOG' => 'false' do
+        subject
+        expect(config.log).to eq(false)
+      end
+    end
+
+    it 'sets defaults' do
+      subject # initialize
+      expect(config.env_key).to eq("flipper")
+      expect(config.memoize).to be(true)
+      expect(config.preload).to be(true)
+    end
+
+    it "configures instrumentor on default instance" do
+      subject # initialize
+      expect(Flipper.instance.instrumenter).to eq(ActiveSupport::Notifications)
+    end
+
+    it 'uses Memoizer middleware if config.memoize = true' do
+      initializer { config.memoize = true }
+      expect(subject.middleware).to include(Flipper::Middleware::Memoizer)
+    end
+
+    it 'does not use Memoizer middleware if config.memoize = false' do
+      initializer { config.memoize = false }
+      expect(subject.middleware).not_to include(Flipper::Middleware::Memoizer)
+    end
+
+    it 'passes config to memoizer' do
+      initializer do
+        config.update(
+          env_key: 'my_flipper',
+          preload: [:stats, :search]
+        )
+      end
+
+      expect(subject.middleware).to include(Flipper::Middleware::Memoizer)
+      middleware = subject.middleware.detect { |m| m.klass == Flipper::Middleware::Memoizer }
+      expect(middleware.args[0]).to eq({
+        env_key: config.env_key,
+        preload: config.preload,
+        if: nil
+      })
+    end
+  end
+
+  context 'with cloud' do
+    around do |example|
+      with_env "FLIPPER_CLOUD_TOKEN" => "test-token" do
+        example.run
+      end
+    end
+
+    # 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: "{}")
+
+      application.initialize!
+
+      expect(Flipper.instance).to be_a(Flipper::Cloud::DSL)
+      expect(Flipper.instance.instrumenter).to be(ActiveSupport::Notifications)
+    end
+
+    context "with CLOUD_SYNC_SECRET" do
+      around do |example|
+        with_env "FLIPPER_CLOUD_SYNC_SECRET" => "test-secret" do
+          example.run
+        end
+      end
+
+      let(:request_body) do
+        JSON.generate({
+          "environment_id" => 1,
+          "webhook_id" => 1,
+          "delivery_id" => SecureRandom.uuid,
+          "action" => "sync",
+        })
+      end
+      let(:timestamp) { Time.now }
+
+      let(:signature) {
+        Flipper::Cloud::MessageVerifier.new(secret: ENV["FLIPPER_CLOUD_SYNC_SECRET"]).generate(request_body, timestamp)
+      }
+      let(:signature_header_value) {
+        Flipper::Cloud::MessageVerifier.new(secret: "").header(signature, timestamp)
+      }
+
+      it "configures webhook app" do
+        application.initialize!
+
+        stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").with({
+          headers: { "Flipper-Cloud-Token" => ENV["FLIPPER_CLOUD_TOKEN"] },
+        }).to_return(status: 200, body: JSON.generate({ features: {} }), headers: {})
+
+        post "/_flipper", request_body, { "HTTP_FLIPPER_CLOUD_SIGNATURE" => signature_header_value }
+
+        expect(last_response.status).to eq(200)
+        expect(stub).to have_been_requested
+      end
+    end
+
+    context "without CLOUD_SYNC_SECRET" do
+      it "does not configure webhook app" do
+        application.initialize!
+
+        post "/_flipper"
+        expect(last_response.status).to eq(404)
+      end
+    end
+
+    context "without FLIPPER_CLOUD_TOKEN" do
+      it "gracefully skips configuring webhook app" do
+        with_env "FLIPPER_CLOUD_TOKEN" => nil do
+          application.initialize!
+          expect(Flipper.instance).to be_a(Flipper::DSL)
+        end
+
+        post "/_flipper"
+        expect(last_response.status).to eq(404)
+      end
+    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
+      block.call
+    end
+  end
+end

data/spec/flipper/export_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe Flipper::Export do
+  it "can initialize" do
+    export = described_class.new(contents: "{}", format: :json, version: 1)
+    expect(export.contents).to eq("{}")
+    expect(export.format).to eq(:json)
+    expect(export.version).to eq(1)
+  end
+
+  it "raises not implemented for features" do
+    export = described_class.new(contents: "{}", format: :json, version: 1)
+    expect { export.features }.to raise_error(NotImplementedError)
+  end
+end

data/spec/flipper/exporter_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Flipper::Exporter do
+  describe ".build" do
+    it "builds instance of exporter" do
+      exporter = described_class.build(format: :json, version: 1)
+      expect(exporter).to be_instance_of(Flipper::Exporters::Json::V1)
+    end
+
+    it "raises if format not found" do
+      expect { described_class.build(format: :nope, version: 1) }.to raise_error(KeyError)
+    end
+
+    it "raises if version not found" do
+      expect { described_class.build(format: :json, version: 0) }.to raise_error(KeyError)
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'flipper/exporters/json/v1'
+
+RSpec.describe Flipper::Exporters::Json::Export do
+  let(:contents) {
+    <<~JSON
+      {
+        "version":1,
+        "features":{
+          "search":{"boolean":null,"groups":["admins","employees"],"actors":["User;1","User;100"],"percentage_of_actors":"10","percentage_of_time":"15"},
+          "plausible":{"boolean":"true","groups":[],"actors":[],"percentage_of_actors":null,"percentage_of_time":null},
+          "google_analytics":{"boolean":null,"groups":[],"actors":[],"percentage_of_actors":null,"percentage_of_time":null}
+        }
+      }
+    JSON
+  }
+
+  it "can initialize" do
+    export = described_class.new(contents: contents)
+    expect(export.format).to eq(:json)
+    expect(export.version).to be(1)
+  end
+
+  it "can initialize with version" do
+    export = described_class.new(contents: contents, version: 1)
+    expect(export.version).to be(1)
+  end
+
+  it "can build features from contents" do
+    export = Flipper::Exporters::Json::Export.new(contents: contents)
+    expect(export.features).to eq({
+      "search" => {actors: Set["User;1", "User;100"], boolean: nil, groups: Set["admins", "employees"], percentage_of_actors: "10", percentage_of_time: "15"},
+      "plausible" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "google_analytics" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+    })
+  end
+
+  it "can build an adapter from features" do
+    export = Flipper::Exporters::Json::Export.new(contents: contents)
+    expect(export.adapter).to be_instance_of(Flipper::Adapters::Memory)
+    expect(export.adapter.get_all).to eq({
+      "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, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+    })
+  end
+
+  it "raises for invalid json" do
+    export = described_class.new(contents: "bad contents")
+    expect {
+      export.features
+    }.to raise_error(Flipper::Exporters::Json::JsonError)
+  end
+
+  it "raises for missing features key" do
+    export = described_class.new(contents: "{}")
+    expect {
+      export.features
+    }.to raise_error(Flipper::Exporters::Json::InvalidError)
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'flipper/exporters/json/v1'
+
+RSpec.describe Flipper::Exporters::Json::V1 do
+  subject { described_class.new }
+
+  it "has a version number" do
+    adapter = Flipper::Adapters::Memory.new
+    export = subject.call(adapter)
+    data = JSON.parse(export.contents)
+    expect(data["version"]).to eq(1)
+  end
+
+  it "exports features and gates" do
+    adapter = Flipper::Adapters::Memory.new
+    flipper = Flipper.new(adapter)
+    flipper.enable_percentage_of_actors :search, 10
+    flipper.enable_percentage_of_time :search, 15
+    flipper.enable_actor :search, Flipper::Actor.new('User;1')
+    flipper.enable_actor :search, Flipper::Actor.new('User;100')
+    flipper.enable_group :search, :admins
+    flipper.enable_group :search, :employees
+    flipper.enable :plausible
+    flipper.disable :google_analytics
+
+    export = subject.call(adapter)
+
+    expect(export.features).to eq({
+      "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