flipper 0.16.0 → 1.4.0

data/lib/flipper/spec/shared_adapter_specs.rb

@@ -1,15 +1,15 @@
 # Requires the following methods:
 # * subject - The instance of the adapter
-# rubocop:disable Metrics/BlockLength
 RSpec.shared_examples_for 'a flipper adapter' 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(:expression_gate) { feature.gate(:expression) }
+  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) }
 
   before do
     Flipper.register(:admins) do |actor|
@@ -34,17 +34,25 @@ RSpec.shared_examples_for 'a flipper adapter' do
     expect(subject.class.ancestors).to include(Flipper::Adapter)
   end
 
+  it 'knows how to get adapter from source' do
+    adapter = Flipper::Adapters::Memory.new
+    flipper = Flipper.new(adapter)
+    expect(subject.class.from(adapter).class.ancestors).to include(Flipper::Adapter)
+    expect(subject.class.from(flipper).class.ancestors).to include(Flipper::Adapter)
+  end
+
   it 'returns correct default values for the gates if none are enabled' do
+    expect(subject.get(feature)).to eq(subject.class.default_config)
     expect(subject.get(feature)).to eq(subject.default_config)
   end
 
   it 'can enable, disable and get value for boolean gate' do
-    expect(subject.enable(feature, boolean_gate, flipper.boolean)).to eq(true)
+    expect(subject.enable(feature, boolean_gate, Flipper::Types::Boolean.new)).to eq(true)
 
     result = subject.get(feature)
     expect(result[:boolean]).to eq('true')
 
-    expect(subject.disable(feature, boolean_gate, flipper.boolean(false))).to eq(true)
+    expect(subject.disable(feature, boolean_gate, Flipper::Types::Boolean.new(false))).to eq(true)
 
     result = subject.get(feature)
     expect(result[:boolean]).to eq(nil)
@@ -52,17 +60,34 @@ RSpec.shared_examples_for 'a flipper adapter' do
 
   it 'fully disables all enabled things when boolean gate disabled' do
     actor22 = Flipper::Actor.new('22')
-    expect(subject.enable(feature, boolean_gate, flipper.boolean)).to eq(true)
+    expect(subject.enable(feature, boolean_gate, Flipper::Types::Boolean.new)).to eq(true)
     expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
-    expect(subject.enable(feature, actor_gate, flipper.actor(actor22))).to eq(true)
-    expect(subject.enable(feature, actors_gate, flipper.actors(25))).to eq(true)
-    expect(subject.enable(feature, time_gate, flipper.time(45))).to eq(true)
-
-    expect(subject.disable(feature, boolean_gate, flipper.boolean(false))).to eq(true)
+    expect(subject.enable(feature, actor_gate, Flipper::Types::Actor.new(actor22))).to eq(true)
+    expect(subject.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(25))).to eq(true)
+    expect(subject.enable(feature, time_gate, Flipper::Types::PercentageOfTime.new(45))).to eq(true)
 
+    expect(subject.disable(feature, boolean_gate, Flipper::Types::Boolean.new(false))).to eq(true)
     expect(subject.get(feature)).to eq(subject.default_config)
   end
 
+  it 'can enable, disable and get value for expression gate' do
+    basic_expression = Flipper.property(:plan).eq("basic")
+    age_expression = Flipper.property(:age).gte(21)
+    any_expression = Flipper.any(basic_expression, age_expression)
+
+    expect(subject.enable(feature, expression_gate, any_expression)).to eq(true)
+    result = subject.get(feature)
+    expect(result[:expression]).to eq(any_expression.value)
+
+    expect(subject.enable(feature, expression_gate, basic_expression)).to eq(true)
+    result = subject.get(feature)
+    expect(result[:expression]).to eq(basic_expression.value)
+
+    expect(subject.disable(feature, expression_gate, basic_expression)).to eq(true)
+    result = subject.get(feature)
+    expect(result[:expression]).to be(nil)
+  end
+
   it 'can enable, disable and get value for group gate' do
     expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
     expect(subject.enable(feature, group_gate, flipper.group(:early_access))).to eq(true)
@@ -83,34 +108,34 @@ RSpec.shared_examples_for 'a flipper adapter' do
     actor22 = Flipper::Actor.new('22')
     actor_asdf = Flipper::Actor.new('asdf')
 
