flipper 0.24.1 → 1.3.0

data/spec/flipper/gates/expression_spec.rb

@@ -0,0 +1,108 @@
+RSpec.describe Flipper::Gates::Expression do
+  let(:feature_name) { :search }
+
+  subject do
+    described_class.new
+  end
+
+  def context(expression, properties: {})
+    Flipper::FeatureCheckContext.new(
+      feature_name: feature_name,
+      values: Flipper::GateValues.new(expression: expression),
+      actors: [Flipper::Types::Actor.new(Flipper::Actor.new(1, properties))]
+    )
+  end
+
+  describe '#enabled?' do
+    context 'for nil value' do
+      it 'returns false' do
+        expect(subject.enabled?(nil)).to eq(false)
+      end
+    end
+
+    context 'for empty value' do
+      it 'returns false' do
+        expect(subject.enabled?({})).to eq(false)
+      end
+    end
+
+    context "for not empty value" do
+      it 'returns true' do
+        expect(subject.enabled?({"Boolean" => [true]})).to eq(true)
+      end
+    end
+  end
+
+  describe '#open?' do
+    context 'for expression that evaluates to true' do
+      it 'returns true' do
+        expression = Flipper.boolean(true).eq(true)
+        expect(subject.open?(context(expression.value))).to be(true)
+      end
+    end
+
+    context 'for expression that evaluates to false' do
+      it 'returns false' do
+        expression = Flipper.boolean(true).eq(false)
+        expect(subject.open?(context(expression.value))).to be(false)
+      end
+    end
+
+    context 'for properties that have string keys' do
+      it 'returns true when expression evalutes to true' do
+        expression = Flipper.property(:type).eq("User")
+        context = context(expression.value, properties: {"type" => "User"})
+        expect(subject.open?(context)).to be(true)
+      end
+
+      it 'returns false when expression evaluates to false' do
+        expression = Flipper.property(:type).eq("User")
+        context = context(expression.value, properties: {"type" => "Org"})
+        expect(subject.open?(context)).to be(false)
+      end
+    end
+
+    context 'for properties that have symbol keys' do
+      it 'returns true when expression evalutes to true' do
+        expression = Flipper.property(:type).eq("User")
+        context = context(expression.value, properties: {type: "User"})
+        expect(subject.open?(context)).to be(true)
+      end
+
+      it 'returns false when expression evaluates to false' do
+        expression = Flipper.property(:type).eq("User")
+        context = context(expression.value, properties: {type: "Org"})
+        expect(subject.open?(context)).to be(false)
+      end
+    end
+  end
+
+  describe '#protects?' do
+    it 'returns true for Flipper::Expression' do
+      expression = Flipper.number(20).eq(20)
+      expect(subject.protects?(expression)).to be(true)
+    end
+
+    it 'returns true for Hash' do
+      expression = Flipper.number(20).eq(20)
+      expect(subject.protects?(expression.value)).to be(true)
+    end
+
+    it 'returns false for other things' do
+      expect(subject.protects?(false)).to be(false)
+    end
+  end
+
+  describe '#wrap' do
+    it 'returns self for Flipper::Expression' do
+      expression = Flipper.number(20).eq(20)
+      expect(subject.wrap(expression)).to be(expression)
+    end
+
+    it 'returns Flipper::Expression for Hash' do
+      expression = Flipper.number(20).eq(20)
+      expect(subject.wrap(expression.value)).to be_instance_of(Flipper::Expression)
+      expect(subject.wrap(expression.value)).to eq(expression)
+    end
+  end
+end

data/spec/flipper/gates/group_spec.rb

@@ -9,18 +9,17 @@ RSpec.describe Flipper::Gates::Group do
     Flipper::FeatureCheckContext.new(
       feature_name: feature_name,
       values: Flipper::GateValues.new(groups: set),
-      thing: Flipper::Types::Actor.new(Flipper::Actor.new('5'))
+      actors: [Flipper::Types::Actor.new(Flipper::Actor.new('5'))]
     )
   end
 
   describe '#open?' do
     context 'with a group in adapter, but not registered' do
       before do
