flipper 0.12.2 → 0.13.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 965343e60248399aab50206cf8f7186575780659
-  data.tar.gz: 6cdcc01506fc5513c8cd29ac27665aaa298afa78
+  metadata.gz: ec6d60d96a353fad27ec23dc10fc62957d0fe5df
+  data.tar.gz: 1c4c0bd098d95eee25f06f745b4e4a8918bbb953
 SHA512:
-  metadata.gz: f8bdbd7c2357b312d0ba05308319b02ef49e200fa051e349f632122da85b17f655bbdb8138c48bf2c605838bc6fcfd92c86870b17d29615213a850ace1238d5a
-  data.tar.gz: 1fee068e18c2a5f1a328abc1c80cc0d6eb29ddb1eb89499958eb6938be87cb088b9e00f4919fef1b5d11d562634862d1b83fbcc75ff0834393b9350deb216aea
+  metadata.gz: 0ec56237a868e32172a0c1a5f25494d1ab13d959101db28dc4db58c8bb994044fa1a8e4907335310c08fc1189fbeb0a61b484808e0ea582785bd3fe2719240c6
+  data.tar.gz: 033d132c8542bda8abd4d716a7debd2a42cc4e35398fa6063abd7f0b7281b00379b212cd373d6fce619624cce10884d9bc323396842c9f00c0413f6f48d949a9

data/.rubocop.yml

@@ -27,6 +27,12 @@ Style/NumericLiterals:
 Style/StringLiterals:
   Enabled: false
 
+Style/GuardClause:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
 Metrics/LineLength:
   Max: 100
   Exclude:

data/Changelog.md

