flipper 1.0.0 → 1.3.6

data/spec/flipper/middleware/memoizer_spec.rb

@@ -80,7 +80,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
   context 'with preload: true' do
     let(:app) do
       # ensure scoped for builder block, annoying...
-      instance = flipper
+      flipper
       middleware = described_class
 
       Rack::Builder.new do
@@ -141,7 +141,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
   context 'with preload specific' do
     let(:app) do
       # ensure scoped for builder block, annoying...
-      instance = flipper
+      flipper
       middleware = described_class
 
       Rack::Builder.new do
@@ -196,10 +196,77 @@ 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...
-      instance = flipper
+      flipper
       middleware = described_class
 
       Rack::Builder.new do
@@ -218,7 +285,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
     end
 
     def get(uri, params = {}, env = {}, &block)
-      silence { super(uri, params, env, &block) }
+      capture_output { super(uri, params, env, &block) }
     end
 
     include_examples 'flipper middleware'
@@ -249,7 +316,7 @@ RSpec.describe Flipper::Middleware::Memoizer do
   context 'with flipper setup in env' do
     let(:app) do
       # ensure scoped for builder block, annoying...
-      instance = flipper
+      flipper
       middleware = described_class
 
       Rack::Builder.new do
@@ -391,9 +458,8 @@ 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)
       flipper[:stats].enable
       flipper[:shiny].enable
@@ -404,15 +470,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,72 @@
+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 DelegatedUser < DelegateClass(User)
+  end
+
+  class Admin < User
+  end
+
+  it "doesn't warn for to_ary" do
+    # looks like we should remove this but you are wrong, we have specs that
+    # fail if there are warnings and if this regresses it will print a warning
+    # so it is in fact testing something
+    user = User.create!(name: "Test")
+    Flipper.enabled?(:something, DelegatedUser.new(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/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

data/spec/flipper/typecast_spec.rb

@@ -56,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,
@@ -65,9 +65,9 @@ RSpec.describe Flipper::Typecast do
     '99' => 99,
     '99.9' => 99.9,
   }.each do |value, expected|
-    context "#to_percentage for #{value.inspect}" do
+    context "#to_number for #{value.inspect}" do
       it "returns #{expected}" do
-        expect(described_class.to_percentage(value)).to be(expected)
+        expect(described_class.to_number(value)).to be(expected)
       end
     end
   end
@@ -99,14 +99,14 @@ 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 a percentage))
+      described_class.to_number(['asdf'])
+    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to a number))
   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 percentage))
+      described_class.to_number(['asdf.0'])
+    end.to raise_error(ArgumentError, %(["asdf.0"] cannot be converted to a number))
   end
 
   it 'raises argument error for set value that cannot be converted to a set' do
@@ -127,6 +127,30 @@ RSpec.describe Flipper::Typecast do
       expect(result["search"]).not_to be(hash["search"])
     end
 
+    it "converts does not convert expressions" do
+      hash = {
+        "search" => {
+          boolean: nil,
+          expression: {"Equal"=>[{"Property"=>["plan"]}, "basic"]},
+          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,
+          expression: {"Equal"=>[{"Property"=>["plan"]}, "basic"]},
+          groups: Set['a', 'b'],
+          actors: Set['User;1'],
+          percentage_of_actors: nil,
+          percentage_of_time: nil,
+        },
+      })
+    end
+
     it "converts gate value arrays to sets" do
       hash = {
         "search" => {
@@ -193,4 +217,16 @@ RSpec.describe Flipper::Typecast do
       })
     end
   end
+
+  it "converts to and from json" do
+    source = {"foo" => "bar"}
+    output = described_class.to_json(source)
+    expect(described_class.from_json(output)).to eq(source)
+  end
+
+  it "converts to and from gzip" do
+    source = "foo bar"
+    output = described_class.to_gzip(source)
+    expect(described_class.from_gzip(output)).to eq(source)
+  end
 end

data/spec/flipper/types/actor_spec.rb

@@ -11,12 +11,19 @@ RSpec.describe Flipper::Types::Actor do
       attr_reader :flipper_id
 
       def initialize(flipper_id)
-        @flipper_id = flipper_id
+        @flipper_id = flipper_id.to_s
       end
 
       def admin?
         true
       end
