flipper 0.10.2 → 0.11.0.beta1

data/spec/flipper/feature_check_context_spec.rb

@@ -3,65 +3,65 @@ require 'helper'
 RSpec.describe Flipper::FeatureCheckContext do
   let(:feature_name) { :new_profiles }
   let(:values) { Flipper::GateValues.new({}) }
-  let(:thing) { Struct.new(:flipper_id).new("5") }
-  let(:options) {
+  let(:thing) { Struct.new(:flipper_id).new('5') }
+  let(:options) do
     {
       feature_name: feature_name,
       values: values,
       thing: thing,
     }
-  }
+  end
 
-  it "initializes just fine" do
+  it 'initializes just fine' do
     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)
   end
 
-  it "requires feature_name" do
+  it 'requires feature_name' do
     options.delete(:feature_name)
-    expect {
+    expect do
       described_class.new(options)
-    }.to raise_error(KeyError)
+    end.to raise_error(KeyError)
   end
 
-  it "requires values" do
+  it 'requires values' do
     options.delete(:values)
-    expect {
+    expect do
       described_class.new(options)
-    }.to raise_error(KeyError)
+    end.to raise_error(KeyError)
   end
 
-  it "requires thing" do
+  it 'requires thing' do
     options.delete(:thing)
-    expect {
+    expect do
       described_class.new(options)
-    }.to raise_error(KeyError)
+    end.to raise_error(KeyError)
   end
 
-  it "knows actors_value" do
-    instance = described_class.new(options.merge(values: Flipper::GateValues.new({actors: Set["User:1"]})))
-    expect(instance.actors_value).to eq(Set["User:1"])
+  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'])
   end
 
-  it "knows groups_value" do
-    instance = described_class.new(options.merge(values: Flipper::GateValues.new({groups: Set["admins"]})))
-    expect(instance.groups_value).to eq(Set["admins"])
+  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'])
   end
 
-  it "knows boolean_value" do
-    instance = described_class.new(options.merge(values: Flipper::GateValues.new({boolean: true})))
+  it 'knows boolean_value' do
+    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
-    instance = described_class.new(options.merge(values: Flipper::GateValues.new({percentage_of_actors: 14})))
-    expect(instance.percentage_of_actors_value).to eq(14)
+  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)
   end
 
-  it "knows percentage_of_time_value" do
-    instance = described_class.new(options.merge(values: Flipper::GateValues.new({percentage_of_time: 41})))
-    expect(instance.percentage_of_time_value).to eq(41)
+  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)
   end
 end

data/spec/flipper/feature_spec.rb

@@ -8,51 +8,49 @@ RSpec.describe Flipper::Feature do
 
   let(:adapter) { Flipper::Adapters::Memory.new }
 
-  describe "#initialize" do
-    it "sets name" do
+  describe '#initialize' do
+    it 'sets name' do
       feature = described_class.new(:search, adapter)
       expect(feature.name).to eq(:search)
     end
 
-    it "sets adapter" do
+    it 'sets adapter' do
       feature = described_class.new(:search, adapter)
       expect(feature.adapter).to eq(adapter)
     end
 