@@ -1,3 +1,13 @@
+## master
+
+### Additions/Changes
+
+* Update PStore adapter to allow setting thread_safe option (https://github.com/jnunemaker/flipper/pull/334).
+* Update Flipper::UI to Bootstrap 4 (https://github.com/jnunemaker/flipper/pull/336).
+* Add Flipper::UI configuration to add a banner with customizeable text and background color (https://github.com/jnunemaker/flipper/pull/337).
+* Add sync adapter (https://github.com/jnunemaker/flipper/pull/341).
+* Make cloud use sync adapter (https://github.com/jnunemaker/flipper/pull/342). This makes local flipper operations resilient to cloud failures.
+
 ## 0.12.2
 
 ### Additions/Changes

data/Gemfile

@@ -24,6 +24,7 @@ gem 'test-unit', '~> 3.0'
 
 group(:guard) do
   gem 'guard', '~> 2.12.5'
+  gem 'guard-rubocop', '~> 1.3.0'
   gem 'guard-rspec', '~> 4.5.0'
   gem 'guard-bundler', '~> 2.1.0'
   gem 'guard-coffeescript', '~> 2.0.1'

data/README.md

@@ -1,5 +1,3 @@
-![flipper logo](https://raw.githubusercontent.com/jnunemaker/flipper/master/lib/flipper/ui/public/images/logo.png)
-
 <pre>
                                    __
                                _.-~  )
@@ -105,4 +103,6 @@ Of course there are more [examples for you to peruse](examples/). You could also
 |---|---|---|
 | ![@jnunemaker](https://avatars3.githubusercontent.com/u/235?s=64) | [@jnunemaker](https://github.com/jnunemaker) | most things |
 | ![@alexwheeler](https://avatars3.githubusercontent.com/u/3260042?s=64) | [@alexwheeler](https://github.com/alexwheeler) | api |
+| ![@thetimbanks](https://avatars1.githubusercontent.com/u/471801?s=64) | [@thetimbanks](https://github.com/thetimbanks) | ui |
 | ![@lazebny](https://avatars1.githubusercontent.com/u/6276766?s=64) | [@lazebny](https://github.com/lazebny) | docker |
+

data/lib/flipper/adapters/operation_logger.rb

@@ -8,7 +8,14 @@ module Flipper
     class OperationLogger < SimpleDelegator
       include ::Flipper::Adapter
 
-      Operation = Struct.new(:type, :args)
+      class Operation
+        attr_reader :type, :args
+
+        def initialize(type, args)
+          @type = type
+          @args = args
+        end
+      end
 
       OperationTypes = [
         :features,
@@ -93,7 +100,12 @@ module Flipper
 
       # Public: Count the number of times a certain operation happened.
       def count(type)
-        @operations.select { |operation| operation.type == type }.size
+        type(type).size
+      end
+
+      # Public: Get all operations of a certain type.
+      def type(type)
+        @operations.select { |operation| operation.type == type }
       end
 
       # Public: Get the last operation of a certain type.

data/lib/flipper/adapters/pstore.rb

@@ -16,10 +16,13 @@ module Flipper
       # Public: The path to where the file is stored.
       attr_reader :path
 
+      # Public: PStore's thread_safe option.
+      attr_reader :thread_safe
+
       # Public
-      def initialize(path = 'flipper.pstore')
+      def initialize(path = 'flipper.pstore', thread_safe = false)
         @path = path
-        @store = ::PStore.new(path)
+        @store = ::PStore.new(path, thread_safe)
         @name = :pstore
       end
 

data/lib/flipper/adapters/sync.rb

@@ -0,0 +1,96 @@
+require "flipper/instrumenters/noop"
+require "flipper/adapters/sync/synchronizer"
+require "flipper/adapters/sync/interval_synchronizer"
+
+module Flipper
+  module Adapters
+    # TODO: Syncing should happen in a background thread on a regular interval
+    # rather than in the main thread only when reads happen.
+    class Sync
+      include ::Flipper::Adapter
+
+      # Public: The name of the adapter.
+      attr_reader :name
+
+      # Public: The synchronizer that will keep the local and remote in sync.
+      attr_reader :synchronizer
+
+      # Public: Build a new sync instance.
+      #
+      # local - The local flipper adapter that should serve reads.
+      # remote - The remote flipper adpater that should serve writes and update
+      #          the local on an interval.
+      # interval - The number of milliseconds between syncs from remote to
+      #            local. Default value is set in IntervalSynchronizer.
+      def initialize(local, remote, options = {})
+        @name = :sync
+        @local = local
+        @remote = remote
+        @synchronizer = options.fetch(:synchronizer) do
+          instrumenter = options[:instrumenter]
+          sync_options = {}
+          sync_options[:instrumenter] = instrumenter if instrumenter
+          synchronizer = Synchronizer.new(@local, @remote, sync_options)
+          IntervalSynchronizer.new(synchronizer, interval: options[:interval])
+        end
+        sync
+      end
+
+      def features
+        sync
+        @local.features
+      end
+
+      def get(feature)
+        sync
+        @local.get(feature)
+      end
+
+      def get_multi(features)
+        sync
+        @local.get_multi(features)
+      end
+
+      def get_all
+        sync
+        @local.get_all
+      end
+
+      def add(feature)
+        result = @remote.add(feature)
+        @local.add(feature)
+        result
+      end
+
+      def remove(feature)
+        result = @remote.remove(feature)
+        @local.remove(feature)
+        result
+      end
+
+      def clear(feature)
+        result = @remote.clear(feature)
+        @local.clear(feature)
+        result
+      end
+
+      def enable(feature, gate, thing)
+        result = @remote.enable(feature, gate, thing)
+        @local.enable(feature, gate, thing)
+        result
+      end
+
+      def disable(feature, gate, thing)
+        result = @remote.disable(feature, gate, thing)
+        @local.disable(feature, gate, thing)
+        result
+      end
+
+      private
+
+      def sync
+        @synchronizer.call
+      end
+    end
+  end
+end

data/lib/flipper/adapters/sync/feature_synchronizer.rb

@@ -0,0 +1,117 @@
+require "flipper/actor"
+require "flipper/gate_values"
+
+module Flipper
+  module Adapters
+    class Sync
+      # Internal: Given a feature, local gate values and remote gate values,
+      # makes the local equal to the remote.
+      class FeatureSynchronizer
+        extend Forwardable
+
+        def_delegator :@local_gate_values, :boolean, :local_boolean
+        def_delegator :@local_gate_values, :actors, :local_actors
+        def_delegator :@local_gate_values, :groups, :local_groups
+        def_delegator :@local_gate_values, :percentage_of_actors,
+                      :local_percentage_of_actors
+        def_delegator :@local_gate_values, :percentage_of_time,
+                      :local_percentage_of_time
+
+        def_delegator :@remote_gate_values, :boolean, :remote_boolean
+        def_delegator :@remote_gate_values, :actors, :remote_actors
+        def_delegator :@remote_gate_values, :groups, :remote_groups
+        def_delegator :@remote_gate_values, :percentage_of_actors,
+                      :remote_percentage_of_actors
+        def_delegator :@remote_gate_values, :percentage_of_time,
+                      :remote_percentage_of_time
+
+        def initialize(feature, local_gate_values, remote_gate_values)
+          @feature = feature
+          @local_gate_values = local_gate_values
+          @remote_gate_values = remote_gate_values
+        end
+
+        def call
+          if remote_disabled?
+            return if local_disabled?
+            @feature.disable
+          elsif remote_boolean_enabled?
+            return if local_boolean_enabled?
+            @feature.enable
+          else
+            sync_actors
+            sync_groups
+            sync_percentage_of_actors
+            sync_percentage_of_time
+          end
+        end
+
+        private
+
+        def sync_actors
+          remote_actors_added = remote_actors - local_actors
+          remote_actors_added.each do |flipper_id|
+            @feature.enable_actor Actor.new(flipper_id)
+          end
+
+          remote_actors_removed = local_actors - remote_actors
+          remote_actors_removed.each do |flipper_id|
+            @feature.disable_actor Actor.new(flipper_id)
+          end
+        end
+
+        def sync_groups
+          remote_groups_added = remote_groups - local_groups
+          remote_groups_added.each do |group_name|
+            @feature.enable_group group_name
+          end
+
+          remote_groups_removed = local_groups - remote_groups
+          remote_groups_removed.each do |group_name|
+            @feature.disable_group group_name
+          end
+        end
+
+        def sync_percentage_of_actors
+          return if local_percentage_of_actors == remote_percentage_of_actors
+
+          @feature.enable_percentage_of_actors remote_percentage_of_actors
+        end
+
+        def sync_percentage_of_time
+          return if local_percentage_of_time == remote_percentage_of_time
+
+          @feature.enable_percentage_of_time remote_percentage_of_time
+        end
+
+        def default_config
+          @default_config ||= @feature.adapter.default_config
+        end
+
+        def default_gate_values
+          @default_gate_values ||= GateValues.new(default_config)
+        end
+
+        def default_gate_values?(gate_values)
+          gate_values == default_gate_values
+        end
+
+        def local_disabled?
+          default_gate_values? @local_gate_values
+        end
+
+        def remote_disabled?
+          default_gate_values? @remote_gate_values
+        end
+
+        def local_boolean_enabled?
+          local_boolean
+        end
+
+        def remote_boolean_enabled?
+          remote_boolean
+        end
+      end
+    end
+  end
+end

data/lib/flipper/adapters/sync/interval_synchronizer.rb

@@ -0,0 +1,53 @@
+module Flipper
+  module Adapters
+    class Sync
+      # Internal: Wraps a Synchronizer instance and only invokes it every
+      # N milliseconds.
+      class IntervalSynchronizer
+        # Private: Number of milliseconds between syncs (default: 10 seconds).
+        DEFAULT_INTERVAL_MS = 10_000
+
+        # Private
+        def self.now_ms
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+        end
+
+        # Public: The number of milliseconds between invocations of the
+        # wrapped synchronizer.
+        attr_reader :interval
+
+        # Public: Initializes a new interval synchronizer.
+        #
+        # synchronizer - The Synchronizer to call when the interval has passed.
+        # interval - The Integer number of milliseconds between invocations of
+        #            the wrapped synchronizer.
+        def initialize(synchronizer, interval: nil)
+          @synchronizer = synchronizer
+          @interval = interval || DEFAULT_INTERVAL_MS
+          # TODO: add jitter to this so all processes booting at the same time
+          # don't phone home at the same time.
+          @last_sync_at = 0
+        end
+
+        def call
+          return unless time_to_sync?
+
+          @last_sync_at = now_ms
+          @synchronizer.call
+
+          nil
+        end
+
+        private
+
+        def time_to_sync?
+          (now_ms - @last_sync_at) >= @interval
+        end
+
+        def now_ms
+          self.class.now_ms
+        end
+      end
+    end
+  end
+end

data/lib/flipper/adapters/sync/synchronizer.rb

@@ -0,0 +1,48 @@
+require "flipper/feature"
+require "flipper/gate_values"
+require "flipper/instrumenters/noop"
+require "flipper/adapters/sync/feature_synchronizer"
+
+module Flipper
+  module Adapters
+    class Sync
+      # Internal: Given a local and remote adapter, it can update the local to
+      # match the remote doing only the necessary enable/disable operations.
+      class Synchronizer
+        def initialize(local, remote, options = {})
+          @local = local
+          @remote = remote
+          @instrumenter = options.fetch(:instrumenter, Instrumenters::Noop)
+        end
+
+        def call
+          @instrumenter.instrument("synchronizer_call.flipper") { sync }
+        end
+
+        private
+
+        def sync
+          local_get_all = @local.get_all
+          # TODO: Move remote get all to background thread to minimize impact to
+          # whatever is happening in main thread.
+          remote_get_all = @remote.get_all
+
+          # Sync all the gate values.
+          remote_get_all.each do |feature_key, remote_gates_hash|
+            feature = Feature.new(feature_key, @local)
+            local_gates_hash = local_get_all[feature_key] || @local.default_config
+            local_gate_values = GateValues.new(local_gates_hash)
+            remote_gate_values = GateValues.new(remote_gates_hash)
+            FeatureSynchronizer.new(feature, local_gate_values, remote_gate_values).call
+          end
+
+          # Add features that are missing
+          features_to_add = remote_get_all.keys - local_get_all.keys
+          features_to_add.each { |key| Feature.new(key, @local).add }
+        rescue => exception
+          @instrumenter.instrument("synchronizer_exception.flipper", exception: exception)
+        end
+      end
+    end
+  end
+end

data/lib/flipper/errors.rb

@@ -21,4 +21,12 @@ module Flipper
       super(message || default)
     end
   end
+
+  # Raised when an invalid value is set to a configuration property
+  class InvalidConfigurationValue < Flipper::Error
+    def initialize(message = nil)
+      default = "Configuration value is not valid."
+      super(message || default)
+    end
+  end
 end

data/lib/flipper/spec/shared_adapter_specs.rb

@@ -272,10 +272,12 @@ RSpec.shared_examples_for 'a flipper adapter' 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'])
   end
 
   it 'can double enable a group without error' do
     expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
     expect(subject.enable(feature, group_gate, flipper.group(:admins))).to eq(true)
+    expect(subject.get(feature).fetch(:groups)).to eq(Set['admins'])
   end
 end

data/lib/flipper/test/shared_adapter_test.rb

@@ -267,11 +267,13 @@ module Flipper
         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)
       end
 
       def test_can_double_enable_a_group_without_error
         assert_equal true, @adapter.enable(@feature, @group_gate, @flipper.group(:admins))
         assert_equal true, @adapter.enable(@feature, @group_gate, @flipper.group(:admins))
+        assert_equal Set['admins'], @adapter.get(@feature).fetch(:groups)
       end
     end
   end

data/lib/flipper/version.rb

@@ -1,3 +1,3 @@
 module Flipper
-  VERSION = '0.12.2'.freeze
+  VERSION = '0.13.0.beta1'.freeze
 end

data/spec/flipper/adapters/sync/feature_synchronizer_spec.rb

@@ -0,0 +1,187 @@
+require "helper"
+require "flipper/adapters/memory"
+require "flipper/adapters/operation_logger"
+require "flipper/adapters/sync/feature_synchronizer"
+
+RSpec.describe Flipper::Adapters::Sync::FeatureSynchronizer do
+  let(:adapter) do
+    Flipper::Adapters::OperationLogger.new Flipper::Adapters::Memory.new
+  end
+  let(:flipper) { Flipper.new(adapter) }
+  let(:feature) { flipper[:search] }
+
+  context "when remote disabled" do
+    let(:remote) { Flipper::GateValues.new({}) }
+
+    it "does nothing if local is disabled" do
+      feature.disable
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(adapter.get(feature).fetch(:boolean)).to be(nil)
+      expect_no_enable_or_disable
+    end
+
+    it "disables if local is enabled" do
+      feature.enable
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(adapter.get(feature).fetch(:boolean)).to be(nil)
+      expect_only_disable
+    end
+  end
+
+  context "when remote boolean enabled" do
+    let(:remote) { Flipper::GateValues.new(boolean: true) }
+
+    it "does nothing if local boolean enabled" do
+      feature.enable
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+      expect(feature.boolean_value).to be(true)
+      expect_no_enable_or_disable
+    end
+
+    it "enables if local is disabled" do
+      feature.disable
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+      expect(feature.boolean_value).to be(true)
+      expect_only_enable
+    end
+  end
+
+  context "when conditionally enabled" do
+    it "adds remotely added actors" do
+      remote = Flipper::GateValues.new(actors: Set["1", "2"])
+      feature.enable_actor(Flipper::Actor.new("1"))
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.actors_value).to eq(Set["1", "2"])
+      expect_only_enable
+    end
+
+    it "removes remotely removed actors" do
+      remote = Flipper::GateValues.new(actors: Set["1"])
+      feature.enable_actor(Flipper::Actor.new("1"))
+      feature.enable_actor(Flipper::Actor.new("2"))
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.actors_value).to eq(Set["1"])
+      expect_only_disable
+    end
+
+    it "does nothing to actors if in sync" do
+      remote = Flipper::GateValues.new(actors: Set["1"])
+      feature.enable_actor(Flipper::Actor.new("1"))
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.actors_value).to eq(Set["1"])
+      expect_no_enable_or_disable
+    end
+
+    it "adds remotely added groups" do
+      remote = Flipper::GateValues.new(groups: Set["staff", "early_access"])
+      feature.enable_group(:staff)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.groups_value).to eq(Set["staff", "early_access"])
+      expect_only_enable
+    end
+
+    it "removes remotely removed groups" do
+      remote = Flipper::GateValues.new(groups: Set["staff"])
+      feature.enable_group(:staff)
+      feature.enable_group(:early_access)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.groups_value).to eq(Set["staff"])
+      expect_only_disable
+    end
+
+    it "does nothing if groups in sync" do
+      remote = Flipper::GateValues.new(groups: Set["staff"])
+      feature.enable_group(:staff)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.groups_value).to eq(Set["staff"])
+      expect_no_enable_or_disable
+    end
+
+    it "updates percentage of actors when remote is updated" do
+      remote = Flipper::GateValues.new(percentage_of_actors: 25)
+      feature.enable_percentage_of_actors(10)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.percentage_of_actors_value).to be(25)
+      expect_only_enable
+    end
+
+    it "does nothing if local percentage of actors matches remote" do
+      remote = Flipper::GateValues.new(percentage_of_actors: 25)
+      feature.enable_percentage_of_actors(25)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.percentage_of_actors_value).to be(25)
+      expect_no_enable_or_disable
+    end
+
+    it "updates percentage of time when remote is updated" do
+      remote = Flipper::GateValues.new(percentage_of_time: 25)
+      feature.enable_percentage_of_time(10)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.percentage_of_time_value).to be(25)
+      expect_only_enable
+    end
+
+    it "does nothing if local percentage of time matches remote" do
+      remote = Flipper::GateValues.new(percentage_of_time: 25)
+      feature.enable_percentage_of_time(25)
+      adapter.reset
+
+      described_class.new(feature, feature.gate_values, remote).call
+
+      expect(feature.percentage_of_time_value).to be(25)
+      expect_no_enable_or_disable
+    end
+  end
+
+  def expect_no_enable_or_disable
+    expect(adapter.count(:enable)).to be(0)
+    expect(adapter.count(:disable)).to be(0)
+  end
+
+  def expect_only_enable
+    expect(adapter.count(:enable)).to be(1)
+    expect(adapter.count(:disable)).to be(0)
+  end
+
+  def expect_only_disable
+    expect(adapter.count(:enable)).to be(0)
+    expect(adapter.count(:disable)).to be(1)
+  end
+end

