flipper 1.1.2 → 1.3.0

data/spec/flipper/engine_spec.rb

@@ -4,8 +4,10 @@ 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
 
@@ -33,86 +35,102 @@ RSpec.describe Flipper::Engine 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
+      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
-      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
+      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
-      with_env 'FLIPPER_STRICT' => 'false' 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(config.strict).to eq(false)
-        expect(adapter).to be_instance_of(Flipper::Adapters::Memory)
+        expect(adapter).to be_instance_of(Flipper::Adapters::Strict)
+        expect(adapter.handler).to be(value)
       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)
+    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
 
-    %w(development test).each do |env|
+    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(:warn)
-        expect(adapter).to be_instance_of(Flipper::Adapters::Strict)
-        expect(adapter.handler).to be(Flipper::Adapters::Strict::HANDLERS.fetch(:warn))
+        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
-      with_env 'FLIPPER_ENV_KEY' => 'flopper' do
-        subject
-        expect(config.env_key).to eq('flopper')
-      end
+      ENV['FLIPPER_ENV_KEY'] = 'flopper'
+      subject
+      expect(config.env_key).to eq('flopper')
     end
 
     it 'can set memoize from ENV' do
-      with_env 'FLIPPER_MEMOIZE' => 'false' do
-        subject
-        expect(config.memoize).to eq(false)
-      end
+      ENV['FLIPPER_MEMOIZE'] = 'false'
+      subject
+      expect(config.memoize).to eq(false)
     end
 
     it 'can set preload from ENV' do
-      with_env 'FLIPPER_PRELOAD' => 'false' do
-        subject
-        expect(config.preload).to eq(false)
-      end
+      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)
-      with_env 'FLIPPER_INSTRUMENTER' => 'My::Cool::Instrumenter' do
-        subject
-        expect(config.instrumenter).to eq(My::Cool::Instrumenter)
-      end
+      ENV['FLIPPER_INSTRUMENTER'] = 'My::Cool::Instrumenter'
+      subject
+      expect(config.instrumenter).to eq(My::Cool::Instrumenter)
     end
 
     it 'can set log from ENV' do
-      with_env 'FLIPPER_LOG' => 'false' do
-        subject
-        expect(config.log).to eq(false)
-      end
+      ENV['FLIPPER_LOG'] = 'false'
+      subject
+      expect(config.log).to eq(false)
     end
 
     it 'sets defaults' do
@@ -153,13 +171,51 @@ RSpec.describe Flipper::Engine do
         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
-    around do |example|
-      with_env "FLIPPER_CLOUD_TOKEN" => "test-token" do
-        example.run
-      end
+    before do
+      ENV["FLIPPER_CLOUD_TOKEN"] = "test-token"
     end
 
     # App for Rack::Test
@@ -167,7 +223,8 @@ RSpec.describe Flipper::Engine do
 
     it_behaves_like 'config.strict' do
       let(:adapter) do
-        dual_write = Flipper.adapter.adapter
+        memoizable = Flipper.adapter
+        dual_write = memoizable.adapter
         poll = dual_write.local
         poll.adapter
       end
@@ -179,14 +236,13 @@ RSpec.describe Flipper::Engine do
       application.initialize!
 
       expect(Flipper.instance).to be_a(Flipper::Cloud::DSL)
-      expect(Flipper.instance.instrumenter).to be(ActiveSupport::Notifications)
+      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
-      around do |example|
-        with_env "FLIPPER_CLOUD_SYNC_SECRET" => "test-secret" do
-          example.run
-        end
+      before do
+        ENV["FLIPPER_CLOUD_SYNC_SECRET"] = "test-secret"
       end
 
       let(:request_body) do
@@ -210,7 +266,7 @@ RSpec.describe Flipper::Engine 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"] },
+          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 }
@@ -231,10 +287,9 @@ RSpec.describe Flipper::Engine do
 
     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
+        ENV["FLIPPER_CLOUD_TOKEN"] = nil
+        application.initialize!
+        expect(Flipper.instance).to be_a(Flipper::DSL)
 
         post "/_flipper"
         expect(last_response.status).to eq(404)
@@ -282,6 +337,33 @@ RSpec.describe Flipper::Engine do
     expect(ActiveRecord::Base.ancestors).to include(Flipper::Model::ActiveRecord)
   end
 
+  describe "config.actor_limit" do
+    let(:adapter) do
+      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

data/spec/flipper/instrumentation/log_subscriber_spec.rb

@@ -1,6 +1,6 @@
 require 'logger'
-require 'flipper/adapters/instrumented'
 require 'flipper/instrumentation/log_subscriber'
+require 'flipper/adapters/instrumented'
 
 begin
   require 'active_support/isolated_execution_state'