-    it "defaults instrumenter" do
+    it 'defaults instrumenter' do
       feature = described_class.new(:search, adapter)
       expect(feature.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
-        feature = described_class.new(:search, adapter, {
-          :instrumenter => instrumenter,
-        })
+      it 'overrides default instrumenter' do
+        feature = described_class.new(:search, adapter, instrumenter: instrumenter)
         expect(feature.instrumenter).to be(instrumenter)
       end
     end
   end
 
-  describe "#to_s" do
-    it "returns name as string" do
+  describe '#to_s' do
+    it 'returns name as string' do
       feature = described_class.new(:search, adapter)
-      expect(feature.to_s).to eq("search")
+      expect(feature.to_s).to eq('search')
     end
   end
 
-  describe "#to_param" do
-    it "returns name as string" do
+  describe '#to_param' do
+    it 'returns name as string' do
       feature = described_class.new(:search, adapter)
-      expect(feature.to_param).to eq("search")
+      expect(feature.to_param).to eq('search')
     end
   end
 
-  describe "#gate_for" do
-    context "with percentage of actors" do
-      it "returns percentage of actors gate" do
+  describe '#gate_for' do
+    context 'with percentage of actors' do
+      it 'returns percentage of actors gate' do
         percentage = Flipper::Types::PercentageOfActors.new(10)
         gate = subject.gate_for(percentage)
         expect(gate).to be_instance_of(Flipper::Gates::PercentageOfActors)
@@ -60,8 +58,8 @@ RSpec.describe Flipper::Feature do
     end
   end
 
-  describe "#gates" do
-    it "returns array of gates" do
+  describe '#gates' do
+    it 'returns array of gates' do
       instance = described_class.new(:search, adapter)
       expect(instance.gates).to be_instance_of(Array)
       instance.gates.each do |gate|
@@ -71,28 +69,28 @@ RSpec.describe Flipper::Feature do
     end
   end
 
-  describe "#gate" do
-    context "with symbol name" do
-      it "returns gate by name" do
+  describe '#gate' do
+    context 'with symbol name' do
+      it 'returns gate by name' do
         expect(subject.gate(:boolean)).to be_instance_of(Flipper::Gates::Boolean)
       end
     end
 
-    context "with string name" do
-      it "returns gate by name" do
+    context 'with string name' do
+      it 'returns gate by name' do
         expect(subject.gate('boolean')).to be_instance_of(Flipper::Gates::Boolean)
       end
     end
 
-    context "with name that does not exist" do
-      it "returns nil" do
+    context 'with name that does not exist' do
+      it 'returns nil' do
         expect(subject.gate(:poo)).to be_nil
       end
     end
   end
 
-  describe "#inspect" do
-    it "returns easy to read string representation" do
+  describe '#inspect' do
+    it 'returns easy to read string representation' do
       string = subject.inspect
       expect(string).to include('Flipper::Feature')
       expect(string).to include('name=:search')
@@ -107,15 +105,15 @@ RSpec.describe Flipper::Feature do
     end
   end
 
-  describe "instrumentation" do
+  describe 'instrumentation' do
     let(:instrumenter) { Flipper::Instrumenters::Memory.new }
 
-    subject {
-      described_class.new(:search, adapter, :instrumenter => instrumenter)
-    }
+    subject do
+      described_class.new(:search, adapter, instrumenter: instrumenter)
+    end
 
-    it "is recorded for enable" do
-      thing = Flipper::Types::Actor.new(Struct.new(:flipper_id).new("1"))
+    it 'is recorded for enable' do
+      thing = Flipper::Types::Actor.new(Struct.new(:flipper_id).new('1'))
       gate = subject.gate_for(thing)
 
       subject.enable(thing)
@@ -129,8 +127,8 @@ RSpec.describe Flipper::Feature do
       expect(event.payload[:result]).not_to be_nil
     end
 
-    it "always instruments flipper type instance for enable" do
-      thing = Struct.new(:flipper_id).new("1")
+    it 'always instruments flipper type instance for enable' do
+      thing = Struct.new(:flipper_id).new('1')
       gate = subject.gate_for(thing)
 
       subject.enable(thing)
@@ -140,7 +138,7 @@ RSpec.describe Flipper::Feature do
       expect(event.payload[:thing]).to eq(Flipper::Types::Actor.new(thing))
     end
 
-    it "is recorded for disable" do
+    it 'is recorded for disable' do
       thing = Flipper::Types::Boolean.new
       gate = subject.gate_for(thing)
 
@@ -155,7 +153,7 @@ RSpec.describe Flipper::Feature do
       expect(event.payload[:result]).not_to be_nil
     end
 
-    user = Struct.new(:flipper_id).new("1")
+    user = Struct.new(:flipper_id).new('1')
     actor = Flipper::Types::Actor.new(user)
     boolean_true = Flipper::Types::Boolean.new(true)
     boolean_false = Flipper::Types::Boolean.new(false)
@@ -185,8 +183,8 @@ RSpec.describe Flipper::Feature do
       end
     end
 
-    it "always instruments flipper type instance for disable" do
-      thing = Struct.new(:flipper_id).new("1")
+    it 'always instruments flipper type instance for disable' do
+      thing = Struct.new(:flipper_id).new('1')
       gate = subject.gate_for(thing)
 
       subject.disable(thing)
@@ -197,7 +195,7 @@ RSpec.describe Flipper::Feature do
       expect(event.payload[:thing]).to eq(Flipper::Types::Actor.new(thing))
     end
 
-    it "is recorded for remove" do
+    it 'is recorded for remove' do
       subject.remove
 
       event = instrumenter.events.last
@@ -208,8 +206,8 @@ RSpec.describe Flipper::Feature do
       expect(event.payload[:result]).not_to be_nil
     end
 
-    it "is recorded for enabled?" do
-      thing = Flipper::Types::Actor.new(Struct.new(:flipper_id).new("1"))
+    it 'is recorded for enabled?' do
+      thing = Flipper::Types::Actor.new(Struct.new(:flipper_id).new('1'))
       gate = subject.gate_for(thing)
 
       subject.enabled?(thing)
@@ -223,7 +221,7 @@ RSpec.describe Flipper::Feature do
       expect(event.payload[:result]).to eq(false)
     end
 
-    user = Struct.new(:flipper_id).new("1")
+    user = Struct.new(:flipper_id).new('1')
     actor = Flipper::Types::Actor.new(user)
     {
       nil => nil,
@@ -241,176 +239,176 @@ RSpec.describe Flipper::Feature do
     end
   end
 
-  describe "#state" do
-    context "fully on" do
+  describe '#state' do
+    context 'fully on' do
       before do
         subject.enable
       end
 
-      it "returns :on" do
+      it 'returns :on' do
         expect(subject.state).to be(:on)
       end
 
-      it "returns true for on?" do
+      it 'returns true for on?' do
         expect(subject.on?).to be(true)
       end
 
-      it "returns false for off?" do
+      it 'returns false for off?' do
         expect(subject.off?).to be(false)
       end
 
-      it "returns false for conditional?" do
+      it 'returns false for conditional?' do
         expect(subject.conditional?).to be(false)
       end
     end
 
-    context "percentage of time set to 100" do
+    context 'percentage of time set to 100' do
       before do
         subject.enable_percentage_of_time 100
       end
 
-      it "returns :on" do
+      it 'returns :on' do
         expect(subject.state).to be(:on)
       end
 
-      it "returns true for on?" do
+      it 'returns true for on?' do
         expect(subject.on?).to be(true)
       end
 
-      it "returns false for off?" do
+      it 'returns false for off?' do
         expect(subject.off?).to be(false)
       end
 
-      it "returns false for conditional?" do
+      it 'returns false for conditional?' do
         expect(subject.conditional?).to be(false)
       end
     end
 
-    context "percentage of actors set to 100" do
+    context 'percentage of actors set to 100' do
       before do
         subject.enable_percentage_of_actors 100
       end
 
-      it "returns :on" do
+      it 'returns :on' do
         expect(subject.state).to be(:on)
       end
 
-      it "returns true for on?" do
+      it 'returns true for on?' do
         expect(subject.on?).to be(true)
       end
 
-      it "returns false for off?" do
+      it 'returns false for off?' do
         expect(subject.off?).to be(false)
       end
 
-      it "returns false for conditional?" do
+      it 'returns false for conditional?' do
         expect(subject.conditional?).to be(false)
       end
     end
 
-    context "fully off" do
+    context 'fully off' do
       before do
         subject.disable
       end
 
-      it "returns :off" do
+      it 'returns :off' do
         expect(subject.state).to be(:off)
       end
 
-      it "returns false for on?" do
+      it 'returns false for on?' do
         expect(subject.on?).to be(false)
       end
 
-      it "returns true for off?" do
+      it 'returns true for off?' do
         expect(subject.off?).to be(true)
       end
 
-      it "returns false for conditional?" do
+      it 'returns false for conditional?' do
         expect(subject.conditional?).to be(false)
       end
     end
 
-    context "partially on" do
+    context 'partially on' do
       before do
         subject.enable Flipper::Types::PercentageOfTime.new(5)
       end
 
-      it "returns :conditional" do
+      it 'returns :conditional' do
         expect(subject.state).to be(:conditional)
       end
 
-      it "returns false for on?" do
+      it 'returns false for on?' do
         expect(subject.on?).to be(false)
       end
 
-      it "returns false for off?" do
+      it 'returns false for off?' do
         expect(subject.off?).to be(false)
       end
 
-      it "returns true for conditional?" do
+      it 'returns true for conditional?' do
         expect(subject.conditional?).to be(true)
       end
     end
   end
 
-  describe "#enabled_groups" do
-    context "when no groups enabled" do
-      it "returns empty set" do
+  describe '#enabled_groups' do
+    context 'when no groups enabled' do
+      it 'returns empty set' do
         expect(subject.enabled_groups).to eq(Set.new)
       end
     end
 
-    context "when one or more groups enabled" do
+    context 'when one or more groups enabled' do
       before do
-        @staff = Flipper.register(:staff) { |thing| true }
-        @preview_features = Flipper.register(:preview_features) { |thing| true }
-        @not_enabled = Flipper.register(:not_enabled) { |thing| true }
-        @disabled = Flipper.register(:disabled) { |thing| true }
+        @staff = Flipper.register(:staff) { |_thing| true }
+        @preview_features = Flipper.register(:preview_features) { |_thing| true }
+        @not_enabled = Flipper.register(:not_enabled) { |_thing| true }
+        @disabled = Flipper.register(:disabled) { |_thing| true }
         subject.enable @staff
         subject.enable @preview_features
         subject.disable @disabled
       end
 
-      it "returns set of enabled groups" do
+      it 'returns set of enabled groups' do
         expect(subject.enabled_groups).to eq(Set.new([
-                  @staff,
-                  @preview_features,
-                ]))
+                                                       @staff,
+                                                       @preview_features,
+                                                     ]))
       end
 
