flipper 0.26.0 → 1.1.0

data/spec/flipper/types/actor_spec.rb

@@ -2,34 +2,41 @@ 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
 
       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
 
   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
@@ -38,27 +45,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
@@ -68,48 +75,58 @@ 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 '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)
+    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)
+      expect(actor_type_instance.respond_to?(:flipper_properties)).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/group_spec.rb

@@ -90,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)
@@ -101,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_integration_spec.rb

@@ -7,25 +7,32 @@ RSpec.describe Flipper do
   let(:admin_group) { flipper.group(:admins) }
   let(:dev_group)   { flipper.group(:devs) }
 
-  let(:admin_thing) do
-    double 'Non Flipper Thing', flipper_id: 1,  admin?: true, dev?: false
+  let(:admin_actor) do
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: true, dev?: false, flipper_properties: {"admin" => true, "dev" => false}
   end
-  let(:dev_thing) do
-    double 'Non Flipper Thing', flipper_id: 10, admin?: false, dev?: true
+  let(:dev_actor) do
+    double 'Non Flipper Thing', flipper_id: 10, admin?: false, dev?: true, flipper_properties: {"admin" => false, "dev" => true}
   end
 
-  let(:admin_truthy_thing) do
-    double 'Non Flipper Thing', flipper_id: 1,  admin?: 'true-ish', dev?: false
+  let(:admin_truthy_actor) do
+    double 'Non Flipper Thing', flipper_id: 1,  admin?: 'true-ish', dev?: false, flipper_properties: {"admin" => "true-ish", "dev" => false}
   end
-  let(:admin_falsey_thing) do
-    double 'Non Flipper Thing', flipper_id: 1,  admin?: nil, dev?: false
+  let(:admin_falsey_actor) do
+    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) }
   let(:clooney)     { Flipper::Actor.new(10) }
 
-  let(:five_percent_of_actors) { flipper.actors(5) }
-  let(:five_percent_of_time) { flipper.time(5) }
+  let(:five_percent_of_actors) { Flipper::Types::PercentageOfActors.new(5) }
+  let(:five_percent_of_time) { Flipper::Types::PercentageOfTime.new(5) }
 
   before do
     described_class.register(:admins, &:admin?)
@@ -60,20 +67,22 @@ RSpec.describe Flipper do
         expect(@result).to eq(true)
       end
 
-      it 'enables feature for non flipper thing in group' do
-        expect(feature.enabled?(admin_thing)).to eq(true)
+      it 'enables feature for non flipper actor in group' do
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
 
-      it 'does not enable feature for non flipper thing in other group' do
-        expect(feature.enabled?(dev_thing)).to eq(false)
+      it 'does not enable feature for non flipper actor in other group' do
+        expect(feature.enabled?(dev_actor)).to eq(false)
       end
 
       it 'enables feature for flipper actor in group' do
-        expect(feature.enabled?(flipper.actor(admin_thing))).to eq(true)
+        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.actor(dev_thing))).to eq(false)
+        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
@@ -118,8 +127,8 @@ RSpec.describe Flipper do
 
       it 'enables feature for actor within percentage' do
         enabled = (1..100).select do |i|
-          thing = Flipper::Actor.new(i)
-          feature.enabled?(thing)
+          actor = Flipper::Actor.new(i)
+          feature.enabled?(actor)
         end.size
 
         expect(enabled).to be_within(2).of(5)
@@ -141,8 +150,8 @@ RSpec.describe Flipper do
 
       it 'enables feature for actor within percentage' do
         enabled = (1..100).select do |i|
-          thing = Flipper::Actor.new(i)
-          feature.enabled?(thing)
+          actor = Flipper::Actor.new(i)
+          feature.enabled?(actor)
         end.size
 
         expect(enabled).to be_within(2).of(5)
@@ -180,10 +189,10 @@ RSpec.describe Flipper do
 
     context 'with argument that has no gate' do
       it 'raises error' do
-        thing = Object.new
+        actor = Object.new
         expect do
-          feature.enable(thing)
-        end.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
+          feature.enable(actor)
+        end.to raise_error(Flipper::GateNotFound, "Could not find gate for #{actor.inspect}")
       end
     end
   end
@@ -215,13 +224,13 @@ RSpec.describe Flipper do
       end
 
       it 'disables actor in group' do
-        expect(feature.enabled?(admin_thing)).to eq(false)
+        expect(feature.enabled?(admin_actor)).to eq(false)
       end
 
       it 'disables actor in percentage of actors' do
         enabled = (1..100).select do |i|
-          thing = Flipper::Actor.new(i)
-          feature.enabled?(thing)
+          actor = Flipper::Actor.new(i)
+          feature.enabled?(actor)
         end.size
 
         expect(enabled).to be(0)
@@ -247,20 +256,22 @@ RSpec.describe Flipper do
         expect(@result).to eq(true)
       end
 
-      it 'disables the feature for non flipper thing in the group' do
-        expect(feature.enabled?(admin_thing)).to eq(false)
+      it 'disables the feature for non flipper actor in the group' do
+        expect(feature.enabled?(admin_actor)).to eq(false)
       end
 
-      it 'does not disable feature for non flipper thing in other groups' do
-        expect(feature.enabled?(dev_thing)).to eq(true)
+      it 'does not disable feature for non flipper actor in other groups' do
+        expect(feature.enabled?(dev_actor)).to eq(true)
       end
 
       it 'disables feature for flipper actor in group' do
-        expect(feature.enabled?(flipper.actor(admin_thing))).to eq(false)
+        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.actor(dev_thing))).to eq(true)
+        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
@@ -294,7 +305,7 @@ RSpec.describe Flipper do
 
     context 'with a percentage of actors' do
       before do
