flipper 0.7.1 → 0.7.2

data/spec/flipper_spec.rb

@@ -1,27 +1,27 @@
 require 'helper'
 
-describe Flipper do
+RSpec.describe Flipper do
   describe ".new" do
     it "returns new instance of dsl" do
       instance = Flipper.new(double('Adapter'))
-      instance.should be_instance_of(Flipper::DSL)
+      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? }
-      Flipper.group_exists?(:admins).should eq(true)
+      expect(Flipper.group_exists?(:admins)).to eq(true)
     end
 
     it "returns false when the group is not yet registered" do
-      Flipper.group_exists?(:non_existing).should eq(false)
+      expect(Flipper.group_exists?(:non_existing)).to eq(false)
     end
   end
 
   describe ".groups_registry" do
     it "returns a registry instance" do
-      Flipper.groups_registry.should be_instance_of(Flipper::Registry)
+      expect(Flipper.groups_registry).to be_instance_of(Flipper::Registry)
     end
   end
 
@@ -29,7 +29,7 @@ describe Flipper do
     it "sets groups_registry registry" do
       registry = Flipper::Registry.new
       Flipper.groups_registry = registry
-      Flipper.instance_variable_get("@groups_registry").should eq(registry)
+      expect(Flipper.instance_variable_get("@groups_registry")).to eq(registry)
     end
   end
 
@@ -38,14 +38,14 @@ describe Flipper do
       registry = Flipper::Registry.new
       Flipper.groups_registry = registry
       group = Flipper.register(:admins) { |actor| actor.admin? }
-      registry.get(:admins).should eq(group)
+      expect(registry.get(:admins)).to eq(group)
     end
 
     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? }
-      registry.get(:admins).should eq(group)
+      expect(registry.get(:admins)).to eq(group)
     end
 
     it "raises exception if group already registered" do
@@ -59,7 +59,7 @@ describe Flipper do
 
   describe ".unregister_groups" do
     it "clear group registry" do
-      Flipper.groups_registry.should_receive(:clear)
+      expect(Flipper.groups_registry).to receive(:clear)
       Flipper.unregister_groups
     end
   end
@@ -71,11 +71,11 @@ describe Flipper do
       end
 
       it "returns group" do
-        Flipper.group(:admins).should eq(@group)
+        expect(Flipper.group(:admins)).to eq(@group)
       end
 
       it "returns group with string key" do
-        Flipper.group('admins').should eq(@group)
+        expect(Flipper.group('admins')).to eq(@group)
       end
     end
 
@@ -92,10 +92,10 @@ describe Flipper 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? }
-      Flipper.groups.should eq(Set[
-        admins,
-        preview_features,
-      ])
+      expect(Flipper.groups).to eq(Set[
+              admins,
+              preview_features,
+            ])
     end
   end
 
@@ -103,10 +103,10 @@ describe Flipper do
     it "returns array of group names" do
       Flipper.register(:admins) { |actor| actor.admin? }
       Flipper.register(:preview_features) { |actor| actor.preview_features? }
-      Flipper.group_names.should eq(Set[
-        :admins,
-        :preview_features,
-      ])
+      expect(Flipper.group_names).to eq(Set[
+              :admins,
+              :preview_features,
+            ])
     end
   end
 end

data/spec/helper.rb

@@ -14,25 +14,25 @@ require 'flipper-ui'
 Dir[FlipperRoot.join("spec/support/**/*.rb")].each { |f| require f }
 
 RSpec.configure do |config|
-  config.before(:each) do
+  config.before(:example) do
     Flipper.unregister_groups
   end
 end
 
-shared_examples_for 'a percentage' do
+RSpec.shared_examples_for 'a percentage' do
   it "initializes with value" do
     percentage = described_class.new(12)
-    percentage.should be_instance_of(described_class)
+    expect(percentage).to be_instance_of(described_class)
   end
 
   it "converts string values to integers when initializing" do
     percentage = described_class.new('15')
-    percentage.value.should eq(15)
+    expect(percentage.value).to eq(15)
   end
 
   it "has a value" do
     percentage = described_class.new(19)
-    percentage.value.should eq(19)
+    expect(percentage.value).to eq(19)
   end
 
   it "raises exception for value higher than 100" do
@@ -50,23 +50,23 @@ end
 
 shared_examples_for 'a DSL feature' do
   it "returns instance of feature" do
-    feature.should be_instance_of(Flipper::Feature)
+    expect(feature).to be_instance_of(Flipper::Feature)
   end
 
   it "sets name" do
-    feature.name.should eq(:stats)
+    expect(feature.name).to eq(:stats)
   end
 
   it "sets adapter" do
-    feature.adapter.name.should eq(dsl.adapter.name)
+    expect(feature.adapter.name).to eq(dsl.adapter.name)
   end
 
   it "sets instrumenter" do
