rspec-given 3.1.1 → 3.2.0

data/spec/lib/given/file_cache_spec.rb

@@ -10,15 +10,15 @@ module Given
     When(:result) { cache.get(file_name) }
 
     context "when reading the file" do
-      Then { result[DESCRIBE_LINE].should =~ /describe FileCache do/ }
-      Then { result.size.should == MAX_LINE }
+      Then { expect(result[DESCRIBE_LINE]).to match(/describe FileCache do/) }
+      Then { expect(result.size).to eq MAX_LINE }
     end
 
     context "when getting the same file twice" do
-      Given { cache.should_receive(:read_lines).once.and_return(["A"]) }
+      Given { expect(cache).to receive(:read_lines).once.and_return(["A"]) }
       When(:result2) { cache.get(file_name) }
-      Then { result.should == ["A"] }
-      Then { result2.should == ["A"] }
+      Then { expect(result).to eq ["A"] }
+      Then { expect(result2).to eq ["A"] }
     end
   end
 end

data/spec/lib/given/have_failed_spec.rb

@@ -6,65 +6,65 @@ module HaveFailedSpec
   ExpectationError = RSpec::Expectations::ExpectationNotMetError
 
   describe "#have_failed" do
-  context "with a failure" do
-    When(:result) { fail CustomError, "Ouch" }
+    context "with a failure" do
+      When(:result) { fail CustomError, "Ouch" }
 
-    Then { result.should raise_error(CustomError, "Ouch") }
-    Then { result.should have_failed(CustomError, "Ouch") }
-    Then { result.should have_raised(CustomError, "Ouch") }
+      Then { expect(result).to raise_error(CustomError, "Ouch") }
+      Then { expect(result).to have_failed(CustomError, "Ouch") }
+      Then { expect(result).to have_raised(CustomError, "Ouch") }
 
-    Then { expect { result.should be_nil }.to raise_error(CustomError, "Ouch") }
-    Then { expect { result.should == 0 }.to raise_error(CustomError, "Ouch") }
-    Then { expect { result.should_not == 0 }.to raise_error(CustomError, "Ouch") }
+      Then { expect { expect(result).to be_nil }.to raise_error(CustomError, "Ouch") }
+      Then { expect { expect(result).to eq(0) }.to raise_error(CustomError, "Ouch") }
+      Then { expect { expect(result).to_not eq(0) }.to raise_error(CustomError, "Ouch") }
 
-    Then { expect { result.should_not have_failed }.to raise_error(ExpectationError) }
-  end
+      Then { expect { expect(result).to_not have_failed }.to raise_error(ExpectationError) }
+    end
 
-  context "with a standard failure" do
-    When(:result) { fail "Ouch" }
+    context "with a standard failure" do
+      When(:result) { fail "Ouch" }
 
-    Then { result.should raise_error(StandardError, "Ouch") }
-    Then { result.should raise_error(StandardError, /^O/) }
-    Then { result.should raise_error(StandardError) }
-    Then { result.should raise_error }
+      Then { expect(result).to raise_error(StandardError, "Ouch") }
+      Then { expect(result).to raise_error(StandardError, /^O/) }
+      Then { expect(result).to raise_error(StandardError) }
+      Then { expect(result).to raise_error }
 
-    Then { result.should have_failed(StandardError, "Ouch") }
-    Then { result.should have_failed(StandardError, /^O/) }
-    Then { result.should have_failed(StandardError) }
-    Then { result.should have_failed }
-  end
+      Then { expect(result).to have_failed(StandardError, "Ouch") }
+      Then { expect(result).to have_failed(StandardError, /^O/) }
+      Then { expect(result).to have_failed(StandardError) }
+      Then { expect(result).to have_failed }
+    end
 
-  context "with a different failure" do
-    When(:result) { fail CustomError, "Ouch" }
-    Then { expect { result.should have_failed(DifferentError) }.to raise_error(ExpectationError) }
-  end
+    context "with a different failure" do
+      When(:result) { fail CustomError, "Ouch" }
+      Then { expect { expect(result).to have_failed(DifferentError) }.to raise_error(ExpectationError) }
+    end
 
-  context "with a pending exception" do
-    When(:result) { fail RSpec::Core::Pending::PendingDeclaredInExample, "Required pending in example ... please ignore" }
-    Then { Given.fail_with "This example should have been pending" }
-  end
+    context "with a pending exception" do
+      When(:result) { fail RSpec::Core::Pending::PendingDeclaredInExample, "Required pending in example ... please ignore" }
+      Then { Given.fail_with "This example should have been pending" }
+    end
 
