flipper 0.16.0 → 1.4.0

data/spec/flipper/adapters/memoizable_spec.rb

@@ -1,10 +1,8 @@
-require 'helper'
 require 'flipper/adapters/memoizable'
 require 'flipper/adapters/operation_logger'
-require 'flipper/spec/shared_adapter_specs'
 
 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)   { {} }
@@ -13,16 +11,6 @@ RSpec.describe Flipper::Adapters::Memoizable 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
-    memoizable = described_class.new(adapter)
-    expect(memoizable.foo).to eq(:foo)
-  end
-
   describe '#name' do
     it 'is instrumented' do
       expect(subject.name).to be(:memoizable)
@@ -66,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
 
@@ -95,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
@@ -127,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
@@ -200,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' }
-        subject.enable(feature, gate, flipper.bool)
-        expect(cache[described_class.key_for(feature.key)]).to be_nil
+        cache["feature/#{feature.key}"] = { some: 'thing' }
+        subject.enable(feature, gate, Flipper::Types::Boolean.new)
+        expect(cache["feature/#{feature.key}"]).to be_nil
       end
     end
 
@@ -214,8 +202,8 @@ RSpec.describe Flipper::Adapters::Memoizable do
       it 'returns result' do
         feature = flipper[:stats]
         gate = feature.gate(:boolean)
-        result = subject.enable(feature, gate, flipper.bool)
-        adapter_result = adapter.enable(feature, gate, flipper.bool)
+        result = subject.enable(feature, gate, Flipper::Types::Boolean.new)
+        adapter_result = adapter.enable(feature, gate, Flipper::Types::Boolean.new)
         expect(result).to eq(adapter_result)
       end
     end
@@ -230,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' }
-        subject.disable(feature, gate, flipper.bool)
-        expect(cache[described_class.key_for(feature.key)]).to be_nil
+        cache["feature/#{feature.key}"] = { some: 'thing' }
+        subject.disable(feature, gate, Flipper::Types::Boolean.new)
+        expect(cache["feature/#{feature.key}"]).to be_nil
       end
     end
 
@@ -244,13 +232,43 @@ RSpec.describe Flipper::Adapters::Memoizable do
       it 'returns result' do
         feature = flipper[:stats]
         gate = feature.gate(:boolean)
-        result = subject.disable(feature, gate, flipper.bool)
-        adapter_result = adapter.disable(feature, gate, flipper.bool)
+        result = subject.disable(feature, gate, Flipper::Types::Boolean.new)
+        adapter_result = adapter.disable(feature, gate, Flipper::Types::Boolean.new)
         expect(result).to eq(adapter_result)
       end
     end
   end
 
+  describe "#import" do
+    context "with memoization enabled" do
+      before do
+        subject.memoize = true
+      end
+
+      it "unmemoizes features" do
+        cache[:foo] = "bar"
+        flipper[:stats].enable
+        flipper[:search].disable
+        subject.import(Flipper::Adapters::Memory.new)
+        expect(cache).to be_empty
+      end
+    end
+
+    context "with memoization disabled" do
+      before do
+        subject.memoize = false
+      end
+
+      it "does not unmemoize features" do
+        cache[:foo] = "bar"
+        flipper[:stats].enable
+        flipper[:search].disable
+        subject.import(Flipper::Adapters::Memory.new)
+        expect(cache).not_to be_empty
+      end
+    end
+  end
+
   describe '#features' do
     context 'with memoization enabled' do
       before do
@@ -314,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
 
@@ -339,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/memory_spec.rb

@@ -1,8 +1,36 @@
-require 'helper'
-require 'flipper/spec/shared_adapter_specs'
-
 RSpec.describe Flipper::Adapters::Memory do
-  subject { described_class.new }
+  let(:source) { {} }
+
+  context 'threadsafe: true' do
+    subject { described_class.new(source, threadsafe: true) }
+
+    it_should_behave_like 'a flipper adapter'
+  end
+
+  context 'threadsafe: false' do
+    subject { described_class.new(source, threadsafe: false) }
+
+    it_should_behave_like 'a flipper adapter'
+  end
+
+  it "can initialize from big hash" do
+    flipper = Flipper.new(subject)
+    flipper.enable :subscriptions
+    flipper.disable :search
+    flipper.enable_percentage_of_actors :pro_deal, 20
+    flipper.enable_percentage_of_time :logging, 30
+    flipper.enable_actor :following, Flipper::Actor.new('1')
+    flipper.enable_actor :following, Flipper::Actor.new('3')
+    flipper.enable_group :following, Flipper::Types::Group.new(:staff)
+
+    dup = described_class.new(subject.get_all)
 
-  it_should_behave_like 'a flipper adapter'
+    expect(dup.get_all).to eq({
+      "subscriptions" => subject.default_config.merge(boolean: "true"),
+      "search" => subject.default_config,
+      "logging" => subject.default_config.merge(:percentage_of_time => "30"),
+      "pro_deal" => subject.default_config.merge(:percentage_of_actors => "20"),
+      "following" => subject.default_config.merge(actors: Set["1", "3"], groups: Set["staff"]),
+    })
+  end
 end

data/spec/flipper/adapters/operation_logger_spec.rb

@@ -1,6 +1,4 @@
-require 'helper'
 require 'flipper/adapters/operation_logger'
-require 'flipper/spec/shared_adapter_specs'
 
 RSpec.describe Flipper::Adapters::OperationLogger do
   let(:operations) { [] }