-        Flipper.register(:staff) { |_thing| true }
+        Flipper.register(:staff) { |actor| true }
       end
 
       it 'ignores group' do
-        thing = Flipper::Actor.new('5')
         expect(subject.open?(context(Set[:newbs, :staff]))).to be(true)
       end
     end

data/spec/flipper/gates/percentage_of_actors_spec.rb

@@ -5,11 +5,11 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
     described_class.new
   end
 
-  def context(percentage_of_actors_value, feature = feature_name, thing = nil)
+  def context(percentage_of_actors_value, feature = feature_name, actors = nil)
     Flipper::FeatureCheckContext.new(
       feature_name: feature,
       values: Flipper::GateValues.new(percentage_of_actors: percentage_of_actors_value),
-      thing: thing || Flipper::Types::Actor.new(Flipper::Actor.new(1))
+      actors: Array(actors) || [Flipper::Types::Actor.new(Flipper::Actor.new('1'))]
     )
   end
 
@@ -20,7 +20,7 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
       let(:number_of_actors) { 10_000 }
 
       let(:actors) do
-        (1..number_of_actors).map { |n| Flipper::Actor.new(n) }
+        (1..number_of_actors).map { |n| Flipper::Types::Actor.new(Flipper::Actor.new(n.to_s)) }
       end
 
       let(:feature_one_enabled_actors) do
@@ -48,13 +48,69 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
       end
     end
 
+    context "with an array of actors" do
+      let(:percentage) { 0.05 }
+      let(:percentage_as_integer) { percentage * 100 }
+      let(:number_of_actors) { 3_000 }
+
+      let(:user_actors) do
+        (1..number_of_actors).map { |n| Flipper::Types::Actor.new(Flipper::Actor.new("User;#{n}")) }
+      end
+
+      let(:team_actors) do
+        (1..number_of_actors).map { |n| Flipper::Types::Actor.new(Flipper::Actor.new("Team;#{n}")) }
+      end
+
+      let(:org_actors) do
+        (1..number_of_actors).map { |n| Flipper::Types::Actor.new(Flipper::Actor.new("Org;#{n}")) }
+      end
+
+      let(:actors) { user_actors + team_actors + org_actors }
+
+      let(:feature_one_enabled_actors) do
+        actors.each_slice(3).select do |group|
+          context = context(percentage_as_integer, :name_one, group)
+          subject.open?(context)
+        end.flatten
+      end
+
+      let(:feature_two_enabled_actors) do
+        actors.each_slice(3).select do |group|
+          context = context(percentage_as_integer, :name_two, group)
+          subject.open?(context)
+        end.flatten
+      end
+
+      it 'does not enable both features for same set of actors' do
+        expect(feature_one_enabled_actors).not_to eq(feature_two_enabled_actors)
+      end
+
+      it 'enables feature for accurate number of actors for each feature' do
+        margin_of_error = 0.02 * actors.size # 2 percent margin of error
+        expected_enabled_size = actors.size * percentage
+
+        [
+          feature_one_enabled_actors.size,
+          feature_two_enabled_actors.size,
+        ].each do |size|
+          expect(size).to be_within(margin_of_error).of(expected_enabled_size)
+        end
+      end
+
+      it "is consistent regardless of order of actors" do
+        actors = user_actors.first(10)
+        results = 100.times.map { |n| subject.open?(context(75, :some_feature, actors.shuffle)) }
+        expect(results.uniq).to eq([true])
+      end
+    end
+
     context 'for fractional percentage' do
       let(:decimal) { 0.001 }
       let(:percentage) { decimal * 100 }
       let(:number_of_actors) { 10_000 }
 
       let(:actors) do
-        (1..number_of_actors).map { |n| Flipper::Actor.new(n) }
+        (1..number_of_actors).map { |n| Flipper::Types::Actor.new(Flipper::Actor.new(n.to_s)) }
       end
 
       subject { described_class.new }
@@ -64,7 +120,7 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
         expected_open_count = number_of_actors * decimal
 
         open_count = actors.select do |actor|
-          context = context(percentage, :feature, actor)
+          context = context(percentage, :feature, [actor])
           subject.open?(context)
         end.size
 