+
+      def flipper_properties
+        {
+          "flipper_id" => flipper_id,
+          "admin" => admin?,
+        }
+      end
     end
   end
 
@@ -87,6 +94,15 @@ RSpec.describe Flipper::Types::Actor do
     expect(actor.admin?).to eq(true)
   end
 
+  it 'proxies flipper_properties to actor' do
+    actor = actor_class.new(10)
+    actor = described_class.new(actor)
+    expect(actor.flipper_properties).to eq({
+      "flipper_id" => "10",
+      "admin" => true,
+    })
+  end
+
   it 'exposes actor' do
     actor = actor_class.new(10)
     actor_type_instance = described_class.new(actor)
@@ -104,6 +120,7 @@ RSpec.describe Flipper::Types::Actor do
       actor = actor_class.new(10)
       actor_type_instance = described_class.new(actor)
       expect(actor_type_instance.respond_to?(:admin?)).to eq(true)
+      expect(actor_type_instance.respond_to?(:flipper_properties)).to eq(true)
     end
 
     it 'returns false if does not respond to method and actor does not respond to method' do

data/spec/flipper_integration_spec.rb

@@ -8,17 +8,24 @@ RSpec.describe Flipper do
   let(:dev_group)   { flipper.group(:devs) }
 
   let(:admin_actor) do
-    double 'Non Flipper Thing', flipper_id: 1,  admin?: true, dev?: false
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: true, dev?: false, flipper_properties: {"admin" => true, "dev" => false}
   end
   let(:dev_actor) do
-    double 'Non Flipper Thing', flipper_id: 10, admin?: false, dev?: true
+    double 'Non Flipper Thing', flipper_id: 10, admin?: false, dev?: true, flipper_properties: {"admin" => false, "dev" => true}
   end
 
   let(:admin_truthy_actor) do
-    double 'Non Flipper Thing', flipper_id: 1,  admin?: 'true-ish', dev?: false
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: 'true-ish', dev?: false, flipper_properties: {"admin" => "true-ish", "dev" => false}
   end
   let(:admin_falsey_actor) do
-    double 'Non Flipper Thing', flipper_id: 1,  admin?: nil, dev?: false
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: nil, dev?: false, flipper_properties: {"admin" => nil, "dev" => false}
+  end
+
+  let(:basic_plan_actor) do
+    double 'Non Flipper Thing', flipper_id: 1, flipper_properties: {"plan" => "basic"}
+  end
+  let(:premium_plan_actor) do
+    double 'Non Flipper Thing', flipper_id: 10, flipper_properties: {"plan" => "premium"}
   end
 
   let(:pitt)        { Flipper::Actor.new(1) }
@@ -70,10 +77,12 @@ RSpec.describe Flipper do
 
       it 'enables feature for flipper actor in group' do
         expect(feature.enabled?(Flipper::Types::Actor.new(admin_actor))).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
 
       it 'does not enable for flipper actor not in group' do
         expect(feature.enabled?(Flipper::Types::Actor.new(dev_actor))).to eq(false)
+        expect(feature.enabled?(dev_actor)).to eq(false)
       end
 
       it 'does not enable feature for all' do
@@ -257,10 +266,12 @@ RSpec.describe Flipper do
 
       it 'disables feature for flipper actor in group' do
         expect(feature.enabled?(Flipper::Types::Actor.new(admin_actor))).to eq(false)
+        expect(feature.enabled?(admin_actor)).to eq(false)
       end
 
       it 'does not disable feature for flipper actor in other groups' do
         expect(feature.enabled?(Flipper::Types::Actor.new(dev_actor))).to eq(true)
+        expect(feature.enabled?(dev_actor)).to eq(true)
       end
 
       it 'adds feature to set of features' do
@@ -379,6 +390,7 @@ RSpec.describe Flipper do
 
       it 'returns true for truthy block values' do
         expect(feature.enabled?(Flipper::Types::Actor.new(admin_truthy_actor))).to eq(true)
+        expect(feature.enabled?(admin_truthy_actor)).to eq(true)
       end
 
       it 'returns true if any actor is in enabled group' do