-    expect(subject.enable(feature, actor_gate, flipper.actor(actor22))).to eq(true)
-    expect(subject.enable(feature, actor_gate, flipper.actor(actor_asdf))).to eq(true)
+    expect(feature.enable(actor22)).to be(true)
+    expect(feature.enable(actor_asdf)).to be(true)
 
-    result = subject.get(feature)
-    expect(result[:actors]).to eq(Set['22', 'asdf'])
+    expect(feature).to be_enabled(actor22)
+    expect(feature).to be_enabled(actor_asdf)
 
-    expect(subject.disable(feature, actor_gate, flipper.actor(actor22))).to eq(true)
-    result = subject.get(feature)
-    expect(result[:actors]).to eq(Set['asdf'])
+    expect(feature.disable(actor22)).to be(true)
+    expect(feature).not_to be_enabled(actor22)
+    expect(feature).to be_enabled(actor_asdf)
 
-    expect(subject.disable(feature, actor_gate, flipper.actor(actor_asdf))).to eq(true)
-    result = subject.get(feature)
-    expect(result[:actors]).to eq(Set.new)
+    expect(feature.disable(actor_asdf)).to eq(true)
+    expect(feature).not_to be_enabled(actor22)
+    expect(feature).not_to be_enabled(actor_asdf)
   end
 
   it 'can enable, disable and get value for percentage of actors gate' do
-    expect(subject.enable(feature, actors_gate, flipper.actors(15))).to eq(true)
+    expect(subject.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(15))).to eq(true)
     result = subject.get(feature)
     expect(result[:percentage_of_actors]).to eq('15')
 
-    expect(subject.disable(feature, actors_gate, flipper.actors(0))).to eq(true)
+    expect(subject.disable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(0))).to eq(true)
     result = subject.get(feature)
     expect(result[:percentage_of_actors]).to eq('0')
   end
 
   it 'can enable percentage of actors gate many times and consistently return values' do
     (1..100).each do |percentage|
-      expect(subject.enable(feature, actors_gate, flipper.actors(percentage))).to eq(true)
+      expect(subject.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(percentage))).to eq(true)
       result = subject.get(feature)
       expect(result[:percentage_of_actors]).to eq(percentage.to_s)
     end
@@ -118,25 +143,25 @@ RSpec.shared_examples_for 'a flipper adapter' do
 
   it 'can disable percentage of actors gate many times and consistently return values' do
     (1..100).each do |percentage|
-      expect(subject.disable(feature, actors_gate, flipper.actors(percentage))).to eq(true)
+      expect(subject.disable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(percentage))).to eq(true)
       result = subject.get(feature)
       expect(result[:percentage_of_actors]).to eq(percentage.to_s)
     end
   end
 
   it 'can enable, disable and get value for percentage of time gate' do
-    expect(subject.enable(feature, time_gate, flipper.time(10))).to eq(true)
+    expect(subject.enable(feature, time_gate, Flipper::Types::PercentageOfTime.new(10))).to eq(true)
     result = subject.get(feature)
     expect(result[:percentage_of_time]).to eq('10')
 
-    expect(subject.disable(feature, time_gate, flipper.time(0))).to eq(true)
+    expect(subject.disable(feature, time_gate, Flipper::Types::PercentageOfTime.new(0))).to eq(true)
     result = subject.get(feature)
     expect(result[:percentage_of_time]).to eq('0')
   end
 
   it 'can enable percentage of time gate many times and consistently return values' do
     (1..100).each do |percentage|
-      expect(subject.enable(feature, time_gate, flipper.time(percentage))).to eq(true)
+      expect(subject.enable(feature, time_gate, Flipper::Types::PercentageOfTime.new(percentage))).to eq(true)
       result = subject.get(feature)
       expect(result[:percentage_of_time]).to eq(percentage.to_s)
     end
@@ -144,22 +169,23 @@ RSpec.shared_examples_for 'a flipper adapter' do
 
   it 'can disable percentage of time gate many times and consistently return values' do
     (1..100).each do |percentage|
-      expect(subject.disable(feature, time_gate, flipper.time(percentage))).to eq(true)
+      expect(subject.disable(feature, time_gate, Flipper::Types::PercentageOfTime.new(percentage))).to eq(true)
       result = subject.get(feature)
       expect(result[:percentage_of_time]).to eq(percentage.to_s)
     end
   end
 
   it 'converts boolean value to a string' do