-    feature.instrumenter.should eq(dsl.instrumenter)
+    expect(feature.instrumenter).to eq(dsl.instrumenter)
   end
 
   it "memoizes the feature" do
-    dsl.send(method_name, :stats).should equal(feature)
+    expect(dsl.send(method_name, :stats)).to equal(feature)
   end
 
   it "raises argument error if not string or symbol" do
@@ -79,11 +79,11 @@ end
 shared_examples_for "a DSL boolean method" do
   it "returns boolean with value set" do
     result = subject.send(method_name, true)
-    result.should be_instance_of(Flipper::Types::Boolean)
-    result.value.should be(true)
+    expect(result).to be_instance_of(Flipper::Types::Boolean)
+    expect(result.value).to be(true)
 
     result = subject.send(method_name, false)
-    result.should be_instance_of(Flipper::Types::Boolean)
-    result.value.should be(false)
+    expect(result).to be_instance_of(Flipper::Types::Boolean)
+    expect(result.value).to be(false)
   end
 end

data/spec/integration_spec.rb

@@ -2,7 +2,7 @@ require 'helper'
 require 'flipper/feature'
 require 'flipper/adapters/memory'
 
-describe Flipper do
+RSpec.describe Flipper do
   let(:adapter)     { Flipper::Adapters::Memory.new }
   let(:flipper)     { Flipper.new(adapter) }
   let(:feature)     { flipper[:search] }
@@ -33,15 +33,15 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should eq(true)
+        expect(@result).to eq(true)
       end
 
       it "enables feature for all" do
-        feature.enabled?.should eq(true)
+        expect(feature.enabled?).to eq(true)
       end
 
       it "adds feature to set of features" do
-        flipper.features.map(&:name).should include(:search)
+        expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
@@ -51,31 +51,31 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should eq(true)
+        expect(@result).to eq(true)
       end
 
       it "enables feature for non flipper thing in group" do
-        feature.enabled?(admin_thing).should eq(true)
+        expect(feature.enabled?(admin_thing)).to eq(true)
       end
 
       it "does not enable feature for non flipper thing in other group" do
-        feature.enabled?(dev_thing).should eq(false)
+        expect(feature.enabled?(dev_thing)).to eq(false)
       end
 
       it "enables feature for flipper actor in group" do
-        feature.enabled?(flipper.actor(admin_thing)).should eq(true)
+        expect(feature.enabled?(flipper.actor(admin_thing))).to eq(true)
       end
 
       it "does not enable for flipper actor not in group" do
-        feature.enabled?(flipper.actor(dev_thing)).should eq(false)
+        expect(feature.enabled?(flipper.actor(dev_thing))).to eq(false)
       end
 
       it "does not enable feature for all" do
-        feature.enabled?.should eq(false)
+        expect(feature.enabled?).to eq(false)
       end
 
       it "adds feature to set of features" do
-        flipper.features.map(&:name).should include(:search)
+        expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
@@ -85,19 +85,19 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should eq(true)
+        expect(@result).to eq(true)
       end
 
       it "enables feature for actor" do
-        feature.enabled?(pitt).should eq(true)
+        expect(feature.enabled?(pitt)).to eq(true)
       end
 
       it "does not enable feature for other actors" do
-        feature.enabled?(clooney).should eq(false)
+        expect(feature.enabled?(clooney)).to eq(false)
       end
 
       it "adds feature to set of features" do
-        flipper.features.map(&:name).should include(:search)
+        expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
@@ -107,7 +107,7 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should eq(true)
+        expect(@result).to eq(true)
       end
 
       it "enables feature for actor within percentage" do
@@ -116,11 +116,11 @@ describe Flipper do
           feature.enabled?(thing)
         }.size
 
-        enabled.should be_within(2).of(5)
+        expect(enabled).to be_within(2).of(5)
       end
 
       it "adds feature to set of features" do
-        flipper.features.map(&:name).should include(:search)
+        expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
@@ -131,21 +131,21 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should eq(true)
+        expect(@result).to eq(true)
       end
 
       it "enables feature for time within percentage" do
-        @gate.stub(:rand => 0.04)
-        feature.enabled?.should eq(true)
+        allow(@gate).to receive_messages(:rand => 0.04)
+        expect(feature.enabled?).to eq(true)
       end
 
       it "does not enable feature for time not within percentage" do
-        @gate.stub(:rand => 0.10)
-        feature.enabled?.should eq(false)
+        allow(@gate).to receive_messages(:rand => 0.10)
+        expect(feature.enabled?).to eq(false)
       end
 
       it "adds feature to set of features" do
