flipper 0.22.0 → 0.28.0

data/lib/flipper/test/shared_adapter_test.rb

@@ -34,7 +34,16 @@ module Flipper
         assert_includes @adapter.class.ancestors, Flipper::Adapter
       end
 
+      def test_knows_how_to_get_adapter_from_source
+        adapter = Flipper::Adapters::Memory.new
+        flipper = Flipper.new(adapter)
+
+        assert_includes adapter.class.from(adapter).class.ancestors, Flipper::Adapter
+        assert_includes adapter.class.from(flipper).class.ancestors, Flipper::Adapter
+      end
+
       def test_returns_correct_default_values_for_gates_if_none_are_enabled
+        assert_equal @adapter.class.default_config, @adapter.get(@feature)
         assert_equal @adapter.default_config, @adapter.get(@feature)
       end
 
@@ -300,6 +309,21 @@ module Flipper
         assert_equal true, @adapter.enable(@feature, @boolean_gate, @flipper.boolean(true))
         assert_equal @adapter.default_config.merge(boolean: "true"), @adapter.get(@feature)
       end
+
+      def test_can_import_and_export
+        adapter = Flipper::Adapters::Memory.new
+        source_flipper = Flipper.new(adapter)
+        source_flipper.enable(:stats)
+        export = adapter.export
+
+        # some adapters cannot import so if they return false lets assert it
+        # didn't happen
+        if @adapter.import(export)
+          assert @flipper[:stats].enabled?
+        else
+          refute @flipper[:stats].enabled?
+        end
+      end
     end
   end
 end

data/lib/flipper/typecast.rb

@@ -21,11 +21,9 @@ module Flipper
     # Returns an Integer representation of the value.
     # Raises ArgumentError if conversion is not possible.
     def self.to_integer(value)
-      if value.respond_to?(:to_i)
-        value.to_i
-      else
-        raise ArgumentError, "#{value.inspect} cannot be converted to an integer"
-      end
+      value.to_i
+    rescue NoMethodError
+      raise ArgumentError, "#{value.inspect} cannot be converted to an integer"
     end
 
     # Internal: Convert value to a float.
@@ -33,11 +31,9 @@ module Flipper
     # Returns a Float representation of the value.
     # Raises ArgumentError if conversion is not possible.
     def self.to_float(value)
-      if value.respond_to?(:to_f)
-        value.to_f
-      else
-        raise ArgumentError, "#{value.inspect} cannot be converted to a float"
-      end
+      value.to_f
+    rescue NoMethodError
+      raise ArgumentError, "#{value.inspect} cannot be converted to a float"
     end
 
     # Internal: Convert value to a percentage.
@@ -45,11 +41,11 @@ module Flipper
     # Returns a Integer or Float representation of the value.
     # Raises ArgumentError if conversion is not possible.
     def self.to_percentage(value)
-      if value.to_s.include?('.'.freeze)
-        to_float(value)
-      else
-        to_integer(value)
-      end
+      result_to_f = value.to_f
+      result_to_i = result_to_f.to_i
+      result_to_f == result_to_i ? result_to_i : result_to_f
+    rescue NoMethodError
+      raise ArgumentError, "#{value.inspect} cannot be converted to a percentage"
     end
 
     # Internal: Convert value to a set.
@@ -66,5 +62,22 @@ module Flipper
         raise ArgumentError, "#{value.inspect} cannot be converted to a set"
       end
     end
+
+    def self.features_hash(source)
+      normalized_source = {}
+      (source || {}).each do |feature_key, gates|
+        normalized_source[feature_key] ||= {}
+        gates.each do |gate_key, value|
+          normalized_value = case value
+          when Array, Set
+            value.to_set
+          else
+            value ? value.to_s : value
+          end
+          normalized_source[feature_key][gate_key.to_sym] = normalized_value
+        end
+      end
+      normalized_source
+    end
   end
 end

data/lib/flipper/types/actor.rb

