flipper 0.22.0 → 0.28.0

data/spec/flipper/adapters/instrumented_spec.rb

@@ -1,7 +1,5 @@
-require 'helper'
 require 'flipper/adapters/instrumented'
 require 'flipper/instrumenters/memory'
-require 'flipper/spec/shared_adapter_specs'
 
 RSpec.describe Flipper::Adapters::Instrumented do
   let(:instrumenter) { Flipper::Instrumenters::Memory.new }
@@ -18,16 +16,6 @@ RSpec.describe Flipper::Adapters::Instrumented do
 
   it_should_behave_like 'a flipper adapter'
 
-  it 'forwards missing methods to underlying adapter' do
-    adapter = Class.new do
-      def foo
-        :foo
-      end
-    end.new
-    instrumented = described_class.new(adapter)
-    expect(instrumented.foo).to eq(:foo)
-  end
-
   describe '#name' do
     it 'is instrumented' do
       expect(subject.name).to be(:instrumented)
@@ -148,4 +136,32 @@ RSpec.describe Flipper::Adapters::Instrumented do
       expect(event.payload[:result]).to be(result)
     end
   end
+
+  describe '#import' do
+    it 'records instrumentation' do
+      result = subject.import(Flipper::Adapters::Memory.new)
+
+      event = instrumenter.events.last
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:import)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:result]).to be(result)
+    end
+  end
+
+  describe '#export' do
+    it 'records instrumentation' do
+      result = subject.export(format: :json, version: 1)
+
+      event = instrumenter.events.last
+      expect(event).not_to be_nil
+      expect(event.name).to eq('adapter_operation.flipper')
+      expect(event.payload[:operation]).to eq(:export)
+      expect(event.payload[:adapter_name]).to eq(:memory)
+      expect(event.payload[:format]).to be(:json)
+      expect(event.payload[:version]).to be(1)
+      expect(event.payload[:result]).to be(result)
+    end
+  end
 end

data/spec/flipper/adapters/memoizable_spec.rb

@@ -1,7 +1,5 @@
-require 'helper'
 require 'flipper/adapters/memoizable'
 require 'flipper/adapters/operation_logger'
-require 'flipper/spec/shared_adapter_specs'
 
 RSpec.describe Flipper::Adapters::Memoizable do
   let(:features_key) { described_class::FeaturesKey }
@@ -13,16 +11,6 @@ RSpec.describe Flipper::Adapters::Memoizable do
 
   it_should_behave_like 'a flipper adapter'
 
-  it 'forwards missing methods to underlying adapter' do
-    adapter = Class.new do
-      def foo
-        :foo
-      end
-    end.new
-    memoizable = described_class.new(adapter)
-    expect(memoizable.foo).to eq(:foo)
-  end
-
   describe '#name' do
     it 'is instrumented' do
       expect(subject.name).to be(:memoizable)
@@ -251,6 +239,36 @@ RSpec.describe Flipper::Adapters::Memoizable do
     end
   end
 
+  describe "#import" do
+    context "with memoization enabled" do
+      before do
+        subject.memoize = true
+      end
+
+      it "unmemoizes features" do
+        cache[:foo] = "bar"
+        flipper[:stats].enable
+        flipper[:search].disable
+        subject.import(Flipper::Adapters::Memory.new)
+        expect(cache).to be_empty
+      end
+    end
+
+    context "with memoization disabled" do
+      before do
+        subject.memoize = false
+      end
+
+      it "does not unmemoize features" do
+        cache[:foo] = "bar"
+        flipper[:stats].enable
+        flipper[:search].disable
+        subject.import(Flipper::Adapters::Memory.new)
+        expect(cache).not_to be_empty
+      end
+    end
+  end
+
   describe '#features' do
     context 'with memoization enabled' do
       before do

data/spec/flipper/adapters/memory_spec.rb

