flipper 0.16.0 → 1.4.0

data/spec/flipper/adapters/http_spec.rb

@@ -1,120 +1,455 @@
-require 'helper'
 require 'flipper/adapters/http'
 require 'flipper/adapters/pstore'
-require 'flipper/spec/shared_adapter_specs'
-require 'rack/handler/webrick'
+
+rack_handler = begin
+  # Rack 3+
+  require 'rackup/handler/webrick'
+  Rackup::Handler::WEBrick
+rescue LoadError
+  require 'rack/handler/webrick'
+  Rack::Handler::WEBrick
+end
+
 
 FLIPPER_SPEC_API_PORT = ENV.fetch('FLIPPER_SPEC_API_PORT', 9001).to_i
 
 RSpec.describe Flipper::Adapters::Http do
-  context 'adapter' do
-    subject do
-      described_class.new(url: "http://localhost:#{FLIPPER_SPEC_API_PORT}")
-    end
-
-    before :all do
-      dir = FlipperRoot.join('tmp').tap(&:mkpath)
-      log_path = dir.join('flipper_adapters_http_spec.log')
-      @pstore_file = dir.join('flipper.pstore')
-      @pstore_file.unlink if @pstore_file.exist?
-
-      api_adapter = Flipper::Adapters::PStore.new(@pstore_file)
-      flipper_api = Flipper.new(api_adapter)
-      app = Flipper::Api.app(flipper_api)
-      server_options = {
-        Port: FLIPPER_SPEC_API_PORT,
-        StartCallback: -> { @started = true },
-        Logger: WEBrick::Log.new(log_path.to_s, WEBrick::Log::INFO),
-        AccessLog: [
-          [log_path.open('w'), WEBrick::AccessLog::COMBINED_LOG_FORMAT],
-        ],
-      }
-      @server = WEBrick::HTTPServer.new(server_options)
-      @server.mount '/', Rack::Handler::WEBrick, app
+  default_options = {
+    url: "http://localhost:#{FLIPPER_SPEC_API_PORT}",
+  }
 
-      Thread.new { @server.start }
-      Timeout.timeout(1) { :wait until @started }
-    end
+  {
+    basic: default_options.dup,
+    gzip: default_options.dup.merge(headers: { 'accept-encoding': 'gzip' }),
+  }.each do |name, options|
+    context "adapter (#{name} #{options.inspect})" do
+      subject do
+        described_class.new(options)
+      end
 
-    after :all do
-      @server.shutdown if @server
-    end
+      before :all do
+        @started = false
+        dir = FlipperRoot.join('tmp').tap(&:mkpath)
+        log_path = dir.join('flipper_adapters_http_spec.log')
+        @pstore_file = dir.join('flipper.pstore')
+        @pstore_file.unlink if @pstore_file.exist?
 
-    before(:each) do
-      @pstore_file.unlink if @pstore_file.exist?
-    end
+        api_adapter = Flipper::Adapters::PStore.new(@pstore_file)
+        flipper_api = Flipper.new(api_adapter)
+        app = Flipper::Api.app(flipper_api)
+        server_options = {
+          Port: FLIPPER_SPEC_API_PORT,
+          StartCallback: -> { @started = true },
+          Logger: WEBrick::Log.new(log_path.to_s, WEBrick::Log::INFO),
+          AccessLog: [
+            [log_path.open('w'), WEBrick::AccessLog::COMBINED_LOG_FORMAT],
+          ],
+        }
+        @server = WEBrick::HTTPServer.new(server_options)
+        @server.mount '/', rack_handler, app
+
+        Thread.new { @server.start }
+        Timeout.timeout(1) { :wait until @started }
+      end
 
-    it_should_behave_like 'a flipper adapter'
+      after :all do
+        @server.shutdown if @server
+      end
 
-    it "can enable and disable unregistered group" do
-      flipper = Flipper.new(subject)
-      expect(flipper[:search].enable_group(:some_made_up_group)).to be(true)
-      expect(flipper[:search].groups_value).to eq(Set["some_made_up_group"])
+      before(:each) do
+        @pstore_file.unlink if @pstore_file.exist?
+      end
 