@@ -1,30 +1,36 @@
 module Flipper
   module Types
     class Actor < Type
-      def self.wrappable?(thing)
-        return false if thing.nil?
-        thing.respond_to?(:flipper_id)
+      def self.wrappable?(actor)
+        return false if actor.nil?
+        actor.respond_to?(:flipper_id)
       end
 
-      attr_reader :thing
+      attr_reader :actor
 
-      def initialize(thing)
-        raise ArgumentError, 'thing cannot be nil' if thing.nil?
+      def initialize(actor)
+        raise ArgumentError, 'actor cannot be nil' if actor.nil?
 
-        unless thing.respond_to?(:flipper_id)
-          raise ArgumentError, "#{thing.inspect} must respond to flipper_id, but does not"
+        unless actor.respond_to?(:flipper_id)
+          raise ArgumentError, "#{actor.inspect} must respond to flipper_id, but does not"
         end
 
-        @thing = thing
-        @value = thing.flipper_id.to_s
+        @actor = actor
+        @value = actor.flipper_id.to_s
       end
 
       def respond_to?(*args)
-        super || @thing.respond_to?(*args)
+        super || @actor.respond_to?(*args)
       end
 
-      def method_missing(name, *args, &block)
-        @thing.send name, *args, &block
+      if RUBY_VERSION >= '3.0'
+        def method_missing(name, *args, **kwargs, &block)
+          @actor.send name, *args, **kwargs, &block
+        end
+      else
+        def method_missing(name, *args, &block)
+          @actor.send name, *args, &block
+        end
       end
     end
   end

data/lib/flipper/types/group.rb

@@ -14,20 +14,27 @@ module Flipper
 
         if block_given?
           @block = block
-          @single_argument = @block.arity.abs == 1
+          @single_argument = call_with_no_context?(@block)
         else
-          @block = ->(_thing, _context) { false }
+          @block = ->(actor, context) { false }
           @single_argument = false
         end
       end
 
-      def match?(thing, context)
+      def match?(actor, context)
         if @single_argument
-          @block.call(thing)
+          @block.call(actor)
         else
-          @block.call(thing, context)
+          @block.call(actor, context)
         end
       end
+
+      NO_PARAMS_IN_RUBY_3 = [[:req], [:rest]]
+      def call_with_no_context?(block)
+        return true if block.parameters == NO_PARAMS_IN_RUBY_3
+
+        block.arity.abs == 1
+      end
     end
   end
 end

data/lib/flipper/version.rb

@@ -1,3 +1,3 @@
 module Flipper
-  VERSION = '0.22.0'.freeze
+  VERSION = '0.28.0'.freeze
 end

data/lib/flipper.rb

@@ -64,7 +64,7 @@ module Flipper
                  :enable_percentage_of_time, :disable_percentage_of_time,
                  :time, :percentage_of_time,
                  :features, :feature, :[], :preload, :preload_all,
-                 :adapter, :add, :exist?, :remove, :import,
+                 :adapter, :add, :exist?, :remove, :import, :export,
                  :memoize=, :memoizing?,
                  :sync, :sync_secret # For Flipper::Cloud. Will error for OSS Flipper.
 
@@ -72,12 +72,12 @@ module Flipper
   #
   # name - The Symbol name of the group.
   # block - The block that should be used to determine if the group matches a
-  #         given thing.
+  #         given actor.
   #
   # Examples
   #
-  #   Flipper.register(:admins) { |thing|
-  #     thing.respond_to?(:admin?) && thing.admin?
+  #   Flipper.register(:admins) { |actor|
+  #     actor.respond_to?(:admin?) && actor.admin?
   #   }
   #
   # Returns a Flipper::Group.
@@ -155,6 +155,7 @@ require 'flipper/instrumenters/noop'
 require 'flipper/identifier'
 require 'flipper/middleware/memoizer'
 require 'flipper/middleware/setup_env'
