flipper 1.3.5 → 1.4.1

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

data/spec/flipper/poller_spec.rb

@@ -1,19 +1,23 @@
 require "flipper/poller"
+require "flipper/adapters/http"
 
 RSpec.describe Flipper::Poller do
-  let(:remote_adapter) { Flipper::Adapters::Memory.new }
-  let(:remote) { Flipper.new(remote_adapter) }
+  let(:url) { "http://app.com/flipper" }
+  let(:remote_adapter) { Flipper::Adapters::Http.new(url: url) }
   let(:local) { Flipper.new(subject.adapter) }
 
   subject do
     described_class.new(
       remote_adapter: remote_adapter,
       start_automatically: false,
-      interval: Float::INFINITY
+      interval: 3600 # 1 hour
     )
   end
 
   before do
+    stub_request(:get, "#{url}/features?exclude_gate_names=true")
+      .to_return(status: 200, body: JSON.generate(features: []))
+
     allow(subject).to receive(:loop).and_yield # Make loop just call once
     allow(subject).to receive(:sleep)          # Disable sleep
     allow(Thread).to receive(:new).and_yield   # Disable separate thread
@@ -28,12 +32,320 @@ RSpec.describe Flipper::Poller do
 
   describe "#sync" do
     it "syncs remote adapter to local adapter" do
-      remote.enable :polling
+      stub_request(:get, "#{url}/features?exclude_gate_names=true")
+        .to_return(status: 200, body: JSON.generate(
+          features: [
+            {
+              key: "polling",
+              gates: [
+                { key: "boolean", value: true }
+              ]
+            }
+          ]
+        ))
 
       expect(local.enabled?(:polling)).to be(false)
       subject.sync
       expect(local.enabled?(:polling)).to be(true)
     end