-      it "does not include groups that have not been enabled" do
+      it 'does not include groups that have not been enabled' do
         expect(subject.enabled_groups).not_to include(@not_enabled)
       end
 
-      it "does not include disabled groups" do
+      it 'does not include disabled groups' do
         expect(subject.enabled_groups).not_to include(@disabled)
       end
 
-      it "is aliased to groups" do
+      it 'is aliased to groups' do
         expect(subject.enabled_groups).to eq(subject.groups)
       end
     end
   end
 
-  describe "#disabled_groups" do
-    context "when no groups enabled" do
-      it "returns empty set" do
+  describe '#disabled_groups' do
+    context 'when no groups enabled' do
+      it 'returns empty set' do
         expect(subject.disabled_groups).to eq(Set.new)
       end
     end
 
-    context "when one or more groups enabled" do
+    context 'when one or more groups enabled' do
       before do
-        @staff = Flipper.register(:staff) { |thing| true }
-        @preview_features = Flipper.register(:preview_features) { |thing| true }
-        @not_enabled = Flipper.register(:not_enabled) { |thing| true }
-        @disabled = Flipper.register(:disabled) { |thing| true }
+        @staff = Flipper.register(:staff) { |_thing| true }
+        @preview_features = Flipper.register(:preview_features) { |_thing| true }
+        @not_enabled = Flipper.register(:not_enabled) { |_thing| true }
+        @disabled = Flipper.register(:disabled) { |_thing| true }
         subject.enable @staff
         subject.enable @preview_features
         subject.disable @disabled
       end
 
