flipper 0.22.0 → 0.28.0

data/spec/flipper/poller_spec.rb

@@ -0,0 +1,47 @@
+require "flipper/poller"
+
+RSpec.describe Flipper::Poller do
+  let(:remote_adapter) { Flipper::Adapters::Memory.new }
+  let(:remote) { Flipper.new(remote_adapter) }
+  let(:local) { Flipper.new(subject.adapter) }
+
+  subject do
+    described_class.new(
+      remote_adapter: remote_adapter,
+      start_automatically: false,
+      interval: Float::INFINITY
+    )
+  end
+
+  before do
+    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
+      remote.enable :polling
+
+      expect(local.enabled?(:polling)).to be(false)
+      subject.sync
+      expect(local.enabled?(:polling)).to be(true)
+    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
+  end
+end

data/spec/flipper/railtie_spec.rb

@@ -1,63 +1,96 @@
-require 'helper'
 require 'rails'
 require 'flipper/railtie'
 
 RSpec.describe Flipper::Railtie do
   let(:application) do
-    app = Class.new(Rails::Application).new(
-      railties: [Flipper::Railtie],
-      ordered_railties: [Flipper::Railtie]
-    )
-    app.config.eager_load = false
-    app.config.logger = ActiveSupport::Logger.new($stdout)
-    app.run_load_hooks!
+    Class.new(Rails::Application).create(railties: [Flipper::Railtie]) do
+      config.eager_load = false
+    end
   end
 
   before do
-    Rails.application = nil
+    ActiveSupport::Dependencies.autoload_paths = ActiveSupport::Dependencies.autoload_paths.dup
+    ActiveSupport::Dependencies.autoload_once_paths = ActiveSupport::Dependencies.autoload_once_paths.dup
   end
 
-  subject do
-    application.initialize!
-    application
-  end
+  let(:config) { application.config.flipper }
+
+  subject { application.initialize! }
 
   describe 'initializers' do
-    it 'sets defaults' do
-      expect(application.config.flipper.env_key).to eq("flipper")
-      expect(application.config.flipper.memoize).to be(true)
-      expect(application.config.flipper.preload).to be(true)
+    it 'can set env_key from ENV' do
+      ENV['FLIPPER_ENV_KEY'] = 'flopper'
+
+      subject
+      expect(config.env_key).to eq('flopper')
     end
 
-    it "configures instrumentor on default instance" do
+    it 'can set memoize from ENV' do
+      ENV['FLIPPER_MEMOIZE'] = 'false'
+
       subject
+      expect(config.memoize).to eq(false)
+    end
+
+    it 'can set preload from ENV' do
+      ENV['FLIPPER_PRELOAD'] = 'false'
+
+      subject
+      expect(config.preload).to eq(false)
+    end
+
+    it 'can set instrumenter from ENV' do
+      stub_const('My::Cool::Instrumenter', Class.new)
+      ENV['FLIPPER_INSTRUMENTER'] = 'My::Cool::Instrumenter'
+
+      subject
+      expect(config.instrumenter).to eq(My::Cool::Instrumenter)
+    end
 
+    it 'can set log from ENV' do
+      ENV['FLIPPER_LOG'] = 'false'
+
+      subject
+      expect(config.log).to eq(false)
+    end
+
+    it 'sets defaults' do
+      subject # initialize
+      expect(config.env_key).to eq("flipper")
+      expect(config.memoize).to be(true)
+      expect(config.preload).to be(true)
+    end
+
+    it "configures instrumentor on default instance" do
+      subject # initialize
       expect(Flipper.instance.instrumenter).to eq(ActiveSupport::Notifications)
     end
 
     it 'uses Memoizer middleware if config.memoize = true' do
-      expect(subject.middleware.last).to eq(Flipper::Middleware::Memoizer)
+      initializer { config.memoize = true }
+      expect(subject.middleware).to include(Flipper::Middleware::Memoizer)
     end
 
     it 'does not use Memoizer middleware if config.memoize = false' do
-      # load but don't initialize
-      application.config.flipper.memoize = false
-
-      expect(subject.middleware.last).not_to eq(Flipper::Middleware::Memoizer)
+      initializer { config.memoize = false }
+      expect(subject.middleware).not_to include(Flipper::Middleware::Memoizer)
     end
 
     it 'passes config to memoizer' do