@@ -394,6 +406,7 @@ RSpec.describe Flipper do
 
       it 'returns false for falsey block values' do
         expect(feature.enabled?(Flipper::Types::Actor.new(admin_falsey_actor))).to eq(false)
+        expect(feature.enabled?(admin_falsey_actor)).to eq(false)
       end
     end
 
@@ -549,4 +562,89 @@ RSpec.describe Flipper do
       expect(feature.enabled?(dev_actor)).to eq(false)
     end
   end
+
+  context "for expression" do
+    it "works" do
+      feature.enable Flipper.property(:plan).eq("basic")
+
+      expect(feature.enabled?).to be(false)
+      expect(feature.enabled?(basic_plan_actor)).to be(true)
+      expect(feature.enabled?(premium_plan_actor)).to be(false)
+      expect(feature.enabled?(admin_actor)).to be(false)
+    end
+
+    it "works for true expression with no actor" do
+      feature.enable Flipper.boolean(true)
+      expect(feature.enabled?).to be(true)
+    end
+
+    it "works for multiple actors" do
+      feature.enable Flipper.property(:plan).eq("basic")
+
+      expect(feature.enabled?(basic_plan_actor, premium_plan_actor)).to be(true)
+      expect(feature.enabled?(premium_plan_actor, basic_plan_actor)).to be(true)
+      expect(feature.enabled?(premium_plan_actor, admin_actor)).to be(false)
+    end
+  end
+
+  context "for Any" do
+    it "works" do
+      expression = Flipper.any(
+        Flipper.property(:plan).eq("basic"),
+        Flipper.property(:plan).eq("plus"),
+      )
+      feature.enable expression
+
+      expect(feature.enabled?(basic_plan_actor)).to be(true)
+      expect(feature.enabled?(premium_plan_actor)).to be(false)
+    end
+  end
+
+  context "for All" do
+    it "works" do
+      true_actor = Flipper::Actor.new("User;1", {
+        "plan" => "basic",
+        "age" => 21,
+      })
+      false_actor = Flipper::Actor.new("User;1", {
+        "plan" => "basic",
+        "age" => 20,
+      })
+      expression = Flipper.all(
+        Flipper.property(:plan).eq("basic"),
+        Flipper.property(:age).eq(21)
+      )
+      feature.enable expression
+
+      expect(feature.enabled?(true_actor)).to be(true)
+      expect(feature.enabled?(false_actor)).to be(false)
+    end
+
+    it "works when nested" do
+      admin_actor = Flipper::Actor.new("User;1", {
+        "admin" => true,
+      })
+      true_actor = Flipper::Actor.new("User;1", {
+        "plan" => "basic",
+        "age" => 21,
+      })
+      false_actor = Flipper::Actor.new("User;1", {
+        "plan" => "basic",
+        "age" => 20,
+      })
+      expression = Flipper.any(
+        Flipper.property(:admin).eq(true),
+        Flipper.all(
+          Flipper.property(:plan).eq("basic"),
+          Flipper.property(:age).eq(21)
+        )
+      )
+
+      feature.enable expression
+
+      expect(feature.enabled?(admin_actor)).to be(true)
+      expect(feature.enabled?(true_actor)).to be(true)
+      expect(feature.enabled?(false_actor)).to be(false)
+    end
+  end
 end

data/spec/flipper_spec.rb

@@ -64,7 +64,12 @@ RSpec.describe Flipper do
 
   describe "delegation to instance" do
     let(:group) { Flipper::Types::Group.new(:admins) }
-    let(:actor) { Flipper::Actor.new("1") }
+    let(:actor) {
+      Flipper::Actor.new("1", {
+        "plan" => "basic",
+      })
+    }
+    let(:expression) { Flipper.property(:plan).eq("basic") }
 
     before do
       described_class.configure do |config|
@@ -88,6 +93,37 @@ RSpec.describe Flipper do
       expect(described_class.instance.enabled?(:search)).to be(false)
     end
 