-      expect(flipper[:search].disable_group(:some_made_up_group)).to be(true)
-      expect(flipper[:search].groups_value).to eq(Set.new)
+      it_should_behave_like 'a flipper adapter'
+
+      it "can enable and disable unregistered group" do
+        flipper = Flipper.new(subject)
+        expect(flipper[:search].enable_group(:some_made_up_group)).to be(true)
+        expect(flipper[:search].groups_value).to eq(Set["some_made_up_group"])
+
+        expect(flipper[:search].disable_group(:some_made_up_group)).to be(true)
+        expect(flipper[:search].groups_value).to eq(Set.new)
+      end
+
+      it "can import" do
+        adapter = Flipper::Adapters::Memory.new
+        source_flipper = Flipper.new(adapter)
+        source_flipper.enable_percentage_of_actors :search, 10
+        source_flipper.enable_percentage_of_time :search, 15
+        source_flipper.enable_actor :search, Flipper::Actor.new('User;1')
+        source_flipper.enable_actor :search, Flipper::Actor.new('User;100')
+        source_flipper.enable_group :search, :admins
+        source_flipper.enable_group :search, :employees
+        source_flipper.enable :plausible
+        source_flipper.disable :google_analytics
+
+        flipper = Flipper.new(subject)
+        flipper.import(source_flipper)
+        expect(flipper[:search].percentage_of_actors_value).to be(10)
+        expect(flipper[:search].percentage_of_time_value).to be(15)
+        expect(flipper[:search].actors_value).to eq(Set["User;1", "User;100"])
+        expect(flipper[:search].groups_value).to eq(Set["admins", "employees"])
+        expect(flipper[:plausible].boolean_value).to be(true)
+        expect(flipper[:google_analytics].boolean_value).to be(false)
+      end
     end
   end
 
   it "sends default headers" do
     headers = {
-      'Accept' => 'application/json',
-      'Content-Type' => 'application/json',
-      'User-Agent' => "Flipper HTTP Adapter v#{Flipper::VERSION}",
+      'accept' => 'application/json',
+      'content-type' => 'application/json',
+      'user-agent' => "Flipper HTTP Adapter v#{Flipper::VERSION}",
+    }
+    stub_request(:get, "http://app.com/flipper/features/feature_panel")
+      .with(headers: headers)
+      .to_return(status: 404)
+
+    adapter = described_class.new(url: 'http://app.com/flipper')
+    adapter.get(flipper[:feature_panel])
+  end
+
+  it "sends framework versions" do
+    stub_const("Rails", double(version: "7.1.0"))
+    stub_const("Sinatra::VERSION", "3.1.0")
+    stub_const("Hanami::VERSION", "0.7.2")
+    stub_const("GoodJob::VERSION", "3.21.5")
+    stub_const("Sidekiq::VERSION", "7.2.0")
+
+    headers = {
+      "client-framework" => [
+        "rails=7.1.0",
+        "sinatra=3.1.0",
+        "hanami=0.7.2",
+        "good_job=3.21.5",
+        "sidekiq=7.2.0",
+      ]
     }
+
     stub_request(:get, "http://app.com/flipper/features/feature_panel")
       .with(headers: headers)
-      .to_return(status: 404, body: "", headers: {})
+      .to_return(status: 404)
 
     adapter = described_class.new(url: 'http://app.com/flipper')
     adapter.get(flipper[:feature_panel])
   end
 
+  it "does not send undefined framework versions" do
+    stub_const("Rails", double(version: "7.1.0"))
+    stub_const("Sinatra::VERSION", "3.1.0")
+
+    headers = {
+      "client-framework" => ["rails=7.1.0", "sinatra=3.1.0"]
+    }
+
+    stub_request(:get, "http://app.com/flipper/features/feature_panel")
+      .with(headers: headers)
+      .to_return(status: 404)
+
+    adapter = described_class.new(url: 'http://app.com/flipper')
+    adapter.get(flipper[:feature_panel])
+  end
+
+
   describe "#get" do
     it "raises error when not successful response" do
       stub_request(:get, "http://app.com/flipper/features/feature_panel")
-        .to_return(status: 503, body: "", headers: {})
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
-      expect do
+      expect {
         adapter.get(flipper[:feature_panel])
-      end.to raise_error(Flipper::Adapters::Http::Error)
+      }.to raise_error(Flipper::Adapters::Http::Error)
     end
   end
 
   describe "#get_multi" do
     it "raises error when not successful response" do