-    expect(subject.enable(feature, boolean_gate, flipper.boolean)).to eq(true)
+    expect(subject.enable(feature, boolean_gate, Flipper::Types::Boolean.new)).to eq(true)
     result = subject.get(feature)
     expect(result[:boolean]).to eq('true')
   end
 
   it 'converts the actor value to a string' do
-    expect(subject.enable(feature, actor_gate, flipper.actor(Flipper::Actor.new(22)))).to eq(true)
-    result = subject.get(feature)
-    expect(result[:actors]).to eq(Set['22'])
+    actor = Flipper::Actor.new(22)
+    expect(feature).not_to be_enabled(actor)
+    feature.enable_actor actor
+    expect(feature).to be_enabled(actor)
   end
 
   it 'converts group value to a string' do
@@ -169,13 +195,13 @@ RSpec.shared_examples_for 'a flipper adapter' do
   end
 
   it 'converts percentage of time integer value to a string' do
-    expect(subject.enable(feature, time_gate, flipper.time(10))).to eq(true)
+    expect(subject.enable(feature, time_gate, Flipper::Types::PercentageOfTime.new(10))).to eq(true)
     result = subject.get(feature)
     expect(result[:percentage_of_time]).to eq('10')
   end
 
   it 'converts percentage of actors integer value to a string' do
-    expect(subject.enable(feature, actors_gate, flipper.actors(10))).to eq(true)
+    expect(subject.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(10))).to eq(true)
     result = subject.get(feature)
     expect(result[:percentage_of_actors]).to eq('10')
   end
@@ -198,11 +224,11 @@ RSpec.shared_examples_for 'a flipper adapter' do
 
   it 'clears all the gate values for the feature on remove' do
     actor22 = Flipper::Actor.new('22')
-    expect(subject.enable(feature, boolean_gate, flipper.boolean)).to eq(true)
+    expect(subject.enable(feature, boolean_gate, Flipper::Types::Boolean.new)).to eq(true)
     expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
-    expect(subject.enable(feature, actor_gate, flipper.actor(actor22))).to eq(true)
-    expect(subject.enable(feature, actors_gate, flipper.actors(25))).to eq(true)
-    expect(subject.enable(feature, time_gate, flipper.time(45))).to eq(true)
+    expect(subject.enable(feature, actor_gate, Flipper::Types::Actor.new(actor22))).to eq(true)
+    expect(subject.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(25))).to eq(true)
+    expect(subject.enable(feature, time_gate, Flipper::Types::PercentageOfTime.new(45))).to eq(true)
 
     expect(subject.remove(feature)).to eq(true)
 
@@ -214,11 +240,11 @@ RSpec.shared_examples_for 'a flipper adapter' do
     subject.add(feature)
     expect(subject.features).to include(feature.key)
 
-    expect(subject.enable(feature, boolean_gate, flipper.boolean)).to eq(true)
+    expect(subject.enable(feature, boolean_gate, Flipper::Types::Boolean.new)).to eq(true)
     expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
-    expect(subject.enable(feature, actor_gate, flipper.actor(actor22))).to eq(true)
-    expect(subject.enable(feature, actors_gate, flipper.actors(25))).to eq(true)
-    expect(subject.enable(feature, time_gate, flipper.time(45))).to eq(true)
+    expect(subject.enable(feature, actor_gate, Flipper::Types::Actor.new(actor22))).to eq(true)
+    expect(subject.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(25))).to eq(true)
+    expect(subject.enable(feature, time_gate, Flipper::Types::PercentageOfTime.new(45))).to eq(true)
 
     expect(subject.clear(feature)).to eq(true)
     expect(subject.features).to include(feature.key)
@@ -231,7 +257,7 @@ RSpec.shared_examples_for 'a flipper adapter' do
 
   it 'can get multiple features' do
     expect(subject.add(flipper[:stats])).to eq(true)
-    expect(subject.enable(flipper[:stats], boolean_gate, flipper.boolean)).to eq(true)
+    expect(subject.enable(flipper[:stats], boolean_gate, Flipper::Types::Boolean.new)).to eq(true)
     expect(subject.add(flipper[:search])).to eq(true)
 
     result = subject.get_multi([flipper[:stats], flipper[:search], flipper[:other]])
