flipper 0.10.2 → 0.11.0.beta1

data/spec/flipper/gate_spec.rb

@@ -3,14 +3,14 @@ require 'helper'
 RSpec.describe Flipper::Gate do
   let(:feature_name) { :stats }
 
-  subject {
+  subject do
     described_class.new
-  }
+  end
 
-  describe "#inspect" do
-    context "for subclass" do
-      let(:subclass) {
-        Class.new(described_class) {
+  describe '#inspect' do
+    context 'for subclass' do
+      let(:subclass) do
+        Class.new(described_class) do
           def name
             :name
           end
@@ -22,14 +22,14 @@ RSpec.describe Flipper::Gate do
           def data_type
             :set
           end
-        }
-      }
+        end
+      end
 
-      subject {
+      subject do
         subclass.new
-      }
+      end
 
-      it "includes attributes" do
+      it 'includes attributes' do
         string = subject.inspect
         expect(string).to include(subject.object_id.to_s)
         expect(string).to include('name=:name')

data/spec/flipper/gate_values_spec.rb

@@ -4,15 +4,15 @@ require 'flipper/gate_values'
 RSpec.describe Flipper::GateValues do
   {
     nil => false,
-    "" => false,
+    '' => false,
     0 => false,
     1 => true,
-    "0" => false,
-    "1" => true,
+    '0' => false,
+    '1' => true,
     true => true,
     false => false,
-    "true" => true,
-    "false" => false,
+    'true' => true,
+    'false' => false,
   }.each do |value, expected|
     context "with #{value.inspect} boolean" do
       it "returns #{expected}" do
@@ -23,11 +23,11 @@ RSpec.describe Flipper::GateValues do
 
   {
     nil => 0,
-    "" => 0,
+    '' => 0,
     0 => 0,
     1 => 1,
-    "1" => 1,
-    "99" => 99,
+    '1' => 1,
+    '99' => 99,
   }.each do |value, expected|
     context "with #{value.inspect} percentage of time" do
       it "returns #{expected}" do
@@ -38,24 +38,25 @@ RSpec.describe Flipper::GateValues do
 
   {
     nil => 0,
-    "" => 0,
+    '' => 0,
     0 => 0,
     1 => 1,
-    "1" => 1,
-    "99" => 99,
+    '1' => 1,
+    '99' => 99,
   }.each do |value, expected|
     context "with #{value.inspect} percentage of actors" do
       it "returns #{expected}" do
-        expect(described_class.new(percentage_of_actors: value).percentage_of_actors).to be(expected)
+        expect(described_class.new(percentage_of_actors: value).percentage_of_actors)
+          .to be(expected)
       end
     end
   end
 
   {
     nil => Set.new,
-    "" => Set.new,
+    '' => Set.new,
     Set.new([1, 2]) => Set.new([1, 2]),
-    [1, 2] => Set.new([1, 2])
+    [1, 2] => Set.new([1, 2]),
   }.each do |value, expected|
     context "with #{value.inspect} actors" do
       it "returns #{expected}" do
@@ -66,9 +67,9 @@ RSpec.describe Flipper::GateValues do
 
   {
     nil => Set.new,
-    "" => Set.new,
+    '' => Set.new,
     Set.new([:admins, :preview_features]) => Set.new([:admins, :preview_features]),
-    [:admins, :preview_features] => Set.new([:admins, :preview_features])
+    [:admins, :preview_features] => Set.new([:admins, :preview_features]),
   }.each do |value, expected|
     context "with #{value.inspect} groups" do
       it "returns #{expected}" do
@@ -77,58 +78,58 @@ RSpec.describe Flipper::GateValues do
     end
   end
 
-  it "raises argument error for percentage of time value that cannot be converted to an integer" do
-    expect {
-      described_class.new(percentage_of_time: ["asdf"])
-    }.to raise_error(ArgumentError, %Q(["asdf"] cannot be converted to an integer))
+  it 'raises argument error for percentage of time value that cannot be converted to an integer' do
+    expect do
+      described_class.new(percentage_of_time: ['asdf'])
+    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to an integer))
   end
 