@@ -11,14 +9,13 @@ RSpec.describe Flipper::Adapters::OperationLogger 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
-    operation_logger = described_class.new(adapter)
-    expect(operation_logger.foo).to eq(:foo)
+  it 'shows itself when inspect' do
+    subject.features
+    output = subject.inspect
+    expect(output).to match(/OperationLogger/)
+    expect(output).to match(/operation_logger/)
+    expect(output).to match(/@type=:features/)
+    expect(output).to match(/@adapter=#<Flipper::Adapters::Memory/)
   end
 
   describe '#get' do
@@ -40,7 +37,7 @@ RSpec.describe Flipper::Adapters::OperationLogger do
     before do
       @feature = flipper[:stats]
       @gate = @feature.gate(:boolean)
-      @thing = flipper.bool
+      @thing = Flipper::Types::Boolean.new
       @result = subject.enable(@feature, @gate, @thing)
     end
 
@@ -57,7 +54,7 @@ RSpec.describe Flipper::Adapters::OperationLogger do
     before do
       @feature = flipper[:stats]
       @gate = @feature.gate(:boolean)
-      @thing = flipper.bool
+      @thing = Flipper::Types::Boolean.new
       @result = subject.disable(@feature, @gate, @thing)
     end
 
@@ -99,4 +96,33 @@ RSpec.describe Flipper::Adapters::OperationLogger do
       expect(@result).to eq(adapter.add(@feature))
     end
   end
+
+  describe '#import' do
+    before do
+      @source = Flipper::Adapters::Memory.new
+      @result = subject.import(@source)
+    end
+
+    it 'logs operation' do
+      expect(subject.count(:import)).to be(1)
+    end
+
+    it 'returns result' do
+      expect(@result).to eq(adapter.import(@source))
+    end
+  end
+
+  describe '#export' do
+    before do
+      @result = subject.export(format: :json, version: 1)
+    end
+
+    it 'logs operation' do
+      expect(subject.count(:export)).to be(1)
+    end
+
+    it 'returns result' do
+      expect(@result).to eq(adapter.export(format: :json, version: 1))
+    end
+  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/pstore_spec.rb

@@ -1,6 +1,4 @@
-require 'helper'
 require 'flipper/adapters/pstore'
-require 'flipper/spec/shared_adapter_specs'
 
 RSpec.describe Flipper::Adapters::PStore do
   subject do

data/spec/flipper/adapters/read_only_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/adapters/read_only'
 
 RSpec.describe Flipper::Adapters::ReadOnly do
@@ -6,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) }
 
@@ -42,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.boolean)
+    adapter.enable(feature, boolean_gate, Flipper::Types::Boolean.new)
     adapter.enable(feature, group_gate, flipper.group(:admins))
-    adapter.enable(feature, actor_gate, flipper.actor(actor22))
-    adapter.enable(feature, actors_gate, flipper.actors(25))
-    adapter.enable(feature, time_gate, flipper.time(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, 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))
+    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
@@ -62,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
@@ -75,12 +89,12 @@ RSpec.describe Flipper::Adapters::ReadOnly do
   end
 
   it 'raises error on enable' do
-    expect { subject.enable(feature, boolean_gate, flipper.boolean) }
+    expect { subject.enable(feature, boolean_gate, Flipper::Types::Boolean.new) }
       .to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end
 
   it 'raises error on disable' do
-    expect { subject.disable(feature, boolean_gate, flipper.boolean) }
+    expect { subject.disable(feature, boolean_gate, Flipper::Types::Boolean.new) }
       .to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end
 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

@@ -1,4 +1,3 @@
-require "helper"
 require "flipper/adapters/memory"
 require "flipper/adapters/operation_logger"
 require "flipper/adapters/sync/feature_synchronizer"
@@ -9,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({}) }
@@ -64,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,
       }
@@ -75,10 +77,46 @@ 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 "updates expression when remote conditionally enabled but expression is nil" do
+      remote = Flipper::GateValues.new(expression: nil, actors: Set["1"])
+      feature.enable_expression(plan_expression)
+      feature.enable_actor(Flipper::Actor.new("1"))
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.expression_value).to eq(nil)
+      expect_only_disable
+    end
+
     it "adds remotely added actors" do
       remote = Flipper::GateValues.new(actors: Set["1", "2"])
       feature.enable_actor(Flipper::Actor.new("1"))

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

@@ -1,10 +1,10 @@
-require "helper"
 require "flipper/adapters/sync/interval_synchronizer"
 
 RSpec.describe Flipper::Adapters::Sync::IntervalSynchronizer do
   let(:events) { [] }
-  let(:synchronizer) { -> { events << described_class.now } }
+  let(:synchronizer) { -> { events << now } }
   let(:interval) { 10 }
+  let(:now) { subject.send(:now) }
 
   subject { described_class.new(synchronizer, interval: interval) }
 
@@ -15,19 +15,18 @@ RSpec.describe Flipper::Adapters::Sync::IntervalSynchronizer do
   end
 
   it "only invokes wrapped synchronizer every interval seconds" do
-    now = described_class.now
     subject.call
     events.clear
 
     # move time to one millisecond less than last sync + interval
     1.upto(interval) do |i|
-      allow(described_class).to receive(:now).and_return(now + i - 1)
+      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(described_class).to receive(:now).and_return(now + interval)
+    allow(subject).to receive(:now).and_return(now + interval)
     subject.call
     expect(events.size).to be(1)
   end