@@ -247,16 +273,16 @@ RSpec.shared_examples_for 'a flipper adapter' do
 
   it 'can get all features' do
     expect(subject.add(flipper[:stats])).to eq(true)
-    expect(subject.enable(flipper[:stats], boolean_gate, flipper.boolean)).to eq(true)
+    expect(subject.enable(flipper[:stats], boolean_gate, Flipper::Types::Boolean.new)).to eq(true)
     expect(subject.add(flipper[:search])).to eq(true)
+    flipper.enable :analytics, Flipper.property(:plan).eq("pro")
 
     result = subject.get_all
-    expect(result).to be_instance_of(Hash)
 
-    stats = result["stats"]
-    search = result["search"]
-    expect(stats).to eq(subject.default_config.merge(boolean: 'true'))
-    expect(search).to eq(subject.default_config)
+    expect(result).to be_instance_of(Hash)
+    expect(result["stats"]).to eq(subject.default_config.merge(boolean: 'true'))
+    expect(result["search"]).to eq(subject.default_config)
+    expect(result["analytics"]).to eq(subject.default_config.merge(expression: {"Equal"=>[{"Property"=>["plan"]}, "pro"]}))
   end
 
   it 'includes explicitly disabled features when getting all features' do
@@ -270,9 +296,9 @@ RSpec.shared_examples_for 'a flipper adapter' do
 
   it 'can double enable an actor without error' do
     actor = Flipper::Actor.new('Flipper::Actor;22')
-    expect(subject.enable(feature, actor_gate, flipper.actor(actor))).to eq(true)
-    expect(subject.enable(feature, actor_gate, flipper.actor(actor))).to eq(true)
-    expect(subject.get(feature).fetch(:actors)).to eq(Set['Flipper::Actor;22'])
+    expect(feature.enable(actor)).to be(true)
+    expect(feature.enable(actor)).to be(true)
+    expect(feature).to be_enabled(actor)
   end
 
   it 'can double enable a group without error' do
@@ -280,4 +306,44 @@ RSpec.shared_examples_for 'a flipper adapter' do
     expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
     expect(subject.get(feature).fetch(:groups)).to eq(Set['admins'])
   end
+
+  it 'can double enable percentage without error' do
+    expect(subject.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(25))).to eq(true)
+    expect(subject.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(25))).to eq(true)
+  end
+
+  it 'can double enable without error' do
+    expect(subject.enable(feature, boolean_gate, Flipper::Types::Boolean.new)).to eq(true)
+    expect(subject.enable(feature, boolean_gate, Flipper::Types::Boolean.new)).to eq(true)
+  end
+
+  it 'can get_all features when there are none' do
+    expect(subject.features).to eq(Set.new)
+    expect(subject.get_all).to eq({})
+  end
+
+  it 'clears other gate values on enable' do
+    actor = Flipper::Actor.new('Flipper::Actor;22')
+    subject.enable(feature, actors_gate, Flipper::Types::PercentageOfActors.new(25))
+    subject.enable(feature, time_gate, Flipper::Types::PercentageOfTime.new(25))
+    subject.enable(feature, group_gate, flipper.group(:admins))
+    subject.enable(feature, actor_gate, Flipper::Types::Actor.new(actor))
+    subject.enable(feature, boolean_gate, Flipper::Types::Boolean.new(true))
+    expect(subject.get(feature)).to eq(subject.default_config.merge(boolean: "true"))
+  end
+
+  it 'can import and export' do
+    adapter = Flipper::Adapters::Memory.new
+    source_flipper = Flipper.new(adapter)
+    source_flipper.enable(:stats)
+    export = adapter.export
+
+    # some adapters cannot import so if they return false lets assert it
+    # didn't happen
+    if subject.import(export)
+      expect(flipper[:stats]).to be_enabled
+    else
+      expect(flipper[:stats]).not_to be_enabled
+    end
+  end
 end

data/lib/flipper/test/shared_adapter_test.rb

@@ -1,4 +1,3 @@
-# rubocop:disable Metrics/ModuleLength
 module Flipper
   module Test
     module SharedAdapterTests
@@ -8,6 +7,7 @@ module Flipper
         @feature = @flipper[:stats]
         @boolean_gate = @feature.gate(:boolean)
         @group_gate = @feature.gate(:group)
