flipper 0.16.0 → 1.4.0

data/spec/flipper/middleware/memoizer_spec.rb

@@ -1,9 +1,9 @@
-require 'helper'
 require 'rack/test'
 require 'active_support/cache'
-require 'active_support/cache/dalli_store'
 require 'flipper/adapters/active_support_cache_store'
 require 'flipper/adapters/operation_logger'
+require 'flipper/adapters/actor_limit'
+require 'flipper/adapters/sync'
 
 RSpec.describe Flipper::Middleware::Memoizer do
   include Rack::Test::Methods
@@ -15,10 +15,6 @@ RSpec.describe Flipper::Middleware::Memoizer do
   let(:flipper) { Flipper.new(adapter) }
   let(:env) { { 'flipper' => flipper } }
 
-  after do
-    flipper.memoize = nil
-  end
-
   it 'raises if initialized with app and flipper instance' do
     expect do
       described_class.new(app, flipper)
@@ -44,26 +40,6 @@ RSpec.describe Flipper::Middleware::Memoizer do
       expect(called).to eq(true)
     end
 
-    it 'disables local cache after body close' do
-      app = ->(_env) { [200, {}, []] }
-      middleware = described_class.new(app)
-      body = middleware.call(env).last
-
-      expect(flipper.memoizing?).to eq(true)
-      body.close
-      expect(flipper.memoizing?).to eq(false)
-    end
-
-    it 'clears local cache after body close' do
-      app = ->(_env) { [200, {}, []] }
-      middleware = described_class.new(app)
-      body = middleware.call(env).last
-
-      flipper.adapter.cache['hello'] = 'world'
-      body.close
-      expect(flipper.adapter.cache).to be_empty
-    end
-
     it 'clears the local cache with a successful request' do
       flipper.adapter.cache['hello'] = 'world'
       get '/', {}, 'flipper' => flipper
@@ -103,14 +79,14 @@ RSpec.describe Flipper::Middleware::Memoizer do
     end
   end
 
-  context 'with preload_all' do
+  context 'with preload: true' do
     let(:app) do
       # ensure scoped for builder block, annoying...
-      instance = flipper
+      flipper
       middleware = described_class
 
       Rack::Builder.new do
-        use middleware, preload_all: true
+        use middleware, preload: true
 
         map '/' do
           run ->(_env) { [200, {}, []] }
@@ -139,7 +115,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
         [200, {}, []]
       end
 
-      middleware = described_class.new(app, preload_all: true)
+      middleware = described_class.new(app, preload: true)
       middleware.call(env)
 
       expect(adapter.operations.size).to be(1)
@@ -156,7 +132,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
         [200, {}, []]
       end
 
-      middleware = described_class.new(app, preload_all: true)
+      middleware = described_class.new(app, preload: true)
       middleware.call(env)
 
       expect(adapter.count(:get)).to be(1)
@@ -167,7 +143,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
   context 'with preload specific' do
     let(:app) do
       # ensure scoped for builder block, annoying...
-      instance = flipper
+      flipper
       middleware = described_class
 
       Rack::Builder.new do
@@ -222,6 +198,111 @@ RSpec.describe Flipper::Middleware::Memoizer do
     end
   end
 