-  it "raises argument error for percentage of actors value that cannot be converted to an integer" do
-    expect {
-      described_class.new(percentage_of_actors: ["asdf"])
-    }.to raise_error(ArgumentError, %Q(["asdf"] cannot be converted to an integer))
+  it 'raises argument error for percentage of actors value that cannot be converted to an int' do
+    expect do
+      described_class.new(percentage_of_actors: ['asdf'])
+    end.to raise_error(ArgumentError, %(["asdf"] cannot be converted to an integer))
   end
 
-  it "raises argument error for actors value that cannot be converted to a set" do
-    expect {
-      described_class.new(actors: "asdf")
-    }.to raise_error(ArgumentError, %Q("asdf" cannot be converted to a set))
+  it 'raises argument error for actors value that cannot be converted to a set' do
+    expect do
+      described_class.new(actors: 'asdf')
+    end.to raise_error(ArgumentError, %("asdf" cannot be converted to a set))
   end
 
-  it "raises argument error for groups value that cannot be converted to a set" do
-    expect {
-      described_class.new(groups: "asdf")
-    }.to raise_error(ArgumentError, %Q("asdf" cannot be converted to a set))
+  it 'raises argument error for groups value that cannot be converted to a set' do
+    expect do
+      described_class.new(groups: 'asdf')
+    end.to raise_error(ArgumentError, %("asdf" cannot be converted to a set))
   end
 
-  describe "#[]" do
-    it "can read the boolean value" do
+  describe '#[]' do
+    it 'can read the boolean value' do
       expect(described_class.new(boolean: true)[:boolean]).to be(true)
-      expect(described_class.new(boolean: true)["boolean"]).to be(true)
+      expect(described_class.new(boolean: true)['boolean']).to be(true)
     end
 
-    it "can read the actors value" do
+    it 'can read the actors value' do
       expect(described_class.new(actors: Set[1, 2])[:actors]).to eq(Set[1, 2])
-      expect(described_class.new(actors: Set[1, 2])["actors"]).to eq(Set[1, 2])
+      expect(described_class.new(actors: Set[1, 2])['actors']).to eq(Set[1, 2])
     end
 
-    it "can read the groups value" do
+    it 'can read the groups value' do
       expect(described_class.new(groups: Set[:admins])[:groups]).to eq(Set[:admins])
-      expect(described_class.new(groups: Set[:admins])["groups"]).to eq(Set[:admins])
+      expect(described_class.new(groups: Set[:admins])['groups']).to eq(Set[:admins])
     end
 
-    it "can read the percentage of time value" do
+    it 'can read the percentage of time value' do
       expect(described_class.new(percentage_of_time: 15)[:percentage_of_time]).to eq(15)
-      expect(described_class.new(percentage_of_time: 15)["percentage_of_time"]).to eq(15)
+      expect(described_class.new(percentage_of_time: 15)['percentage_of_time']).to eq(15)
     end
 
-    it "can read the percentage of actors value" do
+    it 'can read the percentage of actors value' do
       expect(described_class.new(percentage_of_actors: 15)[:percentage_of_actors]).to eq(15)
-      expect(described_class.new(percentage_of_actors: 15)["percentage_of_actors"]).to eq(15)
+      expect(described_class.new(percentage_of_actors: 15)['percentage_of_actors']).to eq(15)
     end
 
-    it "returns nil for value that is not present" do
-      expect(described_class.new({})["not legit"]).to be(nil)
+    it 'returns nil for value that is not present' do
+      expect(described_class.new({})['not legit']).to be(nil)
     end
   end
 end

data/spec/flipper/gates/actor_spec.rb

@@ -3,7 +3,7 @@ require 'helper'
 RSpec.describe Flipper::Gates::Actor do
   let(:feature_name) { :search }
 