+        @expression_gate = @feature.gate(:expression)
         @actor_gate = @feature.gate(:actor)
         @actors_gate = @feature.gate(:percentage_of_actors)
         @time_gate = @feature.gate(:percentage_of_time)
@@ -35,28 +35,55 @@ module Flipper
         assert_includes @adapter.class.ancestors, Flipper::Adapter
       end
 
+      def test_knows_how_to_get_adapter_from_source
+        adapter = Flipper::Adapters::Memory.new
+        flipper = Flipper.new(adapter)
+
+        assert_includes adapter.class.from(adapter).class.ancestors, Flipper::Adapter
+        assert_includes adapter.class.from(flipper).class.ancestors, Flipper::Adapter
+      end
+
       def test_returns_correct_default_values_for_gates_if_none_are_enabled
+        assert_equal @adapter.class.default_config, @adapter.get(@feature)
         assert_equal @adapter.default_config, @adapter.get(@feature)
       end
 
       def test_can_enable_disable_and_get_value_for_boolean_gate
-        assert_equal true, @adapter.enable(@feature, @boolean_gate, @flipper.boolean)
+        assert_equal true, @adapter.enable(@feature, @boolean_gate, Flipper::Types::Boolean.new)
         assert_equal 'true', @adapter.get(@feature)[:boolean]
-        assert_equal true, @adapter.disable(@feature, @boolean_gate, @flipper.boolean(false))
-        assert_equal nil, @adapter.get(@feature)[:boolean]
+        assert_equal true, @adapter.disable(@feature, @boolean_gate, Flipper::Types::Boolean.new(false))
+        assert_nil @adapter.get(@feature)[:boolean]
       end
 
       def test_fully_disables_all_enabled_things_when_boolean_gate_disabled
         actor22 = Flipper::Actor.new('22')
-        assert_equal true, @adapter.enable(@feature, @boolean_gate, @flipper.boolean)
+        assert_equal true, @adapter.enable(@feature, @boolean_gate, Flipper::Types::Boolean.new)
         assert_equal true, @adapter.enable(@feature, @group_gate, @flipper.group(:admins))
-        assert_equal true, @adapter.enable(@feature, @actor_gate, @flipper.actor(actor22))
-        assert_equal true, @adapter.enable(@feature, @actors_gate, @flipper.actors(25))
-        assert_equal true, @adapter.enable(@feature, @time_gate, @flipper.time(45))
-        assert_equal true, @adapter.disable(@feature, @boolean_gate, @flipper.boolean(false))
+        assert_equal true, @adapter.enable(@feature, @actor_gate, Flipper::Types::Actor.new(actor22))
+        assert_equal true, @adapter.enable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(25))
+        assert_equal true, @adapter.enable(@feature, @time_gate, Flipper::Types::PercentageOfTime.new(45))
+        assert_equal true, @adapter.disable(@feature, @boolean_gate, Flipper::Types::Boolean.new(false))
         assert_equal @adapter.default_config, @adapter.get(@feature)
       end
 
+      def test_can_enable_disable_and_get_value_for_expression_gate
+        basic_expression = Flipper.property(:plan).eq("basic")
+        age_expression = Flipper.property(:age).gte(21)
+        any_expression = Flipper.any(basic_expression, age_expression)
+
+        assert_equal true, @adapter.enable(@feature, @expression_gate, any_expression)
+        result = @adapter.get(@feature)
+        assert_equal any_expression.value, result[:expression]
+
+        assert_equal true, @adapter.enable(@feature, @expression_gate, basic_expression)
+        result = @adapter.get(@feature)
+        assert_equal basic_expression.value, result[:expression]
+
+        assert_equal true, @adapter.disable(@feature, @expression_gate, basic_expression)
+        result = @adapter.get(@feature)
+        assert_nil result[:expression]
+      end
+
       def test_can_enable_disable_get_value_for_group_gate
         assert_equal true, @adapter.enable(@feature, @group_gate, @flipper.group(:admins))
         assert_equal true, @adapter.enable(@feature, @group_gate, @flipper.group(:early_access))
@@ -77,34 +104,34 @@ module Flipper
         actor22 = Flipper::Actor.new('22')
         actor_asdf = Flipper::Actor.new('asdf')
 