+require 'flipper/poller'
 require 'flipper/registry'
 require 'flipper/type'
 require 'flipper/types/actor'
@@ -164,5 +165,6 @@ require 'flipper/types/percentage'
 require 'flipper/types/percentage_of_actors'
 require 'flipper/types/percentage_of_time'
 require 'flipper/typecast'
+require 'flipper/version'
 
 require "flipper/railtie" if defined?(Rails::Railtie)

data/spec/fixtures/flipper_pstore_1679087600.json

@@ -0,0 +1,46 @@
+{
+  "version": 1,
+  "features": {
+    "search": {
+      "boolean": null,
+      "actors": [
+        "john",
+        "another",
+        "testing"
+      ],
+      "percentage_of_actors": null,
+      "percentage_of_time": null,
+      "groups": [
+        "admins"
+      ]
+    },
+    "new_pricing": {
+      "boolean": "true",
+      "actors": [],
+      "percentage_of_actors": null,
+      "percentage_of_time": null,
+      "groups": []
+    },
+    "google_analytics_tag": {
+      "boolean": null,
+      "actors": [],
+      "percentage_of_actors": "100",
+      "percentage_of_time": null,
+      "groups": []
+    },
+    "help_scout_tag": {
+      "boolean": null,
+      "actors": [],
+      "percentage_of_actors": null,
+      "percentage_of_time": "50",
+      "groups": []
+    },
+    "nope": {
+      "boolean": null,
+      "actors": [],
+      "percentage_of_actors": null,
+      "percentage_of_time": null,
+      "groups": []
+    }
+  }
+}

data/spec/flipper/actor_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::Actor do
   it 'initializes with and knows flipper_id' do
     actor = described_class.new("User;235")
@@ -45,4 +43,14 @@ RSpec.describe Flipper::Actor do
       expect(actor1.==(actor2)).to be(false)
     end
   end
+
+  describe '#hash' do
+    it 'returns a hash-value based on the flipper id' do
+      h = {
+        described_class.new("User;123") => true
+      }
+      expect(h).to have_key(described_class.new("User;123"))
+      expect(h).not_to have_key(described_class.new("User;456"))
+    end
+  end
 end

data/spec/flipper/adapter_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::Adapter do
   let(:source_flipper) { build_flipper }
   let(:destination_flipper) { build_flipper }
@@ -32,9 +30,9 @@ RSpec.describe Flipper::Adapter do
   end
 
   describe '#import' do
-    it 'returns nothing' do
+    it 'returns true' do
       result = destination_flipper.import(source_flipper)
-      expect(result).to be(nil)
+      expect(result).to be(true)
     end
 
     it 'can import from one adapter to another' do
@@ -116,5 +114,32 @@ RSpec.describe Flipper::Adapter do
       destination_flipper.import(source_flipper)
       expect(destination_flipper.features.map(&:key)).to eq([])
     end
+
+    it 'can import an export' do
+      source_flipper.enable(:search)
+      source_flipper.enable(:google_analytics, Flipper::Actor.new("User;1"))
+
+      destination_flipper.import(source_flipper.export)
+
+      feature = destination_flipper[:search]
+      expect(feature.boolean_value).to be(true)
+
+      feature = destination_flipper[:google_analytics]
+      expect(feature.actors_value).to eq(Set["User;1"])
+    end
+  end
+
+  describe "#export" do
+    it "exports features" do
+      source_flipper.enable(:search)
+      export = source_flipper.export
+      expect(export.features.dig("search", :boolean)).to eq("true")
+    end
+
+    it "exports with arguments" do
+      source_flipper.enable(:search)
+      export = source_flipper.export(format: :json, version: 1)
+      expect(export.features.dig("search", :boolean)).to eq("true")
+    end
   end
 end

data/spec/flipper/adapters/dual_write_spec.rb

@@ -1,7 +1,5 @@
-require 'helper'
 require 'flipper/adapters/dual_write'
 require 'flipper/adapters/operation_logger'