data/spec/flipper/gates/percentage_of_time_spec.rb

@@ -5,11 +5,11 @@ RSpec.describe Flipper::Gates::PercentageOfTime do
     described_class.new
   end
 
-  def context(percentage_of_time_value, feature = feature_name, thing = nil)
+  def context(percentage_of_time_value, feature = feature_name, actors = nil)
     Flipper::FeatureCheckContext.new(
       feature_name: feature,
       values: Flipper::GateValues.new(percentage_of_time: percentage_of_time_value),
-      thing: thing || Flipper::Types::Actor.new(Flipper::Actor.new(1))
+      actors: Array(actors) || [Flipper::Types::Actor.new(Flipper::Actor.new('1'))]
     )
   end
 

data/spec/flipper/identifier_spec.rb

@@ -2,12 +2,11 @@ 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')
+      class BlahBlah < Struct.new(:id)
+        include Flipper::Identifier
+      end
+      expect(BlahBlah.new(5).flipper_id).to eq('BlahBlah;5')
     end
   end
 end

data/spec/flipper/instrumentation/log_subscriber_spec.rb

@@ -1,6 +1,15 @@
 require 'logger'
-require 'flipper/adapters/instrumented'
 require 'flipper/instrumentation/log_subscriber'
+require 'flipper/adapters/instrumented'
+
+begin
+  require 'active_support/isolated_execution_state'
+rescue LoadError
+  # ActiveSupport::IsolatedExecutionState is only available in Rails 5.2+
+end
+
+# Don't log in other tests, we'll manually re-attach when this one starts
+Flipper::Instrumentation::LogSubscriber.detach
 
 RSpec.describe Flipper::Instrumentation::LogSubscriber do
   let(:adapter) do
@@ -12,8 +21,8 @@ RSpec.describe Flipper::Instrumentation::LogSubscriber do
   end
 
   before do
-    Flipper.register(:admins) do |thing|
-      thing.respond_to?(:admin?) && thing.admin?
+    Flipper.register(:admins) do |actor|
+      actor.respond_to?(:admin?) && actor.admin?
     end
 
     @io = StringIO.new
@@ -26,6 +35,14 @@ RSpec.describe Flipper::Instrumentation::LogSubscriber do
     described_class.logger = nil
   end
 
+  before(:all) do
+    described_class.attach
+  end
+
+  after(:all) do
+    described_class.detach
+  end
+
   let(:log) { @io.string }
 
   context 'feature enabled checks' do
@@ -36,7 +53,7 @@ RSpec.describe Flipper::Instrumentation::LogSubscriber do
 
     it 'logs feature calls with result after operation' do
       feature_line = find_line('Flipper feature(search) enabled? false')
-      expect(feature_line).to include('[ thing=nil ]')
+      expect(feature_line).to include('[ actors=nil ]')
     end
 
     it 'logs adapter calls' do
@@ -46,7 +63,7 @@ RSpec.describe Flipper::Instrumentation::LogSubscriber do
     end
   end
 
-  context 'feature enabled checks with a thing' do
+  context 'feature enabled checks with an actor' do
     let(:user) { Flipper::Types::Actor.new(Flipper::Actor.new('1')) }
 
     before do
@@ -54,7 +71,7 @@ RSpec.describe Flipper::Instrumentation::LogSubscriber do
       flipper[:search].enabled?(user)
     end
 
-    it 'logs thing for feature' do
+    it 'logs actors for feature' do
       feature_line = find_line('Flipper feature(search) enabled?')
       expect(feature_line).to include(user.inspect)
     end

data/spec/flipper/instrumentation/statsd_subscriber_spec.rb

@@ -1,6 +1,11 @@
 require 'flipper/adapters/instrumented'
 require 'flipper/instrumentation/statsd'
-require 'statsd'
+
+begin
+  require 'active_support/isolated_execution_state'
+rescue LoadError
+  # ActiveSupport::IsolatedExecutionState is only available in Rails 5.2+
+end
 
 RSpec.describe Flipper::Instrumentation::StatsdSubscriber do
   let(:statsd_client) { Statsd.new }
