flipper 0.26.0 → 1.3.6

data/lib/flipper/instrumentation/statsd.rb

@@ -2,5 +2,7 @@ require 'securerandom'
 require 'active_support/notifications'
 require 'flipper/instrumentation/statsd_subscriber'
 
-ActiveSupport::Notifications.subscribe /\.flipper$/,
-                                       Flipper::Instrumentation::StatsdSubscriber
+ActiveSupport::Notifications.subscribe(
+  /\.flipper$/,
+  Flipper::Instrumentation::StatsdSubscriber
+)

data/lib/flipper/instrumentation/statsd_subscriber.rb

@@ -12,13 +12,11 @@ module Flipper
       end
 
       def update_timer(metric)
-        if self.class.client
-          self.class.client.timing metric, (@duration * 1_000).round
-        end
+        self.class.client&.timing metric, (@duration * 1_000).round
       end
 
       def update_counter(metric)
-        self.class.client.increment metric if self.class.client
+        self.class.client&.increment metric
       end
     end
   end

data/lib/flipper/instrumentation/subscriber.rb

@@ -42,10 +42,8 @@ module Flipper
       # Private
       def update_feature_operation_metrics
         feature_name = @payload[:feature_name]
-        gate_name = @payload[:gate_name]
         operation = strip_trailing_question_mark(@payload[:operation])
         result = @payload[:result]
-        thing = @payload[:thing]
 
         update_timer "flipper.feature_operation.#{operation}"
 
@@ -65,13 +63,18 @@ module Flipper
       def update_adapter_operation_metrics
         adapter_name = @payload[:adapter_name]
         operation = @payload[:operation]
-        result = @payload[:result]
-        value = @payload[:value]
-        key = @payload[:key]
 
         update_timer "flipper.adapter.#{adapter_name}.#{operation}"
       end
 
+      def update_poller_metrics
+        # noop
+      end
+
+      def update_synchronizer_call_metrics
+        # noop
+      end
+
       QUESTION_MARK = '?'.freeze
 
       # Private

data/lib/flipper/metadata.rb

@@ -1,5 +1,12 @@
+require_relative './version'
+
 module Flipper
   METADATA = {
-    'changelog_uri' => 'https://github.com/jnunemaker/flipper/blob/main/Changelog.md',
+    "documentation_uri" => "https://www.flippercloud.io/docs",
+    "homepage_uri"      => "https://www.flippercloud.io",
+    "source_code_uri"   => "https://github.com/flippercloud/flipper",
+    "bug_tracker_uri"   => "https://github.com/flippercloud/flipper/issues",
+    "changelog_uri"     => "https://github.com/flippercloud/flipper/releases/tag/v#{Flipper::VERSION}",
+    "funding_uri"       => "https://github.com/sponsors/flippercloud",
   }.freeze
 end

data/lib/flipper/middleware/memoizer.rb

@@ -20,6 +20,14 @@ module Flipper
       #   # using with preload specific features
       #   use Flipper::Middleware::Memoizer, preload: [:stats, :search, :some_feature]
       #
+      #   # using with preload block that returns true/false
+      #   use Flipper::Middleware::Memoizer, preload: ->(request) { !request.path.start_with?('/assets') }
+      #
+      #   # using with preload block that returns specific features
+      #   use Flipper::Middleware::Memoizer, preload: ->(request) {
+      #     request.path.starts_with?('/admin') ? [:stats, :search] : false
+      #   }
+      #
       def initialize(app, opts = {})
         if opts.is_a?(Flipper::DSL) || opts.is_a?(Proc)
           raise 'Flipper::Middleware::Memoizer no longer initializes with a flipper instance or block. Read more at: https://git.io/vSo31.'
@@ -34,7 +42,7 @@ module Flipper
         request = Rack::Request.new(env)
 
         if memoize?(request)
-          memoized_call(env)
+          memoized_call(request)
         else
           @app.call(env)
         end
@@ -52,26 +60,34 @@ module Flipper
         end
       end
 
-      def memoized_call(env)
-        reset_on_body_close = false
-        flipper = env.fetch(@env_key) { Flipper }
+      def memoized_call(request)
+        flipper = request.env.fetch(@env_key) { Flipper }
 
         # Already memoizing. This instance does not need to do anything.
         if flipper.memoizing?
-          warn "Flipper::Middleware::Memoizer appears to be running twice. Read how to resolve this at https://github.com/jnunemaker/flipper/pull/523"
-          return @app.call(env)
+          warn "Flipper::Middleware::Memoizer appears to be running twice. Read how to resolve this at https://github.com/flippercloud/flipper/pull/523"
+          return @app.call(request.env)
         end
 
-        flipper.memoize = true
+        begin
+          flipper.memoize = true
 
-        case @opts[:preload]
-        when true then flipper.preload_all
-        when Array then flipper.preload(@opts[:preload])
-        end
+          # Preloading is pointless without memoizing.
+          preload = if @opts[:preload].respond_to?(:call)
+            @opts[:preload].call(request)
+          else
+            @opts[:preload]
+          end
 
-        @app.call(env)
-      ensure
-        flipper.memoize = false if flipper
+          case preload
+          when true then flipper.preload_all
+          when Array then flipper.preload(preload)
+          end
+
+          @app.call(request.env)
+        ensure
+          flipper.memoize = false
+        end
       end
     end
   end

data/lib/flipper/model/active_record.rb

@@ -0,0 +1,23 @@
+module Flipper
+  module Model
+    module ActiveRecord
+      # The id of the record when used as an actor.
+      #
+      #   class User < ActiveRecord::Base
+      #   end
+      #
+      #   user = User.first
+      #   Flipper.enable :some_feature, user
+      #   Flipper.enabled? :some_feature, user #=> true
+      #
+      def flipper_id
+        "#{self.class.base_class.name};#{id}"
+      end
+
+      # Properties used to evaluate expressions
+      def flipper_properties
+        {"type" => self.class.name}.merge(attributes)
+      end
+    end
+  end
+end

