rspec-expectations 2.12.1 → 2.13.0

data/spec/rspec/matchers/start_with_end_with_spec.rb

@@ -1,181 +1,185 @@
 require "spec_helper"
 
-describe "should start_with" do
+describe "expect(...).to start_with" do
   it_behaves_like "an RSpec matcher", :valid_value => "ab", :invalid_value => "bc" do
     let(:matcher) { start_with("a") }
   end
 
   context "with a string" do
     it "passes if it matches the start of the actual string" do
-      "this string".should start_with "this str"
+      expect("this string").to start_with "this str"
     end
 
     it "fails if it does not match the start of the actual string" do
       expect {
-        "this string".should start_with "that str"
+        expect("this string").to start_with "that str"
       }.to fail_with("expected \"this string\" to start with \"that str\"")
     end
   end
 
   context "with an array" do
     it "passes if it is the first element of the array" do
-      [0, 1, 2].should start_with 0
+      expect([0, 1, 2]).to start_with 0
     end
 
     it "passes if the first elements of the array match" do
-      [0, 1, 2].should start_with 0, 1
+      expect([0, 1, 2]).to start_with 0, 1
     end
 
     it "fails if it does not match the first element of the array" do
       expect {
-        [0, 1, 2].should start_with 2
+        expect([0, 1, 2]).to start_with 2
       }.to fail_with("expected [0, 1, 2] to start with 2")
     end
 
     it "fails if it the first elements of the array do not match" do
       expect {
-        [0, 1, 2].should start_with 1, 2
+        expect([0, 1, 2]).to start_with 1, 2
       }.to fail_with("expected [0, 1, 2] to start with [1, 2]")
     end
   end
 
   context "with an object that does not respond to :[]" do
     it "raises an ArgumentError" do
-      expect { Object.new.should start_with 0 }.to raise_error(ArgumentError, /does not respond to :\[\]/)
+      expect {
+        expect(Object.new).to start_with 0
+      }.to raise_error(ArgumentError, /does not respond to :\[\]/)
     end
   end
 
   context "with a hash" do
     it "raises an ArgumentError if trying to match more than one element" do
       expect{
-        {:a => 'b', :b => 'b', :c => 'c'}.should start_with({:a => 'b', :b => 'b'})
+        expect({:a => 'b', :b => 'b', :c => 'c'}).to start_with({:a => 'b', :b => 'b'})
       }.to raise_error(ArgumentError, /does not have ordered elements/)
     end
   end
 end
 
-describe "should_not start_with" do
+describe "expect(...).to_not start_with" do
   context "with a string" do
     it "passes if it does not match the start of the actual string" do
-      "this string".should_not start_with "that str"
+      expect("this string").not_to start_with "that str"
     end
 
     it "fails if it does match the start of the actual string" do
       expect {
-        "this string".should_not start_with "this str"
+        expect("this string").not_to start_with "this str"
       }.to fail_with("expected \"this string\" not to start with \"this str\"")
     end
   end
 
   context "with an array" do
     it "passes if it is not the first element of the array" do
-      [0, 1, 2].should_not start_with 2
+      expect([0, 1, 2]).not_to start_with 2
     end
 
     it "passes if the first elements of the array do not match" do
-      [0, 1, 2].should_not start_with 1, 2
+      expect([0, 1, 2]).not_to start_with 1, 2
     end
 
     it "fails if it matches the first element of the array" do
       expect {
-        [0, 1, 2].should_not start_with 0
+        expect([0, 1, 2]).not_to start_with 0
       }.to fail_with("expected [0, 1, 2] not to start with 0")
     end
 
     it "fails if it the first elements of the array match" do
       expect {
-        [0, 1, 2].should_not start_with 0, 1
+        expect([0, 1, 2]).not_to start_with 0, 1
       }.to fail_with("expected [0, 1, 2] not to start with [0, 1]")
     end
   end
 end
 
-describe "should end_with" do
+describe "expect(...).to end_with" do
   it_behaves_like "an RSpec matcher", :valid_value => "ab", :invalid_value => "bc" do
     let(:matcher) { end_with("b") }
   end
 
   context "with a string" do
     it "passes if it matches the end of the actual string" do