data/spec/flipper/adapters/sync/interval_synchronizer_spec.rb

@@ -0,0 +1,34 @@
+require "helper"
+require "flipper/adapters/sync/interval_synchronizer"
+
+RSpec.describe Flipper::Adapters::Sync::IntervalSynchronizer do
+  let(:events) { [] }
+  let(:synchronizer) { -> { events << described_class.now_ms } }
+  let(:interval) { 10 }
+
+  subject { described_class.new(synchronizer, interval: interval) }
+
+  it 'synchronizes on first call' do
+    expect(events.size).to be(0)
+    subject.call
+    expect(events.size).to be(1)
+  end
+
+  it "only invokes wrapped synchronizer every interval milliseconds" do
+    now = described_class.now_ms
+    subject.call
+    events.clear
+
+    # move time to one millisecond less than last sync + interval
+    1.upto(interval) do |i|
+      allow(described_class).to receive(:now_ms).and_return(now + i - 1)
+      subject.call
+    end
+    expect(events.size).to be(0)
+
+    # move time to last sync + interval
+    allow(described_class).to receive(:now_ms).and_return(now + interval)
+    subject.call
+    expect(events.size).to be(1)
+  end
+end

data/spec/flipper/adapters/sync/synchronizer_spec.rb

@@ -0,0 +1,35 @@
+require "helper"
+require "flipper/adapters/memory"
+require "flipper/instrumenters/memory"
+require "flipper/adapters/sync/synchronizer"
+
+RSpec.describe Flipper::Adapters::Sync::Synchronizer do
+  let(:local) { Flipper::Adapters::Memory.new }
+  let(:remote) { Flipper::Adapters::Memory.new }
+  let(:instrumenter) { Flipper::Instrumenters::Memory.new }
+
+  subject { described_class.new(local, remote, instrumenter: instrumenter) }
+
+  it "instruments call" do
+    subject.call
+    events = instrumenter.events.select do |event|
+      event.name == "synchronizer_call.flipper"
+    end
+    expect(events.size).to be(1)
+  end
+
+  it "does not raise, but instruments exceptions for visibility" do
+    exception = StandardError.new
+    expect(remote).to receive(:get_all).and_raise(exception)
+
+    expect { subject.call }.not_to raise_error
+
+    events = instrumenter.events.select do |event|
+      event.name == "synchronizer_exception.flipper"
+    end
+    expect(events.size).to be(1)
+
+    event = events[0]
+    expect(event.payload[:exception]).to eq(exception)
+  end
+end

