flipper 0.10.2 → 0.11.0.beta1

data/spec/flipper/types/boolean_spec.rb

@@ -2,23 +2,23 @@ require 'helper'
 require 'flipper/types/boolean'
 
 RSpec.describe Flipper::Types::Boolean do
-  it "defaults value to true" do
-    boolean = Flipper::Types::Boolean.new
+  it 'defaults value to true' do
+    boolean = described_class.new
     expect(boolean.value).to be(true)
   end
 
-  it "allows overriding default value" do
-    boolean = Flipper::Types::Boolean.new(false)
+  it 'allows overriding default value' do
+    boolean = described_class.new(false)
     expect(boolean.value).to be(false)
   end
 
-  it "returns true for nil value" do
-    boolean = Flipper::Types::Boolean.new(nil)
+  it 'returns true for nil value' do
+    boolean = described_class.new(nil)
     expect(boolean.value).to be(true)
   end
 
-  it "typecasts value" do
-    boolean = Flipper::Types::Boolean.new(1)
+  it 'typecasts value' do
+    boolean = described_class.new(1)
     expect(boolean.value).to be(true)
   end
 end

data/spec/flipper/types/group_spec.rb

@@ -2,85 +2,85 @@ require 'helper'
 require 'flipper/types/group'
 
 RSpec.describe Flipper::Types::Group do
-  let(:fake_context) { double("FeatureCheckContext") }
+  let(:fake_context) { double('FeatureCheckContext') }
 
   subject do
-    Flipper.register(:admins) { |actor| actor.admin? }
+    Flipper.register(:admins, &:admin?)
   end
 
-  describe ".wrap" do
-    context "with group instance" do
-      it "returns group instance" do
+  describe '.wrap' do
+    context 'with group instance' do
+      it 'returns group instance' do
         expect(described_class.wrap(subject)).to eq(subject)
       end
     end
 
-    context "with Symbol group name" do
-      it "returns group instance" do
+    context 'with Symbol group name' do
+      it 'returns group instance' do
         expect(described_class.wrap(subject.name)).to eq(subject)
       end
     end
 
-    context "with String group name" do
-      it "returns group instance" do
+    context 'with String group name' do
+      it 'returns group instance' do
         expect(described_class.wrap(subject.name.to_s)).to eq(subject)
       end
     end
   end
 
-  it "initializes with name" do
-    group = Flipper::Types::Group.new(:admins)
-    expect(group).to be_instance_of(Flipper::Types::Group)
+  it 'initializes with name' do
+    group = described_class.new(:admins)
+    expect(group).to be_instance_of(described_class)
   end
 
-  describe "#name" do
-    it "returns name" do
+  describe '#name' do
+    it 'returns name' do
       expect(subject.name).to eq(:admins)
     end
   end
 
-  describe "#match?" do
-    let(:admin_actor) { double('Actor', :admin? => true) }
-    let(:non_admin_actor) { double('Actor', :admin? => false) }
+  describe '#match?' do
+    let(:admin_actor) { double('Actor', admin?: true) }
+    let(:non_admin_actor) { double('Actor', admin?: false) }
 
-    it "returns true if block matches" do
+    it 'returns true if block matches' do
       expect(subject.match?(admin_actor, fake_context)).to eq(true)
     end
 
-    it "returns false if block does not match" do
+    it 'returns false if block does not match' do
       expect(subject.match?(non_admin_actor, fake_context)).to eq(false)
     end
 
-    it "returns true for truthy block results" do
-      group = Flipper::Types::Group.new(:examples) do |actor|
+    it 'returns true for truthy block results' do
+      group = described_class.new(:examples) do |actor|
         actor.email =~ /@example\.com/
       end
-      expect(group.match?(double('Actor', :email => "foo@example.com"), fake_context)).to be_truthy
+      expect(group.match?(double('Actor', email: 'foo@example.com'), fake_context)).to be_truthy
     end
 
-    it "returns false for falsey block results" do
-      group = Flipper::Types::Group.new(:examples) do |actor|
+    it 'returns false for falsey block results' do
+      group = described_class.new(:examples) do |_actor|
         nil
       end
       expect(group.match?(double('Actor'), fake_context)).to be_falsey
     end
 
