flipper 0.28.3 → 1.4.2

data/spec/flipper/gates/expression_spec.rb

@@ -0,0 +1,190 @@
+RSpec.describe Flipper::Gates::Expression do
+  let(:feature_name) { :search }
+
+  subject do
+    described_class.new
+  end
+
+  def context(expression, properties: {})
+    Flipper::FeatureCheckContext.new(
+      feature_name: feature_name,
+      values: Flipper::GateValues.new(expression: expression),
+      actors: [Flipper::Types::Actor.new(Flipper::Actor.new(1, properties))]
+    )
+  end
+
+  describe '#enabled?' do
+    context 'for nil value' do
+      it 'returns false' do
+        expect(subject.enabled?(nil)).to eq(false)
+      end
+    end
+
+    context 'for empty value' do
+      it 'returns false' do
+        expect(subject.enabled?({})).to eq(false)
+      end
+    end
+
+    context "for not empty value" do
+      it 'returns true' do
+        expect(subject.enabled?({"Boolean" => [true]})).to eq(true)
+      end
+    end
+  end
+
+  describe '#open?' do
+    context 'for expression that evaluates to true' do
+      it 'returns true' do
+        expression = Flipper.boolean(true).eq(true)
+        expect(subject.open?(context(expression.value))).to be(true)
+      end
+    end
+
+    context 'for expression that evaluates to false' do
+      it 'returns false' do
+        expression = Flipper.boolean(true).eq(false)
+        expect(subject.open?(context(expression.value))).to be(false)
+      end
+    end
+
+    context 'for properties that have string keys' do
+      it 'returns true when expression evalutes to true' do
+        expression = Flipper.property(:type).eq("User")
+        context = context(expression.value, properties: {"type" => "User"})
+        expect(subject.open?(context)).to be(true)
+      end
+
+      it 'returns false when expression evaluates to false' do
+        expression = Flipper.property(:type).eq("User")
+        context = context(expression.value, properties: {"type" => "Org"})
+        expect(subject.open?(context)).to be(false)
+      end
+    end
+
+    context 'for actor in context' do
+      it 'passes actor to expression context' do
+        actor = Flipper::Actor.new("User;1", {type: "User"})
+        wrapped_actor = Flipper::Types::Actor.new(actor)
+        expression = Flipper.property(:flipper_id).eq("User;1")
+        ctx = Flipper::FeatureCheckContext.new(
+          feature_name: feature_name,
+          values: Flipper::GateValues.new(expression: expression.value),
+          actors: [wrapped_actor]
+        )
+        expect(subject.open?(ctx)).to be(true)
+      end
+
+      it 'passes nil actor when no actors provided' do
+        expression = Flipper.boolean(true).eq(true)
+        ctx = Flipper::FeatureCheckContext.new(
+          feature_name: feature_name,
+          values: Flipper::GateValues.new(expression: expression.value),
+          actors: nil
+        )
+        expect(subject.open?(ctx)).to be(true)
+      end
+    end
+
+    context 'for properties that have symbol keys' do
+      it 'returns true when expression evalutes to true' do
+        expression = Flipper.property(:type).eq("User")
+        context = context(expression.value, properties: {type: "User"})
+        expect(subject.open?(context)).to be(true)
+      end
+
+      it 'returns false when expression evaluates to false' do
+        expression = Flipper.property(:type).eq("User")
+        context = context(expression.value, properties: {type: "Org"})
+        expect(subject.open?(context)).to be(false)
+      end
+    end
+
+    context 'for time-based expressions' do
+      it 'enables when now is past a scheduled epoch' do
+        past_epoch = Time.now.to_i - 86_400
+        expression = Flipper.now.gte(Flipper.time(past_epoch))
+        expect(subject.open?(context(expression.value))).to be(true)
+      end
+
+      it 'does not enable when now is before a future epoch' do
+        future_epoch = Time.now.to_i + 86_400
+        expression = Flipper.now.gte(Flipper.time(future_epoch))
+        expect(subject.open?(context(expression.value))).to be(false)
+      end
+
+      it 'enables when now is past a scheduled datetime' do
+        past_time = (Time.now.utc - 86_400).iso8601
+        expression = Flipper.now.gte(Flipper.time(past_time))
+        expect(subject.open?(context(expression.value))).to be(true)
+      end
+
+      it 'does not enable when now is before a future datetime' do
+        future_time = (Time.now.utc + 86_400).iso8601
+        expression = Flipper.now.gte(Flipper.time(future_time))
+        expect(subject.open?(context(expression.value))).to be(false)
+      end
+
+      it 'enables expiring features with lt' do
+        future_time = (Time.now.utc + 86_400).iso8601
+        expression = Flipper.now.lt(Flipper.time(future_time))
+        expect(subject.open?(context(expression.value))).to be(true)
+      end
+
+      it 'disables expired features with lt' do
+        past_time = (Time.now.utc - 86_400).iso8601
+        expression = Flipper.now.lt(Flipper.time(past_time))
+        expect(subject.open?(context(expression.value))).to be(false)
+      end
+
+      it 'enables within a time window using all' do
+        start_time = (Time.now.utc - 86_400).iso8601
+        end_time = (Time.now.utc + 86_400).iso8601
+        expression = Flipper.all(
+          Flipper.now.gte(Flipper.time(start_time)),
+          Flipper.now.lt(Flipper.time(end_time))
+        )
+        expect(subject.open?(context(expression.value))).to be(true)
+      end
+
+      it 'does not enable outside a time window' do
+        start_time = (Time.now.utc + 86_400).iso8601
+        end_time = (Time.now.utc + 172_800).iso8601
+        expression = Flipper.all(
+          Flipper.now.gte(Flipper.time(start_time)),
+          Flipper.now.lt(Flipper.time(end_time))
+        )
+        expect(subject.open?(context(expression.value))).to be(false)
+      end
+    end
+  end
+
+  describe '#protects?' do
+    it 'returns true for Flipper::Expression' do
+      expression = Flipper.number(20).eq(20)
+      expect(subject.protects?(expression)).to be(true)
+    end
+
+    it 'returns true for Hash' do
+      expression = Flipper.number(20).eq(20)
+      expect(subject.protects?(expression.value)).to be(true)
+    end
+
+    it 'returns false for other things' do
+      expect(subject.protects?(false)).to be(false)
+    end
+  end
+
+  describe '#wrap' do
+    it 'returns self for Flipper::Expression' do
+      expression = Flipper.number(20).eq(20)
+      expect(subject.wrap(expression)).to be(expression)
+    end
+
+    it 'returns Flipper::Expression for Hash' do
+      expression = Flipper.number(20).eq(20)
+      expect(subject.wrap(expression.value)).to be_instance_of(Flipper::Expression)
+      expect(subject.wrap(expression.value)).to eq(expression)
+    end
+  end
+end