+  context 'with preload block' do
+    let(:app) do
+      app = lambda do |_env|
+        flipper[:stats].enabled?
+        flipper[:stats].enabled?
+        flipper[:shiny].enabled?
+        flipper[:shiny].enabled?
+        [200, {}, []]
+      end
+
+      described_class.new(app, preload: ->(request) {
+        case request.path
+        when "/true"
+          true
+        when "/specific"
+          [:stats]
+        else
+          false
+        end
+      })
+    end
+
+    include_examples 'flipper middleware'
+
+    it 'eagerly caches known features for duration of request if block returns true' do
+      flipper[:stats].enable
+      flipper[:shiny].enable
+
+      # clear the log of operations
+      adapter.reset
+
+      get '/true', {}, 'flipper' => flipper
+
+      expect(adapter.operations.size).to be(1)
+      expect(adapter.count(:get_all)).to be(1)
+      expect(adapter.count(:get)).to be(0)
+    end
+
+    it 'does not eagerly cache known features if block returns false' do
+      flipper[:stats].enable
+      flipper[:shiny].enable
+
+      # clear the log of operations
+      adapter.reset
+
+      get '/false', {}, 'flipper' => flipper
+
+      expect(adapter.operations.size).to be(2)
+      expect(adapter.count(:get_all)).to be(0)
+      expect(adapter.count(:get)).to be(2)
+    end
+
+    it 'eagerly caches specified features for duration of request if block returns array of specified features' do
+      flipper[:stats].enable
+      flipper[:shiny].enable
+
+      # clear the log of operations
+      adapter.reset
+
+      get '/specific', {}, 'flipper' => flipper
+
+      expect(adapter.operations.size).to be(2)
+      expect(adapter.count(:get_multi)).to be(1)
+      expect(adapter.count(:get)).to be(1)
+    end
+  end
+
+  context 'with multiple instances' do
+    let(:app) do
+      # ensure scoped for builder block, annoying...
+      flipper
+      middleware = described_class
+
+      Rack::Builder.new do
+        use middleware, preload: %i(stats)
+        # Second instance should be a noop
+        use middleware, preload: true
+
+        map '/' do
+          run ->(_env) { [200, {}, []] }
+        end
+
+        map '/fail' do
+          run ->(_env) { raise 'FAIL!' }
+        end
+      end.to_app
+    end
+
+    def get(uri, params = {}, env = {}, &block)
+      capture_output { super(uri, params, env, &block) }
+    end
+
+    include_examples 'flipper middleware'
+
+    it 'does not call preload in second instance' do
+      expect(flipper).not_to receive(:preload_all)
+
+      output = get '/', {}, 'flipper' => flipper
+
+      expect(output).to match(/Flipper::Middleware::Memoizer appears to be running twice/)
+      expect(adapter.count(:get_multi)).to be(1)
+      expect(adapter.last(:get_multi).args).to eq([[flipper[:stats]]])
+    end
+  end
+
   context 'when an app raises an exception' do
     it 'resets memoize' do
       begin
@@ -237,7 +318,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
   context 'with flipper setup in env' do
     let(:app) do
       # ensure scoped for builder block, annoying...
-      instance = flipper
+      flipper
       middleware = described_class
 
       Rack::Builder.new do
@@ -259,10 +340,9 @@ RSpec.describe Flipper::Middleware::Memoizer do
   context 'with Flipper setup in env' do
     it 'caches getting a feature for duration of request' do
       Flipper.configure do |config|
-        config.default do
+        config.adapter do
           memory = Flipper::Adapters::Memory.new
-          logged_adapter = Flipper::Adapters::OperationLogger.new(memory)
-          Flipper.new(logged_adapter)
+          Flipper::Adapters::OperationLogger.new(memory)
         end
       end
       Flipper.enable(:stats)
@@ -308,14 +388,16 @@ RSpec.describe Flipper::Middleware::Memoizer do
     end
   end
 
-  context 'with preload_all and unless option' do
+  context 'with preload:true' do
+    let(:options) { {preload: true} }
+
     let(:app) do
       # ensure scoped for builder block, annoying...
       middleware = described_class
+      opts = options
 
       Rack::Builder.new do
-        use middleware, preload_all: true,
-                        unless: ->(request) { request.path.start_with?("/assets") }
+        use middleware, opts
 
         map '/' do
           run ->(_env) { [200, {}, []] }
@@ -327,26 +409,59 @@ RSpec.describe Flipper::Middleware::Memoizer do
       end.to_app
     end
 
