flipper 0.12.2 → 0.24.1

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

@@ -0,0 +1,33 @@
+require "flipper/adapters/sync/interval_synchronizer"
+
+RSpec.describe Flipper::Adapters::Sync::IntervalSynchronizer do
+  let(:events) { [] }
+  let(:synchronizer) { -> { events << now } }
+  let(:interval) { 10 }
+  let(:now) { subject.send(:now) }
+
+  subject { described_class.new(synchronizer, interval: interval) }
+
+  it 'synchronizes on first call' do
+    expect(events.size).to be(0)
+    subject.call
+    expect(events.size).to be(1)
+  end
+
+  it "only invokes wrapped synchronizer every interval seconds" do
+    subject.call
+    events.clear
+
+    # move time to one millisecond less than last sync + interval
+    1.upto(interval) do |i|
+      allow(subject).to receive(:now).and_return(now + i - 1)
+      subject.call
+    end
+    expect(events.size).to be(0)
+
+    # move time to last sync + interval in milliseconds
+    allow(subject).to receive(:now).and_return(now + interval)
+    subject.call
+    expect(events.size).to be(1)
+  end
+end

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

@@ -0,0 +1,88 @@
+require "flipper/adapters/memory"
+require "flipper/instrumenters/memory"
+require "flipper/adapters/sync/synchronizer"
+
+RSpec.describe Flipper::Adapters::Sync::Synchronizer do
+  let(:local) { Flipper::Adapters::Memory.new }
+  let(:remote) { Flipper::Adapters::Memory.new }
+  let(:local_flipper) { Flipper.new(local) }
+  let(:remote_flipper) { Flipper.new(remote) }
+  let(:instrumenter) { Flipper::Instrumenters::Memory.new }
+
+  subject { described_class.new(local, remote, instrumenter: instrumenter) }
+
+  it "instruments call" do
+    subject.call
+    expect(instrumenter.events_by_name("synchronizer_exception.flipper").size).to be(0)
+
+    events = instrumenter.events_by_name("synchronizer_call.flipper")
+    expect(events.size).to be(1)
+  end
+
+  it "raises errors by default" do
+    exception = StandardError.new
+    expect(remote).to receive(:get_all).and_raise(exception)
+
+    expect { subject.call }.to raise_error(exception)
+  end
+
+  context "when raise disabled" do
+    subject do
+      options = {
+        instrumenter: instrumenter,
+        raise: false,
+      }
+      described_class.new(local, remote, options)
+    end
+
+    it "does not raise, but instruments exceptions for visibility" do
+      exception = StandardError.new
+      expect(remote).to receive(:get_all).and_raise(exception)
+
+      expect { subject.call }.not_to raise_error
+
+      events = instrumenter.events_by_name("synchronizer_exception.flipper")
+      expect(events.size).to be(1)
+
+      event = events[0]
+      expect(event.payload[:exception]).to eq(exception)
+    end
+  end
+
+  describe '#call' do
+    it 'returns nothing' do
+      expect(subject.call).to be(nil)
+      expect(instrumenter.events_by_name("synchronizer_exception.flipper").size).to be(0)
+    end
+
+    it 'syncs each remote feature to local' do
+      remote_flipper.enable(:search)
+      remote_flipper.enable_percentage_of_time(:logging, 10)
+
+      subject.call
+      expect(instrumenter.events_by_name("synchronizer_exception.flipper").size).to be(0)
+
+      expect(local_flipper[:search].boolean_value).to eq(true)
+      expect(local_flipper[:logging].percentage_of_time_value).to eq(10)
+      expect(local_flipper.features.map(&:key).sort).to eq(%w(logging search))
+    end
+
+    it 'adds features in remote that are not in local' do
+      remote_flipper.add(:search)
+
+      subject.call
+      expect(instrumenter.events_by_name("synchronizer_exception.flipper").size).to be(0)
+
+      expect(local_flipper.features.map(&:key)).to eq(["search"])
+    end
+
+    it 'removes features in local that are not in remote' do
+      local_flipper.add(:stats)
+
+      subject.call
+      expect(instrumenter.events_by_name("synchronizer_exception.flipper").size).to be(0)
+
+      expect(local_flipper.features.map(&:key)).to eq([])
+    end
+  end
+end

