flipper 0.10.2 → 0.11.0.beta1

data/spec/flipper/adapters/operation_logger_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe Flipper::Adapters::OperationLogger do
 
   it_should_behave_like 'a flipper adapter'
 
-  it "forwards missing methods to underlying adapter" do
+  it 'forwards missing methods to underlying adapter' do
     adapter = Class.new do
       def foo
         :foo
@@ -22,22 +22,22 @@ RSpec.describe Flipper::Adapters::OperationLogger do
     expect(operation_logger.foo).to eq(:foo)
   end
 
-  describe "#get" do
+  describe '#get' do
     before do
       @feature = flipper[:stats]
       @result = subject.get(@feature)
     end
 
-    it "logs operation" do
+    it 'logs operation' do
       expect(subject.count(:get)).to be(1)
     end
 
-    it "returns result" do
+    it 'returns result' do
       expect(@result).to eq(adapter.get(@feature))
     end
   end
 
-  describe "#enable" do
+  describe '#enable' do
     before do
       @feature = flipper[:stats]
       @gate = @feature.gate(:boolean)
@@ -45,16 +45,16 @@ RSpec.describe Flipper::Adapters::OperationLogger do
       @result = subject.enable(@feature, @gate, @thing)
     end
 
-    it "logs operation" do
+    it 'logs operation' do
       expect(subject.count(:enable)).to be(1)
     end
 
-    it "returns result" do
+    it 'returns result' do
       expect(@result).to eq(adapter.enable(@feature, @gate, @thing))
     end
   end
 
-  describe "#disable" do
+  describe '#disable' do
     before do
       @feature = flipper[:stats]
       @gate = @feature.gate(:boolean)
@@ -62,41 +62,41 @@ RSpec.describe Flipper::Adapters::OperationLogger do
       @result = subject.disable(@feature, @gate, @thing)
     end
 
-    it "logs operation" do
+    it 'logs operation' do
       expect(subject.count(:disable)).to be(1)
     end
 
-    it "returns result" do
+    it 'returns result' do
       expect(@result).to eq(adapter.disable(@feature, @gate, @thing))
     end
   end
 
-  describe "#features" do
+  describe '#features' do
     before do
       flipper[:stats].enable
       @result = subject.features
     end
 
-    it "logs operation" do
+    it 'logs operation' do
       expect(subject.count(:features)).to be(1)
     end
 
-    it "returns result" do
+    it 'returns result' do
       expect(@result).to eq(adapter.features)
     end
   end
 
-  describe "#add" do
+  describe '#add' do
     before do
       @feature = flipper[:stats]
       @result = subject.add(@feature)
     end
 
-    it "logs operation" do
+    it 'logs operation' do
       expect(subject.count(:add)).to be(1)
     end
 
-    it "returns result" do
+    it 'returns result' do
       expect(@result).to eq(adapter.add(@feature))
     end
   end

data/spec/flipper/adapters/pstore_spec.rb

@@ -3,16 +3,16 @@ require 'flipper/adapters/pstore'
 require 'flipper/spec/shared_adapter_specs'
 
 RSpec.describe Flipper::Adapters::PStore do
-  subject {
-    dir = FlipperRoot.join("tmp").tap { |d| d.mkpath }
-    pstore_file = dir.join("flipper.pstore")
+  subject do
+    dir = FlipperRoot.join('tmp').tap(&:mkpath)
+    pstore_file = dir.join('flipper.pstore')
     pstore_file.unlink if pstore_file.exist?
     described_class.new(pstore_file)
-  }
+  end
 
   it_should_behave_like 'a flipper adapter'
 
-  it "defaults path to flipper.pstore" do
-    expect(described_class.new.path).to eq("flipper.pstore")
+  it 'defaults path to flipper.pstore' do
+    expect(described_class.new.path).to eq('flipper.pstore')
   end
 end

data/spec/flipper/adapters/read_only_spec.rb

@@ -17,78 +17,72 @@ RSpec.describe Flipper::Adapters::ReadOnly do
   subject { described_class.new(adapter) }
 
   before do
-    Flipper.register(:admins) { |actor|
+    Flipper.register(:admins) do |actor|
       actor.respond_to?(:admin?) && actor.admin?
-    }
+    end
 
-    Flipper.register(:early_access) { |actor|
+    Flipper.register(:early_access) do |actor|
       actor.respond_to?(:early_access?) && actor.early_access?
-    }
+    end
   end
 
   after do
     Flipper.unregister_groups
   end
 
-  it "has name that is a symbol" do
-    expect(subject.name).to_not be_nil
+  it 'has name that is a symbol' do
+    expect(subject.name).not_to be_nil
     expect(subject.name).to be_instance_of(Symbol)
   end
 