-      stub_request(:get, "http://app.com/flipper/features?keys=feature_panel")
-        .to_return(status: 503, body: "", headers: {})
+      stub_request(:get, "http://app.com/flipper/features?keys=feature_panel&exclude_gate_names=true")
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
-      expect do
+      expect {
         adapter.get_multi([flipper[:feature_panel]])
-      end.to raise_error(Flipper::Adapters::Http::Error)
+      }.to raise_error(Flipper::Adapters::Http::Error)
     end
   end
 
   describe "#get_all" do
     it "raises error when not successful response" do
-      stub_request(:get, "http://app.com/flipper/features")
-        .to_return(status: 503, body: "", headers: {})
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
-      expect do
+      expect {
         adapter.get_all
-      end.to raise_error(Flipper::Adapters::Http::Error)
+      }.to raise_error(Flipper::Adapters::Http::Error)
+    end
+
+    it "stores ETag and sends If-None-Match on subsequent requests" do
+      features_response = {
+        "features" => [
+          {
+            "key" => "search",
+            "gates" => [
+              {"key" => "boolean", "value" => true}
+            ]
+          }
+        ]
+      }
+
+      # First request - server returns ETag
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(
+          status: 200,
+          body: JSON.generate(features_response),
+          headers: { 'ETag' => '"abc123"' }
+        )
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      result = adapter.get_all
+
+      expect(result).to have_key("search")
+
+      # Second request - should send If-None-Match header
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .with(headers: { 'If-None-Match' => '"abc123"' })
+        .to_return(
+          status: 200,
+          body: JSON.generate(features_response),
+          headers: { 'ETag' => '"abc123"' }
+        )
+
+      etag_result = adapter.get_all
+
+      expect(etag_result).to eq(result)
+      expect(etag_result).to have_key("search")
+      expect(
+        a_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .with(headers: { 'If-None-Match' => '"abc123"' })
+      ).to have_been_made.once
+    end
+
+    it "returns cached result when server returns 304 Not Modified" do
+      features_response = {
+        "features" => [
+          {
+            "key" => "search",
+            "gates" => [
+              {"key" => "boolean", "value" => true}
+            ]
+          }
+        ]
+      }
+
+      # First request - server returns ETag
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(
+          status: 200,
+          body: JSON.generate(features_response),
+          headers: { 'ETag' => '"abc123"' }
+        )
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      first_result = adapter.get_all
+
+      expect(first_result).to have_key("search")
+
+      # Second request - server returns 304
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .with(headers: { 'If-None-Match' => '"abc123"' })
+        .to_return(status: 304, headers: { 'ETag' => '"abc123"' })
+
+      second_result = adapter.get_all
+
+      # Should return the cached result
+      expect(second_result).to eq(first_result)
+      expect(second_result).to have_key("search")
+    end
+
+    it "raises error when 304 received without cached result" do
+      # Server returns 304 without any prior request
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(status: 304)
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      expect {
+        adapter.get_all
+      }.to raise_error(Flipper::Adapters::Http::Error)
+    end
+
+    it "does not send If-None-Match for other endpoints" do
+      stub_request(:get, "http://app.com/flipper/features/search")
+        .to_return(status: 404)
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      adapter.get(flipper[:search])
+
+      # Verify no If-None-Match header was sent
+      expect(
+        a_request(:get, "http://app.com/flipper/features/search")
+        .with { |req| req.headers['If-None-Match'].nil? }
+      ).to have_been_made.once
+    end
+
+    it "stores last get_all response for poll-shutdown header checking" do
+      features_response = {
+        "features" => [
+          {
+            "key" => "search",
+            "gates" => [
+              {"key" => "boolean", "value" => true}
+            ]
+          }
+        ]
+      }
+
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(
+          status: 200,
+          body: JSON.generate(features_response),
+          headers: { 'poll-shutdown' => 'true' }
+        )
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      adapter.get_all
+
+      expect(adapter.last_get_all_response).not_to be_nil
+      expect(adapter.last_get_all_response['poll-shutdown']).to eq('true')
+    end
+
+    it "stores last get_all response even for error responses" do
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(
+          status: 404,
+          body: JSON.generate({ error: "Not found" }),
+          headers: { 'poll-shutdown' => 'true' }
+        )
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+
+      expect {
+        adapter.get_all
+      }.to raise_error(Flipper::Adapters::Http::Error)
+
+      # Even though it raised an error, response should be stored
+      expect(adapter.last_get_all_response).not_to be_nil
+      expect(adapter.last_get_all_response['poll-shutdown']).to eq('true')
     end
   end
 
   describe "#features" do
     it "raises error when not successful response" do