data/spec/flipper/adapters/sync_spec.rb

@@ -0,0 +1,197 @@
+require 'helper'
+require 'flipper/adapters/sync'
+require 'flipper/adapters/memory'
+require 'flipper/adapters/operation_logger'
+require 'flipper/spec/shared_adapter_specs'
+require 'active_support/notifications'
+
+RSpec.describe Flipper::Adapters::Sync do
+  let(:local_adapter) do
+    Flipper::Adapters::OperationLogger.new Flipper::Adapters::Memory.new
+  end
+  let(:remote_adapter) do
+    Flipper::Adapters::OperationLogger.new Flipper::Adapters::Memory.new
+  end
+  let(:local) { Flipper.new(local_adapter) }
+  let(:remote) { Flipper.new(remote_adapter) }
+  let(:sync) { Flipper.new(subject) }
+
+  subject do
+    described_class.new(local_adapter, remote_adapter, interval: 1)
+  end
+
+  it_should_behave_like 'a flipper adapter'
+
+  context 'when local has never been synced' do
+    it 'syncs boolean' do
+      remote.enable(:search)
+      expect(sync[:search].boolean_value).to be(true)
+      expect(subject.features.sort).to eq(%w(search))
+    end
+
+    it 'syncs actor' do
+      actor = Flipper::Actor.new("User;1000")
+      remote.enable_actor(:search, actor)
+      expect(sync[:search].actors_value).to eq(Set[actor.flipper_id])
+      expect(subject.features.sort).to eq(%w(search))
+    end
+
+    it 'syncs group' do
+      remote.enable_group(:search, :staff)
+      expect(sync[:search].groups_value).to eq(Set["staff"])
+      expect(subject.features.sort).to eq(%w(search))
+    end
+
+    it 'syncs percentage of actors' do
+      remote.enable_percentage_of_actors(:search, 25)
+      expect(sync[:search].percentage_of_actors_value).to eq(25)
+      expect(subject.features.sort).to eq(%w(search))
+    end
+
+    it 'syncs percentage of time' do
+      remote.enable_percentage_of_time(:search, 15)
+      expect(sync[:search].percentage_of_time_value).to eq(15)
+      expect(subject.features.sort).to eq(%w(search))
+    end
+  end
+
+  it 'enables boolean locally when remote feature boolean enabled' do
+    remote.disable(:search)
+    local.disable(:search)
+    remote.enable(:search)
+    subject # initialize forces sync
+    expect(local[:search].boolean_value).to be(true)
+  end
+
+  it 'disables boolean locally when remote feature disabled' do
+    remote.enable(:search)
+    local.enable(:search)
+    remote.disable(:search)
+    subject # initialize forces sync
+    expect(local[:search].boolean_value).to be(false)
+  end
+
+  it 'adds local actor when remote actor is added' do
+    actor = Flipper::Actor.new("User;235")
+    remote.enable_actor(:search, actor)
+    subject # initialize forces sync
+    expect(local[:search].actors_value).to eq(Set[actor.flipper_id])
+  end
+
+  it 'removes local actor when remote actor is removed' do
+    actor = Flipper::Actor.new("User;235")
+    remote.enable_actor(:search, actor)
+    local.enable_actor(:search, actor)
+    remote.disable(:search, actor)
+    subject # initialize forces sync
+    expect(local[:search].actors_value).to eq(Set.new)
+  end
+
+  it 'adds local group when remote group is added' do
+    group = Flipper::Types::Group.new(:staff)
+    remote.enable_group(:search, group)
+    subject # initialize forces sync
+    expect(local[:search].groups_value).to eq(Set["staff"])
+  end
+
+  it 'removes local group when remote group is removed' do
+    group = Flipper::Types::Group.new(:staff)
+    remote.enable_group(:search, group)
+    local.enable_group(:search, group)
+    remote.disable(:search, group)
+    subject # initialize forces sync
+    expect(local[:search].groups_value).to eq(Set.new)
+  end
+
+  it 'updates percentage of actors when remote is updated' do
+    remote.enable_percentage_of_actors(:search, 10)
+    local.enable_percentage_of_actors(:search, 10)
+    remote.enable_percentage_of_actors(:search, 15)
+    subject # initialize forces sync
+    expect(local[:search].percentage_of_actors_value).to eq(15)
+  end
+
+  it 'updates percentage of time when remote is updated' do
+    remote.enable_percentage_of_time(:search, 10)
+    local.enable_percentage_of_time(:search, 10)
+    remote.enable_percentage_of_time(:search, 15)
+    subject # initialize forces sync
+    expect(local[:search].percentage_of_time_value).to eq(15)
+  end
+
+  context 'when local and remote match' do
+    it 'does not update boolean enabled' do
+      local.enable(:search)
+      remote.enable(:search)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:enable)).to be(0)
+    end
+
+    it 'does not update boolean disabled' do
+      local.disable(:search)
+      remote.disable(:search)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:disable)).to be(0)
+    end
+
+    it 'does not update actors' do
+      actor = Flipper::Actor.new("User;235")
+      local.enable_actor(:search, actor)
+      remote.enable_actor(:search, actor)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:enable)).to be(0)
+      expect(local_adapter.count(:disable)).to be(0)
+    end
+
+    it 'does not update groups' do
+      group = Flipper::Types::Group.new(:staff)
+      local.enable_group(:search, group)
+      remote.enable_group(:search, group)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:enable)).to be(0)
+      expect(local_adapter.count(:disable)).to be(0)
+    end
+
+    it 'does not update percentage of actors' do
+      local.enable_percentage_of_actors(:search, 10)
+      remote.enable_percentage_of_actors(:search, 10)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:enable)).to be(0)
+      expect(local_adapter.count(:disable)).to be(0)
+    end
+
+    it 'does not update percentage of time' do
+      local.enable_percentage_of_time(:search, 10)
+      remote.enable_percentage_of_time(:search, 10)
+      local_adapter.reset
+      subject # initialize forces sync
+      expect(local_adapter.count(:enable)).to be(0)
+      expect(local_adapter.count(:disable)).to be(0)
+    end
+  end
+
+  it 'synchronizes for #features' do
+    expect(subject).to receive(:sync)
+    subject.features
+  end
+
+  it 'synchronizes for #get' do
+    expect(subject).to receive(:sync)
+    subject.get sync[:search]
+  end
+
+  it 'synchronizes for #get_multi' do
+    expect(subject).to receive(:sync)
+    subject.get_multi [sync[:search]]
+  end
+
+  it 'synchronizes for #get_all' do
+    expect(subject).to receive(:sync)
+    subject.get_all
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flipper
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 0.13.0.beta1
 platform: ruby
 authors:
 - John Nunemaker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-22 00:00:00.000000000 Z