-  it "has included the flipper adapter module" do
+  it 'has included the flipper adapter module' do
     expect(subject.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({
-      :boolean => nil,
-      :groups => Set.new,
-      :actors => Set.new,
-      :percentage_of_actors => nil,
-      :percentage_of_time => nil,
-    })
+  it 'returns correct default values for the gates if none are enabled' do
+    expect(subject.get(feature)).to eq(subject.default_config)
   end
 
-  it "can get feature" do
-    actor_22 = actor_class.new('22')
+  it 'can get feature' do
+    actor22 = actor_class.new('22')
     adapter.enable(feature, boolean_gate, flipper.boolean)
     adapter.enable(feature, group_gate, flipper.group(:admins))
-    adapter.enable(feature, actor_gate, flipper.actor(actor_22))
+    adapter.enable(feature, actor_gate, flipper.actor(actor22))
     adapter.enable(feature, actors_gate, flipper.actors(25))
     adapter.enable(feature, time_gate, flipper.time(45))
 
-    expect(subject.get(feature)).to eq({
-      :boolean => "true",
-      :groups => Set["admins"],
-      :actors => Set["22"],
-      :percentage_of_actors => "25",
-      :percentage_of_time => "45",
-    })
+    expect(subject.get(feature)).to eq(boolean: 'true',
+                                       groups: Set['admins'],
+                                       actors: Set['22'],
+                                       percentage_of_actors: '25',
+                                       percentage_of_time: '45')
   end
 
-  it "can get features" do
+  it 'can get features' do
     expect(subject.features).to eq(Set.new)
     adapter.add(feature)
-    expect(subject.features).to eq(Set["stats"])
+    expect(subject.features).to eq(Set['stats'])
   end
 
-  it "raises error on add" do
+  it 'raises error on add' do
     expect { subject.add(feature) }.to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end
 
-  it "raises error on remove" do
+  it 'raises error on remove' do
     expect { subject.remove(feature) }.to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end
 
-  it "raises on clear" do
+  it 'raises on clear' do
     expect { subject.clear(feature) }.to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end
 
-  it "raises error on enable" do
-    expect { subject.enable(feature, boolean_gate, flipper.boolean) }.to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
+  it 'raises error on enable' do
+    expect { subject.enable(feature, boolean_gate, flipper.boolean) }
+      .to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end
 
-  it "raises error on disable" do
-    expect { subject.disable(feature, boolean_gate, flipper.boolean) }.to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
+  it 'raises error on disable' do
+    expect { subject.disable(feature, boolean_gate, flipper.boolean) }
+      .to raise_error(Flipper::Adapters::ReadOnly::WriteAttempted)
   end
 end

data/spec/flipper/dsl_spec.rb

@@ -3,121 +3,110 @@ require 'flipper/dsl'
 require 'flipper/adapters/memory'
 
 RSpec.describe Flipper::DSL do
-  subject { Flipper::DSL.new(adapter) }
+  subject { described_class.new(adapter) }
 
   let(:adapter) { Flipper::Adapters::Memory.new }
 
-  describe "#initialize" do
-    it "sets adapter" do
+  describe '#initialize' do
+    it 'sets adapter' do
       dsl = described_class.new(adapter)
       expect(dsl.adapter).not_to be_nil
     end
 
-    it "defaults instrumenter to noop" do
+    it 'defaults instrumenter to noop' do
       dsl = described_class.new(adapter)
       expect(dsl.instrumenter).to be(Flipper::Instrumenters::Noop)
     end
 
-    context "with overriden instrumenter" do
-      let(:instrumenter) { double('Instrumentor', :instrument => nil) }
+    context 'with overriden instrumenter' do
+      let(:instrumenter) { double('Instrumentor', instrument: nil) }
 
-      it "overrides default instrumenter" do
-        dsl = described_class.new(adapter, :instrumenter => instrumenter)
+      it 'overrides default instrumenter' do
+        dsl = described_class.new(adapter, instrumenter: instrumenter)
         expect(dsl.instrumenter).to be(instrumenter)
       end
     end
   end
 
-  describe "#feature" do
-    it_should_behave_like "a DSL feature" do
+  describe '#feature' do
+    it_should_behave_like 'a DSL feature' do
       let(:method_name) { :feature }
-      let(:instrumenter) { double('Instrumentor', :instrument => nil) }
+      let(:instrumenter) { double('Instrumentor', instrument: nil) }
       let(:feature) { dsl.send(method_name, :stats) }
-      let(:dsl) { Flipper::DSL.new(adapter, :instrumenter => instrumenter) }
+      let(:dsl) { described_class.new(adapter, instrumenter: instrumenter) }
     end
   end
 
-  describe "#preload" do
-    let(:instrumenter) { double('Instrumentor', :instrument => nil) }
-    let(:dsl) { Flipper::DSL.new(adapter, :instrumenter => instrumenter) }
-    let(:names) { %i{stats shiny} }
+  describe '#preload' do
+    let(:instrumenter) { double('Instrumentor', instrument: nil) }
+    let(:dsl) { described_class.new(adapter, instrumenter: instrumenter) }
+    let(:names) { %i(stats shiny) }
     let(:features) { dsl.preload(names) }
 
-    it "returns array of features" do
+    it 'returns array of features' do
       expect(features).to all be_instance_of(Flipper::Feature)
     end
 
-    it "sets names" do
+    it 'sets names' do
       expect(features.map(&:name)).to eq(names)
     end
 
-    it "sets adapter" do
+    it 'sets adapter' do
       features.each do |feature|
         expect(feature.adapter.name).to eq(dsl.adapter.name)
       end
     end
 
-    it "sets instrumenter" do
+    it 'sets instrumenter' do
       features.each do |feature|
         expect(feature.instrumenter).to eq(dsl.instrumenter)
       end
     end
 
-    it "memoizes the feature" do
+    it 'memoizes the feature' do
       features.each do |feature|
         expect(dsl.feature(feature.name)).to equal(feature)
       end
     end
   end
 
-  describe "#[]" do
-    it_should_behave_like "a DSL feature" do
+  describe '#[]' do
+    it_should_behave_like 'a DSL feature' do
       let(:method_name) { :[] }
-      let(:instrumenter) { double('Instrumentor', :instrument => nil) }
+      let(:instrumenter) { double('Instrumentor', instrument: nil) }
       let(:feature) { dsl.send(method_name, :stats) }
-      let(:dsl) { Flipper::DSL.new(adapter, :instrumenter => instrumenter) }
+      let(:dsl) { described_class.new(adapter, instrumenter: instrumenter) }
     end
   end
 
-  describe "#boolean" do
-    it_should_behave_like "a DSL boolean method" do
+  describe '#boolean' do
+    it_should_behave_like 'a DSL boolean method' do
       let(:method_name) { :boolean }
     end
   end
 
-  describe "#bool" do
-    it_should_behave_like "a DSL boolean method" do
+  describe '#bool' do
+    it_should_behave_like 'a DSL boolean method' do
       let(:method_name) { :bool }
     end
   end
 
-  describe "#group" do
-    context "for registered group" do
+  describe '#group' do
+    context 'for registered group' do
       before do
-        @group = Flipper.register(:admins) { }
+        @group = Flipper.register(:admins) {}
       end
 
-      it "returns group" do
-        expect(subject.group(:admins)).to eq(@group)
-      end
-
-      it "always returns same instance for same name" do
-        expect(subject.group(:admins)).to equal(subject.group(:admins))
-      end
-    end
-
-    context "for unregistered group" do
-      it "raises error" do
-        expect {
-          subject.group(:admins)
-        }.to raise_error(Flipper::GroupNotRegistered)
+      it 'delegates to Flipper' do
+        expect(Flipper).to receive(:group).with(:admins).and_return(@group)
+        expect(subject.group(:admins)).to be(@group)
       end
     end
   end
 
-  describe "#actor" do
-    context "for a thing" do
-      it "returns actor instance" do
+  describe '#actor' do
+    context 'for a thing' do
+      it 'returns actor instance' do
         thing = Struct.new(:flipper_id).new(33)
         actor = subject.actor(thing)
         expect(actor).to be_instance_of(Flipper::Types::Actor)
@@ -125,85 +114,85 @@ RSpec.describe Flipper::DSL do
       end
     end
 
-    context "for nil" do
-      it "raises argument error" do
-        expect {
+    context 'for nil' do
+      it 'raises argument error' do
+        expect do
           subject.actor(nil)
-        }.to raise_error(ArgumentError)
+        end.to raise_error(ArgumentError)
       end
     end
 
-    context "for something that is not actor wrappable" do
-      it "raises argument error" do
-        expect {
+    context 'for something that is not actor wrappable' do
+      it 'raises argument error' do
+        expect do
           subject.actor(Object.new)
-        }.to raise_error(ArgumentError)
+        end.to raise_error(ArgumentError)
       end
     end
   end
 
-  describe "#time" do
+  describe '#time' do
     before do
       @result = subject.time(5)
     end
 
-    it "returns percentage of time" do
+    it 'returns percentage of time' do
       expect(@result).to be_instance_of(Flipper::Types::PercentageOfTime)
     end
 
-    it "sets value" do
+    it 'sets value' do
       expect(@result.value).to eq(5)
     end
 
-    it "is aliased to percentage_of_time" do
+    it 'is aliased to percentage_of_time' do
       expect(@result).to eq(subject.percentage_of_time(@result.value))
     end
   end
 
-  describe "#actors" do
+  describe '#actors' do
     before do
       @result = subject.actors(17)
     end
 
-    it "returns percentage of actors" do
+    it 'returns percentage of actors' do
       expect(@result).to be_instance_of(Flipper::Types::PercentageOfActors)
     end
 
-    it "sets value" do
+    it 'sets value' do
       expect(@result.value).to eq(17)
     end
 
-    it "is aliased to percentage_of_actors" do
+    it 'is aliased to percentage_of_actors' do
       expect(@result).to eq(subject.percentage_of_actors(@result.value))
     end
   end
 
-  describe "#features" do
-    context "with no features enabled/disabled" do
-      it "defaults to empty set" do
+  describe '#features' do
+    context 'with no features enabled/disabled' do
+      it 'defaults to empty set' do
         expect(subject.features).to eq(Set.new)
       end
     end
 
-    context "with features enabled and disabled" do
+    context 'with features enabled and disabled' do
       before do
         subject[:stats].enable
         subject[:cache].enable
         subject[:search].disable
       end
 
-      it "returns set of feature instances" do
+      it 'returns set of feature instances' do
         expect(subject.features).to be_instance_of(Set)
         subject.features.each do |feature|
           expect(feature).to be_instance_of(Flipper::Feature)
         end
-        expect(subject.features.map(&:name).map(&:to_s).sort).to eq(['cache', 'search', 'stats'])
+        expect(subject.features.map(&:name).map(&:to_s).sort).to eq(%w(cache search stats))
       end
     end
   end
 
-  describe "#enable/disable" do
-    it "enables and disables the feature" do
+  describe '#enable/disable' do
+    it 'enables and disables the feature' do
       expect(subject[:stats].boolean_value).to eq(false)
       subject.enable(:stats)
       expect(subject[:stats].boolean_value).to eq(true)
@@ -213,35 +202,35 @@ RSpec.describe Flipper::DSL do
     end
   end
 
-  describe "#enable_actor/disable_actor" do
-    it "enables and disables the feature for actor" do
+  describe '#enable_actor/disable_actor' do
+    it 'enables and disables the feature for actor' do
       actor = Struct.new(:flipper_id).new(5)
 
       expect(subject[:stats].actors_value).to be_empty
       subject.enable_actor(:stats, actor)
-      expect(subject[:stats].actors_value).to eq(Set["5"])
+      expect(subject[:stats].actors_value).to eq(Set['5'])
 
       subject.disable_actor(:stats, actor)
       expect(subject[:stats].actors_value).to be_empty
     end
   end
 
-  describe "#enable_group/disable_group" do
-    it "enables and disables the feature for group" do
+  describe '#enable_group/disable_group' do
+    it 'enables and disables the feature for group' do
       actor = Struct.new(:flipper_id).new(5)
       group = Flipper.register(:fives) { |actor| actor.flipper_id == 5 }
 
       expect(subject[:stats].groups_value).to be_empty
       subject.enable_group(:stats, :fives)
-      expect(subject[:stats].groups_value).to eq(Set["fives"])
+      expect(subject[:stats].groups_value).to eq(Set['fives'])
 
       subject.disable_group(:stats, :fives)
       expect(subject[:stats].groups_value).to be_empty
     end
   end
 
-  describe "#enable_percentage_of_time/disable_percentage_of_time" do
-    it "enables and disables the feature for percentage of time" do
+  describe '#enable_percentage_of_time/disable_percentage_of_time' do
+    it 'enables and disables the feature for percentage of time' do
       expect(subject[:stats].percentage_of_time_value).to be(0)
       subject.enable_percentage_of_time(:stats, 6)
       expect(subject[:stats].percentage_of_time_value).to be(6)
@@ -251,8 +240,8 @@ RSpec.describe Flipper::DSL do
     end
   end
 
-  describe "#enable_percentage_of_actors/disable_percentage_of_actors" do
-    it "enables and disables the feature for percentage of time" do
+  describe '#enable_percentage_of_actors/disable_percentage_of_actors' do
+    it 'enables and disables the feature for percentage of time' do
       expect(subject[:stats].percentage_of_actors_value).to be(0)
       subject.enable_percentage_of_actors(:stats, 6)
       expect(subject[:stats].percentage_of_actors_value).to be(6)
@@ -263,7 +252,7 @@ RSpec.describe Flipper::DSL do
   end
 
   describe '#remove' do
-    it "removes the feature" do
+    it 'removes the feature' do
       subject.enable(:stats)
 
       expect { subject.remove(:stats) }.to change { subject.enabled?(:stats) }.to(false)