@@ -8,6 +8,9 @@ rescue LoadError
   # ActiveSupport::IsolatedExecutionState is only available in Rails 5.2+
 end
 
+# Don't log in other tests, we'll manually re-attach when this one starts
+Flipper::Instrumentation::LogSubscriber.detach
+
 RSpec.describe Flipper::Instrumentation::LogSubscriber do
   let(:adapter) do
     memory = Flipper::Adapters::Memory.new
@@ -32,8 +35,12 @@ RSpec.describe Flipper::Instrumentation::LogSubscriber do
     described_class.logger = nil
   end
 
+  before(:all) do
+    described_class.attach
+  end
+
   after(:all) do
-    ActiveSupport::Notifications.unsubscribe("flipper")
+    described_class.detach
   end
 
   let(:log) { @io.string }

data/spec/flipper/middleware/memoizer_spec.rb

@@ -458,7 +458,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
       logged_memory = Flipper::Adapters::OperationLogger.new(memory)
       cache = ActiveSupport::Cache::MemoryStore.new
       cache.clear
-      cached = Flipper::Adapters::ActiveSupportCacheStore.new(logged_memory, cache, expires_in: 10)
+      cached = Flipper::Adapters::ActiveSupportCacheStore.new(logged_memory, cache)
       logged_cached = Flipper::Adapters::OperationLogger.new(cached)
       memo = {}
       flipper = Flipper.new(logged_cached)
@@ -471,15 +471,18 @@ RSpec.describe Flipper::Middleware::Memoizer do
 
       get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(1)
-      expect(logged_memory.count(:get_all)).to be(1)
+      expect(logged_memory.count(:features)).to be(1)
+      expect(logged_memory.count(:get_multi)).to be(1)
 
       get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(2)
-      expect(logged_memory.count(:get_all)).to be(1)
+      expect(logged_memory.count(:features)).to be(1)
+      expect(logged_memory.count(:get_multi)).to be(1)
 
       get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(3)
-      expect(logged_memory.count(:get_all)).to be(1)
+      expect(logged_memory.count(:features)).to be(1)
+      expect(logged_memory.count(:get_multi)).to be(1)
     end
   end
 end

data/spec/flipper_spec.rb