data/spec/flipper/adapters/sync_spec.rb

@@ -0,0 +1,200 @@
+require 'flipper/adapters/sync'
+require 'flipper/adapters/operation_logger'
+require 'active_support/notifications'
+
+RSpec.describe Flipper::Adapters::Sync do
+  let(:local_adapter) do
+    Flipper::Adapters::OperationLogger.new Flipper::Adapters::Memory.new
+  end
+  let(:remote_adapter) do
+    Flipper::Adapters::OperationLogger.new Flipper::Adapters::Memory.new
+  end
+  let(:local) { Flipper.new(local_adapter) }
+  let(:remote) { Flipper.new(remote_adapter) }
+  let(:sync) { Flipper.new(subject) }
+
+  subject do
+    described_class.new(local_adapter, remote_adapter, interval: 1)
+  end
+
+  it_should_behave_like 'a flipper adapter'
+
+  context 'when local has never been synced' do
+    it 'syncs boolean' do
+      remote.enable(:search)
+      expect(sync[:search].boolean_value).to be(true)
+      expect(subject.features.sort).to eq(%w(search))
+    end
+
+    it 'syncs actor' do
+      actor = Flipper::Actor.new("User;1000")
+      remote.enable_actor(:search, actor)
+      expect(sync[:search].actors_value).to eq(Set[actor.flipper_id])
+      expect(subject.features.sort).to eq(%w(search))
+    end
+
+    it 'syncs group' do
+      remote.enable_group(:search, :staff)
+      expect(sync[:search].groups_value).to eq(Set["staff"])
+      expect(subject.features.sort).to eq(%w(search))
+    end
+
+    it 'syncs percentage of actors' do
+      remote.enable_percentage_of_actors(:search, 25)
+      expect(sync[:search].percentage_of_actors_value).to eq(25)
+      expect(subject.features.sort).to eq(%w(search))
+    end
+
+    it 'syncs percentage of time' do
+      remote.enable_percentage_of_time(:search, 15)
+      expect(sync[:search].percentage_of_time_value).to eq(15)
+      expect(subject.features.sort).to eq(%w(search))
+    end
+  end
+
+  it 'enables boolean locally when remote feature boolean enabled' do
+    remote.disable(:search)
+    local.disable(:search)
+    remote.enable(:search)
+    subject # initialize forces sync
+    expect(local[:search].boolean_value).to be(true)
+  end
+
+  it 'disables boolean locally when remote feature disabled' do
+    remote.enable(:search)
+    local.enable(:search)
+    remote.disable(:search)
+    subject # initialize forces sync
+    expect(local[:search].boolean_value).to be(false)
+  end
+
+  it 'adds local actor when remote actor is added' do
+    actor = Flipper::Actor.new("User;235")
+    remote.enable_actor(:search, actor)
+    subject # initialize forces sync
+    expect(local[:search].actors_value).to eq(Set[actor.flipper_id])
+  end
+
+  it 'removes local actor when remote actor is removed' do
+    actor = Flipper::Actor.new("User;235")
+    remote.enable_actor(:search, actor)
+    local.enable_actor(:search, actor)
+    remote.disable(:search, actor)
+    subject # initialize forces sync
+    expect(local[:search].actors_value).to eq(Set.new)
+  end
+
+  it 'adds local group when remote group is added' do
+    group = Flipper::Types::Group.new(:staff)
+    remote.enable_group(:search, group)
+    subject # initialize forces sync
+    expect(local[:search].groups_value).to eq(Set["staff"])
+  end
+
+  it 'removes local group when remote group is removed' do
+    group = Flipper::Types::Group.new(:staff)
+    remote.enable_group(:search, group)
+    local.enable_group(:search, group)
+    remote.disable(:search, group)
+    subject # initialize forces sync
+    expect(local[:search].groups_value).to eq(Set.new)
+  end
+
+  it 'updates percentage of actors when remote is updated' do
+    remote.enable_percentage_of_actors(:search, 10)
+    local.enable_percentage_of_actors(:search, 10)
+    remote.enable_percentage_of_actors(:search, 15)
+    subject # initialize forces sync
+    expect(local[:search].percentage_of_actors_value).to eq(15)
+  end
+
+  it 'updates percentage of time when remote is updated' do
+    remote.enable_percentage_of_time(:search, 10)
+    local.enable_percentage_of_time(:search, 10)
+    remote.enable_percentage_of_time(:search, 15)
+    subject # initialize forces sync
+    expect(local[:search].percentage_of_time_value).to eq(15)
+  end
+
+  context 'when local and remote match' do
+    it 'does not update boolean enabled' do
+      local.enable(:search)
+      remote.enable(:search)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:enable)).to be(0)
+    end
+
+    it 'does not update boolean disabled' do
+      local.disable(:search)
+      remote.disable(:search)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:disable)).to be(0)
+    end
+
+    it 'does not update actors' do
+      actor = Flipper::Actor.new("User;235")
+      local.enable_actor(:search, actor)
+      remote.enable_actor(:search, actor)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:enable)).to be(0)
+      expect(local_adapter.count(:disable)).to be(0)
+    end
+
+    it 'does not update groups' do
+      group = Flipper::Types::Group.new(:staff)
+      local.enable_group(:search, group)
+      remote.enable_group(:search, group)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:enable)).to be(0)
+      expect(local_adapter.count(:disable)).to be(0)
+    end
+
+    it 'does not update percentage of actors' do
+      local.enable_percentage_of_actors(:search, 10)
+      remote.enable_percentage_of_actors(:search, 10)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:enable)).to be(0)
+      expect(local_adapter.count(:disable)).to be(0)
+    end
+
+    it 'does not update percentage of time' do
+      local.enable_percentage_of_time(:search, 10)
+      remote.enable_percentage_of_time(:search, 10)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:enable)).to be(0)
+      expect(local_adapter.count(:disable)).to be(0)
+    end
+  end
+
+  it 'synchronizes for #features' do
+    expect(subject).to receive(:synchronize)
+    subject.features
+  end
+
+  it 'synchronizes for #get' do
+    expect(subject).to receive(:synchronize)
+    subject.get sync[:search]
+  end
+
+  it 'synchronizes for #get_multi' do
+    expect(subject).to receive(:synchronize)
+    subject.get_multi [sync[:search]]
+  end
+
+  it 'synchronizes for #get_all' do
+    expect(subject).to receive(:synchronize)
+    subject.get_all
+  end
+
+  it 'does not raise sync exceptions' do
+    exception = StandardError.new
+    expect(remote_adapter).to receive(:get_all).and_raise(exception)
+    expect { subject.get_all }.not_to raise_error
+  end
+end