-  subject {
+  subject do
     described_class.new
-  }
+  end
 end

data/spec/flipper/gates/boolean_spec.rb

@@ -3,71 +3,72 @@ require 'helper'
 RSpec.describe Flipper::Gates::Boolean do
   let(:feature_name) { :search }
 
-  subject {
+  subject do
     described_class.new
-  }
+  end
 
   def context(bool)
     Flipper::FeatureCheckContext.new(
       feature_name: feature_name,
-      values: Flipper::GateValues.new({boolean: bool}),
-      thing: Flipper::Types::Actor.new(Struct.new(:flipper_id).new(1)),
+      values: Flipper::GateValues.new(boolean: bool),
+      thing: Flipper::Types::Actor.new(Struct.new(:flipper_id).new(1))
     )
   end
 
-  describe "#enabled?" do
-    context "for true value" do
-      it "returns true" do
+  describe '#enabled?' do
+    context 'for true value' do
+      it 'returns true' do
         expect(subject.enabled?(true)).to eq(true)
       end
     end
 
-    context "for false value" do
-      it "returns false" do
+    context 'for false value' do
+      it 'returns false' do
         expect(subject.enabled?(false)).to eq(false)
       end
     end
   end
 
-  describe "#open?" do
-    context "for true value" do
-      it "returns true" do
+  describe '#open?' do
+    context 'for true value' do
+      it 'returns true' do
         expect(subject.open?(context(true))).to be(true)
       end
     end
 
-    context "for false value" do
-      it "returns false" do
+    context 'for false value' do
+      it 'returns false' do
         expect(subject.open?(context(false))).to be(false)
       end
     end
   end
 
-  describe "#protects?" do
-    it "returns true for boolean type" do
+  describe '#protects?' do
+    it 'returns true for boolean type' do
       expect(subject.protects?(Flipper::Types::Boolean.new(true))).to be(true)
     end
 
-    it "returns true for true" do
+    it 'returns true for true' do
       expect(subject.protects?(true)).to be(true)
     end
 
-    it "returns true for false" do
+    it 'returns true for false' do
       expect(subject.protects?(false)).to be(true)
     end
   end
 
-  describe "#wrap" do
-    it "returns boolean type for boolean type" do
-      expect(subject.wrap(Flipper::Types::Boolean.new(true))).to be_instance_of(Flipper::Types::Boolean)
+  describe '#wrap' do
+    it 'returns boolean type for boolean type' do
+      expect(subject.wrap(Flipper::Types::Boolean.new(true)))
+        .to be_instance_of(Flipper::Types::Boolean)
     end
 
-    it "returns boolean type for true" do
+    it 'returns boolean type for true' do
       expect(subject.wrap(true)).to be_instance_of(Flipper::Types::Boolean)
       expect(subject.wrap(true).value).to be(true)
     end
 
-    it "returns boolean type for true" do
+    it 'returns boolean type for true' do
       expect(subject.wrap(false)).to be_instance_of(Flipper::Types::Boolean)
       expect(subject.wrap(false).value).to be(false)
     end

data/spec/flipper/gates/group_spec.rb

@@ -3,62 +3,62 @@ require 'helper'
 RSpec.describe Flipper::Gates::Group do
   let(:feature_name) { :search }
 
-  subject {
+  subject do
     described_class.new
-  }
+  end
 
   def context(set)
     Flipper::FeatureCheckContext.new(
       feature_name: feature_name,
-      values: Flipper::GateValues.new({groups: set}),
-      thing: Flipper::Types::Actor.new(Struct.new(:flipper_id).new("5")),
+      values: Flipper::GateValues.new(groups: set),
+      thing: Flipper::Types::Actor.new(Struct.new(:flipper_id).new('5'))
     )
   end
 
-  describe "#open?" do
-    context "with a group in adapter, but not registered" do
+  describe '#open?' do
+    context 'with a group in adapter, but not registered' do
       before do