-      stub_request(:get, "http://app.com/flipper/features")
-        .to_return(status: 503, body: "", headers: {})
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
-      expect do
+      expect {
         adapter.features
-      end.to raise_error(Flipper::Adapters::Http::Error)
+      }.to raise_error(Flipper::Adapters::Http::Error)
+    end
+  end
+
+  describe "#add" do
+    it "raises error when not successful" do
+      stub_request(:post, /app.com/)
+        .to_return(status: 503, body: "{}", headers: {})
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      expect {
+        adapter.add(Flipper::Feature.new(:search, adapter))
+      }.to raise_error(Flipper::Adapters::Http::Error)
+    end
+  end
+
+  describe "#remove" do
+    it "raises error when not successful" do
+      stub_request(:delete, /app.com/)
+        .to_return(status: 503, body: "{}", headers: {})
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      expect {
+        adapter.remove(Flipper::Feature.new(:search, adapter))
+      }.to raise_error(Flipper::Adapters::Http::Error)
+    end
+  end
+
+  describe "#clear" do
+    it "raises error when not successful" do
+      stub_request(:delete, /app.com/)
+        .to_return(status: 503, body: "{}", headers: {})
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      expect {
+        adapter.clear(Flipper::Feature.new(:search, adapter))
+      }.to raise_error(Flipper::Adapters::Http::Error)
+    end
+  end
+
+  describe "#enable" do
+    it "raises error when not successful" do
+      stub_request(:post, /app.com/)
+        .to_return(status: 503, body: "{}", headers: {})
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      feature = Flipper::Feature.new(:search, adapter)
+      gate = feature.gate(:boolean)
+      thing = gate.wrap(true)
+      expect {
+        adapter.enable(feature, gate, thing)
+      }.to raise_error(Flipper::Adapters::Http::Error, "Failed with status: 503")
+    end
+
+    it "doesn't raise json error if body cannot be parsed" do
+      stub_request(:post, /app.com/)
+        .to_return(status: 503, body: "barf", headers: {})
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      feature = Flipper::Feature.new(:search, adapter)
+      gate = feature.gate(:boolean)
+      thing = gate.wrap(true)
+      expect {
+        adapter.enable(feature, gate, thing)
+      }.to raise_error(Flipper::Adapters::Http::Error)
+    end
+
+    it "includes response information if available when raising error" do
+      api_response = {
+        "code" => "error",
+        "message" => "This feature has reached the limit to the number of " +
+                     "actors per feature. Check out groups as a more flexible " +
+                     "way to enable many actors.",
+        "more_info" => "https://www.flippercloud.io/docs",
+      }
+      stub_request(:post, /app.com/)
+        .to_return(status: 503, body: JSON.dump(api_response), headers: {})
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      feature = Flipper::Feature.new(:search, adapter)
+      gate = feature.gate(:boolean)
+      thing = gate.wrap(true)
+      error_message = "Failed with status: 503\n\nThis feature has reached the " +
+                      "limit to the number of actors per feature. Check out " +
+                      "groups as a more flexible way to enable many actors.\n" +
+                      "https://www.flippercloud.io/docs"
+      expect {
+        adapter.enable(feature, gate, thing)
+      }.to raise_error(Flipper::Adapters::Http::Error, error_message)
+    end
+  end
+
+  describe "#disable" do
+    it "raises error when not successful" do
+      stub_request(:delete, /app.com/)
+        .to_return(status: 503, body: "{}", headers: {})
+
+      adapter = described_class.new(url: 'http://app.com/flipper')
+      feature = Flipper::Feature.new(:search, adapter)
+      gate = feature.gate(:boolean)
+      thing = gate.wrap(false)
+      expect {
+        adapter.disable(feature, gate, thing)
+      }.to raise_error(Flipper::Adapters::Http::Error)
     end
   end
 