data/spec/flipper/configuration_spec.rb

@@ -1,14 +1,31 @@
-require 'helper'
 require 'flipper/configuration'
 
 RSpec.describe Flipper::Configuration do
+  describe '#adapter' do
+    it 'returns instance using Memory adapter' do
+      expect(subject.adapter).to be_a(Flipper::Adapters::Memory)
+    end
+
+    it 'can be set' do
+      instance = Flipper::Adapters::Memory.new
+      expect(subject.adapter).not_to be(instance)
+      subject.adapter { instance }
+      expect(subject.adapter).to be(instance)
+      # All adapters are wrapped in Memoizable
+      expect(subject.default.adapter.adapter).to be(instance)
+    end
+  end
+
   describe '#default' do
-    it 'raises if default not configured' do
-      expect { subject.default }.to raise_error(Flipper::DefaultNotSet)
+    it 'returns instance using Memory adapter' do
+      expect(subject.default).to be_a(Flipper::DSL)
+      # All adapters are wrapped in Memoizable
+      expect(subject.default.adapter.adapter).to be_a(Flipper::Adapters::Memory)
     end
 
     it 'can be set default' do
       instance = Flipper.new(Flipper::Adapters::Memory.new)
+      expect(subject.default).not_to be(instance)
       subject.default { instance }
       expect(subject.default).to be(instance)
     end

data/spec/flipper/dsl_spec.rb

@@ -1,6 +1,4 @@
-require 'helper'
 require 'flipper/dsl'
-require 'flipper/adapters/memory'
 
 RSpec.describe Flipper::DSL do
   subject { described_class.new(adapter) }
@@ -8,9 +6,19 @@ RSpec.describe Flipper::DSL do
   let(:adapter) { Flipper::Adapters::Memory.new }
 
   describe '#initialize' do