-  context "with a non-failure" do
-    When(:result) { :ok }
-    Then { result.should_not have_failed }
-    Then { expect { result.should have_failed }.to raise_error(RSpec::Expectations::ExpectationNotMetError) }
-  end
+    context "with a non-failure" do
+      When(:result) { :ok }
+      Then { expect(result).to_not have_failed }
+      Then { expect { expect(result).to have_failed }.to raise_error(RSpec::Expectations::ExpectationNotMetError) }
+    end
 
-  context "with natural assertions" do
-    use_natural_assertions_if_supported
+    context "with natural assertions" do
+      use_natural_assertions_if_supported
 
-    context "with failure" do
-      When(:result) { fail CustomError, "Ouch" }
-      Then { result == have_failed(CustomError, "Ouch") }
-      Then { ! (result != have_failed) }
-      Then { expect { result == :something }.to raise_error(CustomError, "Ouch") }
-    end
+      context "with failure" do
+        When(:result) { fail CustomError, "Ouch" }
+        Then { result == have_failed(CustomError, "Ouch") }
+        Then { ! (result != have_failed) }
+        Then { expect { result == :something }.to raise_error(CustomError, "Ouch") }
+      end
 
-    context "with different failure" do
-      When(:result) { fail DifferentError, "Ouch" }
-      Then { ! (result == have_failed(CustomError, "Ouch")) }
-    end
+      context "with different failure" do
+        When(:result) { fail DifferentError, "Ouch" }
+        Then { ! (result == have_failed(CustomError, "Ouch")) }
+      end
 
+    end
   end
 end
-end

data/spec/lib/given/line_extractor_spec.rb

@@ -27,12 +27,12 @@ module Given
         "  of their fellowmen\n"
       }
       Given(:expected_line) { "  for all good men\n" }
-      Then { result.should == expected_line }
+      Then { expect(result).to eq(expected_line) }
     end
 
     context "when the line doesn't exist" do
       Given(:input) { "" }
-      Then { result.should be_nil }
+      Then { expect(result).to be_nil }
     end
 
     context "when the line has leading and trailing white space" do
@@ -40,7 +40,7 @@ module Given
         "  Then { y } \n" +
         "  Then { x }\n"
       }
-      Then { result.should == "  Then { x }\n" }
+      Then { expect(result).to eq("  Then { x }\n") }
     end
 
     context "when the Then is split over several lines with {}" do
@@ -51,7 +51,7 @@ module Given
         "  }\n" +
         "end\n"
       }
-      Then { result.should == "  Then {\n    x\n  }\n" }
+      Then { expect(result).to eq("  Then {\n    x\n  }\n") }
     end
 
     context "when the Then is has blank lines" do
@@ -62,7 +62,7 @@ module Given
         "  }\n" +
         "end\n"
       }
-      Then { result.should == "  Then {\n\n    x\n  }\n" }
+      Then { expect(result).to eq("  Then {\n\n    x\n  }\n") }
     end
 
     context "when the Then is split over several lines with do/end" do
@@ -73,12 +73,12 @@ module Given
         "  end\n" +
         "end\n"
       }
-      Then { result.should == "  Then do\n    x\n  end\n" }
+      Then { expect(result).to eq("  Then do\n    x\n  end\n") }
     end
 
     describe "converting to a string" do
       Given(:input) { "" }
-      Then { extractor.to_s.should =~ /line *extractor/i }
+      Then { expect(extractor.to_s).to match(/line *extractor/i) }
     end
   end
 end

data/spec/lib/given/module_methods_spec.rb

@@ -5,9 +5,9 @@ describe "RSpec::Given.use_natural_assertions" do
     When(:result) { ::Given.use_natural_assertions }
 
     if ::Given::NATURAL_ASSERTIONS_SUPPORTED
-      Then { result.should_not have_failed }
+      Then { expect(result).to_not have_failed }
     else
-      Then { result.should have_failed(ArgumentError) }
+      Then { expect(result).to have_failed(ArgumentError) }
     end
   end
 end

data/spec/lib/given/natural_assertion_spec.rb

@@ -9,107 +9,107 @@ describe Given::NaturalAssertion do
   describe "#content?" do
     context "with empty block" do
       FauxThen { }
-      Then { na.should_not have_content }
+      Then { expect(na).to_not have_content }
     end
     context "with block returning false" do
       FauxThen { false }
-      Then { na.should have_content }
+      Then { expect(na).to have_content }
     end
   end
 
   describe "failure messages" do
     let(:msg) { na.message }