@@ -25,6 +30,10 @@ RSpec.describe Flipper::Instrumentation::StatsdSubscriber do
     Thread.current[:statsd_socket] = nil
   end
 
+  after(:all) do
+    ActiveSupport::Notifications.unsubscribe("flipper")
+  end
+
   def assert_timer(metric)
     regex = /#{Regexp.escape metric}\:\d+\|ms/
     result = socket.buffer.detect { |op| op.first =~ regex }
@@ -68,4 +77,19 @@ RSpec.describe Flipper::Instrumentation::StatsdSubscriber do
     flipper[:stats].disable(user)
     assert_timer 'flipper.adapter.memory.disable'
   end
+
+  context 'when client is nil' do
+    before do
+      described_class.client = nil
+    end
+
+    it 'does not raise error' do
+      expect { flipper[:stats].enable(user) }.not_to raise_error
+    end
+
+    it 'does not update metrics' do
+      flipper[:stats].enable(user)
+      expect(socket.buffer).to be_empty
+    end
+  end
 end

data/spec/flipper/middleware/memoizer_spec.rb

@@ -38,26 +38,6 @@ RSpec.describe Flipper::Middleware::Memoizer do
       expect(called).to eq(true)
     end
 
-    it 'disables local cache after body close' do
-      app = ->(_env) { [200, {}, []] }
-      middleware = described_class.new(app)
-      body = middleware.call(env).last
-
-      expect(flipper.memoizing?).to eq(true)
-      body.close
-      expect(flipper.memoizing?).to eq(false)
-    end
-
-    it 'clears local cache after body close' do
-      app = ->(_env) { [200, {}, []] }
-      middleware = described_class.new(app)
-      body = middleware.call(env).last
-
-      flipper.adapter.cache['hello'] = 'world'
-      body.close
-      expect(flipper.adapter.cache).to be_empty
-    end
-
     it 'clears the local cache with a successful request' do
       flipper.adapter.cache['hello'] = 'world'
       get '/', {}, 'flipper' => flipper
@@ -216,6 +196,73 @@ RSpec.describe Flipper::Middleware::Memoizer do
     end
   end
 
+  context 'with preload block' do
+    let(:app) do
+      app = lambda do |_env|
+        flipper[:stats].enabled?
+        flipper[:stats].enabled?
+        flipper[:shiny].enabled?
+        flipper[:shiny].enabled?
+        [200, {}, []]
+      end
+
+      described_class.new(app, preload: ->(request) {
+        case request.path
+        when "/true"
+          true
+        when "/specific"
+          [:stats]
+        else
+          false
+        end
+      })
+    end
+
+    include_examples 'flipper middleware'
+
+    it 'eagerly caches known features for duration of request if block returns true' do
+      flipper[:stats].enable
+      flipper[:shiny].enable
+
+      # clear the log of operations
+      adapter.reset
+
+      get '/true', {}, 'flipper' => flipper
+
+      expect(adapter.operations.size).to be(1)
+      expect(adapter.count(:get_all)).to be(1)
+      expect(adapter.count(:get)).to be(0)
+    end
+
+    it 'does not eagerly cache known features if block returns false' do
+      flipper[:stats].enable
+      flipper[:shiny].enable
+
+      # clear the log of operations
+      adapter.reset
+
+      get '/false', {}, 'flipper' => flipper
+
+      expect(adapter.operations.size).to be(2)
+      expect(adapter.count(:get_all)).to be(0)
+      expect(adapter.count(:get)).to be(2)
+    end
+
+    it 'eagerly caches specified features for duration of request if block returns array of specified features' do
+      flipper[:stats].enable
+      flipper[:shiny].enable
+
+      # clear the log of operations
+      adapter.reset
+
+      get '/specific', {}, 'flipper' => flipper
+
+      expect(adapter.operations.size).to be(2)
+      expect(adapter.count(:get_multi)).to be(1)
+      expect(adapter.count(:get)).to be(1)
+    end
+  end
+
   context 'with multiple instances' do
     let(:app) do
       # ensure scoped for builder block, annoying...