-        assert_equal true, @adapter.enable(@feature, @actor_gate, @flipper.actor(actor22))
-        assert_equal true, @adapter.enable(@feature, @actor_gate, @flipper.actor(actor_asdf))
+        assert_equal true, @feature.enable(actor22)
+        assert_equal true, @feature.enable(actor_asdf)
 
-        result = @adapter.get(@feature)
-        assert_equal Set['22', 'asdf'], result[:actors]
+        assert @feature.enabled?(actor22)
+        assert @feature.enabled?(actor_asdf)
 
-        assert true, @adapter.disable(@feature, @actor_gate, @flipper.actor(actor22))
-        result = @adapter.get(@feature)
-        assert_equal Set['asdf'], result[:actors]
+        assert_equal true, @feature.disable(actor22)
+        refute @feature.enabled?(actor22)
+        assert @feature.enabled?(actor_asdf)
 
-        assert_equal true, @adapter.disable(@feature, @actor_gate, @flipper.actor(actor_asdf))
-        result = @adapter.get(@feature)
-        assert_equal Set.new, result[:actors]
+        assert_equal true, @feature.disable(actor_asdf)
+        refute @feature.enabled?(actor22)
+        refute @feature.enabled?(actor_asdf)
       end
 
       def test_can_enable_disable_get_value_for_percentage_of_actors_gate
-        assert_equal true, @adapter.enable(@feature, @actors_gate, @flipper.actors(15))
+        assert_equal true, @adapter.enable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(15))
         result = @adapter.get(@feature)
         assert_equal '15', result[:percentage_of_actors]
 
-        assert_equal true, @adapter.disable(@feature, @actors_gate, @flipper.actors(0))
+        assert_equal true, @adapter.disable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(0))
         result = @adapter.get(@feature)
         assert_equal '0', result[:percentage_of_actors]
       end
 
       def test_can_enable_percentage_of_actors_gate_many_times_and_consistently_return_values
         (1..100).each do |percentage|
-          assert_equal true, @adapter.enable(@feature, @actors_gate, @flipper.actors(percentage))
+          assert_equal true, @adapter.enable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(percentage))
           result = @adapter.get(@feature)
           assert_equal percentage.to_s, result[:percentage_of_actors]
         end
@@ -112,25 +139,25 @@ module Flipper
 
       def test_can_disable_percentage_of_actors_gate_many_times_and_consistently_return_values
         (1..100).each do |percentage|
-          assert_equal true, @adapter.disable(@feature, @actors_gate, @flipper.actors(percentage))
+          assert_equal true, @adapter.disable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(percentage))
           result = @adapter.get(@feature)
           assert_equal percentage.to_s, result[:percentage_of_actors]
         end
       end
 
       def test_can_enable_disable_and_get_value_for_percentage_of_time_gate
-        assert_equal true, @adapter.enable(@feature, @time_gate, @flipper.time(10))
+        assert_equal true, @adapter.enable(@feature, @time_gate, Flipper::Types::PercentageOfTime.new(10))
         result = @adapter.get(@feature)
         assert_equal '10', result[:percentage_of_time]
 
-        assert_equal true, @adapter.disable(@feature, @time_gate, @flipper.time(0))
+        assert_equal true, @adapter.disable(@feature, @time_gate, Flipper::Types::PercentageOfTime.new(0))
         result = @adapter.get(@feature)
         assert_equal '0', result[:percentage_of_time]
       end
 
       def test_can_enable_percentage_of_time_gate_many_times_and_consistently_return_values
         (1..100).each do |percentage|
-          assert_equal true, @adapter.enable(@feature, @time_gate, @flipper.time(percentage))
+          assert_equal true, @adapter.enable(@feature, @time_gate, Flipper::Types::PercentageOfTime.new(percentage))
           result = @adapter.get(@feature)
           assert_equal percentage.to_s, result[:percentage_of_time]
         end
@@ -138,23 +165,23 @@ module Flipper
 
       def test_can_disable_percentage_of_time_gate_many_times_and_consistently_return_values
         (1..100).each do |percentage|