-        @result = feature.disable(flipper.actors(0))
+        @result = feature.disable(Flipper::Types::PercentageOfActors.new(0))
       end
 
       it 'returns true' do
@@ -303,8 +314,8 @@ RSpec.describe Flipper do
 
       it 'disables feature' do
         enabled = (1..100).select do |i|
-          thing = Flipper::Actor.new(i)
-          feature.enabled?(thing)
+          actor = Flipper::Actor.new(i)
+          feature.enabled?(actor)
         end.size
 
         expect(enabled).to be(0)
@@ -318,7 +329,7 @@ RSpec.describe Flipper do
     context 'with a percentage of time' do
       before do
         @gate = feature.gate(:percentage_of_time)
-        @result = feature.disable(flipper.time(0))
+        @result = feature.disable(Flipper::Types::PercentageOfTime.new(0))
       end
 
       it 'returns true' do
@@ -342,10 +353,10 @@ RSpec.describe Flipper do
 
     context 'with argument that has no gate' do
       it 'raises error' do
-        thing = Object.new
+        actor = Object.new
         expect do
-          feature.disable(thing)
-        end.to raise_error(Flipper::GateNotFound, "Could not find gate for #{thing.inspect}")
+          feature.disable(actor)
+        end.to raise_error(Flipper::GateNotFound, "Could not find gate for #{actor.inspect}")
       end
     end
   end
@@ -373,23 +384,29 @@ RSpec.describe Flipper do
       end
 
       it 'returns true' do
-        expect(feature.enabled?(flipper.actor(admin_thing))).to eq(true)
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(Flipper::Types::Actor.new(admin_actor))).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
 
       it 'returns true for truthy block values' do
-        expect(feature.enabled?(flipper.actor(admin_truthy_thing))).to eq(true)
+        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
+        expect(feature.enabled?(dev_actor, admin_actor)).to be(true)
       end
     end
 
     context 'for actor in disabled group' do
       it 'returns false' do
-        expect(feature.enabled?(flipper.actor(dev_thing))).to eq(false)
-        expect(feature.enabled?(dev_thing)).to eq(false)
+        expect(feature.enabled?(Flipper::Types::Actor.new(dev_actor))).to eq(false)
+        expect(feature.enabled?(dev_actor)).to eq(false)
       end
 
       it 'returns false for falsey block values' do
-        expect(feature.enabled?(flipper.actor(admin_falsey_thing))).to eq(false)
+        expect(feature.enabled?(Flipper::Types::Actor.new(admin_falsey_actor))).to eq(false)
+        expect(feature.enabled?(admin_falsey_actor)).to eq(false)
       end
     end
 
@@ -408,6 +425,10 @@ RSpec.describe Flipper do
         expect(feature.enabled?(clooney)).to eq(false)
       end
 
+      it 'returns false if all actors are disabled' do
+        expect(feature.enabled?(clooney, pitt)).to be(false)
+      end
+
       it 'returns true if boolean enabled' do
         feature.enable
         expect(feature.enabled?(clooney)).to eq(true)
@@ -428,7 +449,7 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(true)
         expect(feature.enabled?(nil)).to eq(true)
         expect(feature.enabled?(pitt)).to eq(true)
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
     end
 
@@ -446,7 +467,7 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(true)
         expect(feature.enabled?(nil)).to eq(true)
         expect(feature.enabled?(pitt)).to eq(true)
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
     end
 
@@ -463,7 +484,7 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(false)
         expect(feature.enabled?(nil)).to eq(false)
         expect(feature.enabled?(pitt)).to eq(false)
-        expect(feature.enabled?(admin_thing)).to eq(false)
+        expect(feature.enabled?(admin_actor)).to eq(false)
       end
 
       it 'returns true if boolean enabled' do
@@ -471,7 +492,7 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(true)
         expect(feature.enabled?(nil)).to eq(true)
         expect(feature.enabled?(pitt)).to eq(true)
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
     end
 
@@ -488,7 +509,7 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(false)
         expect(feature.enabled?(nil)).to eq(false)
         expect(feature.enabled?(pitt)).to eq(false)
-        expect(feature.enabled?(admin_thing)).to eq(false)
+        expect(feature.enabled?(admin_actor)).to eq(false)
       end
 
       it 'returns true if boolean enabled' do
@@ -496,27 +517,31 @@ RSpec.describe Flipper do
         expect(feature.enabled?).to eq(true)
         expect(feature.enabled?(nil)).to eq(true)
         expect(feature.enabled?(pitt)).to eq(true)
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
     end
 
-    context 'for a non flipper thing' do
+    context 'for a non flipper actor' do
       before do
         feature.enable admin_group
       end
 
       it 'returns true if in enabled group' do
-        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
       end
 
       it 'returns false if not in enabled group' do
-        expect(feature.enabled?(dev_thing)).to eq(false)
+        expect(feature.enabled?(dev_actor)).to eq(false)
+      end
+
+      it 'retruns true if any actor is true' do
+        expect(feature.enabled?(admin_actor, dev_actor)).to eq(true)
       end
 
       it 'returns true if boolean enabled' do
         feature.enable
-        expect(feature.enabled?(admin_thing)).to eq(true)
-        expect(feature.enabled?(dev_thing)).to eq(true)
+        expect(feature.enabled?(admin_actor)).to eq(true)
+        expect(feature.enabled?(dev_actor)).to eq(true)
       end
     end
   end
@@ -530,11 +555,96 @@ RSpec.describe Flipper do
     end
 
     it 'enables feature for object in enabled group' do
-      expect(feature.enabled?(admin_thing)).to eq(true)
+      expect(feature.enabled?(admin_actor)).to eq(true)
     end
 
     it 'does not enable feature for object in not enabled group' do
-      expect(feature.enabled?(dev_thing)).to eq(false)
+      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