-    Invariant { msg.should =~ /^FauxThen expression/ }
+    Invariant { expect(msg).to match(/^FauxThen expression/) }
 
     context "with equals assertion" do
       Given(:a) { 1 }
       FauxThen { a == 2 }
-      Then { msg.should =~ /\bexpected: +1\b/ }
-      Then { msg.should =~ /\bto equal: +2\b/ }
-      Then { msg.should =~ /\bfalse +<- +a == 2\b/ }
-      Then { msg.should =~ /\b1 +<- +a\b/ }
+      Then { expect(msg).to match(/\bexpected: +1\b/) }
+      Then { expect(msg).to match(/\bto equal: +2\b/) }
+      Then { expect(msg).to match(/\bfalse +<- +a == 2\b/) }
+      Then { expect(msg).to match(/\b1 +<- +a\b/) }
     end
 
     context "with equals assertion with do/end" do
       Given(:a) { 1 }
       FauxThen do a == 2 end
-      Then { msg.should =~ /\bexpected: +1\b/ }
-      Then { msg.should =~ /\bto equal: +2\b/ }
-      Then { msg.should =~ /\bfalse +<- +a == 2\b/ }
-      Then { msg.should =~ /\b1 +<- +a\b/ }
+      Then { expect(msg).to match(/\bexpected: +1\b/) }
+      Then { expect(msg).to match(/\bto equal: +2\b/) }
+      Then { expect(msg).to match(/\bfalse +<- +a == 2\b/) }
+      Then { expect(msg).to match(/\b1 +<- +a\b/) }
     end
 
     context "with not-equals assertion" do
       Given(:a) { 1 }
       FauxThen { a != 1 }
-      Then { msg.should =~ /\bexpected: +1\b/ }
-      Then { msg.should =~ /\bto not equal: +1\b/ }
-      Then { msg.should =~ /\bfalse +<- +a != 1\b/ }
-      Then { msg.should =~ /\b1 +<- +a\b/ }
+      Then { expect(msg).to match(/\bexpected: +1\b/) }
+      Then { expect(msg).to match(/\bto not equal: +1\b/) }
+      Then { expect(msg).to match(/\bfalse +<- +a != 1\b/) }
+      Then { expect(msg).to match(/\b1 +<- +a\b/) }
     end
 
     context "with less than assertion" do
       Given(:a) { 1 }
       FauxThen { a < 1 }
-      Then { msg.should =~ /\bexpected: +1\b/ }
-      Then { msg.should =~ /\bto be less than: +1\b/ }
-      Then { msg.should =~ /\bfalse +<- +a < 1\b/ }
-      Then { msg.should =~ /\b1 +<- +a\b/ }
+      Then { expect(msg).to match(/\bexpected: +1\b/) }
+      Then { expect(msg).to match(/\bto be less than: +1\b/) }
+      Then { expect(msg).to match(/\bfalse +<- +a < 1\b/) }
+      Then { expect(msg).to match(/\b1 +<- +a\b/) }
     end
 
     context "with less than or equal to assertion" do
       Given(:a) { 1 }
       FauxThen { a <= 0 }
-      Then { msg.should =~ /\bexpected: +1\b/ }
-      Then { msg.should =~ /\bto be less or equal to: +0\b/ }
-      Then { msg.should =~ /\bfalse +<- +a <= 0\b/ }
-      Then { msg.should =~ /\b1 +<- +a\b/ }
+      Then { expect(msg).to match(/\bexpected: +1\b/) }
+      Then { expect(msg).to match(/\bto be less or equal to: +0\b/) }
+      Then { expect(msg).to match(/\bfalse +<- +a <= 0\b/) }
+      Then { expect(msg).to match(/\b1 +<- +a\b/) }
     end
 
     context "with greater than assertion" do
       Given(:a) { 1 }
       FauxThen { a > 1 }
-      Then { msg.should =~ /\bexpected: +1\b/ }
-      Then { msg.should =~ /\bto be greater than: +1\b/ }
-      Then { msg.should =~ /\bfalse +<- +a > 1\b/ }
-      Then { msg.should =~ /\b1 +<- +a\b/ }
+      Then { expect(msg).to match(/\bexpected: +1\b/) }
+      Then { expect(msg).to match(/\bto be greater than: +1\b/) }
+      Then { expect(msg).to match(/\bfalse +<- +a > 1\b/) }
+      Then { expect(msg).to match(/\b1 +<- +a\b/) }
     end
 
     context "with greater than or equal to assertion" do
       Given(:a) { 1 }
       FauxThen { a >= 3 }