-          assert_equal true, @adapter.disable(@feature, @time_gate, @flipper.time(percentage))
+          assert_equal true, @adapter.disable(@feature, @time_gate, Flipper::Types::PercentageOfTime.new(percentage))
           result = @adapter.get(@feature)
           assert_equal percentage.to_s, result[:percentage_of_time]
         end
       end
 
       def test_converts_boolean_value_to_a_string
-        assert_equal true, @adapter.enable(@feature, @boolean_gate, @flipper.boolean)
+        assert_equal true, @adapter.enable(@feature, @boolean_gate, Flipper::Types::Boolean.new)
         result = @adapter.get(@feature)
         assert_equal 'true', result[:boolean]
       end
 
       def test_converts_the_actor_value_to_a_string
-        assert_equal true,
-                     @adapter.enable(@feature, @actor_gate, @flipper.actor(Flipper::Actor.new(22)))
-        result = @adapter.get(@feature)
-        assert_equal Set['22'], result[:actors]
+        actor = Flipper::Actor.new(22)
+        refute @feature.enabled?(actor)
+        @feature.enable_actor actor
+        assert @feature.enabled?(actor)
       end
 
       def test_converts_group_value_to_a_string
@@ -164,13 +191,13 @@ module Flipper
       end
 
       def test_converts_percentage_of_time_integer_value_to_a_string
-        assert_equal true, @adapter.enable(@feature, @time_gate, @flipper.time(10))
+        assert_equal true, @adapter.enable(@feature, @time_gate, Flipper::Types::PercentageOfTime.new(10))
         result = @adapter.get(@feature)
         assert_equal '10', result[:percentage_of_time]
       end
 
       def test_converts_percentage_of_actors_integer_value_to_a_string
-        assert_equal true, @adapter.enable(@feature, @actors_gate, @flipper.actors(10))
+        assert_equal true, @adapter.enable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(10))
         result = @adapter.get(@feature)
         assert_equal '10', result[:percentage_of_actors]
       end
@@ -193,11 +220,11 @@ module Flipper
 
       def test_clears_all_the_gate_values_for_the_feature_on_remove
         actor22 = Flipper::Actor.new('22')
-        assert_equal true, @adapter.enable(@feature, @boolean_gate, @flipper.boolean)
+        assert_equal true, @adapter.enable(@feature, @boolean_gate, Flipper::Types::Boolean.new)
         assert_equal true, @adapter.enable(@feature, @group_gate, @flipper.group(:admins))
-        assert_equal true, @adapter.enable(@feature, @actor_gate, @flipper.actor(actor22))
-        assert_equal true, @adapter.enable(@feature, @actors_gate, @flipper.actors(25))
-        assert_equal true, @adapter.enable(@feature, @time_gate, @flipper.time(45))
+        assert_equal true, @adapter.enable(@feature, @actor_gate, Flipper::Types::Actor.new(actor22))
+        assert_equal true, @adapter.enable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(25))
+        assert_equal true, @adapter.enable(@feature, @time_gate, Flipper::Types::PercentageOfTime.new(45))
 
         assert_equal true, @adapter.remove(@feature)
 
@@ -209,11 +236,11 @@ module Flipper
         @adapter.add(@feature)
         assert_includes @adapter.features, @feature.key
 
-        assert_equal true, @adapter.enable(@feature, @boolean_gate, @flipper.boolean)
+        assert_equal true, @adapter.enable(@feature, @boolean_gate, Flipper::Types::Boolean.new)
         assert_equal true, @adapter.enable(@feature, @group_gate, @flipper.group(:admins))
-        assert_equal true, @adapter.enable(@feature, @actor_gate, @flipper.actor(actor22))
-        assert_equal true, @adapter.enable(@feature, @actors_gate, @flipper.actors(25))
-        assert_equal true, @adapter.enable(@feature, @time_gate, @flipper.time(45))
+        assert_equal true, @adapter.enable(@feature, @actor_gate, Flipper::Types::Actor.new(actor22))
+        assert_equal true, @adapter.enable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(25))
+        assert_equal true, @adapter.enable(@feature, @time_gate, Flipper::Types::PercentageOfTime.new(45))
 
         assert_equal true, @adapter.clear(@feature)
         assert_includes @adapter.features, @feature.key
@@ -226,7 +253,7 @@ module Flipper
 
       def test_can_get_multiple_features
         assert @adapter.add(@flipper[:stats])