-    it 'sets adapter' do
-      dsl = described_class.new(adapter)
-      expect(dsl.adapter).not_to be_nil
+    context 'when using default memoize strategy' do
+      it 'wraps the given adapter with Flipper::Adapters::Memoizable' do
+        dsl = described_class.new(adapter)
+        expect(dsl.adapter.class).to be(Flipper::Adapters::Memoizable)
+        expect(dsl.adapter.adapter).to be(adapter)
+      end
+    end
+
+    context 'when disabling memoization' do
+      it 'uses the given adapter directly' do
+        dsl = described_class.new(adapter, memoize: false)
+        expect(dsl.adapter).to be(adapter)
+      end
     end
 
     it 'defaults instrumenter to noop' do
@@ -313,6 +321,17 @@ RSpec.describe Flipper::DSL do
     end
   end
 
+  describe '#exist?' do
+    it 'returns true if the feature is added in adapter' do
+      subject.add(:stats)
+      expect(subject.exist?(:stats)).to be(true)
+    end
+
+    it 'returns false if the feature is NOT added in adapter' do
+      expect(subject.exist?(:stats)).to be(false)
+    end
+  end
+
   describe '#remove' do
     it 'removes the feature' do
       subject.adapter.add(subject[:stats])

data/spec/flipper/feature_check_context_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::FeatureCheckContext do
   let(:feature_name) { :new_profiles }
   let(:values) { Flipper::GateValues.new({}) }
@@ -41,8 +39,8 @@ RSpec.describe Flipper::FeatureCheckContext do
   end
 
   it 'knows actors_value' do
-    args = options.merge(values: Flipper::GateValues.new(actors: Set['User:1']))
-    expect(described_class.new(args).actors_value).to eq(Set['User:1'])
+    args = options.merge(values: Flipper::GateValues.new(actors: Set['User;1']))
+    expect(described_class.new(args).actors_value).to eq(Set['User;1'])
   end
 
   it 'knows groups_value' do

data/spec/flipper/feature_spec.rb

@@ -1,6 +1,4 @@
-require 'helper'
 require 'flipper/feature'
-require 'flipper/adapters/memory'
 require 'flipper/instrumenters/memory'
 
 RSpec.describe Flipper::Feature do
@@ -97,6 +95,17 @@ RSpec.describe Flipper::Feature do
     end
   end
 
+  describe '#exist?' do
+    it 'returns true if feature is added in adapter' do
+      subject.add
+      expect(subject.exist?).to be(true)
+    end
+
+    it 'returns false if feature is NOT added in adapter' do
+      expect(subject.exist?).to be(false)
+    end
+  end
+
   describe '#remove' do
     it 'removes feature from adapter' do
       adapter.add(subject)
@@ -232,6 +241,17 @@ RSpec.describe Flipper::Feature do
       expect(event.payload[:result]).not_to be_nil
     end
 
+    it 'is recorded for exist?' do
+      subject.exist?
+
+      event = instrumenter.events.last
+      expect(event).not_to be_nil
+      expect(event.name).to eq('feature_operation.flipper')
+      expect(event.payload[:feature_name]).to eq(:search)
+      expect(event.payload[:operation]).to eq(:exist?)
+      expect(event.payload[:result]).not_to be_nil
+    end
+
     it 'is recorded for remove' do
       subject.remove
 
@@ -338,19 +358,19 @@ RSpec.describe Flipper::Feature do
       end
 
       it 'returns :on' do
-        expect(subject.state).to be(:on)
+        expect(subject.state).to be(:conditional)
       end
 
-      it 'returns true for on?' do
-        expect(subject.on?).to be(true)
+      it 'returns false for on?' do
+        expect(subject.on?).to be(false)
       end
 
       it 'returns false for off?' do
         expect(subject.off?).to be(false)
       end
 
-      it 'returns false for conditional?' do
-        expect(subject.conditional?).to be(false)
+      it 'returns true for conditional?' do
+        expect(subject.conditional?).to be(true)
       end
     end
 
@@ -509,12 +529,12 @@ RSpec.describe Flipper::Feature do
 
     context 'when one or more actors are enabled' do
       before do