-        flipper.features.map(&:name).should include(:search)
+        expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
@@ -164,7 +164,7 @@ describe Flipper do
       before do
         # ensures that time gate is stubbed with result that would be true for pitt
         @gate = feature.gate(:percentage_of_time)
-        @gate.stub(:rand => 0.04)
+        allow(@gate).to receive_messages(:rand => 0.04)
 
         feature.enable admin_group
         feature.enable pitt
@@ -174,19 +174,19 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should be(true)
+        expect(@result).to be(true)
       end
 
       it "disables feature" do
-        feature.enabled?.should eq(false)
+        expect(feature.enabled?).to eq(false)
       end
 
       it "disables for individual actor" do
-        feature.enabled?(pitt).should eq(false)
+        expect(feature.enabled?(pitt)).to eq(false)
       end
 
       it "disables actor in group" do
-        feature.enabled?(admin_thing).should eq(false)
+        expect(feature.enabled?(admin_thing)).to eq(false)
       end
 
       it "disables actor in percentage of actors" do
@@ -195,15 +195,15 @@ describe Flipper do
           feature.enabled?(thing)
         }.size
 
-        enabled.should be(0)
+        expect(enabled).to be(0)
       end
 
       it "disables percentage of time" do
-        feature.enabled?(pitt).should eq(false)
+        expect(feature.enabled?(pitt)).to eq(false)
       end
 
       it "adds feature to set of features" do
-        flipper.features.map(&:name).should include(:search)
+        expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
@@ -215,27 +215,27 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should eq(true)
+        expect(@result).to eq(true)
       end
 
       it "disables the feature for non flipper thing in the group" do
-        feature.enabled?(admin_thing).should eq(false)
+        expect(feature.enabled?(admin_thing)).to eq(false)
       end
 
       it "does not disable feature for non flipper thing in other groups" do
-        feature.enabled?(dev_thing).should eq(true)
+        expect(feature.enabled?(dev_thing)).to eq(true)
       end
 
       it "disables feature for flipper actor in group" do
-        feature.enabled?(flipper.actor(admin_thing)).should eq(false)
+        expect(feature.enabled?(flipper.actor(admin_thing))).to eq(false)
       end
 
       it "does not disable feature for flipper actor in other groups" do
-        feature.enabled?(flipper.actor(dev_thing)).should eq(true)
+        expect(feature.enabled?(flipper.actor(dev_thing))).to eq(true)
       end
 
       it "adds feature to set of features" do
-        flipper.features.map(&:name).should include(:search)
+        expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
@@ -247,19 +247,19 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should eq(true)
+        expect(@result).to eq(true)
       end
 
       it "disables feature for actor" do
-        feature.enabled?(pitt).should eq(false)
+        expect(feature.enabled?(pitt)).to eq(false)
       end
 
       it "does not disable feature for other actors" do
-        feature.enabled?(clooney).should eq(true)
+        expect(feature.enabled?(clooney)).to eq(true)
       end
 
       it "adds feature to set of features" do
-        flipper.features.map(&:name).should include(:search)
+        expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
@@ -269,7 +269,7 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should eq(true)
+        expect(@result).to eq(true)
       end
 
       it "disables feature" do
@@ -278,11 +278,11 @@ describe Flipper do
           feature.enabled?(thing)
         }.size
 
-        enabled.should be(0)
+        expect(enabled).to be(0)
       end
 
       it "adds feature to set of features" do
-        flipper.features.map(&:name).should include(:search)
+        expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
@@ -293,21 +293,21 @@ describe Flipper do
       end
 
       it "returns true" do
-        @result.should eq(true)
+        expect(@result).to eq(true)
       end
 
       it "disables feature for time within percentage" do
-        @gate.stub(:rand => 0.04)
-        feature.enabled?.should eq(false)
+        allow(@gate).to receive_messages(:rand => 0.04)
+        expect(feature.enabled?).to eq(false)
       end
 
       it "disables feature for time not within percentage" do
-        @gate.stub(:rand => 0.10)
-        feature.enabled?.should eq(false)
+        allow(@gate).to receive_messages(:rand => 0.10)
+        expect(feature.enabled?).to eq(false)
       end
 
       it "adds feature to set of features" do
-        flipper.features.map(&:name).should include(:search)
+        expect(flipper.features.map(&:name)).to include(:search)
       end
     end
 
@@ -324,7 +324,7 @@ describe Flipper do
   describe "#enabled?" do
     context "with no arguments" do
       it "defaults to false" do
-        feature.enabled?.should eq(false)
+        expect(feature.enabled?).to eq(false)
       end
     end
 
@@ -334,7 +334,7 @@ describe Flipper do
       end
 
       it "returns true" do
-        feature.enabled?.should eq(true)
+        expect(feature.enabled?).to eq(true)
       end
     end
 