-        assert @adapter.enable(@flipper[:stats], @boolean_gate, @flipper.boolean)
+        assert @adapter.enable(@flipper[:stats], @boolean_gate, Flipper::Types::Boolean.new)
         assert @adapter.add(@flipper[:search])
 
         result = @adapter.get_multi([@flipper[:stats], @flipper[:search], @flipper[:other]])
@@ -242,16 +269,16 @@ module Flipper
 
       def test_can_get_all_features
         assert @adapter.add(@flipper[:stats])
-        assert @adapter.enable(@flipper[:stats], @boolean_gate, @flipper.boolean)
+        assert @adapter.enable(@flipper[:stats], @boolean_gate, Flipper::Types::Boolean.new)
         assert @adapter.add(@flipper[:search])
+        @flipper.enable :analytics, Flipper.property(:plan).eq("pro")
 
         result = @adapter.get_all
-        assert_instance_of Hash, result
 
-        stats = result["stats"]
-        search = result["search"]
-        assert_equal @adapter.default_config.merge(boolean: 'true'), stats
-        assert_equal @adapter.default_config, search
+        assert_instance_of Hash, result
+        assert_equal @adapter.default_config.merge(boolean: 'true'), result["stats"]
+        assert_equal @adapter.default_config, result["search"]
+        assert_equal @adapter.default_config.merge(expression: {"Equal"=>[{"Property"=>["plan"]}, "pro"]}), result["analytics"]
       end
 
       def test_includes_explicitly_disabled_features_when_getting_all_features
@@ -265,9 +292,9 @@ module Flipper
 
       def test_can_double_enable_an_actor_without_error
         actor = Flipper::Actor.new('Flipper::Actor;22')
-        assert_equal true, @adapter.enable(@feature, @actor_gate, @flipper.actor(actor))
-        assert_equal true, @adapter.enable(@feature, @actor_gate, @flipper.actor(actor))
-        assert_equal Set['Flipper::Actor;22'], @adapter.get(@feature).fetch(:actors)
+        assert_equal true, @feature.enable(actor)
+        assert_equal true, @feature.enable(actor)
+        assert @feature.enabled?(actor)
       end
 
       def test_can_double_enable_a_group_without_error
@@ -275,6 +302,47 @@ module Flipper
         assert_equal true, @adapter.enable(@feature, @group_gate, @flipper.group(:admins))
         assert_equal Set['admins'], @adapter.get(@feature).fetch(:groups)
       end
+
+      def test_can_double_enable_percentage_without_error
+        assert_equal true, @adapter.enable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(25))
+        assert_equal true, @adapter.enable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(25))
+      end
+
+      def test_can_double_enable_without_error
+        assert_equal true, @adapter.enable(@feature, @boolean_gate, Flipper::Types::Boolean.new)
+        assert_equal true, @adapter.enable(@feature, @boolean_gate, Flipper::Types::Boolean.new)
+      end
+
+      def test_can_get_all_features_when_there_are_none
+        expected = {}
+        assert_equal Set.new, @adapter.features
+        assert_equal expected, @adapter.get_all
+      end
+
+      def test_clears_other_gate_values_on_enable
+        actor = Flipper::Actor.new('Flipper::Actor;22')
+        assert_equal true, @adapter.enable(@feature, @actors_gate, Flipper::Types::PercentageOfActors.new(25))
+        assert_equal true, @adapter.enable(@feature, @time_gate, Flipper::Types::PercentageOfTime.new(25))
+        assert_equal true, @adapter.enable(@feature, @group_gate, @flipper.group(:admins))
+        assert_equal true, @adapter.enable(@feature, @actor_gate, Flipper::Types::Actor.new(actor))
+        assert_equal true, @adapter.enable(@feature, @boolean_gate, Flipper::Types::Boolean.new(true))
+        assert_equal @adapter.default_config.merge(boolean: "true"), @adapter.get(@feature)
+      end
+
+      def test_can_import_and_export
+        adapter = Flipper::Adapters::Memory.new
+        source_flipper = Flipper.new(adapter)
+        source_flipper.enable(:stats)
+        export = adapter.export
+
+        # some adapters cannot import so if they return false lets assert it
+        # didn't happen
+        if @adapter.import(export)
+          assert @flipper[:stats].enabled?
+        else
+          refute @flipper[:stats].enabled?
+        end
+      end
     end
   end
 end