flipper 1.3.4 → 1.4.2

data/spec/flipper/adapters/strict_spec.rb

@@ -21,6 +21,12 @@ RSpec.describe Flipper::Adapters::Strict do
           expect { subject.get_multi([feature]) }.to raise_error(Flipper::Adapters::Strict::NotFound)
         end
       end
+
+      context "#add" do
+        it "raises an error for unknown feature" do
+          expect { subject.add(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+        end
+      end
     end
   end
 
@@ -28,16 +34,22 @@ RSpec.describe Flipper::Adapters::Strict do
     subject { described_class.new(Flipper::Adapters::Memory.new, :warn) }
 
     context "#get" do
-      it "raises an error for unknown feature" do
+      it "warns for unknown feature" do
         expect(capture_output { subject.get(feature) }).to match(/Could not find feature "unknown"/)
       end
     end
 
     context "#get_multi" do
-      it "raises an error for unknown feature" do
+      it "warns for unknown feature" do
         expect(capture_output { subject.get_multi([feature]) }).to match(/Could not find feature "unknown"/)
       end
     end
+
+    context "#add" do
+      it "warns for unknown feature" do
+        expect(capture_output { subject.add(feature) }).to match(/Could not find feature "unknown"/)
+      end
+    end
   end
 
   context "handler = Block" do
@@ -48,17 +60,63 @@ RSpec.describe Flipper::Adapters::Strict do
 
 
     context "#get" do
-      it "raises an error for unknown feature" do
+      it "calls block for unknown feature" do
         subject.get(feature)
         expect(unknown_features).to eq(["unknown"])
       end
     end
 
     context "#get_multi" do
-      it "raises an error for unknown feature" do
+      it "calls block for unknown feature" do
         subject.get_multi([flipper[:foo], flipper[:bar]])
         expect(unknown_features).to eq(["foo", "bar"])
       end
     end
+
+    context "#add" do
+      it "calls block for unknown feature" do
+        subject.add(feature)
+        expect(unknown_features).to eq(["unknown"])
+      end
+    end
+  end
+
+  describe ".with_sync_mode" do
+    subject { described_class.new(Flipper::Adapters::Memory.new, :raise) }
+
+    it "bypasses strict checks for add" do
+      described_class.with_sync_mode do
+        expect { subject.add(feature) }.not_to raise_error
+      end
+    end
+
+    it "bypasses strict checks for get" do
+      described_class.with_sync_mode do
+        expect { subject.get(feature) }.not_to raise_error
+      end
+    end
+
+    it "bypasses strict checks for get_multi" do
+      described_class.with_sync_mode do
+        expect { subject.get_multi([feature]) }.not_to raise_error
+      end
+    end
+
+    it "restores previous sync mode after block" do
+      described_class.with_sync_mode do
+        # inside sync mode
+      end
+      expect { subject.add(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+    end
+
+    it "restores previous sync mode even on error" do
+      begin
+        described_class.with_sync_mode do
+          raise "boom"
+        end
+      rescue RuntimeError
+      end
+      expect { subject.add(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+    end
   end
 end

data/spec/flipper/adapters/sync/feature_synchronizer_spec.rb

@@ -105,6 +105,18 @@ RSpec.describe Flipper::Adapters::Sync::FeatureSynchronizer do
       expect_no_enable_or_disable
     end
 
+    it "updates expression when remote conditionally enabled but expression is nil" do
+      remote = Flipper::GateValues.new(expression: nil, actors: Set["1"])
+      feature.enable_expression(plan_expression)
+      feature.enable_actor(Flipper::Actor.new("1"))
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.expression_value).to eq(nil)
+      expect_only_disable
+    end
+
     it "adds remotely added actors" do
       remote = Flipper::GateValues.new(actors: Set["1", "2"])
       feature.enable_actor(Flipper::Actor.new("1"))

data/spec/flipper/adapters/sync/synchronizer_spec.rb

@@ -1,4 +1,5 @@
 require "flipper/adapters/memory"
+require "flipper/adapters/actor_limit"
 require "flipper/instrumenters/memory"
 require "flipper/adapters/sync/synchronizer"
 
@@ -84,5 +85,91 @@ RSpec.describe Flipper::Adapters::Sync::Synchronizer do
 
       expect(local_flipper.features.map(&:key)).to eq([])
     end
+
+    it 'emits feature_operation.flipper events when syncing' do
+      remote_flipper.enable(:search)
+
+      subject.call
+
+      events = instrumenter.events_by_name("feature_operation.flipper")
+      enable_events = events.select { |e| e.payload[:operation] == :enable }
+      expect(enable_events).not_to be_empty
+
+      feature_names = enable_events.map { |e| e.payload[:feature_name].to_s }
+      expect(feature_names).to include("search")
+    end
+
+    it 'emits feature_operation.flipper events when adding features' do
+      remote_flipper.add(:new_feature)
+
+      subject.call
+
+      events = instrumenter.events_by_name("feature_operation.flipper")
+      add_events = events.select { |e| e.payload[:operation] == :add }
+      expect(add_events).not_to be_empty
+
+      feature_names = add_events.map { |e| e.payload[:feature_name].to_s }
+      expect(feature_names).to include("new_feature")
+    end
+
+    it 'emits feature_operation.flipper events when removing features' do
+      local_flipper.add(:old_feature)
+
+      subject.call
+
+      events = instrumenter.events_by_name("feature_operation.flipper")
+      remove_events = events.select { |e| e.payload[:operation] == :remove }
+      expect(remove_events).not_to be_empty
+
+      feature_names = remove_events.map { |e| e.payload[:feature_name].to_s }
+      expect(feature_names).to include("old_feature")
+    end
+  end
+
+  context 'with ActorLimit adapter wrapping local' do
+    let(:limit) { 10 }
+    let(:limited_local) { Flipper::Adapters::ActorLimit.new(local, limit) }
+    let(:limited_local_flipper) { Flipper.new(limited_local) }
+
+    subject { described_class.new(limited_local, remote, instrumenter: instrumenter) }
+
+    it 'syncs actors even when remote has more actors than local limit' do
+      # Remote has more actors than local limit allows
+      20.times { |i| remote_flipper[:search].enable_actor Flipper::Actor.new("User;#{i}") }
+
+      # This should NOT raise - sync should bypass actor limits
+      expect { subject.call }.not_to raise_error
+
+      # All actors should be synced
+      expect(limited_local_flipper[:search].actors_value.size).to eq(20)
+    end
+
+    it 'syncs new actors added to remote after initial sync' do
+      # Initial state: remote has 20 actors, local limit is 10
+      20.times { |i| remote_flipper[:search].enable_actor Flipper::Actor.new("User;#{i}") }
+
+      # First sync - should work despite exceeding limit
+      subject.call
+      expect(limited_local_flipper[:search].actors_value.size).to eq(20)
+
+      # Add a 21st actor to remote (simulating Cloud adding a new actor)
+      remote_flipper[:search].enable_actor Flipper::Actor.new("User;20")
+
+      # Sync again - should pick up the new actor
+      expect { subject.call }.not_to raise_error
+      expect(limited_local_flipper[:search].actors_value.size).to eq(21)
+      expect(limited_local_flipper[:search].actors_value).to include("User;20")
+    end
+
+    it 'still enforces limit for direct enable operations' do
+      # First sync 20 actors from remote
+      20.times { |i| remote_flipper[:search].enable_actor Flipper::Actor.new("User;#{i}") }
+      subject.call
+
+      # Direct enable should still fail because we're over limit
+      expect {
+        limited_local_flipper[:search].enable_actor Flipper::Actor.new("User;new")
+      }.to raise_error(Flipper::Adapters::ActorLimit::LimitExceeded)
+    end
   end
 end

data/spec/flipper/adapters/sync_spec.rb

@@ -197,4 +197,17 @@ RSpec.describe Flipper::Adapters::Sync do
     expect(remote_adapter).to receive(:get_all).and_raise(exception)
     expect { subject.get_all }.not_to raise_error
   end
+
+  describe '#adapter_stack' do
+    it 'returns the tree representation' do
+      expect(subject.adapter_stack).to eq("sync(local: operation_logger -> memory, remote: operation_logger -> memory)")
+    end
+
+    it 'shows nested adapters in the tree' do
+      memory = Flipper::Adapters::Memory.new
+      strict = Flipper::Adapters::Strict.new(Flipper::Adapters::Memory.new)
+      adapter = described_class.new(memory, strict, interval: 1)
+      expect(adapter.adapter_stack).to eq("sync(local: memory, remote: strict -> memory)")
+    end
+  end
 end

data/spec/flipper/cli_spec.rb

@@ -147,6 +147,57 @@ RSpec.describe Flipper::CLI do
     it { should have_attributes(status: 1, stderr: /invalid option: --nope/) }
   end
 
+  describe "export" do
+    before do
+      Flipper.enable :search
+      Flipper.disable :analytics
+    end
+
+    it "outputs valid JSON export" do
+      expect(subject).to have_attributes(status: 0)
+      data = JSON.parse(subject.stdout)
+      expect(data["version"]).to eq(1)
+      expect(data["features"]).to have_key("search")
+      expect(data["features"]).to have_key("analytics")
+    end
+  end
+
+  describe "cloud" do
+    it "shows help when no subcommand given" do
+      expect(subject).to have_attributes(status: 0, stdout: /migrate/)
+      expect(subject.stdout).to match(/push/)
+    end
+  end
+
+  describe "cloud migrate" do
+    before do
+      Flipper.enable :search
+      require 'flipper/cloud/migrate'
+      allow(Flipper::Cloud).to receive(:migrate).and_return(
+        Flipper::Cloud::MigrateResult.new(code: 200, url: "https://www.flippercloud.io/cloud/setup/abc123")
+      )
+      allow(cli).to receive(:system)
+    end
+
+    it "prints the cloud URL" do
+      expect(subject).to have_attributes(status: 0, stdout: /flippercloud\.io/)
+    end
+  end
+
+  describe "cloud push test-token" do
+    before do
+      Flipper.enable :search
+      require 'flipper/cloud/migrate'
+      allow(Flipper::Cloud).to receive(:push).and_return(
+        Flipper::Cloud::MigrateResult.new(code: 204, url: nil)
+      )
+    end
+
+    it "prints success message" do
+      expect(subject).to have_attributes(status: 0, stdout: /Successfully pushed/)
+    end
+  end
+
   describe "show foo" do
     context "boolean" do
       before { Flipper.enable :foo }

data/spec/flipper/cloud/middleware_spec.rb

@@ -274,7 +274,7 @@ RSpec.describe Flipper::Cloud::Middleware do
   private
 
   def stub_request_for_token(token, status: 200)
-    stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
+    stub = stub_request(:get, %r{\Ahttps://www\.flippercloud\.io/adapter/features\?(?=.*\bexclude_gate_names=true\b)(?=.*\b_cb=\d+\b)}).
       with({
         headers: {
           'flipper-cloud-token' => token,

data/spec/flipper/cloud/migrate_spec.rb

@@ -0,0 +1,160 @@
+require "flipper/cloud/migrate"
+require "flipper/typecast"
+require "webmock/rspec"
+
+RSpec.describe Flipper::Cloud, ".migrate" do
+  let(:flipper) { Flipper.new(Flipper::Adapters::Memory.new) }
+
+  before do
+    flipper.enable :search
+    flipper.disable :analytics
+    flipper.enable_percentage_of_actors :checkout, 50
+  end
+
+  around do |example|
+    original = ENV["FLIPPER_CLOUD_URL"]
+    ENV["FLIPPER_CLOUD_URL"] = "http://localhost:5555"
+    example.run
+  ensure
+    ENV["FLIPPER_CLOUD_URL"] = original
+  end
+
+  def decompress_request_body
+    raw = WebMock::RequestRegistry.instance.requested_signatures.hash.keys.last.body
+    JSON.parse(Flipper::Typecast.from_gzip(raw))
+  end
+
+  describe ".migrate" do
+    it "returns a MigrateResult with code and url on success" do
+      stub_request(:post, "http://localhost:5555/api/migrate")
+        .to_return(status: 200, body: '{"url":"http://localhost:5555/cloud/setup/abc123"}', headers: {"Content-Type" => "application/json"})
+
+      result = Flipper::Cloud.migrate(flipper)
+
+      expect(result).to be_a(Flipper::Cloud::MigrateResult)
+      expect(result.code).to eq(200)
+      expect(result.url).to eq("http://localhost:5555/cloud/setup/abc123")
+    end
+
+    it "sends export data and metadata in the request body" do
+      stub = stub_request(:post, "http://localhost:5555/api/migrate")
+        .to_return(status: 200, body: '{"url":"http://localhost:5555/cloud/setup/abc123"}')
+
+      Flipper::Cloud.migrate(flipper, app_name: "MyApp")
+
+      expect(stub).to have_been_requested
+      body = decompress_request_body
+      expect(body["metadata"]["app_name"]).to eq("MyApp")
+      expect(body["export"]["version"]).to eq(1)
+      expect(body["export"]["features"]).to have_key("search")
+    end
+
+    it "sends gzip-compressed request body" do
+      stub = stub_request(:post, "http://localhost:5555/api/migrate")
+        .with(headers: {"content-encoding" => "gzip"})
+        .to_return(status: 200, body: '{"url":"http://localhost:5555/cloud/setup/abc"}')
+
+      Flipper::Cloud.migrate(flipper)
+
+      expect(stub).to have_been_requested
+      body = decompress_request_body
+      expect(body["export"]["features"]).to have_key("search")
+    end
+
+    it "handles error responses" do
+      stub_request(:post, "http://localhost:5555/api/migrate")
+        .to_return(status: 500, body: '{"error":"Internal Server Error"}')
+
+      result = Flipper::Cloud.migrate(flipper)
+
+      expect(result.code).to eq(500)
+      expect(result.url).to be_nil
+    end
+
+    it "includes error message from response body" do
+      stub_request(:post, "http://localhost:5555/api/migrate")
+        .to_return(status: 422, body: '{"error":"Invalid export format"}')
+
+      result = Flipper::Cloud.migrate(flipper)
+
+      expect(result.code).to eq(422)
+      expect(result.message).to eq("Invalid export format")
+    end
+
+    it "uses FLIPPER_CLOUD_URL environment variable" do
+      stub = stub_request(:post, "http://localhost:5555/api/migrate")
+        .to_return(status: 200, body: '{"url":"http://localhost:5555/cloud/setup/abc"}')
+
+      Flipper::Cloud.migrate(flipper)
+
+      expect(stub).to have_been_requested
+    end
+
+    it "sends content-type and accept headers" do
+      stub = stub_request(:post, "http://localhost:5555/api/migrate")
+        .with(headers: {
+          "content-type" => "application/json",
+          "accept" => "application/json",
+        })
+        .to_return(status: 200, body: '{"url":"http://localhost:5555/cloud/setup/abc"}')
+
+      Flipper::Cloud.migrate(flipper)
+
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe ".push" do
+    it "returns a MigrateResult with code on success" do
+      stub_request(:post, "http://localhost:5555/adapter/import")
+        .to_return(status: 204, body: "")
+
+      result = Flipper::Cloud.push("test-token", flipper)
+
+      expect(result).to be_a(Flipper::Cloud::MigrateResult)
+      expect(result.code).to eq(204)
+    end
+
+    it "sends the token as a header" do
+      stub = stub_request(:post, "http://localhost:5555/adapter/import")
+        .with(headers: {"flipper-cloud-token" => "test-token"})
+        .to_return(status: 204, body: "")
+
+      Flipper::Cloud.push("test-token", flipper)
+
+      expect(stub).to have_been_requested
+    end
+
+    it "sends gzip-compressed export contents as the body" do
+      stub = stub_request(:post, "http://localhost:5555/adapter/import")
+        .with(headers: {"content-encoding" => "gzip"})
+        .to_return(status: 204, body: "")
+
+      Flipper::Cloud.push("test-token", flipper)
+
+      expect(stub).to have_been_requested
+      body = decompress_request_body
+      expect(body["version"]).to eq(1)
+      expect(body["features"]).to have_key("search")
+    end
+
+    it "handles error responses" do
+      stub_request(:post, "http://localhost:5555/adapter/import")
+        .to_return(status: 401, body: '{"error":"Unauthorized"}')
+
+      result = Flipper::Cloud.push("bad-token", flipper)
+
+      expect(result.code).to eq(401)
+    end
+
+    it "includes error message from response body" do
+      stub_request(:post, "http://localhost:5555/adapter/import")
+        .to_return(status: 401, body: '{"error":"Invalid token"}')
+
+      result = Flipper::Cloud.push("bad-token", flipper)
+
+      expect(result.code).to eq(401)
+      expect(result.message).to eq("Invalid token")
+    end
+  end
+end

data/spec/flipper/cloud/telemetry_spec.rb

@@ -122,7 +122,7 @@ RSpec.describe Flipper::Cloud::Telemetry do
     # Check the conig interval and the timer interval.
     expect(telemetry.interval).to eq(120)
     expect(telemetry.timer.execution_interval).to eq(120)
-    expect(stub).to have_been_requested.times(5)
+    expect(stub).to have_been_requested.at_least_times(5)
   end
 
   it "doesn't try to update telemetry interval from error if not response error" do

data/spec/flipper/engine_spec.rb

@@ -263,10 +263,10 @@ RSpec.describe Flipper::Engine do
         Flipper::Cloud::MessageVerifier.new(secret: "").header(signature, timestamp)
       }
 
-      it "configures webhook app" do
+      it "configures webhook app and uses cache busting" do
         silence { application.initialize! }
 
-        stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").with({
+        stub = stub_request(:get, /https:\/\/www\.flippercloud\.io\/adapter\/features\?_cb=\d+&exclude_gate_names=true/).with({
           headers: { "flipper-cloud-token" => ENV["FLIPPER_CLOUD_TOKEN"] },
         }).to_return(status: 200, body: JSON.generate({ features: {} }), headers: {})
 

data/spec/flipper/expressions/time_spec.rb

@@ -9,5 +9,21 @@ RSpec.describe Flipper::Expressions::Time do
     it "returns time for #iso8601 format" do
       expect(described_class.call(time.iso8601)).to eq(time)
     end
+
+    it "returns time for epoch integer" do
+      expect(described_class.call(time.to_i)).to eq(Time.at(time.to_i).utc)
+    end
+
+    it "returns time for epoch float" do
+      expect(described_class.call(time.to_f)).to be_within(0.001).of(time)
+    end
+
+    it "returns utc for string input" do
+      expect(described_class.call(time.to_s).utc?).to be(true)
+    end
+
+    it "returns utc for numeric input" do
+      expect(described_class.call(time.to_i).utc?).to be(true)
+    end
   end
 end

data/spec/flipper/gates/expression_spec.rb

@@ -62,6 +62,30 @@ RSpec.describe Flipper::Gates::Expression do
       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")
@@ -75,6 +99,64 @@ RSpec.describe Flipper::Gates::Expression do
         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

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
@@ -470,18 +472,47 @@ RSpec.describe Flipper::Middleware::Memoizer do
 
       get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(1)
-      expect(logged_memory.count(:features)).to be(1)
-      expect(logged_memory.count(:get_multi)).to be(1)
+      expect(logged_memory.count(:get_all)).to be(1)
 
       get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(2)
-      expect(logged_memory.count(:features)).to be(1)
-      expect(logged_memory.count(:get_multi)).to be(1)
+      expect(logged_memory.count(:get_all)).to be(1)
 
       get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(3)
-      expect(logged_memory.count(:features)).to be(1)
-      expect(logged_memory.count(:get_multi)).to be(1)
+      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