-    it "can yield without context as block argument" do
+    it 'can yield without context as block argument' do
       context = Flipper::FeatureCheckContext.new(
         feature_name: :my_feature,
         values: Flipper::GateValues.new({}),
-        thing: Flipper::Types::Actor.new(Struct.new(:flipper_id).new(1)),
+        thing: Flipper::Types::Actor.new(Struct.new(:flipper_id).new(1))
       )
       group = Flipper.register(:group_with_context) { |actor| actor }
       yielded_actor = group.match?(admin_actor, context)
       expect(yielded_actor).to be(admin_actor)
     end
 
-    it "can yield with context as block argument" do
+    it 'can yield with context as block argument' do
       context = Flipper::FeatureCheckContext.new(
         feature_name: :my_feature,
         values: Flipper::GateValues.new({}),
-        thing: Flipper::Types::Actor.new(Struct.new(:flipper_id).new(1)),
+        thing: Flipper::Types::Actor.new(Struct.new(:flipper_id).new(1))
       )
       group = Flipper.register(:group_with_context) { |actor, context| [actor, context] }
       yielded_actor, yielded_context = group.match?(admin_actor, context)

data/spec/flipper/types/percentage_spec.rb

@@ -2,45 +2,45 @@ require 'helper'
 require 'flipper/types/percentage_of_actors'
 
 RSpec.describe Flipper::Types::Percentage do
-  subject {
+  subject do
     described_class.new(5)
-  }
+  end
   it_should_behave_like 'a percentage'
 
-  describe ".wrap" do
-    context "with percentage instance" do
-      it "returns percentage instance" do
+  describe '.wrap' do
+    context 'with percentage instance' do
+      it 'returns percentage instance' do
         expect(described_class.wrap(subject)).to eq(subject)
       end
     end
 
-    context "with Integer" do
-      it "returns percentage instance" do
+    context 'with Integer' do
+      it 'returns percentage instance' do
         expect(described_class.wrap(subject.value)).to eq(subject)
       end
     end
 
-    context "with String" do
-      it "returns percentage instance" do
+    context 'with String' do
+      it 'returns percentage instance' do
         expect(described_class.wrap(subject.value.to_s)).to eq(subject)
       end
     end
   end
 
-  describe "#eql?" do
-    it "returns true for same class and value" do
+  describe '#eql?' do
+    it 'returns true for same class and value' do
       expect(subject.eql?(described_class.new(subject.value))).to eq(true)
     end
 
-    it "returns false for different value" do
+    it 'returns false for different value' do
       expect(subject.eql?(described_class.new(subject.value + 1))).to eq(false)
     end
 
-    it "returns false for different class" do
+    it 'returns false for different class' do
       expect(subject.eql?(Object.new)).to eq(false)
     end
 
-    it "is aliased to ==" do
+    it 'is aliased to ==' do
       expect((subject == described_class.new(subject.value))).to eq(true)
     end
   end

data/spec/flipper_spec.rb

@@ -1,109 +1,116 @@
 require 'helper'
 
 RSpec.describe Flipper do
-  describe ".new" do
-    it "returns new instance of dsl" do
-      instance = Flipper.new(double('Adapter'))
+  describe '.new' do
+    it 'returns new instance of dsl' do
+      instance = described_class.new(double('Adapter'))
       expect(instance).to be_instance_of(Flipper::DSL)
     end
   end
 
-  describe ".group_exists" do
-    it "returns true if the group is already created" do
-      group = Flipper.register('admins') { |actor| actor.admin? }
-      expect(Flipper.group_exists?(:admins)).to eq(true)
+  describe '.group_exists' do
+    it 'returns true if the group is already created' do
+      group = described_class.register('admins', &:admin?)
+      expect(described_class.group_exists?(:admins)).to eq(true)
     end
 
-    it "returns false when the group is not yet registered" do
-      expect(Flipper.group_exists?(:non_existing)).to eq(false)
+    it 'returns false when the group is not yet registered' do
+      expect(described_class.group_exists?(:non_existing)).to eq(false)
     end
   end
 
