flipper 1.0.0 → 1.3.6

data/spec/flipper/adapters/http_spec.rb

@@ -1,99 +1,160 @@
 require 'flipper/adapters/http'
 require 'flipper/adapters/pstore'
-require 'rack/handler/webrick'
 
-FLIPPER_SPEC_API_PORT = ENV.fetch('FLIPPER_SPEC_API_PORT', 9001).to_i
+rack_handler = begin
+  # Rack 3+
+  require 'rackup/handler/webrick'
+  Rackup::Handler::WEBrick
+rescue LoadError
+  require 'rack/handler/webrick'
+  Rack::Handler::WEBrick
+end
 
-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
+FLIPPER_SPEC_API_PORT = ENV.fetch('FLIPPER_SPEC_API_PORT', 9001).to_i
 
-      Thread.new { @server.start }
-      Timeout.timeout(1) { :wait until @started }
+RSpec.describe Flipper::Adapters::Http do
+  default_options = {
+    url: "http://localhost:#{FLIPPER_SPEC_API_PORT}",
+  }
+
+  {
+    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
+
+      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?
+
+        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
+
+      after :all do
+        @server.shutdown if @server
+      end
+
+      before(:each) do
+        @pstore_file.unlink if @pstore_file.exist?
+      end
+
+      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
 
-    after :all do
-      @server.shutdown if @server
-    end
+  it "sends default headers" do
+    headers = {
+      '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)
 
-    before(:each) do
-      @pstore_file.unlink if @pstore_file.exist?
-    end
+    adapter = described_class.new(url: 'http://app.com/flipper')
+    adapter.get(flipper[:feature_panel])
+  end
 
-    it_should_behave_like 'a flipper adapter'
+  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")
 
-    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"])
+    headers = {
+      "client-framework" => [
+        "rails=7.1.0",
+        "sinatra=3.1.0",
+        "hanami=0.7.2",
+        "good_job=3.21.5",
+        "sidekiq=7.2.0",
+      ]
+    }
 
-      expect(flipper[:search].disable_group(:some_made_up_group)).to be(true)
-      expect(flipper[:search].groups_value).to eq(Set.new)
-    end
+    stub_request(:get, "http://app.com/flipper/features/feature_panel")
+      .with(headers: headers)
+      .to_return(status: 404)
 
-    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
+    adapter = described_class.new(url: 'http://app.com/flipper')
+    adapter.get(flipper[:feature_panel])
   end
 
-  it "sends default headers" do
+  it "does not send undefined framework versions" do
+    stub_const("Rails", double(version: "7.1.0"))
+    stub_const("Sinatra::VERSION", "3.1.0")
+
     headers = {
-      'Accept' => 'application/json',
-      'Content-Type' => 'application/json',
-      'User-Agent' => "Flipper HTTP Adapter v#{Flipper::VERSION}",
+      "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, body: "", 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 {
@@ -105,7 +166,7 @@ RSpec.describe Flipper::Adapters::Http do
   describe "#get_multi" do
     it "raises error when not successful response" do
       stub_request(:get, "http://app.com/flipper/features?keys=feature_panel&exclude_gate_names=true")
-        .to_return(status: 503, body: "", headers: {})
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
       expect {
@@ -117,7 +178,7 @@ RSpec.describe Flipper::Adapters::Http do
   describe "#get_all" do
     it "raises error when not successful response" do
       stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
-        .to_return(status: 503, body: "", headers: {})
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
       expect {
@@ -129,7 +190,7 @@ RSpec.describe Flipper::Adapters::Http do
   describe "#features" do
     it "raises error when not successful response" do
       stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
-        .to_return(status: 503, body: "", headers: {})
+        .to_return(status: 503)
 
       adapter = described_class.new(url: 'http://app.com/flipper')
       expect {
@@ -246,7 +307,7 @@ 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,
@@ -267,7 +328,7 @@ RSpec.describe Flipper::Adapters::Http 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/memoizable_spec.rb

@@ -2,7 +2,7 @@ require 'flipper/adapters/memoizable'
 require 'flipper/adapters/operation_logger'
 
 RSpec.describe Flipper::Adapters::Memoizable do
-  let(:features_key) { described_class::FeaturesKey }
+  let(:features_key) { :flipper_features }
   let(:adapter) { Flipper::Adapters::Memory.new }
   let(:flipper) { Flipper.new(adapter) }
   let(:cache)   { {} }
@@ -54,7 +54,7 @@ RSpec.describe Flipper::Adapters::Memoizable do
       it 'memoizes feature' do
         feature = flipper[:stats]
         result = subject.get(feature)
-        expect(cache[described_class.key_for(feature.key)]).to be(result)
+        expect(cache["feature/#{feature.key}"]).to be(result)
       end
     end
 
@@ -83,8 +83,8 @@ RSpec.describe Flipper::Adapters::Memoizable do
         features = names.map { |name| flipper[name] }
         results = subject.get_multi(features)
         features.each do |feature|
-          expect(cache[described_class.key_for(feature.key)]).not_to be(nil)
-          expect(cache[described_class.key_for(feature.key)]).to be(results[feature.key])
+          expect(cache["feature/#{feature.key}"]).not_to be(nil)
+          expect(cache["feature/#{feature.key}"]).to be(results[feature.key])
         end
       end
     end
@@ -115,10 +115,10 @@ RSpec.describe Flipper::Adapters::Memoizable do
         features = names.map { |name| flipper[name].tap(&:enable) }
         results = subject.get_all
         features.each do |feature|
-          expect(cache[described_class.key_for(feature.key)]).not_to be(nil)
-          expect(cache[described_class.key_for(feature.key)]).to be(results[feature.key])
+          expect(cache["feature/#{feature.key}"]).not_to be(nil)
+          expect(cache["feature/#{feature.key}"]).to be(results[feature.key])
         end
-        expect(cache[subject.class::FeaturesKey]).to eq(names.map(&:to_s).to_set)
+        expect(cache[:flipper_features]).to eq(names.map(&:to_s).to_set)
       end
 
       it 'only calls get_all once for memoized adapter' do
@@ -188,9 +188,9 @@ RSpec.describe Flipper::Adapters::Memoizable do
       it 'unmemoizes feature' do
         feature = flipper[:stats]
         gate = feature.gate(:boolean)
-        cache[described_class.key_for(feature.key)] = { some: 'thing' }
+        cache["feature/#{feature.key}"] = { some: 'thing' }
         subject.enable(feature, gate, Flipper::Types::Boolean.new)
-        expect(cache[described_class.key_for(feature.key)]).to be_nil
+        expect(cache["feature/#{feature.key}"]).to be_nil
       end
     end
 
@@ -218,9 +218,9 @@ RSpec.describe Flipper::Adapters::Memoizable do
       it 'unmemoizes feature' do
         feature = flipper[:stats]
         gate = feature.gate(:boolean)
-        cache[described_class.key_for(feature.key)] = { some: 'thing' }
+        cache["feature/#{feature.key}"] = { some: 'thing' }
         subject.disable(feature, gate, Flipper::Types::Boolean.new)
-        expect(cache[described_class.key_for(feature.key)]).to be_nil
+        expect(cache["feature/#{feature.key}"]).to be_nil
       end
     end
 
@@ -332,9 +332,9 @@ RSpec.describe Flipper::Adapters::Memoizable do
 
       it 'unmemoizes the feature' do
         feature = flipper[:stats]
-        cache[described_class.key_for(feature.key)] = { some: 'thing' }
+        cache["feature/#{feature.key}"] = { some: 'thing' }
         subject.remove(feature)
-        expect(cache[described_class.key_for(feature.key)]).to be_nil
+        expect(cache["feature/#{feature.key}"]).to be_nil
       end
     end
 
@@ -357,9 +357,9 @@ RSpec.describe Flipper::Adapters::Memoizable do
 
       it 'unmemoizes feature' do
         feature = flipper[:stats]
-        cache[described_class.key_for(feature.key)] = { some: 'thing' }
+        cache["feature/#{feature.key}"] = { some: 'thing' }
         subject.clear(feature)
-        expect(cache[described_class.key_for(feature.key)]).to be_nil
+        expect(cache["feature/#{feature.key}"]).to be_nil
       end
     end
 

data/spec/flipper/adapters/poll_spec.rb

@@ -0,0 +1,41 @@
+require 'flipper/adapters/poll'
+
+RSpec.describe Flipper::Adapters::Poll do
+  let(:remote_adapter) {
+    adapter = Flipper::Adapters::Memory.new(threadsafe: true)
+    flipper = Flipper.new(adapter)
+    flipper.enable(:search)
+    flipper.enable(:analytics)
+    adapter
+  }
+  let(:local_adapter) { Flipper::Adapters::Memory.new(threadsafe: true) }
+  let(:poller) {
+    Flipper::Poller.get("for_spec", {
+      start_automatically: false,
+      remote_adapter: remote_adapter,
+    })
+  }
+
+  it "syncs in main thread if local adapter is empty" do
+    instance = described_class.new(poller, local_adapter)
+    instance.features # call something to force sync
+    expect(local_adapter.features).to eq(remote_adapter.features)
+  end
+
+  it "does not sync in main thread if local adapter is not empty" do
+    # make local not empty by importing remote
+    flipper = Flipper.new(local_adapter)
+    flipper.import(remote_adapter)
+
+    # make a fake poller to verify calls
+    poller = double("Poller", last_synced_at: Concurrent::AtomicFixnum.new(0))
+    expect(poller).to receive(:start).twice
+    expect(poller).not_to receive(:sync)
+
+    # create new instance and call something to force sync
+    instance = described_class.new(poller, local_adapter)
+    instance.features # call something to force sync
+
+    expect(local_adapter.features).to eq(remote_adapter.features)
+  end
+end

data/spec/flipper/adapters/read_only_spec.rb

@@ -5,11 +5,12 @@ RSpec.describe Flipper::Adapters::ReadOnly do
   let(:flipper) { Flipper.new(subject) }
   let(:feature) { flipper[:stats] }
 
-  let(:boolean_gate) { feature.gate(:boolean) }
-  let(:group_gate)   { feature.gate(:group) }
-  let(:actor_gate)   { feature.gate(:actor) }
-  let(:actors_gate)  { feature.gate(:percentage_of_actors) }
-  let(:time_gate)    { feature.gate(:percentage_of_time) }
+  let(:boolean_gate)    { feature.gate(:boolean) }
+  let(:group_gate)      { feature.gate(:group) }
+  let(:actor_gate)      { feature.gate(:actor) }
+  let(:expression_gate) { feature.gate(:expression) }
+  let(:actors_gate)     { feature.gate(:percentage_of_actors) }
+  let(:time_gate)       { feature.gate(:percentage_of_time) }
 
   subject { described_class.new(adapter) }
 
@@ -41,18 +42,28 @@ RSpec.describe Flipper::Adapters::ReadOnly do
   end
 
   it 'can get feature' do
+    expression = Flipper.property(:plan).eq("basic")
     actor22 = Flipper::Actor.new('22')
     adapter.enable(feature, boolean_gate, Flipper::Types::Boolean.new)
     adapter.enable(feature, group_gate, flipper.group(:admins))
     adapter.enable(feature, actor_gate, Flipper::Types::Actor.new(actor22))
     adapter.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(25))
     adapter.enable(feature, time_gate, Flipper::Types::PercentageOfTime.new(45))
-
-    expect(subject.get(feature)).to eq(boolean: 'true',
-                                       groups: Set['admins'],
-                                       actors: Set['22'],
-                                       percentage_of_actors: '25',
-                                       percentage_of_time: '45')
+    adapter.enable(feature, expression_gate, expression)
+
+    expect(subject.get(feature)).to eq({
+      boolean: 'true',
+      groups: Set['admins'],
+      actors: Set['22'],
+      expression: {
+        "Equal" => [
+          {"Property" => ["plan"]},
+          "basic",
+        ]
+      },
+      percentage_of_actors: '25',
+      percentage_of_time: '45',
+    })
   end
 
   it 'can get features' do
@@ -61,6 +72,10 @@ RSpec.describe Flipper::Adapters::ReadOnly do
     expect(subject.features).to eq(Set['stats'])
   end
 
+  it 'is configured as read only' do
+    expect(subject.read_only?).to eq(true)
+  end
+
   it 'raises error on add' do
     expect { subject.add(feature) }.to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end

data/spec/flipper/adapters/strict_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe Flipper::Adapters::Strict do
+  let(:flipper) { Flipper.new(subject) }
+  let(:feature) { flipper[:unknown] }
+
+  it_should_behave_like 'a flipper adapter' do
+    subject { described_class.new(Flipper::Adapters::Memory.new, :noop) }
+  end
+
+  [true, :raise].each do |handler|
+    context "handler = #{handler}" do
+      subject { described_class.new(Flipper::Adapters::Memory.new, handler) }
+
+      context "#get" do
+        it "raises an error for unknown feature" do
+          expect { subject.get(feature) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+        end
+      end
+
+      context "#get_multi" do
+        it "raises an error for unknown feature" do
+          expect { subject.get_multi([feature]) }.to raise_error(Flipper::Adapters::Strict::NotFound)
+        end
+      end
+    end
+  end
+
+  context "handler = :warn" do
+    subject { described_class.new(Flipper::Adapters::Memory.new, :warn) }
+
+    context "#get" do
+      it "raises an error 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
+        expect(capture_output { subject.get_multi([feature]) }).to match(/Could not find feature "unknown"/)
+      end
+    end
+  end
+
+  context "handler = Block" do
+    let(:unknown_features) { [] }
+    subject do
+      described_class.new(Flipper::Adapters::Memory.new) { |feature| unknown_features << feature.key}
+    end
+
+
+    context "#get" do
+      it "raises an error 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
+        subject.get_multi([flipper[:foo], flipper[:bar]])
+        expect(unknown_features).to eq(["foo", "bar"])
+      end
+    end
+  end
+end

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

@@ -8,6 +8,8 @@ RSpec.describe Flipper::Adapters::Sync::FeatureSynchronizer do
   end
   let(:flipper) { Flipper.new(adapter) }
   let(:feature) { flipper[:search] }
+  let(:plan_expression) { Flipper.property(:plan).eq("basic") }
+  let(:age_expression) { Flipper.property(:age).gte(21) }
 
   context "when remote disabled" do
     let(:remote) { Flipper::GateValues.new({}) }
@@ -63,6 +65,7 @@ RSpec.describe Flipper::Adapters::Sync::FeatureSynchronizer do
         boolean: nil,
         actors: Set["1"],
         groups: Set["staff"],
+        expression: plan_expression.value,
         percentage_of_time: 10,
         percentage_of_actors: 15,
       }
@@ -74,10 +77,34 @@ RSpec.describe Flipper::Adapters::Sync::FeatureSynchronizer do
       expect(local_gate_values_hash.fetch(:boolean)).to be(nil)
       expect(local_gate_values_hash.fetch(:actors)).to eq(Set["1"])
       expect(local_gate_values_hash.fetch(:groups)).to eq(Set["staff"])
+      expect(local_gate_values_hash.fetch(:expression)).to eq(plan_expression.value)
       expect(local_gate_values_hash.fetch(:percentage_of_time)).to eq("10")
       expect(local_gate_values_hash.fetch(:percentage_of_actors)).to eq("15")
     end
 
+    it "updates expression when remote is updated" do
+      any_expression = Flipper.any(plan_expression, age_expression)
+      remote = Flipper::GateValues.new(expression: any_expression.value)
+      feature.enable_expression(age_expression)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.expression_value).to eq(any_expression.value)
+      expect_only_enable
+    end
+
+    it "does nothing to expression if in sync" do
+      remote = Flipper::GateValues.new(expression: plan_expression.value)
+      feature.enable_expression(plan_expression)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.expression_value).to eq(plan_expression.value)
+      expect_no_enable_or_disable
+    end
+
     it "adds remotely added actors" do
       remote = Flipper::GateValues.new(actors: Set["1", "2"])
       feature.enable_actor(Flipper::Actor.new("1"))