-      Then { msg.should =~ /\bexpected: +1\b/ }
-      Then { msg.should =~ /\bto be greater or equal to: +3\b/ }
-      Then { msg.should =~ /\bfalse +<- +a >= 3\b/ }
-      Then { msg.should =~ /\b1 +<- +a\b/ }
+      Then { expect(msg).to match(/\bexpected: +1\b/) }
+      Then { expect(msg).to match(/\bto be greater or equal to: +3\b/) }
+      Then { expect(msg).to match(/\bfalse +<- +a >= 3\b/) }
+      Then { expect(msg).to match(/\b1 +<- +a\b/) }
     end
 
     context "with match assertion" do
       Given(:s) { "Hello" }
       FauxThen { s =~ /HI/ }
-      Then { msg.should =~ /\bexpected: +"Hello"$/ }
-      Then { msg.should =~ /\bto match: +\/HI\/$/ }
-      Then { msg.should =~ /\bnil +<- +s =~ \/HI\/$/ }
-      Then { msg.should =~ /"Hello" +<- +s$/ }
+      Then { expect(msg).to match(/\bexpected: +"Hello"$/) }
+      Then { expect(msg).to match(/\bto match: +\/HI\/$/) }
+      Then { expect(msg).to match(/\bnil +<- +s =~ \/HI\/$/) }
+      Then { expect(msg).to match(/"Hello" +<- +s$/) }
     end
 
     context "with not match assertion" do
       Given(:s) { "Hello" }
       FauxThen { s !~ /Hello/ }
-      Then { msg.should =~ /\bexpected: +"Hello"$/ }
-      Then { msg.should =~ /\bto not match: +\/Hello\/$/ }
-      Then { msg.should =~ /\bfalse +<- +s !~ \/Hello\/$/ }
-      Then { msg.should =~ /"Hello" +<- +s$/ }
+      Then { expect(msg).to match(/\bexpected: +"Hello"$/) }
+      Then { expect(msg).to match(/\bto not match: +\/Hello\/$/) }
+      Then { expect(msg).to match(/\bfalse +<- +s !~ \/Hello\/$/) }
+      Then { expect(msg).to match(/"Hello" +<- +s$/) }
     end
 
     context "with exception" do
       Given(:ary) { nil }
       FauxThen { ary[1] == 3 }
-      Then { msg.should =~ /\bexpected: +NoMethodError/ }
-      Then { msg.should =~ /\bto equal: +3$/ }
-      Then { msg.should =~ /\bNoMethodError.+NilClass\n +<- +ary\[1\] == 3$/ }
-      Then { msg.should =~ /\bNoMethodError.+NilClass\n +<- +ary\[1\]$/ }
-      Then { msg.should =~ /\bnil +<- +ary$/ }
+      Then { expect(msg).to match(/\bexpected: +NoMethodError/) }
+      Then { expect(msg).to match(/\bto equal: +3$/) }
+      Then { expect(msg).to match(/\bNoMethodError.+NilClass\n +<- +ary\[1\] == 3$/) }
+      Then { expect(msg).to match(/\bNoMethodError.+NilClass\n +<- +ary\[1\]$/) }
+      Then { expect(msg).to match(/\bnil +<- +ary$/) }
     end
 
     context "with value with newlines" do
@@ -123,10 +123,10 @@ describe Given::NaturalAssertion do
       end
       Given(:zzzz) { FunkyInspect.new }
       FauxThen { zzzz.ok? }
-      Then { msg.should =~ /\n  false   <- zzzz\.ok\?/ }
-      Then { msg.should =~ /\n  XXXX\n/ }
-      Then { msg.should =~ /\n  YYYY\n/ }
-      Then { msg.should =~ /\n          <- zzzz$/ }
+      Then { expect(msg).to match(/\n  false   <- zzzz\.ok\?/) }
+      Then { expect(msg).to match(/\n  XXXX\n/) }
+      Then { expect(msg).to match(/\n  YYYY\n/) }
+      Then { expect(msg).to match(/\n          <- zzzz$/) }
     end
   end
 
@@ -134,7 +134,7 @@ describe Given::NaturalAssertion do
     context "with no statements" do
       FauxThen {  }
       When(:result) { na.message }
-      Then { result.should_not have_failed }
+      Then { expect(result).to_not have_failed }
     end
 
     context "with multiple statements" do
@@ -143,7 +143,7 @@ describe Given::NaturalAssertion do
         ary[1] == 3
       }
       When(:result) { na.message }
-      Then { result.should have_failed(Given::InvalidThenError, /multiple.*statements/i) }
+      Then { expect(result).to have_failed(Given::InvalidThenError, /multiple.*statements/i) }
     end
 
   end

data/spec/lib/given/options_spec.rb