+    it 'delegates expression to instance' do
+      expect(described_class.expression(:search)).to be(nil)
+
+      expression = Flipper.property(:plan).eq("basic")
+      Flipper.instance.enable_expression :search, expression
+
+      expect(described_class.expression(:search)).to eq(expression)
+    end
+
+    it 'delegates enable_expression to instance' do
+      described_class.enable_expression(:search, expression)
+      expect(described_class.instance.enabled?(:search, actor)).to be(true)
+    end
+
+    it 'delegates disable_expression to instance' do
+      described_class.disable_expression(:search)
+      expect(described_class.instance.enabled?(:search, actor)).to be(false)
+    end
+
+    it 'delegates add_expression to instance' do
+      described_class.add_expression(:search, expression)
+      expect(described_class.instance.enabled?(:search, actor)).to be(true)
+    end
+
+    it 'delegates remove_expression to instance' do
+      described_class.enable_expression(:search, Flipper.any(expression))
+      expect(described_class.instance.enabled?(:search, actor)).to be(true)
+      described_class.remove_expression(:search, expression)
+      expect(described_class.instance.enabled?(:search, actor)).to be(false)
+    end
+
     it 'delegates enable_actor to instance' do
       described_class.enable_actor(:search, actor)
       expect(described_class.instance.enabled?(:search, actor)).to be(true)
@@ -192,6 +228,10 @@ RSpec.describe Flipper do
       expect(described_class.memoizing?).to eq(described_class.adapter.memoizing?)
     end
 
+    it 'delegates read_only? to instance' do
+      expect(described_class.read_only?).to eq(described_class.adapter.read_only?)
+    end
+
     it 'delegates sync stuff to instance and does nothing' do
       expect(described_class.sync).to be(nil)
       expect(described_class.sync_secret).to be(nil)
@@ -201,7 +241,7 @@ RSpec.describe Flipper do
       stub = stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
         with({
           headers: {
-            'Flipper-Cloud-Token'=>'asdf',
+            'flipper-cloud-token'=>'asdf',
           },
         }).to_return(status: 200, body: '{"features": {}}', headers: {})
       cloud_configuration = Flipper::Cloud::Configuration.new({
@@ -273,7 +313,7 @@ RSpec.describe Flipper do
 
   describe '.group_exists' do
     it 'returns true if the group is already created' do
-      group = described_class.register('admins', &:admin?)
+      described_class.register('admins', &:admin?)
       expect(described_class.group_exists?(:admins)).to eq(true)
     end
 
@@ -326,4 +366,52 @@ RSpec.describe Flipper do
       expect(described_class.instance_variable_get('@groups_registry')).to eq(registry)
     end
   end
+
+  describe ".constant" do
+    it "returns Flipper::Expression::Constant instance" do
+      expect(described_class.constant(false)).to eq(Flipper::Expression::Constant.new(false))
+      expect(described_class.constant("string")).to eq(Flipper::Expression::Constant.new("string"))
+    end
+  end
+
+  describe ".property" do
+    it "returns Flipper::Expressions::Property expression" do
+      expect(Flipper.property("name")).to eq(Flipper::Expression.build(Property: "name"))
+    end
+  end
+
+  describe ".boolean" do
+    it "returns Flipper::Expressions::Boolean expression" do
+      expect(described_class.boolean(true)).to eq(Flipper::Expression.build(Boolean: true))
+      expect(described_class.boolean(false)).to eq(Flipper::Expression.build(Boolean: false))
+    end
+  end
+
+  describe ".random" do
+    it "returns Flipper::Expressions::Random expression" do
+      expect(Flipper.random(100)).to eq(Flipper::Expression.build(Random: 100))
+    end
+  end
+
+  describe ".any" do
+    let(:age_expression) { Flipper.property(:age).gte(21) }
+    let(:plan_expression) { Flipper.property(:plan).eq("basic") }
+
+    it "returns Flipper::Expressions::Any instance" do
+      expect(Flipper.any(age_expression, plan_expression)).to eq(
+        Flipper::Expression.build({Any: [age_expression, plan_expression]})
+      )
+    end
+  end
+
+  describe ".all" do
+    let(:age_expression) { Flipper.property(:age).gte(21) }
+    let(:plan_expression) { Flipper.property(:plan).eq("basic") }
+
+    it "returns Flipper::Expressions::All instance" do
+      expect(Flipper.all(age_expression, plan_expression)).to eq(
+        Flipper::Expression.build({All: [age_expression, plan_expression]})
+      )
+    end
+  end
 end