-  describe ".groups_registry" do
-    it "returns a registry instance" do
-      expect(Flipper.groups_registry).to be_instance_of(Flipper::Registry)
+  describe '.groups_registry' do
+    it 'returns a registry instance' do
+      expect(described_class.groups_registry).to be_instance_of(Flipper::Registry)
     end
   end
 
-  describe ".groups_registry=" do
-    it "sets groups_registry registry" do
+  describe '.groups_registry=' do
+    it 'sets groups_registry registry' do
       registry = Flipper::Registry.new
-      Flipper.groups_registry = registry
-      expect(Flipper.instance_variable_get("@groups_registry")).to eq(registry)
+      described_class.groups_registry = registry
+      expect(described_class.instance_variable_get('@groups_registry')).to eq(registry)
     end
   end
 
-  describe ".register" do
-    it "adds a group to the group_registry" do
+  describe '.register' do
+    it 'adds a group to the group_registry' do
       registry = Flipper::Registry.new
-      Flipper.groups_registry = registry
-      group = Flipper.register(:admins) { |actor| actor.admin? }
+      described_class.groups_registry = registry
+      group = described_class.register(:admins, &:admin?)
       expect(registry.get(:admins)).to eq(group)
     end
 
-    it "adds a group to the group_registry for string name" do
+    it 'adds a group to the group_registry for string name' do
       registry = Flipper::Registry.new
-      Flipper.groups_registry = registry
-      group = Flipper.register('admins') { |actor| actor.admin? }
+      described_class.groups_registry = registry
+      group = described_class.register('admins', &:admin?)
       expect(registry.get(:admins)).to eq(group)
     end
 
-    it "raises exception if group already registered" do
-      Flipper.register(:admins) { }
+    it 'raises exception if group already registered' do
+      described_class.register(:admins) {}
 
-      expect {
-        Flipper.register(:admins) { }
-      }.to raise_error(Flipper::DuplicateGroup, "Group :admins has already been registered")
+      expect do
+        described_class.register(:admins) {}
+      end.to raise_error(Flipper::DuplicateGroup, 'Group :admins has already been registered')
     end
   end
 
-  describe ".unregister_groups" do
-    it "clear group registry" do
-      expect(Flipper.groups_registry).to receive(:clear)
-      Flipper.unregister_groups
+  describe '.unregister_groups' do
+    it 'clear group registry' do
+      expect(described_class.groups_registry).to receive(:clear)
+      described_class.unregister_groups
     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 = described_class.register(:admins) {}
       end
 
-      it "returns group" do
-        expect(Flipper.group(:admins)).to eq(@group)
+      it 'returns group' do
+        expect(described_class.group(:admins)).to eq(@group)
       end
 
-      it "returns group with string key" do
-        expect(Flipper.group('admins')).to eq(@group)
+      it 'returns group with string key' do
+        expect(described_class.group('admins')).to eq(@group)
       end
     end
 
-    context "for unregistered group" do
-      it "raises group not registered error" do
-        expect {
-          Flipper.group(:cats)
-        }.to raise_error(Flipper::GroupNotRegistered, 'Group :cats has not been registered')
+    context 'for unregistered group' do
+      before do
+        @group = described_class.group(:cats)
+      end
+
+      it 'returns group' do
+        expect(@group).to be_instance_of(Flipper::Types::Group)
+        expect(@group.name).to eq(:cats)
+      end
+
+      it 'does not add group to registry' do
+        expect(described_class.group_exists?(@group.name)).to be(false)
       end
     end
   end
 