+date: 2018-03-03 00:00:00.000000000 Z
 dependencies: []
 description: Feature flipper is the act of enabling/disabling features in your application,
   ideally without re-deploying or changing anything in your code base. Flipper makes
@@ -67,6 +67,10 @@ files:
 - lib/flipper/adapters/operation_logger.rb
 - lib/flipper/adapters/pstore.rb
 - lib/flipper/adapters/read_only.rb
+- lib/flipper/adapters/sync.rb
+- lib/flipper/adapters/sync/feature_synchronizer.rb
+- lib/flipper/adapters/sync/interval_synchronizer.rb
+- lib/flipper/adapters/sync/synchronizer.rb
 - lib/flipper/configuration.rb
 - lib/flipper/dsl.rb
 - lib/flipper/errors.rb
@@ -109,6 +113,10 @@ files:
 - spec/flipper/adapters/operation_logger_spec.rb
 - spec/flipper/adapters/pstore_spec.rb
 - spec/flipper/adapters/read_only_spec.rb
+- spec/flipper/adapters/sync/feature_synchronizer_spec.rb
+- spec/flipper/adapters/sync/interval_synchronizer_spec.rb
+- spec/flipper/adapters/sync/synchronizer_spec.rb
+- spec/flipper/adapters/sync_spec.rb
 - spec/flipper/configuration_spec.rb
 - spec/flipper/dsl_spec.rb
 - spec/flipper/feature_check_context_spec.rb
@@ -158,12 +166,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Feature flipper for ANYTHING
@@ -178,6 +186,10 @@ test_files:
 - spec/flipper/adapters/operation_logger_spec.rb
 - spec/flipper/adapters/pstore_spec.rb
 - spec/flipper/adapters/read_only_spec.rb
+- spec/flipper/adapters/sync/feature_synchronizer_spec.rb
+- spec/flipper/adapters/sync/interval_synchronizer_spec.rb
+- spec/flipper/adapters/sync/synchronizer_spec.rb
+- spec/flipper/adapters/sync_spec.rb
 - spec/flipper/configuration_spec.rb
 - spec/flipper/dsl_spec.rb
 - spec/flipper/feature_check_context_spec.rb