-require 'flipper/spec/shared_adapter_specs'
 require 'active_support/notifications'
 
 RSpec.describe Flipper::Adapters::DualWrite do

data/spec/flipper/adapters/failover_spec.rb

@@ -0,0 +1,129 @@
+require 'dalli'
+require 'flipper/adapters/failover'
+require 'net/http'
+require 'pstore'
+require 'redis'
+
+RSpec.describe Flipper::Adapters::Failover do
+  subject { described_class.new(primary, secondary, options) }
+
+  let(:primary) { Flipper::Adapters::Memory.new }
+  let(:secondary) { Flipper::Adapters::Memory.new }
+  let(:options) { {} }
+  let(:flipper) { Flipper.new(subject) }
+
+  context 'when the primary is a functioning adapter' do
+    it_should_behave_like 'a flipper adapter'
+
+    it 'should not call the secondary' do
+      expect(secondary).not_to receive(:features)
+      subject.features
+    end
+
+    it 'should not write to secondary' do
+      expect(secondary).not_to receive(:add)
+      expect(secondary).not_to receive(:enable)
+
+      flipper[:flag].enable
+    end
+
+    context 'when dual_write is enabled' do
+      let(:options) { { dual_write: true } }
+
+      it_should_behave_like 'a flipper adapter'
+
+      it 'writes to both primary and secondary' do
+        expect(primary).to receive(:add).and_call_original
+        expect(primary).to receive(:enable).and_call_original
+
+        expect(secondary).to receive(:add)
+        expect(secondary).to receive(:enable)
+
+        flipper[:flag].enable
+      end
+    end
+  end
+
+  context 'when primary fails during read operations' do
+    before do
+      allow(primary).to receive(:features).and_raise(Redis::ConnectionError)
+      allow(primary).to receive(:get).and_raise(Dalli::NetworkError)
+    end
+
+    it 'fails over to the secondary adapter for reads' do
+      expect(secondary).to receive(:features)
+      subject.features
+
+      flipper[:flag].enable
+      expect(secondary).to receive(:get).and_call_original
+      flipper[:flag].enabled?
+    end
+
+    context 'when dual_write is enabled' do
+      let(:options) { { dual_write: true } }
+
+      it_should_behave_like 'a flipper adapter'
+    end
+  end
+
+  context 'when primary fails during write operations' do
+    before do
+      allow(primary).to receive(:add).and_raise(PStore::Error)
+    end
+
+    let(:options) { { dual_write: true } }
+
+    it 'fails and does not write to secondary adapter' do
+      expect(secondary).not_to receive(:add)
+      expect(secondary).not_to receive(:enable)
+
+      expect { flipper[:flag].enable }.to raise_error(PStore::Error)
+    end
+  end
+
+  context 'when primary is instrumented and fails' do
+    before do
+      allow(memory_adapter).to receive(:get).and_raise(Net::ReadTimeout)
+    end
+
+    let(:memory_adapter) { Flipper::Adapters::Memory.new }
+    let(:primary) do
+      Flipper::Adapters::Instrumented.new(
+        memory_adapter,
+        instrumenter: instrumenter,
+      )
+    end
+    let(:instrumenter) { Flipper::Instrumenters::Memory.new }
+
+    it 'logs the raised exception' do
+      flipper[:flag].enabled?
+
+      expect(instrumenter.events.count).to be 1
+
+      payload = instrumenter.events[0].payload
+      expect(payload.keys).to include(:exception, :exception_object)
+      expect(payload[:exception_object]).to be_a Net::ReadTimeout
+    end
+  end
+
+  context 'when adapter raises a SyntaxError' do
+    before do
+      allow(primary).to receive(:features).and_raise(SyntaxError)
+    end
+
+    it 'does not rescue this type by default' do
+      expect {
+        subject.features
+      }.to raise_error(SyntaxError)
+    end
+
+    context 'when Failover adapter is configured to catch SyntaxError' do
+      let(:options) { { errors: [ SyntaxError ] } }
+
+      it 'fails over to secondary adapter' do
+        expect(secondary).to receive(:features)
+        subject.features
+      end
+    end
+  end
+end