@@ -1,6 +1,3 @@
-require 'helper'
-require 'flipper/spec/shared_adapter_specs'
-
 RSpec.describe Flipper::Adapters::Memory do
   let(:source) { {} }
   subject { described_class.new(source) }
@@ -17,7 +14,9 @@ RSpec.describe Flipper::Adapters::Memory do
     flipper.enable_actor :following, Flipper::Actor.new('3')
     flipper.enable_group :following, Flipper::Types::Group.new(:staff)
 
-    expect(source).to eq({
+    dup = described_class.new(subject.get_all)
+
+    expect(dup.get_all).to eq({
       "subscriptions" => subject.default_config.merge(boolean: "true"),
       "search" => subject.default_config,
       "logging" => subject.default_config.merge(:percentage_of_time => "30"),

data/spec/flipper/adapters/operation_logger_spec.rb

@@ -1,6 +1,4 @@
-require 'helper'
 require 'flipper/adapters/operation_logger'
-require 'flipper/spec/shared_adapter_specs'
 
 RSpec.describe Flipper::Adapters::OperationLogger do
   let(:operations) { [] }
@@ -20,16 +18,6 @@ RSpec.describe Flipper::Adapters::OperationLogger do
     expect(output).to match(/@adapter=#<Flipper::Adapters::Memory/)
   end
 
-  it 'forwards missing methods to underlying adapter' do
-    adapter = Class.new do
-      def foo
-        :foo
-      end
-    end.new
-    operation_logger = described_class.new(adapter)
-    expect(operation_logger.foo).to eq(:foo)
-  end
-
   describe '#get' do
     before do
       @feature = flipper[:stats]
@@ -108,4 +96,33 @@ RSpec.describe Flipper::Adapters::OperationLogger do
       expect(@result).to eq(adapter.add(@feature))
     end
   end
+
+  describe '#import' do
+    before do
+      @source = Flipper::Adapters::Memory.new
+      @result = subject.import(@source)
+    end
+
+    it 'logs operation' do
+      expect(subject.count(:import)).to be(1)
+    end
+
+    it 'returns result' do
+      expect(@result).to eq(adapter.import(@source))
+    end
+  end
+
+  describe '#export' do
+    before do
+      @result = subject.export(format: :json, version: 1)
+    end
+
+    it 'logs operation' do
+      expect(subject.count(:export)).to be(1)
+    end
+
+    it 'returns result' do
+      expect(@result).to eq(adapter.export(format: :json, version: 1))
+    end
+  end
 end

data/spec/flipper/adapters/pstore_spec.rb

@@ -1,6 +1,4 @@
-require 'helper'
 require 'flipper/adapters/pstore'
-require 'flipper/spec/shared_adapter_specs'
 
 RSpec.describe Flipper::Adapters::PStore do
   subject do

data/spec/flipper/adapters/read_only_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/adapters/read_only'
 
 RSpec.describe Flipper::Adapters::ReadOnly do

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

@@ -1,4 +1,3 @@
-require "helper"
 require "flipper/adapters/memory"
 require "flipper/adapters/operation_logger"
 require "flipper/adapters/sync/feature_synchronizer"

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

@@ -1,10 +1,10 @@
-require "helper"
 require "flipper/adapters/sync/interval_synchronizer"
 
 RSpec.describe Flipper::Adapters::Sync::IntervalSynchronizer do
   let(:events) { [] }
-  let(:synchronizer) { -> { events << described_class.now } }
+  let(:synchronizer) { -> { events << now } }
   let(:interval) { 10 }
+  let(:now) { subject.send(:now) }
 
   subject { described_class.new(synchronizer, interval: interval) }
 
@@ -15,19 +15,18 @@ RSpec.describe Flipper::Adapters::Sync::IntervalSynchronizer do
   end
 
   it "only invokes wrapped synchronizer every interval seconds" do
-    now = described_class.now
     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).and_return(now + i - 1)
+      allow(subject).to receive(:now).and_return(now + i - 1)
       subject.call
     end
     expect(events.size).to be(0)
 
     # move time to last sync + interval in milliseconds
-    allow(described_class).to receive(:now).and_return(now + interval)
+    allow(subject).to receive(:now).and_return(now + interval)
     subject.call
     expect(events.size).to be(1)
   end

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

@@ -1,4 +1,3 @@
-require "helper"
 require "flipper/adapters/memory"
 require "flipper/instrumenters/memory"
 require "flipper/adapters/sync/synchronizer"

data/spec/flipper/adapters/sync_spec.rb

@@ -1,7 +1,5 @@
-require 'helper'
 require 'flipper/adapters/sync'
 require 'flipper/adapters/operation_logger'
-require 'flipper/spec/shared_adapter_specs'
 require 'active_support/notifications'
 
 RSpec.describe Flipper::Adapters::Sync do

data/spec/flipper/configuration_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/configuration'
 
 RSpec.describe Flipper::Configuration do

data/spec/flipper/dsl_spec.rb

@@ -1,4 +1,3 @@
-require 'helper'
 require 'flipper/dsl'
 
 RSpec.describe Flipper::DSL do
@@ -7,9 +6,19 @@ RSpec.describe Flipper::DSL do
   let(:adapter) { Flipper::Adapters::Memory.new }
 
   describe '#initialize' do
-    it 'sets adapter' do
-      dsl = described_class.new(adapter)
-      expect(dsl.adapter).not_to be_nil
+    context 'when using default memoize strategy' do
+      it 'wraps the given adapter with Flipper::Adapters::Memoizable' do
+        dsl = described_class.new(adapter)
+        expect(dsl.adapter.class).to be(Flipper::Adapters::Memoizable)
+        expect(dsl.adapter.adapter).to be(adapter)
+      end
+    end
+
+    context 'when disabling memoization' do
+      it 'uses the given adapter directly' do
+        dsl = described_class.new(adapter, memoize: false)
+        expect(dsl.adapter).to be(adapter)
+      end
     end
 
     it 'defaults instrumenter to noop' do
@@ -140,12 +149,12 @@ RSpec.describe Flipper::DSL do
   end
 
   describe '#actor' do
-    context 'for a thing' do
+    context 'for an actor' do
       it 'returns actor instance' do
-        thing = Flipper::Actor.new(33)
-        actor = subject.actor(thing)
-        expect(actor).to be_instance_of(Flipper::Types::Actor)
-        expect(actor.value).to eq('33')
+        actor = Flipper::Actor.new(33)
+        flipper_actor = subject.actor(actor)
+        expect(flipper_actor).to be_instance_of(Flipper::Types::Actor)
+        expect(flipper_actor.value).to eq('33')
       end
     end
 
@@ -333,10 +342,27 @@ RSpec.describe Flipper::DSL do
   end
 
   describe '#import' do
+    context "with flipper instance" do
+      it 'delegates to adapter' do
+        destination_flipper = build_flipper
+        expect(subject.adapter).to receive(:import).with(destination_flipper)
+        subject.import(destination_flipper)
+      end
+    end
+
+    context "with flipper adapter" do
+      it 'delegates to adapter' do
+        destination_flipper = build_flipper
+        expect(subject.adapter).to receive(:import).with(destination_flipper.adapter)
+        subject.import(destination_flipper.adapter)
+      end
+    end
+  end
+
+  describe "#export" do
     it 'delegates to adapter' do
-      destination_flipper = build_flipper
-      expect(subject.adapter).to receive(:import).with(destination_flipper.adapter)
-      subject.import(destination_flipper)
+      expect(subject.export).to eq(subject.adapter.export)
+      expect(subject.export(format: :json)).to eq(subject.adapter.export(format: :json))
     end
   end
 

data/spec/flipper/export_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe Flipper::Export do
+  it "can initialize" do
+    export = described_class.new(contents: "{}", format: :json, version: 1)
+    expect(export.contents).to eq("{}")
+    expect(export.format).to eq(:json)
+    expect(export.version).to eq(1)
+  end
+
+  it "raises not implemented for features" do
+    export = described_class.new(contents: "{}", format: :json, version: 1)
+    expect { export.features }.to raise_error(NotImplementedError)
+  end
+end

data/spec/flipper/exporter_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Flipper::Exporter do
+  describe ".build" do
+    it "builds instance of exporter" do
+      exporter = described_class.build(format: :json, version: 1)
+      expect(exporter).to be_instance_of(Flipper::Exporters::Json::V1)
+    end
+
+    it "raises if format not found" do
+      expect { described_class.build(format: :nope, version: 1) }.to raise_error(KeyError)
+    end
+
+    it "raises if version not found" do
+      expect { described_class.build(format: :json, version: 0) }.to raise_error(KeyError)
+    end
+  end
+end

data/spec/flipper/exporters/json/export_spec.rb

@@ -0,0 +1,60 @@
+require 'flipper/exporters/json/v1'
+
+RSpec.describe Flipper::Exporters::Json::Export do
+  let(:contents) {
+    <<~JSON
+      {
+        "version":1,
+        "features":{
+          "search":{"boolean":null,"groups":["admins","employees"],"actors":["User;1","User;100"],"percentage_of_actors":"10","percentage_of_time":"15"},
+          "plausible":{"boolean":"true","groups":[],"actors":[],"percentage_of_actors":null,"percentage_of_time":null},
+          "google_analytics":{"boolean":null,"groups":[],"actors":[],"percentage_of_actors":null,"percentage_of_time":null}
+        }
+      }
+    JSON
+  }
+
+  it "can initialize" do
+    export = described_class.new(contents: contents)
+    expect(export.format).to eq(:json)
+    expect(export.version).to be(1)
+  end
+
+  it "can initialize with version" do
+    export = described_class.new(contents: contents, version: 1)
+    expect(export.version).to be(1)
+  end
+
+  it "can build features from contents" do
+    export = Flipper::Exporters::Json::Export.new(contents: contents)
+    expect(export.features).to eq({
+      "search" => {actors: Set["User;1", "User;100"], boolean: nil, groups: Set["admins", "employees"], percentage_of_actors: "10", percentage_of_time: "15"},
+      "plausible" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "google_analytics" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+    })
+  end
+
+  it "can build an adapter from features" do
+    export = Flipper::Exporters::Json::Export.new(contents: contents)
+    expect(export.adapter).to be_instance_of(Flipper::Adapters::Memory)
+    expect(export.adapter.get_all).to eq({
+      "plausible" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "search" => {actors: Set["User;1", "User;100"], boolean: nil, groups: Set["admins", "employees"], percentage_of_actors: "10", percentage_of_time: "15"},
+      "google_analytics" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+    })
+  end
+
+  it "raises for invalid json" do
+    export = described_class.new(contents: "bad contents")
+    expect {
+      export.features
+    }.to raise_error(Flipper::Exporters::Json::JsonError)
+  end
+
+  it "raises for missing features key" do
+    export = described_class.new(contents: "{}")
+    expect {
+      export.features
+    }.to raise_error(Flipper::Exporters::Json::InvalidError)
+  end
+end

data/spec/flipper/exporters/json/v1_spec.rb

@@ -0,0 +1,33 @@
+require 'flipper/exporters/json/v1'
+
+RSpec.describe Flipper::Exporters::Json::V1 do
+  subject { described_class.new }
+
+  it "has a version number" do
+    adapter = Flipper::Adapters::Memory.new
+    export = subject.call(adapter)
+    data = JSON.parse(export.contents)
+    expect(data["version"]).to eq(1)
+  end
+
+  it "exports features and gates" do
+    adapter = Flipper::Adapters::Memory.new
+    flipper = Flipper.new(adapter)
+    flipper.enable_percentage_of_actors :search, 10
+    flipper.enable_percentage_of_time :search, 15
+    flipper.enable_actor :search, Flipper::Actor.new('User;1')
+    flipper.enable_actor :search, Flipper::Actor.new('User;100')
+    flipper.enable_group :search, :admins
+    flipper.enable_group :search, :employees
+    flipper.enable :plausible
+    flipper.disable :google_analytics
+
+    export = subject.call(adapter)
+
+    expect(export.features).to eq({
+      "google_analytics" => {actors: Set.new, boolean: nil, groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "plausible" => {actors: Set.new, boolean: "true", groups: Set.new, percentage_of_actors: nil, percentage_of_time: nil},
+      "search" => {actors: Set["User;1", "User;100"], boolean: nil, groups: Set["admins", "employees"], percentage_of_actors: "10", percentage_of_time: "15"},
+    })
+  end
+end

data/spec/flipper/feature_check_context_spec.rb

@@ -1,67 +1,65 @@
-require 'helper'
-
 RSpec.describe Flipper::FeatureCheckContext do
   let(:feature_name) { :new_profiles }
   let(:values) { Flipper::GateValues.new({}) }
-  let(:thing) { Flipper::Actor.new('5') }
+  let(:actor) { Flipper::Actor.new('5') }
   let(:options) do
     {
       feature_name: feature_name,
       values: values,
-      thing: thing,
+      actors: [actor],
     }
   end
 
   it 'initializes just fine' do
-    instance = described_class.new(options)
+    instance = described_class.new(**options)
     expect(instance.feature_name).to eq(feature_name)
     expect(instance.values).to eq(values)
-    expect(instance.thing).to eq(thing)
+    expect(instance.actors).to eq([actor])
   end
 
   it 'requires feature_name' do
     options.delete(:feature_name)
     expect do
-      described_class.new(options)
-    end.to raise_error(KeyError)
+      described_class.new(**options)
+    end.to raise_error(ArgumentError)
   end
 
   it 'requires values' do
     options.delete(:values)
     expect do
-      described_class.new(options)
-    end.to raise_error(KeyError)
+      described_class.new(**options)
+    end.to raise_error(ArgumentError)
   end
 
-  it 'requires thing' do
-    options.delete(:thing)
+  it 'requires actors' do
+    options.delete(:actors)
     expect do
-      described_class.new(options)
-    end.to raise_error(KeyError)
+      described_class.new(**options)
+    end.to raise_error(ArgumentError)
   end
 
   it 'knows actors_value' do
     args = options.merge(values: Flipper::GateValues.new(actors: Set['User;1']))
-    expect(described_class.new(args).actors_value).to eq(Set['User;1'])
+    expect(described_class.new(**args).actors_value).to eq(Set['User;1'])
   end
 
   it 'knows groups_value' do
     args = options.merge(values: Flipper::GateValues.new(groups: Set['admins']))
-    expect(described_class.new(args).groups_value).to eq(Set['admins'])
+    expect(described_class.new(**args).groups_value).to eq(Set['admins'])
   end
 
   it 'knows boolean_value' do
-    instance = described_class.new(options.merge(values: Flipper::GateValues.new(boolean: true)))
+    instance = described_class.new(**options.merge(values: Flipper::GateValues.new(boolean: true)))
     expect(instance.boolean_value).to eq(true)
   end
 
   it 'knows percentage_of_actors_value' do
     args = options.merge(values: Flipper::GateValues.new(percentage_of_actors: 14))
-    expect(described_class.new(args).percentage_of_actors_value).to eq(14)
+    expect(described_class.new(**args).percentage_of_actors_value).to eq(14)
   end
 
   it 'knows percentage_of_time_value' do
     args = options.merge(values: Flipper::GateValues.new(percentage_of_time: 41))
-    expect(described_class.new(args).percentage_of_time_value).to eq(41)
+    expect(described_class.new(**args).percentage_of_time_value).to eq(41)
   end
 end