-      it "returns set of groups that are not enabled" do
+      it 'returns set of groups that are not enabled' do
         expect(subject.disabled_groups).to eq(Set[
                   @not_enabled,
                   @disabled,
@@ -419,158 +417,152 @@ RSpec.describe Flipper::Feature do
     end
   end
 
-  describe "#groups_value" do
-    context "when no groups enabled" do
-      it "returns empty set" do
+  describe '#groups_value' do
+    context 'when no groups enabled' do
+      it 'returns empty set' do
         expect(subject.groups_value).to eq(Set.new)
       end
     end
 
-    context "when one or more groups enabled" do
+    context 'when one or more groups enabled' do
       before do
-        @staff = Flipper.register(:staff) { |thing| true }
-        @preview_features = Flipper.register(:preview_features) { |thing| true }
-        @not_enabled = Flipper.register(:not_enabled) { |thing| true }
-        @disabled = Flipper.register(:disabled) { |thing| true }
+        @staff = Flipper.register(:staff) { |_thing| true }
+        @preview_features = Flipper.register(:preview_features) { |_thing| true }
+        @not_enabled = Flipper.register(:not_enabled) { |_thing| true }
+        @disabled = Flipper.register(:disabled) { |_thing| true }
         subject.enable @staff
         subject.enable @preview_features
         subject.disable @disabled
       end
 
-      it "returns set of enabled groups" do
+      it 'returns set of enabled groups' do
         expect(subject.groups_value).to eq(Set.new([
-                  @staff.name.to_s,
-                  @preview_features.name.to_s,
-                ]))
+                                                     @staff.name.to_s,
+                                                     @preview_features.name.to_s,
+                                                   ]))
       end
 