-      "this string".should end_with "is string"
+      expect("this string").to end_with "is string"
     end
 
     it "fails if it does not match the end of the actual string" do
       expect {
-        "this string".should end_with "is stringy"
+        expect("this string").to end_with "is stringy"
       }.to fail_with("expected \"this string\" to end with \"is stringy\"")
     end
   end
 
   context "with an array" do
     it "passes if it is the last element of the array" do
-      [0, 1, 2].should end_with 2
+      expect([0, 1, 2]).to end_with 2
     end
 
     it "passes if the last elements of the array match" do
-      [0, 1, 2].should end_with [1, 2]
+      expect([0, 1, 2]).to end_with [1, 2]
     end
 
     it "fails if it does not match the last element of the array" do
       expect {
-        [0, 1, 2].should end_with 1
+        expect([0, 1, 2]).to end_with 1
       }.to fail_with("expected [0, 1, 2] to end with 1")
     end
 
     it "fails if it the last elements of the array do not match" do
       expect {
-        [0, 1, 2].should end_with [0, 1]
+        expect([0, 1, 2]).to end_with [0, 1]
       }.to fail_with("expected [0, 1, 2] to end with [0, 1]")
     end
   end
 
   context "with an object that does not respond to :[]" do
     it "raises an error if expected value can't be indexed'" do
-      expect { Object.new.should end_with 0 }.to raise_error(ArgumentError, /does not respond to :\[\]/)
+      expect {
+        expect(Object.new).to end_with 0
+      }.to raise_error(ArgumentError, /does not respond to :\[\]/)
     end
   end
 
   context "with a hash" do
     it "raises an ArgumentError if trying to match more than one element" do
       expect{
-        {:a => 'b', :b => 'b', :c => 'c'}.should end_with({:a => 'b', :b =>'b'})
+        expect({:a => 'b', :b => 'b', :c => 'c'}).to end_with({:a => 'b', :b =>'b'})
       }.to raise_error(ArgumentError, /does not have ordered elements/)
     end
   end
 
 end
 
-describe "should_not end_with" do
+describe "expect(...).to_not end_with" do
   context "with a sting" do
     it "passes if it does not match the end of the actual string" do
-      "this string".should_not end_with "stringy"
+      expect("this string").not_to end_with "stringy"
     end
 
     it "fails if it matches the end of the actual string" do
       expect {
-        "this string".should_not end_with "string"
+        expect("this string").not_to end_with "string"
       }.to fail_with("expected \"this string\" not to end with \"string\"")
     end
   end
 
   context "an array" do
     it "passes if it is not the last element of the array" do
-      [0, 1, 2].should_not end_with 1
+      expect([0, 1, 2]).not_to end_with 1
     end
 
     it "passes if the last elements of the array do not match" do
-      [0, 1, 2].should_not end_with [0, 1]
+      expect([0, 1, 2]).not_to end_with [0, 1]
     end
 
     it "fails if it matches the last element of the array" do
       expect {
-        [0, 1, 2].should_not end_with 2
+        expect([0, 1, 2]).not_to end_with 2
       }.to fail_with("expected [0, 1, 2] not to end with 2")
     end
 
     it "fails if it the last elements of the array match" do
       expect {
-        [0, 1, 2].should_not end_with [1, 2]
+        expect([0, 1, 2]).not_to end_with [1, 2]
       }.to fail_with("expected [0, 1, 2] not to end with [1, 2]")
     end
   end

data/spec/rspec/matchers/throw_symbol_spec.rb

@@ -11,21 +11,21 @@ module RSpec::Matchers::BuiltIn
       before(:each) { @matcher = throw_symbol }
 
       it "matches if any Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_true
+        expect(@matcher.matches?(lambda{ throw :sym })).to be_true
       end
       it "matches if any Symbol is thrown with an arg" do
-        @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+        expect(@matcher.matches?(lambda{ throw :sym, "argument" })).to be_true
       end
       it "does not match if no Symbol is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
+        expect(@matcher.matches?(lambda{ })).to be_false
       end
       it "provides a failure message" do
         @matcher.matches?(lambda{})
-        @matcher.failure_message_for_should.should == "expected a Symbol to be thrown, got nothing"
+        expect(@matcher.failure_message_for_should).to eq "expected a Symbol to be thrown, got nothing"
       end
       it "provides a negative failure message" do
         @matcher.matches?(lambda{ throw :sym})