-    it 'does NOT preload_all if request matches unless block' do
-      expect(flipper).to receive(:preload_all).never
-      get '/assets/foo.png', {}, 'flipper' => flipper
+    context 'and unless option' do
+      before do
+        options[:unless] = ->(request) { request.path.start_with?("/assets") }
+      end
+
+      it 'does NOT preload if request matches unless block' do
+        expect(flipper).to receive(:preload_all).never
+        get '/assets/foo.png', {}, 'flipper' => flipper
+      end
+
+      it 'does preload if request does NOT match unless block' do
+        expect(flipper).to receive(:preload_all).once
+        get '/some/other/path', {}, 'flipper' => flipper
+      end
     end
 
-    it 'does preload_all if request does NOT match unless block' do
-      expect(flipper).to receive(:preload_all).once
-      get '/some/other/path', {}, 'flipper' => flipper
+    context 'and if option' do
+      before do
+        options[:if] = ->(request) { !request.path.start_with?("/assets") }
+      end
+
+      it 'does NOT preload if request does not match if block' do
+        expect(flipper).to receive(:preload_all).never
+        get '/assets/foo.png', {}, 'flipper' => flipper
+      end
+
+      it 'does preload if request matches if block' do
+        expect(flipper).to receive(:preload_all).once
+        get '/some/other/path', {}, 'flipper' => flipper
+      end
     end
   end
 
-  context 'with preload_all and caching adapter' do
+  context 'with preload:true and caching adapter' do
+    let(:app) do
+      app = lambda do |_env|
+        flipper[:stats].enabled?
+        flipper[:stats].enabled?
+        flipper[:shiny].enabled?
+        flipper[:shiny].enabled?
+        [200, {}, []]
+      end
+
+      described_class.new(app, preload: true)
+    end
+
     it 'eagerly caches known features for duration of request' do
       memory = Flipper::Adapters::Memory.new
       logged_memory = Flipper::Adapters::OperationLogger.new(memory)
-      cache = ActiveSupport::Cache::DalliStore.new
+      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)
       flipper[:stats].enable
       flipper[:shiny].enable
@@ -355,27 +470,49 @@ RSpec.describe Flipper::Middleware::Memoizer do
       logged_memory.reset
       logged_cached.reset
 
-      app = lambda do |_env|
-        flipper[:stats].enabled?
-        flipper[:stats].enabled?
-        flipper[:shiny].enabled?
-        flipper[:shiny].enabled?
-        [200, {}, []]
-      end
-
-      middleware = described_class.new(app, preload_all: true)
-
-      middleware.call('flipper' => flipper)
+      get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(1)
       expect(logged_memory.count(:get_all)).to be(1)
 
-      middleware.call('flipper' => flipper)
+      get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(2)
       expect(logged_memory.count(:get_all)).to be(1)
 
-      middleware.call('flipper' => flipper)
+      get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(3)
       expect(logged_memory.count(:get_all)).to be(1)
     end
   end
+
+  context 'with preload:true and Sync adapter wrapped with ActorLimit' do
+    it 'preloads even when remote has more actors than local limit' do
+      local = Flipper::Adapters::Memory.new
+      remote = Flipper::Adapters::Memory.new
+      remote_flipper = Flipper.new(remote)
+
+      # Remote has more actors than limit allows (actor-only enables, not boolean)
+      10.times { |i| remote_flipper[:stats].enable_actor Flipper::Actor.new("User;#{i}") }
+
+      # Sync adapter will sync from remote to local, then ActorLimit wraps it
+      # Use interval: 0 to force sync on every call
+      sync_adapter = Flipper::Adapters::Sync.new(local, remote, interval: 0)
+      limited_adapter = Flipper::Adapters::ActorLimit.new(sync_adapter, 5)
+      test_flipper = Flipper.new(limited_adapter)
+
+      app = lambda do |env|
+        f = env['flipper']
+        f[:stats].enabled?
+        [200, {}, []]
+      end
+      middleware = described_class.new(app, preload: true)
+
+      # Preload should work without raising ActorLimit::LimitExceeded
+      expect {
+        middleware.call('flipper' => test_flipper)
+      }.not_to raise_error
+
+      # Verify actors were synced (all 10, not just 5)
+      expect(test_flipper[:stats].actors_value.size).to eq(10)
+    end
+  end
 end