-      it "does not include groups that have not been enabled" do
+      it 'does not include groups that have not been enabled' do
         expect(subject.groups_value).not_to include(@not_enabled.name.to_s)
       end
 
-      it "does not include disabled groups" do
+      it 'does not include disabled groups' do
         expect(subject.groups_value).not_to include(@disabled.name.to_s)
       end
     end
   end
 
-  describe "#actors_value" do
-    context "when no groups enabled" do
-      it "returns empty set" do
+  describe '#actors_value' do
+    context 'when no groups enabled' do
+      it 'returns empty set' do
         expect(subject.actors_value).to eq(Set.new)
       end
     end
 
-    context "when one or more actors are enabled" do
+    context 'when one or more actors are enabled' do
       before do
-        subject.enable Flipper::Types::Actor.new(Struct.new(:flipper_id).new("User:5"))
-        subject.enable Flipper::Types::Actor.new(Struct.new(:flipper_id).new("User:22"))
+        subject.enable Flipper::Types::Actor.new(Struct.new(:flipper_id).new('User:5'))
+        subject.enable Flipper::Types::Actor.new(Struct.new(:flipper_id).new('User:22'))
       end
 
-      it "returns set of actor ids" do
-        expect(subject.actors_value).to eq(Set.new(["User:5", "User:22"]))
+      it 'returns set of actor ids' do
+        expect(subject.actors_value).to eq(Set.new(['User:5', 'User:22']))
       end
     end
   end
 
-  describe "#boolean_value" do
-    context "when not enabled or disabled" do
-      it "returns false" do
+  describe '#boolean_value' do
+    context 'when not enabled or disabled' do
+      it 'returns false' do
         expect(subject.boolean_value).to be(false)
       end
     end
 
-    context "when enabled" do
+    context 'when enabled' do
       before do
         subject.enable
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(subject.boolean_value).to be(true)
       end
     end
 
-    context "when disabled" do
+    context 'when disabled' do
       before do
         subject.disable
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(subject.boolean_value).to be(false)
       end
     end
   end
 
-  describe "#percentage_of_actors_value" do
-    context "when not enabled or disabled" do
-      it "returns nil" do
+  describe '#percentage_of_actors_value' do
+    context 'when not enabled or disabled' do
+      it 'returns nil' do
         expect(subject.percentage_of_actors_value).to be(0)
       end
     end
 
-    context "when enabled" do
+    context 'when enabled' do
       before do
         subject.enable Flipper::Types::PercentageOfActors.new(5)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(subject.percentage_of_actors_value).to eq(5)
       end
     end
 
-    context "when disabled" do
+    context 'when disabled' do
       before do
         subject.disable
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(subject.percentage_of_actors_value).to be(0)
       end
     end
   end
 
-  describe "#percentage_of_time_value" do
-    context "when not enabled or disabled" do
-      it "returns nil" do
+  describe '#percentage_of_time_value' do
+    context 'when not enabled or disabled' do
+      it 'returns nil' do
         expect(subject.percentage_of_time_value).to be(0)
       end
     end
 
-    context "when enabled" do
+    context 'when enabled' do
       before do
         subject.enable Flipper::Types::PercentageOfTime.new(5)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(subject.percentage_of_time_value).to eq(5)
       end
     end
 
-    context "when disabled" do
+    context 'when disabled' do
       before do
         subject.disable
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(subject.percentage_of_time_value).to be(0)
       end
     end
   end
 