-        @matcher.failure_message_for_should_not.should == "expected no Symbol to be thrown, got :sym"
+        expect(@matcher.failure_message_for_should_not).to eq "expected no Symbol to be thrown, got :sym"
       end
     end
 
@@ -33,32 +33,32 @@ module RSpec::Matchers::BuiltIn
       before(:each) { @matcher = throw_symbol(:sym) }
 
       it "matches if correct Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_true
+        expect(@matcher.matches?(lambda{ throw :sym })).to be_true
       end
       it "matches if correct Symbol is thrown with an arg" do
-        @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+        expect(@matcher.matches?(lambda{ throw :sym, "argument" })).to be_true
       end
       it "does not match if no Symbol is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
+        expect(@matcher.matches?(lambda{ })).to be_false
       end
       it "does not match if correct Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym }).should be_false
+        expect(@matcher.matches?(lambda{ throw :other_sym })).to be_false
       end
       it "provides a failure message when no Symbol is thrown" do
         @matcher.matches?(lambda{})
-        @matcher.failure_message_for_should.should == "expected :sym to be thrown, got nothing"
+        expect(@matcher.failure_message_for_should).to eq "expected :sym to be thrown, got nothing"
       end
       it "provides a failure message when wrong Symbol is thrown" do
         @matcher.matches?(lambda{ throw :other_sym })
-        @matcher.failure_message_for_should.should == "expected :sym to be thrown, got :other_sym"
+        expect(@matcher.failure_message_for_should).to eq "expected :sym to be thrown, got :other_sym"
       end
       it "provides a negative failure message" do
         @matcher.matches?(lambda{ throw :sym })
-        @matcher.failure_message_for_should_not.should == "expected :sym not to be thrown, got :sym"
+        expect(@matcher.failure_message_for_should_not).to eq "expected :sym not to be thrown, got :sym"
       end
       it "only matches NameErrors raised by uncaught throws" do
         expect {
-          @matcher.matches?(lambda{ sym }).should be_false
+          expect(@matcher.matches?(lambda{ sym })).to be_false
         }.to raise_error(NameError)
       end
     end
@@ -67,43 +67,43 @@ module RSpec::Matchers::BuiltIn
       before(:each) { @matcher = throw_symbol(:sym, "a") }
 
       it "matches if correct Symbol and args are thrown" do
-        @matcher.matches?(lambda{ throw :sym, "a" }).should be_true
+        expect(@matcher.matches?(lambda{ throw :sym, "a" })).to be_true
       end
       it "does not match if nothing is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
+        expect(@matcher.matches?(lambda{ })).to be_false
       end
       it "does not match if other Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
+        expect(@matcher.matches?(lambda{ throw :other_sym, "a" })).to be_false
       end
       it "does not match if no arg is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_false
+        expect(@matcher.matches?(lambda{ throw :sym })).to be_false
       end
       it "does not match if wrong arg is thrown" do
-        @matcher.matches?(lambda{ throw :sym, "b" }).should be_false
+        expect(@matcher.matches?(lambda{ throw :sym, "b" })).to be_false
       end
       it "provides a failure message when no Symbol is thrown" do
         @matcher.matches?(lambda{})
-        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got nothing]
+        expect(@matcher.failure_message_for_should).to eq %q[expected :sym with "a" to be thrown, got nothing]
       end
       it "provides a failure message when wrong Symbol is thrown" do
         @matcher.matches?(lambda{ throw :other_sym })
-        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :other_sym]
+        expect(@matcher.failure_message_for_should).to eq %q[expected :sym with "a" to be thrown, got :other_sym]
       end
       it "provides a failure message when wrong arg is thrown" do
         @matcher.matches?(lambda{ throw :sym, "b" })
-        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with "b"]
+        expect(@matcher.failure_message_for_should).to eq %q[expected :sym with "a" to be thrown, got :sym with "b"]
       end
       it "provides a failure message when no arg is thrown" do
         @matcher.matches?(lambda{ throw :sym })
-        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with no argument]
+        expect(@matcher.failure_message_for_should).to eq %q[expected :sym with "a" to be thrown, got :sym with no argument]
       end
       it "provides a negative failure message" do
         @matcher.matches?(lambda{ throw :sym })