@@ -344,15 +344,15 @@ describe Flipper do
       end
 
       it "returns true" do
-        feature.enabled?(flipper.actor(admin_thing)).should eq(true)
-        feature.enabled?(admin_thing).should eq(true)
+        expect(feature.enabled?(flipper.actor(admin_thing))).to eq(true)
+        expect(feature.enabled?(admin_thing)).to eq(true)
       end
     end
 
     context "for actor in disabled group" do
       it "returns false" do
-        feature.enabled?(flipper.actor(dev_thing)).should eq(false)
-        feature.enabled?(dev_thing).should eq(false)
+        expect(feature.enabled?(flipper.actor(dev_thing))).to eq(false)
+        expect(feature.enabled?(dev_thing)).to eq(false)
       end
     end
 
@@ -362,18 +362,18 @@ describe Flipper do
       end
 
       it "returns true" do
-        feature.enabled?(pitt).should eq(true)
+        expect(feature.enabled?(pitt)).to eq(true)
       end
     end
 
     context "for not enabled actor" do
       it "returns false" do
-        feature.enabled?(clooney).should eq(false)
+        expect(feature.enabled?(clooney)).to eq(false)
       end
 
       it "returns true if boolean enabled" do
         feature.enable
-        feature.enabled?(clooney).should eq(true)
+        expect(feature.enabled?(clooney)).to eq(true)
       end
     end
 
@@ -382,16 +382,16 @@ describe Flipper do
         # ensure percentage of time returns percentage that makes five percent
         # of time true
         @gate = feature.gate(:percentage_of_time)
-        @gate.stub(:rand => 0.04)
+        allow(@gate).to receive_messages(:rand => 0.04)
 
         feature.enable five_percent_of_time
       end
 
       it "returns true" do
-        feature.enabled?.should eq(true)
-        feature.enabled?(nil).should eq(true)
-        feature.enabled?(pitt).should eq(true)
-        feature.enabled?(admin_thing).should eq(true)
+        expect(feature.enabled?).to eq(true)
+        expect(feature.enabled?(nil)).to eq(true)
+        expect(feature.enabled?(pitt)).to eq(true)
+        expect(feature.enabled?(admin_thing)).to eq(true)
       end
     end
 
@@ -400,24 +400,24 @@ describe Flipper do
         # ensure percentage of time returns percentage that makes five percent
         # of time false
         @gate = feature.gate(:percentage_of_time)
-        @gate.stub(:rand => 0.10)
+        allow(@gate).to receive_messages(:rand => 0.10)
 
         feature.enable five_percent_of_time
       end
 
       it "returns false" do
-        feature.enabled?.should eq(false)
-        feature.enabled?(nil).should eq(false)
-        feature.enabled?(pitt).should eq(false)
-        feature.enabled?(admin_thing).should eq(false)
+        expect(feature.enabled?).to eq(false)
+        expect(feature.enabled?(nil)).to eq(false)
+        expect(feature.enabled?(pitt)).to eq(false)
+        expect(feature.enabled?(admin_thing)).to eq(false)
       end
 
       it "returns true if boolean enabled" do
         feature.enable
-        feature.enabled?.should eq(true)
-        feature.enabled?(nil).should eq(true)
-        feature.enabled?(pitt).should eq(true)
-        feature.enabled?(admin_thing).should eq(true)
+        expect(feature.enabled?).to eq(true)
+        expect(feature.enabled?(nil)).to eq(true)
+        expect(feature.enabled?(pitt)).to eq(true)
+        expect(feature.enabled?(admin_thing)).to eq(true)
       end
     end
 
@@ -427,17 +427,17 @@ describe Flipper do
       end
 
       it "returns true if in enabled group" do
-        feature.enabled?(admin_thing).should eq(true)
+        expect(feature.enabled?(admin_thing)).to eq(true)
       end
 
       it "returns false if not in enabled group" do
-        feature.enabled?(dev_thing).should eq(false)
+        expect(feature.enabled?(dev_thing)).to eq(false)
       end
 
       it "returns true if boolean enabled" do
         feature.enable
-        feature.enabled?(admin_thing).should eq(true)
-        feature.enabled?(dev_thing).should eq(true)
+        expect(feature.enabled?(admin_thing)).to eq(true)
+        expect(feature.enabled?(dev_thing)).to eq(true)
       end
     end
   end
@@ -451,11 +451,11 @@ describe Flipper do
     end
 
     it "enables feature for object in enabled group" do
-      feature.enabled?(admin_thing).should eq(true)
+      expect(feature.enabled?(admin_thing)).to eq(true)
     end
 
     it "does not enable feature for object in not enabled group" do
-      feature.enabled?(dev_thing).should eq(false)
+      expect(feature.enabled?(dev_thing)).to eq(false)
     end
   end
 end