data/spec/flipper/adapters/failsafe_spec.rb

@@ -0,0 +1,58 @@
+require 'flipper/adapters/failsafe'
+
+RSpec.describe Flipper::Adapters::Failsafe do
+  subject { described_class.new(memory_adapter, options) }
+
+  let(:memory_adapter) { Flipper::Adapters::Memory.new }
+  let(:options) { {} }
+  let(:flipper) { Flipper.new(subject) }
+
+  it_should_behave_like 'a flipper adapter'
+
+  context 'when disaster strikes' do
+    before do
+      expect(flipper[feature.name].enable).to be(true)
+
+      (subject.methods - Object.methods).each do |method_name|
+        allow(memory_adapter).to receive(method_name).and_raise(IOError)
+      end
+    end
+
+    let(:feature) { Flipper::Feature.new(:my_feature, subject) }
+
+    it { expect(subject.features).to eq(Set.new) }
+    it { expect(feature.add).to eq(false) }
+    it { expect(feature.remove).to eq(false) }
+    it { expect(feature.clear).to eq(false) }
+    it { expect(subject.get(feature)).to eq({}) }
+    it { expect(subject.get_multi([feature])).to eq({}) }
+    it { expect(subject.get_all).to eq({}) }
+    it { expect(feature.enable).to eq(false) }
+    it { expect(feature.disable).to eq(false) }
+
+    context 'when used via Flipper' do
+      it { expect(flipper.features).to eq(Set.new) }
+      it { expect(flipper[feature.name].enabled?).to eq(false) }
+      it { expect(flipper[feature.name].enable).to eq(false) }
+      it { expect(flipper[feature.name].disable).to eq(false) }
+    end
+
+    context 'when there is a syntax error' do
+      let(:test) { flipper[feature.name].enabled? }
+
+      before do
+        expect(memory_adapter).to receive(:get).and_raise(SyntaxError)
+      end
+
+      it 'does not catch this type of error' do
+        expect { test }.to raise_error(SyntaxError)
+      end
+
+      context 'when configured to catch SyntaxError' do
+        let(:options) { { errors: [SyntaxError] } }
+
+        it { expect(test).to eq(false) }
+      end
+    end
+  end
+end

data/spec/flipper/adapters/http_spec.rb

@@ -1,7 +1,5 @@
-require 'helper'
 require 'flipper/adapters/http'
 require 'flipper/adapters/pstore'
-require 'flipper/spec/shared_adapter_specs'
 require 'rack/handler/webrick'
 
 FLIPPER_SPEC_API_PORT = ENV.fetch('FLIPPER_SPEC_API_PORT', 9001).to_i
@@ -54,6 +52,28 @@ RSpec.describe Flipper::Adapters::Http do
       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
 
   it "sends default headers" do
@@ -84,7 +104,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")
+      stub_request(:get, "http://app.com/flipper/features?keys=feature_panel&exclude_gate_names=true")
         .to_return(status: 503, body: "", headers: {})
 
       adapter = described_class.new(url: 'http://app.com/flipper')
@@ -96,7 +116,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")
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
         .to_return(status: 503, body: "", headers: {})
 
       adapter = described_class.new(url: 'http://app.com/flipper')
@@ -108,7 +128,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")
+      stub_request(:get, "http://app.com/flipper/features?exclude_gate_names=true")
         .to_return(status: 503, body: "", headers: {})
 
       adapter = described_class.new(url: 'http://app.com/flipper')
@@ -159,6 +179,19 @@ RSpec.describe Flipper::Adapters::Http 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)
@@ -167,6 +200,30 @@ RSpec.describe Flipper::Adapters::Http do
         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
@@ -202,7 +259,8 @@ 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