-        @matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown, got :sym with no argument]
+        expect(@matcher.failure_message_for_should_not).to eq %q[expected :sym with "a" not to be thrown, got :sym with no argument]
       end
       it "only matches NameErrors raised by uncaught throws" do
         expect {
-          @matcher.matches?(lambda{ sym }).should be_false
+          expect(@matcher.matches?(lambda{ sym })).to be_false
         }.to raise_error(NameError)
       end
       it "raises other errors" do

data/spec/rspec/matchers/yield_spec.rb

@@ -44,7 +44,7 @@ describe "yield_control matcher" do
   end
 
   it 'has a description' do
-    yield_control.description.should eq("yield control")
+    expect(yield_control.description).to eq("yield control")
   end
 
   describe "expect {...}.to yield_control" do
@@ -106,7 +106,7 @@ describe "yield_with_no_args matcher" do
   end
 
   it 'has a description' do
-    yield_with_no_args.description.should eq("yield with no args")
+    expect(yield_with_no_args.description).to eq("yield with no args")
   end
 
   describe "expect {...}.to yield_with_no_args" do
@@ -183,9 +183,9 @@ describe "yield_with_args matcher" do
   end
 
   it 'has a description' do
-    yield_with_args.description.should eq("yield with args")
-    yield_with_args(1, 3).description.should eq("yield with args(1, 3)")
-    yield_with_args(false).description.should eq("yield with args(false)")
+    expect(yield_with_args.description).to eq("yield with args")
+    expect(yield_with_args(1, 3).description).to eq("yield with args(1, 3)")
+    expect(yield_with_args(false).description).to eq("yield with args(false)")
   end
 
   describe "expect {...}.to yield_with_args" do
@@ -348,8 +348,8 @@ describe "yield_successive_args matcher" do
   end
 
   it 'has a description' do
-    yield_successive_args(1, 3).description.should eq("yield successive args(1, 3)")
-    yield_successive_args([:a, 1], [:b, 2]).description.should eq("yield successive args([:a, 1], [:b, 2])")
+    expect(yield_successive_args(1, 3).description).to eq("yield successive args(1, 3)")
+    expect(yield_successive_args([:a, 1], [:b, 2]).description).to eq("yield successive args([:a, 1], [:b, 2])")
   end
 
   describe "expect {...}.to yield_successive_args([:a, 1], [:b, 2])" do

data/spec/spec_helper.rb

@@ -1,27 +1,54 @@
-def add_to_load_path(path, prepend=false)
-  path = File.expand_path("../../#{path}/lib", __FILE__)
-  if prepend
-    $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
-  else
-    $LOAD_PATH << path unless $LOAD_PATH.include?(path)
+Dir['./spec/support/**/*'].each {|f| require f}
+
+RSpec::configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.color_enabled = true
+  config.filter_run :focused
+  config.run_all_when_everything_filtered = true
+  config.order = :random
+
+  config.expect_with :rspec do |expectations|
+    $default_expectation_syntax = expectations.syntax
+    expectations.syntax = :expect
   end
 end
 
-require 'test/unit'
+shared_context "with #should enabled", :uses_should do
+  orig_syntax = nil
 
-add_to_load_path("rspec-expectations", :prepend)
-add_to_load_path("rspec-core")
-add_to_load_path("rspec-mocks")
+  before(:all) do
+    orig_syntax = RSpec::Matchers.configuration.syntax
+    RSpec::Matchers.configuration.syntax = [:expect, :should]
+  end
 
-require 'rspec/expectations'
-require 'rspec/core'
-require 'rspec/mocks'
+  after(:all) do
+    RSpec::Matchers.configuration.syntax = orig_syntax
+  end
+end
 
-Dir['./spec/support/**/*'].each {|f| require f}
 
-RSpec::configure do |config|
-  config.color_enabled = true
-  config.filter_run :focused => true
-  config.run_all_when_everything_filtered = true
-  config.order = :random
+shared_context "with #should exclusively enabled", :uses_only_should do
+  orig_syntax = nil
+
+  before(:all) do
+    orig_syntax = RSpec::Matchers.configuration.syntax
+    RSpec::Matchers.configuration.syntax = :should
+  end
+
+  after(:all) do
+    RSpec::Matchers.configuration.syntax = orig_syntax
+  end
+end
+
+module TestUnitIntegrationSupport
+  include InSubProcess
+
+  def with_test_unit_loaded
+    in_sub_process do
+      require 'test/unit'
+      load 'rspec/matchers.rb'
+      yield
+    end
+  end
 end
+