@@ -411,7 +458,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
       logged_memory = Flipper::Adapters::OperationLogger.new(memory)
       cache = ActiveSupport::Cache::MemoryStore.new
       cache.clear
-      cached = Flipper::Adapters::ActiveSupportCacheStore.new(logged_memory, cache, expires_in: 10)
+      cached = Flipper::Adapters::ActiveSupportCacheStore.new(logged_memory, cache)
       logged_cached = Flipper::Adapters::OperationLogger.new(cached)
       memo = {}
       flipper = Flipper.new(logged_cached)
@@ -424,15 +471,18 @@ RSpec.describe Flipper::Middleware::Memoizer do
 
       get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(1)
-      expect(logged_memory.count(:get_all)).to be(1)
+      expect(logged_memory.count(:features)).to be(1)
+      expect(logged_memory.count(:get_multi)).to be(1)
 
       get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(2)
-      expect(logged_memory.count(:get_all)).to be(1)
+      expect(logged_memory.count(:features)).to be(1)
+      expect(logged_memory.count(:get_multi)).to be(1)
 
       get '/', {}, 'flipper' => flipper
       expect(logged_cached.count(:get_all)).to be(3)
-      expect(logged_memory.count(:get_all)).to be(1)
+      expect(logged_memory.count(:features)).to be(1)
+      expect(logged_memory.count(:get_multi)).to be(1)
     end
   end
 end

data/spec/flipper/model/active_record_spec.rb

@@ -0,0 +1,61 @@
+require 'active_record'
+require 'flipper/model/active_record'
+
+# Turn off migration logging for specs
+ActiveRecord::Migration.verbose = false
+
+RSpec.describe Flipper::Model::ActiveRecord do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+  end
+
+  before(:each) do
+    ActiveRecord::Base.connection.execute <<-SQL
+      CREATE TABLE users (
+        id integer PRIMARY KEY,
+        name string NOT NULL,
+        age integer,
+        is_confirmed boolean,
+        created_at datetime NOT NULL,
+        updated_at datetime NOT NULL
+      )
+    SQL
+  end
+
+  after(:each) do
+    ActiveRecord::Base.connection.execute("DROP table IF EXISTS `users`")
+  end
+
+  class User < ActiveRecord::Base
+    include Flipper::Model::ActiveRecord
+  end
+
+  class Admin < User
+  end
+
+  describe "flipper_id" do
+    it "returns class name and id" do
+      expect(User.new(id: 1).flipper_id).to eq("User;1")
+    end
+
+    it "uses base class name" do
+      expect(Admin.new(id: 2).flipper_id).to eq("User;2")
+    end
+  end
+
+  describe "flipper_properties" do
+    subject { User.create!(name: "Test", age: 22, is_confirmed: true) }
+
+    it "includes all attributes" do
+      expect(subject.flipper_properties).to eq({
+        "type" => "User",
+        "id" => subject.id,
+        "name" => "Test",
+        "age" => 22,
+        "is_confirmed" => true,
+        "created_at" => subject.created_at,
+        "updated_at" => subject.updated_at
+      })
+    end
+  end
+end

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/serializers/gzip_spec.rb

@@ -0,0 +1,13 @@
+require 'flipper/serializers/gzip'
+
+RSpec.describe Flipper::Serializers::Gzip do
+  it "serializes and deserializes" do
+    serialized = described_class.serialize("my data")
+    expect(described_class.deserialize(serialized)).to eq("my data")
+  end
+
+  it "doesn't fail with nil" do
+    expect(described_class.serialize(nil)).to be(nil)
+    expect(described_class.deserialize(nil)).to be(nil)
+  end
+end

data/spec/flipper/serializers/json_spec.rb

@@ -0,0 +1,13 @@
+require 'flipper/serializers/json'
+
+RSpec.describe Flipper::Serializers::Json do
+  it "serializes and deserializes" do
+    serialized = described_class.serialize("my data")
+    expect(described_class.deserialize(serialized)).to eq("my data")
+  end
+
+  it "doesn't fail with nil" do
+    expect(described_class.serialize(nil)).to be(nil)
+    expect(described_class.deserialize(nil)).to be(nil)
+  end
+end