data/spec/flipper/middleware/setup_env_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::Middleware::SetupEnv do
   context 'with flipper instance' do
     let(:app) do
@@ -56,21 +54,41 @@ RSpec.describe Flipper::Middleware::SetupEnv do
     end
   end
 
-  context 'when flipper instance is nil' do
+  context 'when flipper instance or block are nil but env flipper is configured' do
     let(:app) do
       app = lambda do |env|
         [200, { 'Content-Type' => 'text/html' }, [env['flipper'].object_id.to_s]]
       end
       builder = Rack::Builder.new
-      builder.use described_class, nil
+      builder.use described_class
       builder.run app
       builder
     end
 
-    it 'leaves env flipper alone' do
+    it 'can use env flipper' do
       env_flipper = build_flipper
       get '/', {}, 'flipper' => env_flipper
       expect(last_response.body).to eq(env_flipper.object_id.to_s)
     end
   end
+
+  context 'when flipper instance or block are nil and default Flipper is configured' do
+    let(:app) do
+      Flipper.configure do |config|
+        config.default { flipper }
+      end
+      app = lambda do |env|
+        [200, { 'Content-Type' => 'text/html' }, [env['flipper'].object_id.to_s]]
+      end
+      builder = Rack::Builder.new
+      builder.use described_class
+      builder.run app
+      builder
+    end
+
+    it 'can use env flipper' do
+      get '/', {}, {}
+      expect(last_response.body).to eq(Flipper.object_id.to_s)
+    end
+  end
 end

data/spec/flipper/model/active_record_spec.rb

@@ -0,0 +1,72 @@
+require 'active_record'
+require 'flipper/model/active_record'
+
+# Turn off migration logging for specs
+ActiveRecord::Migration.verbose = false
+
+RSpec.describe Flipper::Model::ActiveRecord do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+  end
+
+  before(:each) do
+    ActiveRecord::Base.connection.execute <<-SQL
+      CREATE TABLE users (
+        id integer PRIMARY KEY,
+        name string NOT NULL,
+        age integer,
+        is_confirmed boolean,
+        created_at datetime NOT NULL,
+        updated_at datetime NOT NULL
+      )
+    SQL
+  end
+
+  after(:each) do
+    ActiveRecord::Base.connection.execute("DROP table IF EXISTS `users`")
+  end
+
+  class User < ActiveRecord::Base
+    include Flipper::Model::ActiveRecord
+  end
+
+  class DelegatedUser < DelegateClass(User)
+  end
+
+  class Admin < User
+  end
+
+  it "doesn't warn for to_ary" do
+    # looks like we should remove this but you are wrong, we have specs that
+    # fail if there are warnings and if this regresses it will print a warning
+    # so it is in fact testing something
+    user = User.create!(name: "Test")
+    Flipper.enabled?(:something, DelegatedUser.new(user))
+  end
+
+  describe "flipper_id" do
+    it "returns class name and id" do
+      expect(User.new(id: 1).flipper_id).to eq("User;1")
+    end
+
+    it "uses base class name" do
+      expect(Admin.new(id: 2).flipper_id).to eq("User;2")
+    end
+  end
+
+  describe "flipper_properties" do
+    subject { User.create!(name: "Test", age: 22, is_confirmed: true) }
+
+    it "includes all attributes" do
+      expect(subject.flipper_properties).to eq({
+        "type" => "User",
+        "id" => subject.id,
+        "name" => "Test",
+        "age" => 22,
+        "is_confirmed" => true,
+        "created_at" => subject.created_at,
+        "updated_at" => subject.updated_at
+      })
+    end
+  end
+end