-      # load but don't initialize
-      application.config.flipper.update(
-        env_key: 'my_flipper',
-        preload: [:stats, :search]
-      )
-
-      expect(Flipper::Middleware::Memoizer).to receive(:new).with(application.routes,
-        env_key: 'my_flipper', preload: [:stats, :search], if: nil
-      )
+      initializer do
+        config.update(
+          env_key: 'my_flipper',
+          preload: [:stats, :search]
+        )
+      end
 
-      subject # initialize
+      expect(subject.middleware).to include(Flipper::Middleware::Memoizer)
+      middleware = subject.middleware.detect { |m| m.klass == Flipper::Middleware::Memoizer }
+      expect(middleware.args[0]).to eq({
+        env_key: config.env_key,
+        preload: config.preload,
+        if: nil
+      })
     end
 
     it "defines #flipper_id on AR::Base" do
@@ -66,4 +99,11 @@ RSpec.describe Flipper::Railtie do
       expect(ActiveRecord::Base.ancestors).to include(Flipper::Identifier)
     end
   end
+
+  # Add app initializer in the same order as config/initializers/*
+  def initializer(&block)
+    application.initializer 'spec', before: :load_config_initializers do
+      block.call
+    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/typecast_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/typecast'
 
 RSpec.describe Flipper::Typecast do
@@ -57,7 +56,7 @@ RSpec.describe Flipper::Typecast do
     nil => 0,
     '' => 0,
     0 => 0,
-    0.0 => 0.0,
+    0.0 => 0,
     1 => 1,
     1.1 => 1.1,
     '0.01' => 0.01,
@@ -101,13 +100,13 @@ 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))
+    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to a percentage))
   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))
+    end.to raise_error(ArgumentError, %(["asdf.0"] cannot be converted to a percentage))
   end
 
   it 'raises argument error for set value that cannot be converted to a set' do
@@ -115,4 +114,83 @@ 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 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
 end

data/spec/flipper/types/actor_spec.rb

@@ -1,13 +1,12 @@
-require 'helper'
 require 'flipper/types/actor'
 
 RSpec.describe Flipper::Types::Actor do
   subject do
-    thing = thing_class.new('2')
-    described_class.new(thing)
+    actor = actor_class.new('2')
+    described_class.new(actor)
   end
 
-  let(:thing_class) do
+  let(:actor_class) do
     Class.new do
       attr_reader :flipper_id
 
@@ -23,14 +22,14 @@ RSpec.describe Flipper::Types::Actor do
 
   describe '.wrappable?' do
     it 'returns true if actor' do
-      thing = thing_class.new('1')
-      actor = described_class.new(thing)
-      expect(described_class.wrappable?(actor)).to eq(true)
+      actor = actor_class.new('1')
+      actor_type_instance = described_class.new(actor)
+      expect(described_class.wrappable?(actor_type_instance)).to eq(true)
     end
 
     it 'returns true if responds to flipper_id' do
-      thing = thing_class.new(10)
-      expect(described_class.wrappable?(thing)).to eq(true)
+      actor = actor_class.new(10)
+      expect(described_class.wrappable?(actor)).to eq(true)
     end
 
     it 'returns false if nil' do
@@ -39,27 +38,27 @@ RSpec.describe Flipper::Types::Actor do
   end
 
   describe '.wrap' do
-    context 'for actor' do
-      it 'returns actor' do
-        actor = described_class.wrap(subject)
-        expect(actor).to be_instance_of(described_class)
-        expect(actor).to be(subject)
+    context 'for actor type instance' do
+      it 'returns actor type instance' do
+        actor_type_instance = described_class.wrap(subject)
+        expect(actor_type_instance).to be_instance_of(described_class)
+        expect(actor_type_instance).to be(subject)
       end
     end
 
-    context 'for other thing' do
-      it 'returns actor' do
-        thing = thing_class.new('1')
-        actor = described_class.wrap(thing)
-        expect(actor).to be_instance_of(described_class)
+    context 'for other object' do
+      it 'returns actor type instance' do
+        actor = actor_class.new('1')
+        actor_type_instance = described_class.wrap(actor)
+        expect(actor_type_instance).to be_instance_of(described_class)
       end
     end
   end
 
-  it 'initializes with thing that responds to id' do
-    thing = thing_class.new('1')
-    actor = described_class.new(thing)
-    expect(actor.value).to eq('1')
+  it 'initializes with object that responds to flipper_id' do
+    actor = actor_class.new('1')
+    actor_type_instance = described_class.new(actor)
+    expect(actor_type_instance.value).to eq('1')
   end
 
   it 'raises error when initialized with nil' do
