flipper 0.26.0 → 1.3.6

data/spec/flipper/dsl_spec.rb

@@ -123,18 +123,6 @@ RSpec.describe Flipper::DSL do
     end
   end
 
-  describe '#boolean' do
-    it_should_behave_like 'a DSL boolean method' do
-      let(:method_name) { :boolean }
-    end
-  end
-
-  describe '#bool' do
-    it_should_behave_like 'a DSL boolean method' do
-      let(:method_name) { :bool }
-    end
-  end
-
   describe '#group' do
     context 'for registered group' do
       before do
@@ -148,66 +136,15 @@ RSpec.describe Flipper::DSL do
     end
   end
 
-  describe '#actor' do
-    context 'for a thing' do
-      it 'returns actor instance' do
-        thing = Flipper::Actor.new(33)
-        actor = subject.actor(thing)
-        expect(actor).to be_instance_of(Flipper::Types::Actor)
-        expect(actor.value).to eq('33')
-      end
-    end
-
-    context 'for nil' do
-      it 'raises argument error' do
-        expect do
-          subject.actor(nil)
-        end.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'for something that is not actor wrappable' do
-      it 'raises argument error' do
-        expect do
-          subject.actor(Object.new)
-        end.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe '#time' do
-    before do
-      @result = subject.time(5)
-    end
-
-    it 'returns percentage of time' do
-      expect(@result).to be_instance_of(Flipper::Types::PercentageOfTime)
-    end
-
-    it 'sets value' do
-      expect(@result.value).to eq(5)
-    end
-
-    it 'is aliased to percentage_of_time' do
-      expect(@result).to eq(subject.percentage_of_time(@result.value))
-    end
-  end
-
-  describe '#actors' do
-    before do
-      @result = subject.actors(17)
-    end
-
-    it 'returns percentage of actors' do
-      expect(@result).to be_instance_of(Flipper::Types::PercentageOfActors)
+  describe '#expression' do
+    it "returns nil if feature has no expression" do
+      expect(subject.expression(:stats)).to be(nil)
     end
 
-    it 'sets value' do
-      expect(@result.value).to eq(17)
-    end
-
-    it 'is aliased to percentage_of_actors' do
-      expect(@result).to eq(subject.percentage_of_actors(@result.value))
+    it "returns expression if feature has expression" do
+      expression = Flipper.property(:plan).eq("basic")
+      subject[:stats].enable_expression expression
+      expect(subject.expression(:stats)).to eq(expression)
     end
   end
 
@@ -246,6 +183,33 @@ RSpec.describe Flipper::DSL do
     end
   end
 
+  describe '#enable_expression/disable_expression' do
+    it 'enables and disables the feature for the expression' do
+      expression = Flipper.property(:plan).eq("basic")
+
+      expect(subject[:stats].expression).to be(nil)
+      subject.enable_expression(:stats, expression)
+      expect(subject[:stats].expression).to eq(expression)
+
+      subject.disable_expression(:stats)
+      expect(subject[:stats].expression).to be(nil)
+    end
+  end
+
+  describe '#add_expression/remove_expression' do
+    it 'enables and disables the feature for the expression' do
+      expression = Flipper.property(:plan).eq("basic")
+      any_expression = Flipper.any(expression)
+
+      expect(subject[:stats].expression).to be(nil)
+      subject.add_expression(:stats, any_expression)
+      expect(subject[:stats].expression).to eq(any_expression)
+
+      subject.remove_expression(:stats, expression)
+      expect(subject[:stats].expression).to eq(Flipper.any)
+    end
+  end
+
   describe '#enable_actor/disable_actor' do
     it 'enables and disables the feature for actor' do
       actor = Flipper::Actor.new(5)
@@ -261,9 +225,6 @@ RSpec.describe Flipper::DSL do
 
   describe '#enable_group/disable_group' do
     it 'enables and disables the feature for group' do
-      actor = Flipper::Actor.new(5)
-      group = Flipper.register(:fives) { |actor| actor.flipper_id == 5 }
-
       expect(subject[:stats].groups_value).to be_empty
       subject.enable_group(:stats, :fives)
       expect(subject[:stats].groups_value).to eq(Set['fives'])
@@ -342,10 +303,27 @@ RSpec.describe Flipper::DSL do
   end
 
   describe '#import' do
