flipper 0.16.0 → 1.4.0

data/spec/flipper/poller_spec.rb

@@ -0,0 +1,390 @@
+require "flipper/poller"
+require "flipper/adapters/http"
+
+RSpec.describe Flipper::Poller do
+  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: 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
+  end
+
+  describe "#adapter" do
+    it "always returns same memory adapter instance" do
+      expect(subject.adapter).to be_a(Flipper::Adapters::Memory)
+      expect(subject.adapter.object_id).to eq(subject.adapter.object_id)
+    end
+  end
+
+  describe "#sync" do
+    it "syncs remote adapter to local adapter" 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 }
+              ]
+            }
+          ]
+        ))
+
+      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
+    it "starts the poller thread" do
+      expect(Thread).to receive(:new).and_yield
+      expect(subject).to receive(:loop).and_yield
+      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

data/spec/flipper/registry_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/registry'
 
 RSpec.describe Flipper::Registry do

data/spec/flipper/serializers/gzip_spec.rb

@@ -0,0 +1,13 @@
+require 'flipper/serializers/gzip'
+
+RSpec.describe Flipper::Serializers::Gzip do
+  it "serializes and deserializes" do
+    serialized = described_class.serialize("my data")
+    expect(described_class.deserialize(serialized)).to eq("my data")
+  end
+
+  it "doesn't fail with nil" do
+    expect(described_class.serialize(nil)).to be(nil)
+    expect(described_class.deserialize(nil)).to be(nil)
+  end
+end

data/spec/flipper/serializers/json_spec.rb

@@ -0,0 +1,13 @@
+require 'flipper/serializers/json'
+
+RSpec.describe Flipper::Serializers::Json do
+  it "serializes and deserializes" do
+    serialized = described_class.serialize("my data")
+    expect(described_class.deserialize(serialized)).to eq("my data")
+  end
+
+  it "doesn't fail with nil" do
+    expect(described_class.serialize(nil)).to be(nil)
+    expect(described_class.deserialize(nil)).to be(nil)
+  end
+end

data/spec/flipper/typecast_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/typecast'
 
 RSpec.describe Flipper::Typecast do
@@ -66,9 +65,9 @@ RSpec.describe Flipper::Typecast do
     '99' => 99,
     '99.9' => 99.9,
   }.each do |value, expected|
-    context "#to_percentage for #{value.inspect}" do
+    context "#to_number for #{value.inspect}" do
       it "returns #{expected}" do
-        expect(described_class.to_percentage(value)).to be(expected)
+        expect(described_class.to_number(value)).to be(expected)
       end
     end
   end
@@ -100,14 +99,14 @@ RSpec.describe Flipper::Typecast do
 
   it 'raises argument error for bad integer percentage' do
     expect do
-      described_class.to_percentage(['asdf'])
-    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to an integer))
+      described_class.to_number(['asdf'])
+    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to a number))
   end
 
   it 'raises argument error for bad float percentage' do
     expect do
-      described_class.to_percentage(['asdf.0'])
-    end.to raise_error(ArgumentError, %(["asdf.0"] cannot be converted to a float))
+      described_class.to_number(['asdf.0'])
+    end.to raise_error(ArgumentError, %(["asdf.0"] cannot be converted to a number))
   end
 
   it 'raises argument error for set value that cannot be converted to a set' do
@@ -115,4 +114,119 @@ RSpec.describe Flipper::Typecast do
       described_class.to_set('asdf')
     end.to raise_error(ArgumentError, %("asdf" cannot be converted to a set))
   end
+
+  describe "#features_hash" do
+    it "returns new hash" do
+      hash = {
+        "search" => {
+          boolean: nil,
+        }
+      }
+      result = described_class.features_hash(hash)
+      expect(result).not_to be(hash)
+      expect(result["search"]).not_to be(hash["search"])
+    end
+
+    it "converts does not convert expressions" do
+      hash = {
+        "search" => {
+          boolean: nil,
+          expression: {"Equal"=>[{"Property"=>["plan"]}, "basic"]},
+          groups: ['a', 'b'],
+          actors: ['User;1'],
+          percentage_of_actors: nil,
+          percentage_of_time: nil,
+        },
+      }
+      result = described_class.features_hash(hash)
+      expect(result).to eq({
+        "search" => {
+          boolean: nil,
+          expression: {"Equal"=>[{"Property"=>["plan"]}, "basic"]},
+          groups: Set['a', 'b'],
+          actors: Set['User;1'],
+          percentage_of_actors: nil,
+          percentage_of_time: nil,
+        },
+      })
+    end
+
+    it "converts gate value arrays to sets" do
+      hash = {
+        "search" => {
+          boolean: nil,
+          groups: ['a', 'b'],
+          actors: ['User;1'],
+          percentage_of_actors: nil,
+          percentage_of_time: nil,
+        },
+      }
+      result = described_class.features_hash(hash)
+      expect(result).to eq({
+        "search" => {
+          boolean: nil,
+          groups: Set['a', 'b'],
+          actors: Set['User;1'],
+          percentage_of_actors: nil,
+          percentage_of_time: nil,
+        },
+      })
+    end
+
+    it "converts gate value boolean and integers to strings" do
+      hash = {
+        "search" => {
+          boolean: true,
+          groups: Set.new,
+          actors: Set.new,
+          percentage_of_actors: 10,
+          percentage_of_time: 15,
+        },
+      }
+      result = described_class.features_hash(hash)
+      expect(result).to eq({
+        "search" => {
+          boolean: "true",
+          groups: Set.new,
+          actors: Set.new,
+          percentage_of_actors: "10",
+          percentage_of_time: "15",
+        },
+      })
+    end
+
+    it "converts string gate keys to symbols" do
+      hash = {
+        "search" => {
+          "boolean" => nil,
+          "groups" => Set.new,
+          "actors" => Set.new,
+          "percentage_of_actors" => nil,
+          "percentage_of_time" => nil,
+        },
+      }
+      result = described_class.features_hash(hash)
+      expect(result).to eq({
+        "search" => {
+          boolean: nil,
+          groups: Set.new,
+          actors: Set.new,
+          percentage_of_actors: nil,
+          percentage_of_time: nil,
+        },
+      })
+    end
+  end
+
+  it "converts to and from json" do
+    source = {"foo" => "bar"}
+    output = described_class.to_json(source)
+    expect(described_class.from_json(output)).to eq(source)
+  end
+
+  it "converts to and from gzip" do
+    source = "foo bar"
+    output = described_class.to_gzip(source)
+    expect(described_class.from_gzip(output)).to eq(source)
+  end
 end