-  describe ".groups" do
-    it "returns array of group instances" do
-      admins = Flipper.register(:admins) { |actor| actor.admin? }
-      preview_features = Flipper.register(:preview_features) { |actor| actor.preview_features? }
-      expect(Flipper.groups).to eq(Set[
+  describe '.groups' do
+    it 'returns array of group instances' do
+      admins = described_class.register(:admins, &:admin?)
+      preview_features = described_class.register(:preview_features, &:preview_features?)
+      expect(described_class.groups).to eq(Set[
               admins,
               preview_features,
             ])
     end
   end
 
-  describe ".group_names" do
-    it "returns array of group names" do
-      Flipper.register(:admins) { |actor| actor.admin? }
-      Flipper.register(:preview_features) { |actor| actor.preview_features? }
-      expect(Flipper.group_names).to eq(Set[
+  describe '.group_names' do
+    it 'returns array of group names' do
+      described_class.register(:admins, &:admin?)
+      described_class.register(:preview_features, &:preview_features?)
+      expect(described_class.group_names).to eq(Set[
               :admins,
               :preview_features,
             ])

data/spec/helper.rb

@@ -1,4 +1,4 @@
-$:.unshift(File.expand_path('../../lib', __FILE__))
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 
 require 'pp'
 require 'pathname'
@@ -9,11 +9,14 @@ require 'bundler'
 
 Bundler.setup(:default)
 
+require 'webmock/rspec'
+WebMock.disable_net_connect!(allow_localhost: true)
+
 require 'flipper'
 require 'flipper-ui'
 require 'flipper-api'
 
-Dir[FlipperRoot.join("spec/support/**/*.rb")].each { |f| require f }
+Dir[FlipperRoot.join('spec/support/**/*.rb')].each { |f| require f }
 
 RSpec.configure do |config|
   config.before(:example) do
@@ -27,64 +30,66 @@ RSpec.configure do |config|
 end
 
 RSpec.shared_examples_for 'a percentage' do
-  it "initializes with value" do
+  it 'initializes with value' do
     percentage = described_class.new(12)
     expect(percentage).to be_instance_of(described_class)
   end
 
-  it "converts string values to integers when initializing" do
+  it 'converts string values to integers when initializing' do
     percentage = described_class.new('15')
     expect(percentage.value).to eq(15)
   end
 
-  it "has a value" do
+  it 'has a value' do
     percentage = described_class.new(19)
     expect(percentage.value).to eq(19)
   end
 
-  it "raises exception for value higher than 100" do
-    expect {
+  it 'raises exception for value higher than 100' do
+    expect do
       described_class.new(101)
-    }.to raise_error(ArgumentError, "value must be a positive number less than or equal to 100, but was 101")
+    end.to raise_error(ArgumentError,
+                       'value must be a positive number less than or equal to 100, but was 101')
   end
 
-  it "raises exception for negative value" do
-    expect {
+  it 'raises exception for negative value' do
+    expect do
       described_class.new(-1)
-    }.to raise_error(ArgumentError, "value must be a positive number less than or equal to 100, but was -1")
+    end.to raise_error(ArgumentError,
+                       'value must be a positive number less than or equal to 100, but was -1')
   end
 end
 
 RSpec.shared_examples_for 'a DSL feature' do
-  it "returns instance of feature" do
+  it 'returns instance of feature' do
     expect(feature).to be_instance_of(Flipper::Feature)
   end
 
-  it "sets name" do
+  it 'sets name' do
     expect(feature.name).to eq(:stats)
   end
 
-  it "sets adapter" do
+  it 'sets adapter' do
     expect(feature.adapter.name).to eq(dsl.adapter.name)
   end
 
-  it "sets instrumenter" do
+  it 'sets instrumenter' do
     expect(feature.instrumenter).to eq(dsl.instrumenter)
   end
 
-  it "memoizes the feature" do
+  it 'memoizes the feature' do
     expect(dsl.send(method_name, :stats)).to equal(feature)
   end
 
-  it "raises argument error if not string or symbol" do
-    expect {
+  it 'raises argument error if not string or symbol' do
+    expect do
       dsl.send(method_name, Object.new)
-    }.to raise_error(ArgumentError, /must be a String or Symbol/)
+    end.to raise_error(ArgumentError, /must be a String or Symbol/)
   end
 end
 
-RSpec.shared_examples_for "a DSL boolean method" do
-  it "returns boolean with value set" do
+RSpec.shared_examples_for 'a DSL boolean method' do
+  it 'returns boolean with value set' do
     result = subject.send(method_name, true)
     expect(result).to be_instance_of(Flipper::Types::Boolean)
     expect(result.value).to be(true)