+
+    context "when poll-shutdown header is present" do
+      before do
+        stub_request(:get, "#{url}/features?exclude_gate_names=true")
+          .to_return(
+            status: 200,
+            body: JSON.generate(
+              features: [
+                {
+                  key: "polling",
+                  gates: [
+                    { key: "boolean", value: true }
+                  ]
+                }
+              ]
+            ),
+            headers: { "poll-shutdown" => "true" }
+          )
+      end
+
+      it "stops the poller when poll-shutdown header is true" do
+        expect(subject).to receive(:stop).and_call_original
+        subject.sync
+      end
+
+      it "prevents poller from restarting after shutdown" do
+        subject.sync # This should trigger shutdown
+
+        # Try to start again - should be a no-op
+        expect(Thread).not_to receive(:new)
+        subject.start
+      end
+
+      it "instruments the shutdown_requested event" do
+        instrumenter = subject.instance_variable_get(:@instrumenter)
+
+        expect(instrumenter).to receive(:instrument).with(
+          "poller.#{Flipper::InstrumentationNamespace}",
+          { operation: :poll }
+        ).and_call_original
+
+        expect(instrumenter).to receive(:instrument).with(
+          "poller.#{Flipper::InstrumentationNamespace}",
+          { operation: :shutdown_requested }
+        ).and_call_original
+
+        expect(instrumenter).to receive(:instrument).with(
+          "poller.#{Flipper::InstrumentationNamespace}",
+          { operation: :stop }
+        )
+
+        subject.sync
+      end
+    end
+
+    context "when poll-shutdown header is present on error response" do
+      before do
+        stub_request(:get, "#{url}/features?exclude_gate_names=true")
+          .to_return(
+            status: 404,
+            body: JSON.generate({ error: "Not found" }),
+            headers: { "poll-shutdown" => "true" }
+          )
+      end
+
+      it "stops polling even when sync fails with error response" do
+        # sync will raise an error, but should still check shutdown header
+        expect { subject.sync }.to raise_error(Flipper::Adapters::Http::Error)
+
+        # Verify shutdown was triggered
+        expect(Thread).not_to receive(:new)
+        subject.start
+      end
+    end
+
+    context "when poll-shutdown header is false" do
+      before do
+        stub_request(:get, "#{url}/features?exclude_gate_names=true")
+          .to_return(
+            status: 200,
+            body: JSON.generate(
+              features: [
+                {
+                  key: "polling",
+                  gates: [
+                    { key: "boolean", value: true }
+                  ]
+                }
+              ]
+            ),
+            headers: { "poll-shutdown" => "false" }
+          )
+      end
+
+      it "does not stop the poller" do
+        expect(subject).not_to receive(:stop)
+        subject.sync
+      end
+    end
+
+    context "when poll-shutdown header is missing" do
+      before do
+        stub_request(:get, "#{url}/features?exclude_gate_names=true")
+          .to_return(
+            status: 200,
+            body: JSON.generate(
+              features: [
+                {
+                  key: "polling",
+                  gates: [
+                    { key: "boolean", value: true }
+                  ]
+                }
+              ]
+            )
+          )
+      end
+
+      it "does not stop the poller" do
+        expect(subject).not_to receive(:stop)
+        subject.sync
+      end
+    end
+
+    context "when poll-interval header is lower than initial interval" do
+      before do
+        stub_request(:get, "#{url}/features?exclude_gate_names=true")
+          .to_return(
+            status: 200,
+            body: JSON.generate(
+              features: [
+                {
+                  key: "polling",
+                  gates: [
+                    { key: "boolean", value: true }
+                  ]
+                }
+              ]
+            ),
+            headers: { "poll-interval" => "30" }
+          )
+      end
+
+      it "uses the initial interval as minimum" do
+        expect(subject.interval).to eq(3600.0)
+        subject.sync
+        expect(subject.interval).to eq(3600.0) # Keeps 3600 because it's the initial interval
+      end
+    end
+
+    context "when poll-interval header is below minimum" do
+      subject do
+        described_class.new(
+          remote_adapter: remote_adapter,
+          start_automatically: false,
+          interval: 10 # Set initial to minimum
+        )
+      end
+
+      before do
+        stub_request(:get, "#{url}/features?exclude_gate_names=true")
+          .to_return(
+            status: 200,
+            body: JSON.generate(
+              features: [
+                {
+                  key: "polling",
+                  gates: [
+                    { key: "boolean", value: true }
+                  ]
+                }
+              ]
+            ),
+            headers: { "poll-interval" => "5" }
+          )
+      end
+
+      it "enforces minimum poll interval" do
+        expect(subject.interval).to eq(10.0)
+        subject.sync
+        # Header says 5, minimum is 10, initial is 10, so max(5->10, 10) = 10
+        expect(subject.interval).to eq(Flipper::Poller::MINIMUM_POLL_INTERVAL)
+      end
+    end
+
+    context "when poll-interval header is higher than initial interval" do
+      subject do
+        described_class.new(
+          remote_adapter: remote_adapter,
+          start_automatically: false,
+          interval: 20
+        )
+      end
+
+      before do
+        stub_request(:get, "#{url}/features?exclude_gate_names=true")
+          .to_return(
+            status: 200,
+            body: JSON.generate(
+              features: [
+                {
+                  key: "polling",
+                  gates: [
+                    { key: "boolean", value: true }
+                  ]
+                }
+              ]
+            ),
+            headers: { "poll-interval" => "60" }
+          )
+      end
+
+      it "updates to the higher interval from header" do
+        expect(subject.interval).to eq(20.0)
+        subject.sync
+        expect(subject.interval).to eq(60.0) # Uses 60 because it's higher than initial 20
+      end
+    end
+
+    context "when poll-interval header can decrease back to initial interval" do
+      subject do
+        described_class.new(
+          remote_adapter: remote_adapter,
+          start_automatically: false,
+          interval: 10
+        )
+      end
+
+      before do
+        # First sync increases interval to 60
+        stub_request(:get, "#{url}/features?exclude_gate_names=true")
+          .to_return(
+            status: 200,
+            body: JSON.generate(
+              features: [
+                {
+                  key: "polling",
+                  gates: [
+                    { key: "boolean", value: true }
+                  ]
+                }
+              ]
+            ),
+            headers: { "poll-interval" => "60" }
+          ).times(1).then
+          .to_return(
+            status: 200,
+            body: JSON.generate(
+              features: [
+                {
+                  key: "polling",
+                  gates: [
+                    { key: "boolean", value: true }
+                  ]
+                }
+              ]
+            ),
+            headers: { "poll-interval" => "10" }
+          )
+      end
+
+      it "allows interval to go back down to initial after being increased" do
+        expect(subject.interval).to eq(10.0)
+
+        # First sync: header says 60, initial is 10, so use 60
+        subject.sync
+        expect(subject.interval).to eq(60.0)
+
+        # Second sync: header says 10, initial is 10, so use 10
+        subject.sync
+        expect(subject.interval).to eq(10.0)
+      end
+    end
+
+    context "when poll-interval header is missing" do
+      before do
+        stub_request(:get, "#{url}/features?exclude_gate_names=true")
+          .to_return(
+            status: 200,
+            body: JSON.generate(
+              features: [
+                {
+                  key: "polling",
+                  gates: [
+                    { key: "boolean", value: true }
+                  ]
+                }
+              ]
+            )
+          )
+      end
+
+      it "does not change the interval" do
+        original_interval = subject.interval
+        subject.sync
+        expect(subject.interval).to eq(original_interval)
+      end
+    end
   end
 
   describe "#start" do
@@ -43,5 +355,36 @@ RSpec.describe Flipper::Poller do
       expect(subject).to receive(:sync)
       subject.start
     end
+
+    context "after shutdown_requested" do
+      before do
+        stub_request(:get, "#{url}/features?exclude_gate_names=true")
+          .to_return(
+            status: 200,
+            body: JSON.generate(features: []),
+            headers: { "poll-shutdown" => "true" }
+          )
+      end
+
+      it "does not start when shutdown was requested" do
+        subject.sync # This triggers shutdown
+
+        expect(Thread).not_to receive(:new)
+        subject.start
+      end
+
+      it "allows starting after a fork" do
+        subject.sync # This triggers shutdown
+
+        # Simulate fork by changing PID
+        allow(Process).to receive(:pid).and_return(subject.instance_variable_get(:@pid) + 1)
+
+        # After fork, start should work again
+        expect(Thread).to receive(:new).and_yield
+        expect(subject).to receive(:loop).and_yield
+        expect(subject).to receive(:sync)
+        subject.start
+      end
+    end
   end
 end