data/spec/flipper/identifier_spec.rb

@@ -2,12 +2,11 @@ require 'flipper/identifier'
 
 RSpec.describe Flipper::Identifier do
   describe '#flipper_id' do
-    class User < Struct.new(:id)
-      include Flipper::Identifier
-    end
-
     it 'uses class name and id' do
-      expect(User.new(5).flipper_id).to eq('User;5')
+      class BlahBlah < Struct.new(:id)
+        include Flipper::Identifier
+      end
+      expect(BlahBlah.new(5).flipper_id).to eq('BlahBlah;5')
     end
   end
 end

data/spec/flipper/instrumentation/log_subscriber_spec.rb

@@ -1,6 +1,7 @@
 require 'logger'
-require 'flipper/adapters/instrumented'
+require 'active_support/core_ext/object/blank'
 require 'flipper/instrumentation/log_subscriber'
+require 'flipper/adapters/instrumented'
 
 begin
   require 'active_support/isolated_execution_state'
@@ -8,6 +9,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 +36,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/instrumentation/statsd_subscriber_spec.rb

@@ -1,6 +1,5 @@
 require 'flipper/adapters/instrumented'
 require 'flipper/instrumentation/statsd'
-require 'statsd'
 
 begin
   require 'active_support/isolated_execution_state'
@@ -19,7 +18,7 @@ RSpec.describe Flipper::Instrumentation::StatsdSubscriber do
     Flipper.new(adapter, instrumenter: ActiveSupport::Notifications)
   end
 
-  let(:user) { user = Flipper::Actor.new('1') }
+  let(:user) { Flipper::Actor.new('1') }
 
   before do
     described_class.client = statsd_client
@@ -78,4 +77,19 @@ RSpec.describe Flipper::Instrumentation::StatsdSubscriber do
     flipper[:stats].disable(user)
     assert_timer 'flipper.adapter.memory.disable'
   end
+
+  context 'when client is nil' do
+    before do
+      described_class.client = nil
+    end
+
+    it 'does not raise error' do
+      expect { flipper[:stats].enable(user) }.not_to raise_error
+    end
+
+    it 'does not update metrics' do
+      flipper[:stats].enable(user)
+      expect(socket.buffer).to be_empty
+    end
+  end
 end

data/spec/flipper/middleware/memoizer_spec.rb

@@ -2,6 +2,8 @@ require 'rack/test'
 require 'active_support/cache'
 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
@@ -80,7 +82,7 @@ RSpec.describe Flipper::Middleware::Memoizer 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
@@ -141,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
@@ -196,10 +198,77 @@ 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...
-      instance = flipper
+      flipper
       middleware = described_class
 
       Rack::Builder.new do
@@ -218,7 +287,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
     end
 
     def get(uri, params = {}, env = {}, &block)
-      silence { super(uri, params, env, &block) }
+      capture_output { super(uri, params, env, &block) }
     end
 
     include_examples 'flipper middleware'
@@ -249,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
@@ -391,9 +460,8 @@ 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)
       flipper[:stats].enable
       flipper[:shiny].enable
@@ -415,4 +483,36 @@ RSpec.describe Flipper::Middleware::Memoizer do
       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/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