Switch to RSpec 3 expect-based syntax

nfedyashev · nfedyashev · commit 069975d74ece · 2014-09-10T13:29:32.000+06:00
diff --git a/Gemfile b/Gemfile
@@ -4,7 +4,7 @@ gem 'rake'
 gem 'yard'
 
 group :test do
-  gem 'rspec', '>= 2.14'
+  gem 'rspec', '~> 3.1'
 end
 
 platforms :rbx do
diff --git a/lib/retryable.rb b/lib/retryable.rb
@@ -22,7 +22,7 @@ def retryable(options = {}, &block)
 
       # Interrupt Exception could be raised while sleeping
       begin
-        sleep opts[:sleep].respond_to?(:call) ? opts[:sleep].call(retries) : opts[:sleep]
+        Kernel.sleep opts[:sleep].respond_to?(:call) ? opts[:sleep].call(retries) : opts[:sleep]
       rescue *on_exception
       end
 
diff --git a/spec/lib/config_spec.rb b/spec/lib/config_spec.rb
@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Retryable do
+RSpec.describe Retryable do
   it 'is enabled by default' do
-    Retryable.should be_enabled
+    expect(Retryable).to be_enabled
   end
 
   it 'could be disabled' do
     Retryable.disable
-    Retryable.should_not be_enabled
+    expect(Retryable).not_to be_enabled
   end
 
   context 'when disabled' do
@@ -17,7 +17,7 @@
 
     it 'could be re-enabled' do
       Retryable.enable
-      Retryable.should be_enabled
+      expect(Retryable).to be_enabled
     end
   end
 end
diff --git a/spec/lib/retryable_spec.rb b/spec/lib/retryable_spec.rb
@@ -1,118 +1,118 @@
 require 'spec_helper'
 
-describe 'Kernel.retryable' do
+RSpec.describe 'Kernel.retryable' do
   before(:each) do
     Retryable.enable
     @attempt = 0
   end
 
   it 'catch StandardError only by default' do
-    lambda do
+    expect do
       count_retryable(:tries => 2) { |tries, ex| raise Exception if tries < 1 }
-    end.should raise_error Exception
-    @try_count.should == 1
+    end.to raise_error Exception
+    expect(@try_count).to eq(1)
   end
 
   it 'retries on default exception' do
-    Kernel.should_receive(:sleep).once.with(1)
+    expect(Kernel).to receive(:sleep).once.with(1)
 
     count_retryable(:tries => 2) { |tries, ex| raise StandardError if tries < 1 }
-    @try_count.should == 2
+    expect(@try_count).to eq(2)
   end
 
   it 'does not retry if disabled' do
     Retryable.disable
 
-    lambda do
+    expect do
       count_retryable(:tries => 2) { raise }
-    end.should raise_error RuntimeError
-    @try_count.should == 1
+    end.to raise_error RuntimeError
+    expect(@try_count).to eq(1)
   end
 
   it 'executes *ensure* clause' do
     ensure_cb  = Proc.new do |retries|
-      retries.should == 0
+      expect(retries).to eq(0)
     end
 
     Kernel.retryable(:ensure => ensure_cb) { }
   end
 
   it 'passes retry count and exception on retry' do
-    Kernel.should_receive(:sleep).once.with(1)
+    expect(Kernel).to receive(:sleep).once.with(1)
 
     count_retryable(:tries => 2) do |tries, ex|
-      ex.class.should == StandardError if tries > 0
+      expect(ex.class).to eq(StandardError) if tries > 0
       raise StandardError if tries < 1
     end
-    @try_count.should == 2
+    expect(@try_count).to eq(2)
   end
 
   it 'makes another try if exception is covered by :on' do
-    Kernel.stub(:sleep)
+    allow(Kernel).to receive(:sleep)
     count_retryable(:on => [StandardError, ArgumentError, RuntimeError] ) { |tries, ex| raise ArgumentError if tries < 1 }