data/lib/flipper/poller.rb

@@ -0,0 +1,118 @@
+require 'logger'
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/map'
+require 'concurrent/atomic/atomic_fixnum'
+
+module Flipper
+  class Poller
+    attr_reader :adapter, :thread, :pid, :mutex, :interval, :last_synced_at
+
+    def self.instances
+      @instances ||= Concurrent::Map.new
+    end
+    private_class_method :instances
+
+    def self.get(key, options = {})
+      instances.compute_if_absent(key) { new(options) }
+    end
+
+    def self.reset
+      instances.each {|_, instance| instance.stop }.clear
+    end
+
+    MINIMUM_POLL_INTERVAL = 10
+
+    def initialize(options = {})
+      @thread = nil
+      @pid = Process.pid
+      @mutex = Mutex.new
+      @instrumenter = options.fetch(:instrumenter, Instrumenters::Noop)
+      @remote_adapter = options.fetch(:remote_adapter)
+      @interval = options.fetch(:interval, 10).to_f
+      @last_synced_at = Concurrent::AtomicFixnum.new(0)
+      @adapter = Adapters::Memory.new(nil, threadsafe: true)
+
+      if @interval < MINIMUM_POLL_INTERVAL
+        warn "Flipper::Cloud poll interval must be greater than or equal to #{MINIMUM_POLL_INTERVAL} but was #{@interval}. Setting @interval to #{MINIMUM_POLL_INTERVAL}."
+        @interval = MINIMUM_POLL_INTERVAL
+      end
+
+      @start_automatically = options.fetch(:start_automatically, true)
+
+      if options.fetch(:shutdown_automatically, true)
+        at_exit { stop }
+      end
+    end
+
+    def start
+      reset if forked?
+      ensure_worker_running
+    end
+
+    def stop
+      @instrumenter.instrument("poller.#{InstrumentationNamespace}", {
+        operation: :stop,
+      })
+      @thread&.kill
+    end
+
+    def run
+      loop do
+        sleep jitter
+
+        begin
+          sync
+        rescue
+          # you can instrument these using poller.flipper
+        end
+
+        sleep interval
+      end
+    end
+
+    def sync
+      @instrumenter.instrument("poller.#{InstrumentationNamespace}", operation: :poll) do
+        @adapter.import @remote_adapter
+        @last_synced_at.update { |time| Concurrent.monotonic_time }
+      end
+    end
+
+    private
+
+    def jitter
+      rand
+    end
+
+    def forked?
+      pid != Process.pid
+    end
+
+    def ensure_worker_running
+      # Return early if thread is alive and avoid the mutex lock and unlock.
+      return if thread_alive?
+
+      # If another thread is starting worker thread, then return early so this
+      # thread can enqueue and move on with life.
+      return unless mutex.try_lock
+
+      begin
+        return if thread_alive?
+        @thread = Thread.new { run }
+        @instrumenter.instrument("poller.#{InstrumentationNamespace}", {
+          operation: :thread_start,
+        })
+      ensure
+        mutex.unlock
+      end
+    end
+
+    def thread_alive?
+      @thread && @thread.alive?
+    end
+
+    def reset
+      @pid = Process.pid
+      mutex.unlock if mutex.locked?
+    end
+  end
+end

data/lib/flipper/serializers/gzip.rb

@@ -0,0 +1,22 @@
+require "zlib"
+require "stringio"
+
+module Flipper
+  module Serializers
+    class Gzip
+      def self.serialize(source)
+        return if source.nil?
+        output = StringIO.new
+        gz = Zlib::GzipWriter.new(output)
+        gz.write(source)
+        gz.close
+        output.string
+      end
+
+      def self.deserialize(source)
+        return if source.nil?
+        Zlib::GzipReader.wrap(StringIO.new(source), &:read)
+      end
+    end
+  end
+end

data/lib/flipper/serializers/json.rb

@@ -0,0 +1,17 @@
+require "json"
+
+module Flipper
+  module Serializers
+    class Json
+      def self.serialize(source)
+        return if source.nil?
+        JSON.generate(source)
+      end
+
+      def self.deserialize(source)
+        return if source.nil?
+        JSON.parse(source)
+      end
+    end
+  end
+end

data/lib/flipper/spec/shared_adapter_specs.rb

@@ -4,11 +4,12 @@ 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|
@@ -33,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)
@@ -51,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)
@@ -82,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
@@ -117,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
@@ -143,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
@@ -168,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
@@ -197,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)
 
@@ -213,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)
@@ -230,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]])
@@ -246,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
@@ -269,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
@@ -281,13 +308,13 @@ RSpec.shared_examples_for 'a flipper adapter' do
   end
 
   it 'can double enable percentage without error' do
-    expect(subject.enable(feature, actors_gate, flipper.actors(25))).to eq(true)
-    expect(subject.enable(feature, actors_gate, flipper.actors(25))).to eq(true)
+    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.boolean)).to eq(true)
-    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, boolean_gate, Flipper::Types::Boolean.new)).to eq(true)
   end
 
   it 'can get_all features when there are none' do
@@ -297,11 +324,26 @@ RSpec.shared_examples_for 'a flipper adapter' do
 
   it 'clears other gate values on enable' do
     actor = Flipper::Actor.new('Flipper::Actor;22')
-    subject.enable(feature, actors_gate, flipper.actors(25))
-    subject.enable(feature, time_gate, flipper.time(25))
+    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.actor(actor))
-    subject.enable(feature, boolean_gate, flipper.boolean(true))
+    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