@@ -8,17 +8,17 @@ describe "Configuration Options" do
       _Gvn_context_info[:name] = "Outer"
       _Gvn_context_info[:outer] = true
 
-      Then { _gvn_info(:name).should == "Outer" }
-      Then { _gvn_info(:outer).should == true }
-      Then { _gvn_info(:inner).should == nil }
+      Then { expect(_gvn_info(:name)).to eq("Outer") }
+      Then { expect(_gvn_info(:outer)).to eq(true) }
+      Then { expect(_gvn_info(:inner)).to eq(nil) }
 
       context "Inner" do
         _Gvn_context_info[:name] = "Inner"
         _Gvn_context_info[:inner] = true
 
-        Then { _gvn_info(:name).should == "Inner" }
-        Then { _gvn_info(:outer).should == true }
-        Then { _gvn_info(:inner).should == true }
+        Then { expect(_gvn_info(:name)).to eq("Inner") }
+        Then { expect(_gvn_info(:outer)).to eq(true) }
+        Then { expect(_gvn_info(:inner)).to eq(true) }
       end
     end
   end
@@ -43,21 +43,21 @@ describe "Configuration Options" do
     end
 
     context "with no explicit word on natural assertions" do
-      Then { _gvn_need_na_message?(nassert).should be_false }
+      Then { expect(_gvn_need_na_message?(nassert)).to be_falsy }
 
       context "overridden locally" do
         use_natural_assertions_if_supported
-        Then { _gvn_need_na_message?(nassert).should be_true }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_truthy }
       end
     end
 
     context "with global configuration enabled" do
       When { Given.use_natural_assertions }
-      Then { _gvn_need_na_message?(nassert).should be_true }
+      Then { expect(_gvn_need_na_message?(nassert)).to be_truthy }
 
       context "overridden locally" do
         use_natural_assertions false
-        Then { _gvn_need_na_message?(nassert).should be_false }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_falsy }
       end
 
       context "with rspec assertion" do
@@ -67,71 +67,71 @@ describe "Configuration Options" do
             # If RSpec was successfully patched to record matchers,
             # then the "need NA" logic will ignore possible matches in
             # the source code.
-            _gvn_need_na_message?(nassert).should be_true
+            expect(_gvn_need_na_message?(nassert)).to be_truthy
           else
             # If RSpec was not successfully patched to record
             # matchers, then the "need NA" logic will check for
             # should/expect in the source.
-            _gvn_need_na_message?(nassert).should be_false
+            expect(_gvn_need_na_message?(nassert)).to be_falsy
           end
         }
       end
 
       context "without rspec assertion" do
         Given(:rspec) { false }
-        Then { _gvn_need_na_message?(nassert).should be_true }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_truthy }
       end
 
       context "without rspec assertion and no content" do
         Given(:rspec) { false }
         Given(:content) { false }
-        Then { _gvn_need_na_message?(nassert).should be_false }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_falsy }
       end
     end
 
     context "with global configuration set to always" do
       When { Given.use_natural_assertions :always }
-      Then { _gvn_need_na_message?(nassert).should be_true }
+      Then { expect(_gvn_need_na_message?(nassert)).to be_truthy }
 
       context "overridden locally" do
         use_natural_assertions false
-        Then { _gvn_need_na_message?(nassert).should be_false }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_falsy }
       end
 
       context "with rspec assertion" do
         Given(:rspec) { true }
-        Then { _gvn_need_na_message?(nassert).should be_true }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_truthy }
       end
 
       context "without rspec assertion" do
         Given(:rspec) { false }
-        Then { _gvn_need_na_message?(nassert).should be_true }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_truthy }
       end
 
       context "without rspec assertion and no content" do
         Given(:rspec) { false }
         Given(:content) { false }
-        Then { _gvn_need_na_message?(nassert).should be_false }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_falsy }
       end
     end
 
     context "with global configuration disabled" do
       When { Given.use_natural_assertions false }
-      Then { _gvn_need_na_message?(nassert).should be_false }
+      Then { expect(_gvn_need_na_message?(nassert)).to be_falsy }
 
       context "overridden locally" do
         use_natural_assertions_if_supported(true)
-        Then { _gvn_need_na_message?(nassert).should be_true }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_truthy }
       end
 
       context "with rspec assertion" do
         Given(:rspec) { true }
-        Then { _gvn_need_na_message?(nassert).should be_false }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_falsy }
       end
 
       context "without rspec assertion" do
         Given(:rspec) { false }
-        Then { _gvn_need_na_message?(nassert).should be_false }
+        Then { expect(_gvn_need_na_message?(nassert)).to be_falsy }
       end
     end