-  describe "#gate_values" do
-    context "when no gates are set in adapter" do
-      it "returns default gate values" do
-        expect(subject.gate_values).to eq(Flipper::GateValues.new({
-                  :actors => Set.new,
-                  :groups => Set.new,
-                  :boolean => nil,
-                  :percentage_of_actors => nil,
-                  :percentage_of_time => nil,
-                }))
+  describe '#gate_values' do
+    context 'when no gates are set in adapter' do
+      it 'returns default gate values' do
+        expect(subject.gate_values).to eq(Flipper::GateValues.new(adapter.default_config))
       end
     end
 
-    context "with gate values set in adapter" do
+    context 'with gate values set in adapter' do
       before do
         subject.enable Flipper::Types::Boolean.new(true)
         subject.enable Flipper::Types::Actor.new(Struct.new(:flipper_id).new(5))
@@ -579,84 +571,82 @@ RSpec.describe Flipper::Feature do
         subject.enable Flipper::Types::PercentageOfActors.new(25)
       end
 
-      it "returns gate values" do
-        expect(subject.gate_values).to eq(Flipper::GateValues.new({
-                  :actors => Set.new(["5"]),
-                  :groups => Set.new(["admins"]),
-                  :boolean => "true",
-                  :percentage_of_time => "50",
-                  :percentage_of_actors => "25",
-                }))
+      it 'returns gate values' do
+        expect(subject.gate_values).to eq(Flipper::GateValues.new(actors: Set.new(['5']),
+                                                                  groups: Set.new(['admins']),
+                                                                  boolean: 'true',
+                                                                  percentage_of_time: '50',
+                                                                  percentage_of_actors: '25'))
       end
     end
   end
 
-  describe "#enable_actor/disable_actor" do
-    context "with object that responds to flipper_id" do
-      it "updates the gate values to include the actor" do
+  describe '#enable_actor/disable_actor' do
+    context 'with object that responds to flipper_id' do
+      it 'updates the gate values to include the actor' do
         actor = Struct.new(:flipper_id).new(5)
         expect(subject.gate_values.actors).to be_empty
         subject.enable_actor(actor)
-        expect(subject.gate_values.actors).to eq(Set["5"])
+        expect(subject.gate_values.actors).to eq(Set['5'])
         subject.disable_actor(actor)
         expect(subject.gate_values.actors).to be_empty
       end
     end
 
-    context "with actor instance" do
-      it "updates the gate values to include the actor" do
+    context 'with actor instance' do
+      it 'updates the gate values to include the actor' do
         actor = Struct.new(:flipper_id).new(5)
         instance = Flipper::Types::Actor.new(actor)
         expect(subject.gate_values.actors).to be_empty
         subject.enable_actor(instance)
-        expect(subject.gate_values.actors).to eq(Set["5"])
+        expect(subject.gate_values.actors).to eq(Set['5'])
         subject.disable_actor(instance)
         expect(subject.gate_values.actors).to be_empty
       end
     end
   end
 
-  describe "#enable_group/disable_group" do
-    context "with symbol group name" do
-      it "updates the gate values to include the group" do
+  describe '#enable_group/disable_group' do
+    context 'with symbol group name' do
+      it 'updates the gate values to include the group' do
         actor = Struct.new(:flipper_id).new(5)
         group = Flipper.register(:five_only) { |actor| actor.flipper_id == 5 }
         expect(subject.gate_values.groups).to be_empty
         subject.enable_group(:five_only)
-        expect(subject.gate_values.groups).to eq(Set["five_only"])
+        expect(subject.gate_values.groups).to eq(Set['five_only'])
         subject.disable_group(:five_only)
         expect(subject.gate_values.groups).to be_empty
       end
     end
 
-    context "with string group name" do
-      it "updates the gate values to include the group" do
+    context 'with string group name' do
+      it 'updates the gate values to include the group' do
         actor = Struct.new(:flipper_id).new(5)
         group = Flipper.register(:five_only) { |actor| actor.flipper_id == 5 }
         expect(subject.gate_values.groups).to be_empty
-        subject.enable_group("five_only")
-        expect(subject.gate_values.groups).to eq(Set["five_only"])
-        subject.disable_group("five_only")
+        subject.enable_group('five_only')
+        expect(subject.gate_values.groups).to eq(Set['five_only'])
+        subject.disable_group('five_only')
         expect(subject.gate_values.groups).to be_empty
       end
     end
 