-        Flipper.register(:staff) { |thing| true }
+        Flipper.register(:staff) { |_thing| true }
       end
 
-      it "ignores group" do
+      it 'ignores group' do
         thing = Struct.new(:flipper_id).new('5')
         expect(subject.open?(context(Set[:newbs, :staff]))).to be(true)
       end
     end
 
-    context "thing that does not respond to method in group block" do
+    context 'thing that does not respond to method in group block' do
       before do
-        Flipper.register(:stinkers) { |thing| thing.stinker? }
+        Flipper.register(:stinkers, &:stinker?)
       end
 
-      it "raises error" do
-        expect {
+      it 'raises error' do
+        expect do
           subject.open?(context(Set[:stinkers]))
-        }.to raise_error(NoMethodError)
+        end.to raise_error(NoMethodError)
       end
     end
   end
 
-  describe "#wrap" do
-    it "returns group instance for symbol" do
+  describe '#wrap' do
+    it 'returns group instance for symbol' do
       group = Flipper.register(:admins) {}
       expect(subject.wrap(:admins)).to eq(group)
     end
 
-    it "returns group instance for group instance" do
+    it 'returns group instance for group instance' do
       group = Flipper.register(:admins) {}
       expect(subject.wrap(group)).to eq(group)
     end
   end
 
-  describe "#protects?" do
-    it "returns true for group" do
+  describe '#protects?' do
+    it 'returns true for group' do
       group = Flipper.register(:admins) {}
       expect(subject.protects?(group)).to be(true)
     end
 
-    it "returns true for symbol" do
+    it 'returns true for symbol' do
       expect(subject.protects?(:admins)).to be(true)
     end
   end

data/spec/flipper/gates/percentage_of_actors_spec.rb

@@ -3,27 +3,27 @@ require 'helper'
 RSpec.describe Flipper::Gates::PercentageOfActors do
   let(:feature_name) { :search }
 
-  subject {
+  subject do
     described_class.new
-  }
+  end
 
   def context(integer, feature = feature_name, thing = nil)
     Flipper::FeatureCheckContext.new(
       feature_name: feature,
-      values: Flipper::GateValues.new({percentage_of_actors: integer}),
-      thing: thing || Flipper::Types::Actor.new(Struct.new(:flipper_id).new(1)),
+      values: Flipper::GateValues.new(percentage_of_actors: integer),
+      thing: thing || Flipper::Types::Actor.new(Struct.new(:flipper_id).new(1))
     )
   end
 
-  describe "#open?" do
-    context "when compared against two features" do
+  describe '#open?' do
+    context 'when compared against two features' do
       let(:percentage) { 0.05 }
       let(:percentage_as_integer) { percentage * 100 }
       let(:number_of_actors) { 100 }
 
-      let(:actors) {
+      let(:actors) do
         (1..number_of_actors).map { |n| Struct.new(:flipper_id).new(n) }
-      }
+      end
 
       let(:feature_one_enabled_actors) do
         gate = described_class.new
@@ -35,11 +35,11 @@ RSpec.describe Flipper::Gates::PercentageOfActors do
         actors.select { |actor| gate.open? context(percentage_as_integer, :name_two, actor) }
       end
 
-      it "does not enable both features for same set of actors" do
+      it 'does not enable both features for same set of actors' do
         expect(feature_one_enabled_actors).not_to eq(feature_two_enabled_actors)
       end
 
-      it "enables feature for accurate number of actors for each feature" do
+      it 'enables feature for accurate number of actors for each feature' do
         margin_of_error = 0.02 * number_of_actors # 2 percent margin of error
         expected_enabled_size = number_of_actors * percentage
 

data/spec/flipper/gates/percentage_of_time_spec.rb

@@ -3,7 +3,7 @@ require 'helper'
 RSpec.describe Flipper::Gates::PercentageOfTime do
   let(:feature_name) { :search }
 
-  subject {
+  subject do
     described_class.new
-  }
+  end
 end