@@ -69,48 +68,48 @@ RSpec.describe Flipper::Types::Actor do
   end
 
   it 'raises error when initalized with non-wrappable object' do
-    unwrappable_thing = Struct.new(:id).new(1)
+    unwrappable_object = Struct.new(:id).new(1)
     expect do
-      described_class.new(unwrappable_thing)
+      described_class.new(unwrappable_object)
     end.to raise_error(ArgumentError,
-                       "#{unwrappable_thing.inspect} must respond to flipper_id, but does not")
+                       "#{unwrappable_object.inspect} must respond to flipper_id, but does not")
   end
 
   it 'converts id to string' do
-    thing = thing_class.new(2)
-    actor = described_class.new(thing)
+    actor = actor_class.new(2)
+    actor = described_class.new(actor)
     expect(actor.value).to eq('2')
   end
 
-  it 'proxies everything to thing' do
-    thing = thing_class.new(10)
-    actor = described_class.new(thing)
+  it 'proxies everything to actor' do
+    actor = actor_class.new(10)
+    actor = described_class.new(actor)
     expect(actor.admin?).to eq(true)
   end
 
-  it 'exposes thing' do
-    thing = thing_class.new(10)
-    actor = described_class.new(thing)
-    expect(actor.thing).to be(thing)
+  it 'exposes actor' do
+    actor = actor_class.new(10)
+    actor_type_instance = described_class.new(actor)
+    expect(actor_type_instance.actor).to be(actor)
   end
 
   describe '#respond_to?' do
     it 'returns true if responds to method' do
-      thing = thing_class.new('1')
-      actor = described_class.new(thing)
-      expect(actor.respond_to?(:value)).to eq(true)
+      actor = actor_class.new('1')
+      actor_type_instance = described_class.new(actor)
+      expect(actor_type_instance.respond_to?(:value)).to eq(true)
     end
 
-    it 'returns true if thing responds to method' do
-      thing = thing_class.new(10)
-      actor = described_class.new(thing)
-      expect(actor.respond_to?(:admin?)).to eq(true)
+    it 'returns true if actor responds to method' do
+      actor = actor_class.new(10)
+      actor_type_instance = described_class.new(actor)
+      expect(actor_type_instance.respond_to?(:admin?)).to eq(true)
     end
 
-    it 'returns false if does not respond to method and thing does not respond to method' do
-      thing = thing_class.new(10)
-      actor = described_class.new(thing)
-      expect(actor.respond_to?(:frankenstein)).to eq(false)
+    it 'returns false if does not respond to method and actor does not respond to method' do
+      actor = actor_class.new(10)
+      actor_type_instance = described_class.new(actor)
+      expect(actor_type_instance.respond_to?(:frankenstein)).to eq(false)
     end
   end
 end

data/spec/flipper/types/boolean_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/types/boolean'
 
 RSpec.describe Flipper::Types::Boolean do

data/spec/flipper/types/group_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/types/group'
 
 RSpec.describe Flipper::Types::Group do
@@ -91,7 +90,7 @@ RSpec.describe Flipper::Types::Group do
       context = Flipper::FeatureCheckContext.new(
         feature_name: :my_feature,
         values: Flipper::GateValues.new({}),
-        thing: Flipper::Types::Actor.new(Flipper::Actor.new(1))
+        actors: [Flipper::Types::Actor.new(Flipper::Actor.new('1'))]
       )
       group = Flipper.register(:group_with_context) { |actor| actor }
       yielded_actor = group.match?(admin_actor, context)
@@ -102,7 +101,7 @@ RSpec.describe Flipper::Types::Group do
       context = Flipper::FeatureCheckContext.new(
         feature_name: :my_feature,
         values: Flipper::GateValues.new({}),
-        thing: Flipper::Types::Actor.new(Flipper::Actor.new(1))
+        actors: [Flipper::Types::Actor.new(Flipper::Actor.new('1'))]
       )
       group = Flipper.register(:group_with_context) { |actor, context| [actor, context] }
       yielded_actor, yielded_context = group.match?(admin_actor, context)

data/spec/flipper/types/percentage_of_actors_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/types/percentage_of_actors'
 
 RSpec.describe Flipper::Types::PercentageOfActors do

data/spec/flipper/types/percentage_of_time_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/types/percentage_of_time'
 
 RSpec.describe Flipper::Types::PercentageOfTime do

data/spec/flipper/types/percentage_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/types/percentage_of_actors'
 
 RSpec.describe Flipper::Types::Percentage do