-    @try_count.should == 2
+    expect(@try_count).to eq(2)
   end
 
   it 'does not try on unexpected exception' do
-    Kernel.stub(:sleep)
-    lambda do
+    allow(Kernel).to receive(:sleep)
+    expect do
       count_retryable(:on => RuntimeError ) { |tries, ex| raise StandardError if tries < 1 }
-    end.should raise_error StandardError
-    @try_count.should == 1
+    end.to raise_error StandardError
+    expect(@try_count).to eq(1)
   end
 
   it 'retries three times' do
-    Kernel.stub(:sleep)
+    allow(Kernel).to receive(:sleep)
     count_retryable(:tries => 3) { |tries, ex| raise StandardError if tries < 2 }
-    @try_count.should == 3
+    expect(@try_count).to eq(3)
   end
 
   it 'retries on default exception' do
-    Kernel.should_receive(:sleep).once.with(1)
+    expect(Kernel).to receive(:sleep).once.with(1)
 
     count_retryable(:tries => 2) { |tries, ex| raise StandardError if tries < 1 }
-    @try_count.should == 2
+    expect(@try_count).to eq(2)
   end
 
   it 'executes exponential backoff scheme for :sleep option' do
-    [1, 4, 16, 64].each { |i| Kernel.should_receive(:sleep).once.ordered.with(i) }
-    lambda do
+    [1, 4, 16, 64].each { |i| expect(Kernel).to receive(:sleep).once.ordered.with(i) }
+    expect do
       Kernel.retryable(:tries => 5, :sleep => lambda { |n| 4**n }) { raise RangeError }
-    end.should raise_error RangeError
+    end.to raise_error RangeError
   end
 
   it 'does not retry any exception if :on is empty list' do
-    lambda do
+    expect do
       count_retryable(:on => []) { raise }
-    end.should raise_error RuntimeError
-    @try_count.should == 1
+    end.to raise_error RuntimeError
+    expect(@try_count).to eq(1)
   end
 
   it 'catches an exception that matches the regex' do
-    Kernel.should_receive(:sleep).once.with(1)
+    expect(Kernel).to receive(:sleep).once.with(1)
     count_retryable(:matching => /IO timeout/) { |c,e| raise "yo, IO timeout!" if c == 0 }
-    @try_count.should == 2
+    expect(@try_count).to eq(2)
   end
 
   it 'does not catch an exception that does not match the regex' do
-    should_not_receive :sleep
-    lambda do
+    expect(Kernel).not_to receive(:sleep)
+    expect do
       count_retryable(:matching => /TimeError/) { raise "yo, IO timeout!" }
-    end.should raise_error RuntimeError
-    @try_count.should == 1
+    end.to raise_error RuntimeError
+    expect(@try_count).to eq(1)
   end
 
   it 'does not allow invalid options' do
-    lambda do
+    expect do
       retryable(:bad_option => 2) { raise "this is bad" }
-    end.should raise_error ArgumentError, '[Retryable] Invalid options: bad_option'
+    end.to raise_error ArgumentError, '[Retryable] Invalid options: bad_option'
   end
 
   it 'accepts a callback to run after an exception is rescued' do
-    lambda do
+    expect do
       retryable(:sleep => 0, :exception_cb => Proc.new {|e| @raised = e.to_s }) {|tries, ex| raise StandardError.new("this is fun!") if tries < 1 }
-    end.should_not raise_error
+    end.not_to raise_error
 
-    @raised.should == "this is fun!"
+    expect(@raised).to eq("this is fun!")
   end
 end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
@@ -2,9 +2,7 @@
 require 'rspec'
 
 RSpec.configure do |config|
-  # Remove this line if you don't want RSpec's should and should_not
-  # methods or matchers
-  require 'rspec/expectations'
+  config.disable_monkey_patching!
 
   def count_retryable(*opts)
     @try_count = 0