@@ -123,11 +458,12 @@ RSpec.describe Flipper::Adapters::Http do
     let(:options) do
       {
         url: 'http://app.com/mount-point',
-        headers: { 'X-Custom-Header' => 'foo' },
+        headers: { 'x-custom-header' => 'foo' },
         basic_auth_username: 'username',
         basic_auth_password: 'password',
         read_timeout: 100,
         open_timeout: 40,
+        write_timeout: 40,
         debug_output: debug_output,
       }
     end
@@ -135,14 +471,15 @@ RSpec.describe Flipper::Adapters::Http do
     let(:feature) { flipper[:feature_panel] }
 
     before do
-      stub_request(:get, %r{\Ahttp://app.com*}).to_return(body: fixture_file('feature.json'))
+      stub_request(:get, %r{\Ahttp://app.com*}).
+        to_return(body: fixture_file('feature.json'))
     end
 
     it 'allows client to set request headers' do
       subject.get(feature)
       expect(
         a_request(:get, 'http://app.com/mount-point/features/feature_panel')
-        .with(headers: { 'X-Custom-Header' => 'foo' })
+        .with(headers: { 'x-custom-header' => 'foo' })
       ).to have_been_made.once
     end
 

data/spec/flipper/adapters/instrumented_spec.rb

@@ -1,7 +1,5 @@
-require 'helper'
 require 'flipper/adapters/instrumented'
 require 'flipper/instrumenters/memory'
-require 'flipper/spec/shared_adapter_specs'
 
 RSpec.describe Flipper::Adapters::Instrumented do
   let(:instrumenter) { Flipper::Instrumenters::Memory.new }
@@ -10,7 +8,7 @@ RSpec.describe Flipper::Adapters::Instrumented do
 
   let(:feature) { flipper[:stats] }
   let(:gate) { feature.gate(:percentage_of_actors) }
-  let(:thing) { flipper.actors(22) }
+  let(:thing) { Flipper::Types::PercentageOfActors.new(22) }
 
   subject do
     described_class.new(adapter, instrumenter: instrumenter)
@@ -18,16 +16,6 @@ RSpec.describe Flipper::Adapters::Instrumented do
 
   it_should_behave_like 'a flipper adapter'
 
-  it 'forwards missing methods to underlying adapter' do
-    adapter = Class.new do
-      def foo
-        :foo
-      end
-    end.new
-    instrumented = described_class.new(adapter)
-    expect(instrumented.foo).to eq(:foo)
-  end
-
   describe '#name' do
     it 'is instrumented' do
       expect(subject.name).to be(:instrumented)
@@ -73,6 +61,7 @@ RSpec.describe Flipper::Adapters::Instrumented do
       expect(event.payload[:adapter_name]).to eq(:memory)
       expect(event.payload[:feature_name]).to eq(:stats)
       expect(event.payload[:gate_name]).to eq(:percentage_of_actors)
+      expect(event.payload[:thing_value]).to eq(22)
       expect(event.payload[:result]).to be(result)
     end
   end
@@ -88,6 +77,7 @@ RSpec.describe Flipper::Adapters::Instrumented do
       expect(event.payload[:adapter_name]).to eq(:memory)
       expect(event.payload[:feature_name]).to eq(:stats)
       expect(event.payload[:gate_name]).to eq(:percentage_of_actors)
+      expect(event.payload[:thing_value]).to eq(22)
       expect(event.payload[:result]).to be(result)
     end
   end
@@ -146,4 +136,32 @@ RSpec.describe Flipper::Adapters::Instrumented do
       expect(event.payload[:result]).to be(result)
     end
   end
+
+  describe '#import' do
+    it 'records instrumentation' do
+      result = subject.import(Flipper::Adapters::Memory.new)
+
+      event = instrumenter.events.last
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:import)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:result]).to be(result)
+    end
+  end
+
+  describe '#export' do
+    it 'records instrumentation' do
+      result = subject.export(format: :json, version: 1)
+
+      event = instrumenter.events.last
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:export)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:format]).to be(:json)
+      expect(event.payload[:version]).to be(1)
+      expect(event.payload[:result]).to be(result)
+    end
+  end
 end