-        subject.enable Flipper::Types::Actor.new(Flipper::Actor.new('User:5'))
-        subject.enable Flipper::Types::Actor.new(Flipper::Actor.new('User:22'))
+        subject.enable Flipper::Types::Actor.new(Flipper::Actor.new('User;5'))
+        subject.enable Flipper::Types::Actor.new(Flipper::Actor.new('User;22'))
       end
 
       it 'returns set of actor ids' do
-        expect(subject.actors_value).to eq(Set.new(['User:5', 'User:22']))
+        expect(subject.actors_value).to eq(Set.new(['User;5', 'User;22']))
       end
     end
   end

data/spec/flipper/gate_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::Gate do
   let(:feature_name) { :stats }
 

data/spec/flipper/gate_values_spec.rb

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

data/spec/flipper/gates/actor_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::Gates::Actor do
   let(:feature_name) { :search }
 

data/spec/flipper/gates/boolean_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::Gates::Boolean do
   let(:feature_name) { :search }
 

data/spec/flipper/gates/group_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::Gates::Group do
   let(:feature_name) { :search }
 

data/spec/flipper/gates/percentage_of_actors_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::Gates::PercentageOfActors do
   let(:feature_name) { :search }
 

data/spec/flipper/gates/percentage_of_time_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-
 RSpec.describe Flipper::Gates::PercentageOfTime do
   let(:feature_name) { :search }
 

data/spec/flipper/identifier_spec.rb

@@ -0,0 +1,13 @@
+require 'flipper/identifier'
+
+RSpec.describe Flipper::Identifier do
+  describe '#flipper_id' do
+    class User < Struct.new(:id)
+      include Flipper::Identifier
+    end
+
+    it 'uses class name and id' do
+      expect(User.new(5).flipper_id).to eq('User;5')
+    end
+  end
+end

data/spec/flipper/instrumentation/log_subscriber_spec.rb

@@ -1,7 +1,5 @@
 require 'logger'
-require 'helper'
 require 'flipper/adapters/instrumented'
-require 'flipper/adapters/memory'
 require 'flipper/instrumentation/log_subscriber'
 
 RSpec.describe Flipper::Instrumentation::LogSubscriber do

data/spec/flipper/instrumentation/statsd_subscriber_spec.rb

@@ -1,5 +1,3 @@
-require 'helper'
-require 'flipper/adapters/memory'
 require 'flipper/adapters/instrumented'
 require 'flipper/instrumentation/statsd'
 require 'statsd'

data/spec/flipper/instrumenters/memory_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/instrumenters/memory'
 
 RSpec.describe Flipper::Instrumenters::Memory do
@@ -22,5 +21,23 @@ RSpec.describe Flipper::Instrumenters::Memory do
       event = described_class::Event.new(name, payload, block_result)
       expect(instrumenter.events).to eq([event])
     end
+
+    context 'when an error is raised' do
+      subject do
+        instrumenter.instrument(:name) { raise IOError }
+      end
+
+      let(:instrumenter) { described_class.new }
+
+      it 'captures and propagates the error' do
+        expect { subject }.to raise_error(IOError)
+
+        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 IOError
+      end
+    end
   end
 end

data/spec/flipper/instrumenters/noop_spec.rb

@@ -1,21 +1,26 @@
-require 'helper'
-require 'flipper/instrumenters/noop'
-
 RSpec.describe Flipper::Instrumenters::Noop do
   describe '.instrument' do
     context 'with name' do
       it 'yields block' do
-        yielded = false
-        described_class.instrument(:foo) { yielded = true }
-        expect(yielded).to eq(true)
+        expect { |block|
+          described_class.instrument(:foo, &block)
+        }.to yield_control
       end
     end
 
     context 'with name and payload' do
+      let(:payload) { { pay: :load } }
+
       it 'yields block' do
-        yielded = false
-        described_class.instrument(:foo, pay: :load) { yielded = true }
-        expect(yielded).to eq(true)
+        expect { |block|
+          described_class.instrument(:foo, payload, &block)
+        }.to yield_control
+      end
+
+      it 'yields the payload' do
+        described_class.instrument(:foo, payload) do |block_payload|
+          expect(block_payload).to eq payload
+        end
       end
     end
   end