@@ -241,7 +241,7 @@ RSpec.describe Flipper do
       stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
         with({
           headers: {
-            'Flipper-Cloud-Token'=>'asdf',
+            'flipper-cloud-token'=>'asdf',
           },
         }).to_return(status: 200, body: '{"features": {}}', headers: {})
       cloud_configuration = Flipper::Cloud::Configuration.new({

data/spec/spec_helper.rb

@@ -18,6 +18,7 @@ require 'flipper'
 require 'flipper/api'
 require 'flipper/spec/shared_adapter_specs'
 require 'flipper/ui'
+require 'flipper/test_help'
 
 Dir[FlipperRoot.join('spec/support/**/*.rb')].sort.each { |f| require f }
 

data/spec/support/fail_on_output.rb

@@ -0,0 +1,8 @@
+if ENV["CI"] || ENV["FAIL_ON_OUTPUT"]
+  RSpec.configure do |config|
+    config.around do |example|
+      output = silence { example.run }
+      fail "Use `silence { }` to avoid printing to STDOUT/STDERR\n#{output}" unless output.empty?
+    end
+  end
+end

data/spec/support/spec_helpers.rb

@@ -1,8 +1,11 @@
 require 'ice_age'
 require 'json'
 require 'rack/test'
+require 'rack/session'
 
 module SpecHelpers
+  extend self
+
   def self.included(base)
     base.let(:flipper) { build_flipper }
     base.let(:app) { build_app(flipper) }
@@ -10,7 +13,7 @@ module SpecHelpers
 
   def build_app(flipper, options = {})
     Flipper::UI.app(flipper, options) do |builder|
-      builder.use Rack::Session::Cookie, secret: 'test'
+      builder.use Rack::Session::Cookie, secret: 'test' * 16 # Rack 3+ wants a 64-character secret
     end
   end
 
@@ -27,7 +30,11 @@ module SpecHelpers
   end
 
   def json_response
-    JSON.parse(last_response.body)
+    body = last_response.body
+    if last_response["content-encoding"] == 'gzip'
+      body = Flipper::Typecast.from_gzip(body)
+    end
+    JSON.parse(body)
   end
 
   def api_error_code_reference_url
@@ -76,11 +83,11 @@ module SpecHelpers
 
     yield
 
-    $stderr = original_stderr
-    $stdout = original_stdout
-
     # Return output
     output.string
+  ensure
+    $stderr = original_stderr
+    $stdout = original_stdout
   end
 end
 

data/test/adapters/actor_limit_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+require "flipper/test/shared_adapter_test"
+require "flipper/adapters/actor_limit"
+
+class Flipper::Adapters::ActorLimitTest < MiniTest::Test
+  prepend Flipper::Test::SharedAdapterTests
+
+  def setup
+    @memory = Flipper::Adapters::Memory.new
+    @adapter = Flipper::Adapters::ActorLimit.new(@memory, 5)
+  end
+
+  def test_enable_fails_when_limit_exceeded
+    5.times { |i| @feature.enable Flipper::Actor.new("User;#{i}") }
+
+    assert_raises Flipper::Adapters::ActorLimit::LimitExceeded do
+      @feature.enable Flipper::Actor.new("User;6")
+    end
+  end
+end

data/test_rails/generators/flipper/setup_generator_test.rb

@@ -0,0 +1,64 @@
+require "helper"
+require "generators/flipper/setup_generator"
+
+class SetupGeneratorTest < Rails::Generators::TestCase
+  tests Flipper::Generators::SetupGenerator
+  ROOT = File.expand_path("../../../tmp/generators", __dir__)
+  destination ROOT
+  setup :prepare_destination
+
+  test "invokes flipper:active_record generator if ActiveRecord adapter defined" do
+    begin
+      load 'flipper/adapters/active_record.rb'
+      run_generator
+      assert_migration "db/migrate/create_flipper_tables.rb"
+    ensure
+      Flipper::Adapters.send(:remove_const, :ActiveRecord)
+    end
+  end
+
+  test "does not invoke flipper:active_record generator if ActiveRecord adapter not defined" do
+    # Ensure adapter not defined
+    Flipper::Adapters.send(:remove_const, :ActiveRecord) rescue nil
+
+    run_generator
+    assert_no_migration "db/migrate/create_flipper_tables.rb"
+  end
+
+  %w(.env.development .env.local .env).each do |file|
+    test "configures Flipper Cloud token in #{file} if it exists" do
+      File.write("#{ROOT}/#{file}", "")
+      run_generator %w(--token abc123)
+      assert_file file, /^FLIPPER_CLOUD_TOKEN=abc123$/m
+    end
+  end
+
+  test "configures Flipper Cloud token in .env.development before .env" do
+    File.write("#{ROOT}/.env.development", "")
+    File.write("#{ROOT}/.env", "")
+
+    run_generator %w(--token abc123)
+    assert_file ".env.development", /^FLIPPER_CLOUD_TOKEN=abc123$/m
+    assert_file ".env", ""
+  end
+
+  test "does not write to .env if no token provided" do
+    File.write("#{ROOT}/.env", "")
+    run_generator
+    assert_file ".env", ""
+  end
+
+  test "configures Flipper Cloud token in config/credentials.yml.enc if credentials.yml.enc exist" do
+    Dir.chdir(ROOT) do
+      FileUtils.mkdir_p("config")
+      ENV["RAILS_MASTER_KEY"] = "a" * 32
+      Rails.application = Class.new(Rails::Application)
+      Rails.application.credentials.write("")
+
+      run_generator %w(--token abc123)
+      assert_file "config/credentials.yml.enc"
+      expected_config = { flipper: { cloud_token: "abc123" } }
+      assert_equal expected_config, Rails.application.credentials.config
+    end
+  end
+end

data/test_rails/system/test_help_test.rb

@@ -0,0 +1,51 @@
+require_relative "../helper"
+
+# Not worth trying to test on old Rails versions
+return unless Rails::VERSION::MAJOR >= 7
+
+require "capybara/cuprite"
+require "flipper"
+require "flipper/test_help"
+
+require 'action_dispatch/system_testing/server'
+ActionDispatch::SystemTesting::Server.silence_puma = true
+
+class TestApp < Rails::Application
+  config.load_defaults "#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}"
+  config.eager_load = false
+  config.logger = ActiveSupport::Logger.new(StringIO.new)
+  routes.append do
+    root to: "features#index"
+  end
+end
+
+TestApp.initialize!
+
+class FeaturesController < ActionController::Base
+  def index
+    render json: Flipper.enabled?(:test) ? "Enabled" : "Disabled"
+  end
+end
+
+class TestHelpTest < ActionDispatch::SystemTestCase
+  # Any driver that runs the app in a separate thread will test what we want here.
+  driven_by :cuprite, options: { process_timeout: 60 }
+
+  setup do
+    # Reconfigure Flipper since other tests change the adapter.
+    flipper_configure
+
+    # Ensure this test uses this app instance
+    Rails.application = TestApp.instance
+  end
+
+  test "configures a shared adapter between tests and app" do
+    Flipper.disable(:test)
+    visit "/"
+    assert_selector "*", text: "Disabled"
+
+    Flipper.enable(:test)
+    visit "/"
+    assert_selector "*", text: "Enabled"
+  end
+end