-    context "with group instance" do
-      it "updates the gate values for the group" do
+    context 'with group instance' do
+      it 'updates the gate values for the group' do
         actor = Struct.new(:flipper_id).new(5)
         group = Flipper.register(:five_only) { |actor| actor.flipper_id == 5 }
         expect(subject.gate_values.groups).to be_empty
         subject.enable_group(group)
-        expect(subject.gate_values.groups).to eq(Set["five_only"])
+        expect(subject.gate_values.groups).to eq(Set['five_only'])
         subject.disable_group(group)
         expect(subject.gate_values.groups).to be_empty
       end
     end
   end
 
-  describe "#enable_percentage_of_time/disable_percentage_of_time" do
-    context "with integer" do
-      it "updates the gate values" do
+  describe '#enable_percentage_of_time/disable_percentage_of_time' do
+    context 'with integer' do
+      it 'updates the gate values' do
         expect(subject.gate_values.percentage_of_time).to be(0)
         subject.enable_percentage_of_time(56)
         expect(subject.gate_values.percentage_of_time).to be(56)
@@ -665,18 +655,18 @@ RSpec.describe Flipper::Feature do
       end
     end
 
-    context "with string" do
-      it "updates the gate values" do
+    context 'with string' do
+      it 'updates the gate values' do
         expect(subject.gate_values.percentage_of_time).to be(0)
-        subject.enable_percentage_of_time("56")
+        subject.enable_percentage_of_time('56')
         expect(subject.gate_values.percentage_of_time).to be(56)
         subject.disable_percentage_of_time
         expect(subject.gate_values.percentage_of_time).to be(0)
       end
     end
 
-    context "with percentage of time instance" do
-      it "updates the gate values" do
+    context 'with percentage of time instance' do
+      it 'updates the gate values' do
         percentage = Flipper::Types::PercentageOfTime.new(56)
         expect(subject.gate_values.percentage_of_time).to be(0)
         subject.enable_percentage_of_time(percentage)
@@ -687,9 +677,9 @@ RSpec.describe Flipper::Feature do
     end
   end
 
-  describe "#enable_percentage_of_actors/disable_percentage_of_actors" do
-    context "with integer" do
-      it "updates the gate values" do
+  describe '#enable_percentage_of_actors/disable_percentage_of_actors' do
+    context 'with integer' do
+      it 'updates the gate values' do
         expect(subject.gate_values.percentage_of_actors).to be(0)
         subject.enable_percentage_of_actors(56)
         expect(subject.gate_values.percentage_of_actors).to be(56)
@@ -698,18 +688,18 @@ RSpec.describe Flipper::Feature do
       end
     end
 
-    context "with string" do
-      it "updates the gate values" do
+    context 'with string' do
+      it 'updates the gate values' do
         expect(subject.gate_values.percentage_of_actors).to be(0)
-        subject.enable_percentage_of_actors("56")
+        subject.enable_percentage_of_actors('56')
         expect(subject.gate_values.percentage_of_actors).to be(56)
         subject.disable_percentage_of_actors
         expect(subject.gate_values.percentage_of_actors).to be(0)
       end
     end
 
-    context "with percentage of actors instance" do
-      it "updates the gate values" do
+    context 'with percentage of actors instance' do
+      it 'updates the gate values' do
         percentage = Flipper::Types::PercentageOfActors.new(56)
         expect(subject.gate_values.percentage_of_actors).to be(0)
         subject.enable_percentage_of_actors(percentage)
@@ -720,13 +710,13 @@ RSpec.describe Flipper::Feature do
     end
   end
 
-  describe "#enabled/disabled_gates" do
+  describe '#enabled/disabled_gates' do
     before do
       subject.enable_percentage_of_time 5
       subject.enable_percentage_of_actors 5
     end
 
-    it "can return enabled gates" do
+    it 'can return enabled gates' do
       expect(subject.enabled_gates.map(&:name).to_set).to eq(Set[
               :percentage_of_actors,
               :percentage_of_time,
@@ -738,7 +728,7 @@ RSpec.describe Flipper::Feature do
             ])
     end
 
-    it "can return disabled gates" do
+    it 'can return disabled gates' do
       expect(subject.disabled_gates.map(&:name).to_set).to eq(Set[
               :actor,
               :boolean,