+    context "with flipper instance" do
+      it 'delegates to adapter' do
+        destination_flipper = build_flipper
+        expect(subject.adapter).to receive(:import).with(destination_flipper)
+        subject.import(destination_flipper)
+      end
+    end
+
+    context "with flipper adapter" do
+      it 'delegates to adapter' do
+        destination_flipper = build_flipper
+        expect(subject.adapter).to receive(:import).with(destination_flipper.adapter)
+        subject.import(destination_flipper.adapter)
+      end
+    end
+  end
+
+  describe "#export" do
     it 'delegates to adapter' do
-      destination_flipper = build_flipper
-      expect(subject.adapter).to receive(:import).with(destination_flipper.adapter)
-      subject.import(destination_flipper)
+      expect(subject.export).to eq(subject.adapter.export)
+      expect(subject.export(format: :json)).to eq(subject.adapter.export(format: :json))
     end
   end
 

data/spec/flipper/engine_spec.rb

@@ -0,0 +1,374 @@
+require 'rails'
+require 'flipper/engine'
+
+RSpec.describe Flipper::Engine do
+  let(:application) do
+    Class.new(Rails::Application) do
+      config.load_defaults Rails::VERSION::STRING.to_f
+      config.eager_load = false
+      config.logger = ActiveSupport::Logger.new($stdout)
+      config.active_support.remove_deprecated_time_with_zone_name = false
+    end.instance
+  end
+
+  before do
+    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+    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 { SpecHelpers.silence { application.initialize! } }
+
+  shared_examples 'config.strict' do
+    let(:adapter) { Flipper.adapter.adapter }
+
+    it 'can set strict=true from ENV' do
+      ENV['FLIPPER_STRICT'] = 'true'
+      subject
+      expect(config.strict).to eq(:raise)
+      expect(adapter).to be_instance_of(Flipper::Adapters::Strict)
+    end
+
+    it 'can set strict=warn from ENV' do
+      ENV['FLIPPER_STRICT'] = 'warn'
+      subject
+      expect(config.strict).to eq(:warn)
+      expect(adapter).to be_instance_of(Flipper::Adapters::Strict)
+      expect(adapter.handler).to be(:warn)
+    end
+
+    it 'can set strict=false from ENV' do
+      ENV['FLIPPER_STRICT'] = 'false'
+      subject
+      expect(config.strict).to eq(false)
+      expect(adapter).not_to be_instance_of(Flipper::Adapters::Strict)
+    end
+
+    [true, :raise, :warn].each do |value|
+      it "can set strict=#{value.inspect} in initializer" do
+        initializer { config.strict = value }
+        subject
+        expect(adapter).to be_instance_of(Flipper::Adapters::Strict)
+        expect(adapter.handler).to be(value)
+      end
+    end
+
+    it "can set strict=false in initializer" do
+      initializer { config.strict = false }
+      subject
+      expect(config.strict).to eq(false)
+      expect(adapter).not_to be_instance_of(Flipper::Adapters::Strict)
+    end
+
+    it "defaults to strict=:warn in RAILS_ENV=development" do
+      Rails.env = "development"
+      subject
+      expect(config.strict).to eq(:warn)
+      expect(adapter).to be_instance_of(Flipper::Adapters::Strict)
+    end
+
+    %w(production 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(false)
+        expect(adapter).not_to be_instance_of(Flipper::Adapters::Strict)
+      end
+    end
+
+    it "defaults to strict=warn in RAILS_ENV=development" do
+      Rails.env = "development"
+      expect(Rails.env).to eq("development")
+      subject
+      expect(config.strict).to eq(:warn)
+      expect(adapter).to be_instance_of(Flipper::Adapters::Strict)
+      expect(adapter.handler).to be(:warn)
+    end
+  end
+
+  context 'cloudless' do
+    it_behaves_like 'config.strict'
+
+    it 'can set env_key from ENV' do
+      ENV['FLIPPER_ENV_KEY'] = 'flopper'
+      subject
+      expect(config.env_key).to eq('flopper')
+    end
+
+    it 'can set memoize from ENV' do
+      ENV['FLIPPER_MEMOIZE'] = 'false'
+      subject
+      expect(config.memoize).to eq(false)
+    end
+
+    it 'can set preload from ENV' do
+      ENV['FLIPPER_PRELOAD'] = 'false'
+      subject
+      expect(config.preload).to eq(false)
+    end
+
+    it 'can set instrumenter from ENV' do
+      stub_const('My::Cool::Instrumenter', Class.new)
+      ENV['FLIPPER_INSTRUMENTER'] = 'My::Cool::Instrumenter'
+      subject
+      expect(config.instrumenter).to eq(My::Cool::Instrumenter)
+    end
+
+    it 'can set log from ENV' do
+      ENV['FLIPPER_LOG'] = 'false'
+      subject
+      expect(config.log).to eq(false)
+    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
+
+    context "test_help" do
+      it "is loaded if RAILS_ENV=test" do
+        Rails.env = "test"
+        allow(Flipper::Engine.instance).to receive(:require).and_call_original
+        expect(Flipper::Engine.instance).to receive(:require).with("flipper/test_help")
+        subject
+        expect(config.test_help).to eq(true)
+      end
+
+      it "is loaded if FLIPPER_TEST_HELP=true" do
+        ENV["FLIPPER_TEST_HELP"] = "true"
+        allow(Flipper::Engine.instance).to receive(:require).and_call_original
+        expect(Flipper::Engine.instance).to receive(:require).with("flipper/test_help")
+        subject
+        expect(config.test_help).to eq(true)
+      end
+
+      it "is loaded if config.flipper.test_help = true" do
+        initializer { config.test_help = true }
+        allow(Flipper::Engine.instance).to receive(:require).and_call_original
+        expect(Flipper::Engine.instance).to receive(:require).with("flipper/test_help")
+        subject
+      end
+
+      it "is not loaded if FLIPPER_TEST_HELP=false" do
+        ENV["FLIPPER_TEST_HELP"] = "false"
+        allow(Flipper::Engine.instance).to receive(:require).and_call_original
+        expect(Flipper::Engine.instance).to receive(:require).with("flipper/test_help").never
+        subject
+      end
+
+      it "is not loaded if config.flipper.test_help = false" do
+        Rails.env = "true"
+        initializer { config.test_help = false }
+        allow(Flipper::Engine.instance).to receive(:require).and_call_original
+        expect(Flipper::Engine.instance).to receive(:require).with("flipper/test_help").never
+        subject
+      end
+    end
+  end
+
+  context 'with cloud' do
+    before do
+      ENV["FLIPPER_CLOUD_TOKEN"] = "test-token"
+    end
+
+    # App for Rack::Test
+    let(:app) { application.routes }
+
+    it_behaves_like 'config.strict' do
+      let(:adapter) do
+        memoizable = Flipper.adapter
+        dual_write = memoizable.adapter
+        poll = dual_write.local
+        poll.adapter
+      end
+    end
+
+    it "initializes cloud configuration" do
+      stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+
+      silence { application.initialize! }
+
+      expect(Flipper.instance).to be_a(Flipper::Cloud::DSL)
+      expect(Flipper.instance.instrumenter).to be_a(Flipper::Cloud::Telemetry::Instrumenter)
+      expect(Flipper.instance.instrumenter.instrumenter).to be(ActiveSupport::Notifications)
+    end
+
+    context "with CLOUD_SYNC_SECRET" do
+      before do
+        ENV["FLIPPER_CLOUD_SYNC_SECRET"] = "test-secret"
+      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
+        silence { 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
+        silence { 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
+        ENV["FLIPPER_CLOUD_TOKEN"] = nil
+        silence { application.initialize! }
+        expect(Flipper.instance).to be_a(Flipper::DSL)
+
+        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
+      silence { 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
+
+  describe "config.actor_limit" do
+    let(:adapter) do
+      silence { application.initialize! }
+      Flipper.adapter.adapter.adapter
+    end
+
+    it "defaults to 100" do
+      expect(adapter).to be_instance_of(Flipper::Adapters::ActorLimit)
+      expect(adapter.limit).to eq(100)
+    end
+
+    it "can be set from FLIPPER_ACTOR_LIMIT env" do
+      ENV["FLIPPER_ACTOR_LIMIT"] = "500"
+      expect(adapter.limit).to eq(500)
+    end
+
+    it "can be set from an initializer" do
+      initializer { config.actor_limit = 99 }
+      expect(adapter.limit).to eq(99)
+    end
+
+    it "can be disabled from an initializer" do
+      initializer { config.actor_limit = false }
+      expect(adapter).not_to be_instance_of(Flipper::Adapters::ActorLimit)
+    end
+  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