rspec 1.2.4 → 1.2.5

data/lib/spec/mocks/spec_methods.rb

@@ -20,10 +20,10 @@ module Spec
       #   stub_person = stub("thing", :name => "Joe", :email => "joe@domain.com")
       #   stub_person.name => "Joe"
       #   stub_person.email => "joe@domain.com"
-      def mock(name, stubs_and_options={})
-        Spec::Mocks::Mock.new(name, stubs_and_options)
+      def mock(*args)
+        Spec::Mocks::Mock.new(*args)
       end
-      
+
       alias :stub :mock
 
       # DEPRECATED - use mock('name').as_null_object instead
@@ -41,10 +41,10 @@ or stub('#{name}').as_null_object instead.
 WARNING
         mock(name, :null_object => true)
       end
-      
+
       # Disables warning messages about expectations being set on nil.
       #
-      # By default warning messages are issued when expectations are set on nil.  This is to 
+      # By default warning messages are issued when expectations are set on nil.  This is to
       # prevent false-positives and to catch potential bugs early on.
       def allow_message_expectations_on_nil
         Proxy.allow_message_expectations_on_nil

data/lib/spec/runner.rb

@@ -58,8 +58,7 @@ module Spec
       end
 
       def run
-        return true if options.examples_run?
-        options.run_examples
+        options.examples_run? || options.run_examples
       end
 
     end

data/lib/spec/runner/drb_command_line.rb

@@ -12,8 +12,10 @@ module Spec
           DRb.start_service("druby://localhost:0")
           spec_server = DRbObject.new_with_uri("druby://127.0.0.1:8989")
           spec_server.run(options.argv, options.error_stream, options.output_stream)
+          true
         rescue DRb::DRbConnError
           options.error_stream.puts "No server is running"
+          false
         end
       end
     end

data/lib/spec/runner/formatter/base_text_formatter.rb

@@ -28,7 +28,7 @@ module Spec
           @example_group = example_group_proxy
         end
         
-        def example_pending(example, message, ignore)
+        def example_pending(example, message, deprecated_pending_location=nil)
           @pending_examples << ["#{@example_group.description} #{example.description}", message, example.location]
         end
         

data/lib/spec/runner/formatter/no_op_method_missing.rb

@@ -6,7 +6,7 @@ module Spec
           if include_private
             true
           else
-            !private_methods.include?(message.to_s)
+            !private_methods.any? {|m| [message.to_s, message.to_sym].include?(m)}
           end
         end
 

data/lib/spec/version.rb

@@ -3,7 +3,7 @@ module Spec # :nodoc:
     unless defined? MAJOR
       MAJOR  = 1
       MINOR  = 2
-      TINY   = 4
+      TINY   = 5
       
       STRING = [MAJOR, MINOR, TINY].compact.join('.')
 

data/spec/spec/example/example_group_proxy_spec.rb

@@ -78,6 +78,30 @@ module Spec
         end
       end
       
+      describe "#options" do
+        it "provides the options passed to the example group declaration" do
+          group.stub!(:options => {:a => 'b'})
+          proxy.options.should == {:a => 'b'}
+        end
+        
+        it "excludes :location" do
+          group.stub!(:options => {:location => 'b'})
+          proxy.options.should == {}
+        end
+        
+        it "excludes :scope" do
+          group.stub!(:options => {:scope => 'b'})
+          proxy.options.should == {}
+        end
+        
+        it "preserves the original hash" do
+          hash = {:a => 'b', :location => 'here', :scope => 'tiny'}
+          group.stub!(:options => hash)
+          proxy.options.should == {:a => 'b'}
+          hash.should == {:a => 'b', :location => 'here', :scope => 'tiny'}
+        end
+      end
+      
     end
   end
 end

data/spec/spec/example/example_methods_spec.rb

@@ -117,6 +117,18 @@ module Spec
         end.should raise_error(/No description supplied for example declared on this backtrace/)
       end
     end
+    
+    describe "#expect" do
+      it "aliases #should with #to on the proc" do
+        a = 3
+        expect { a += 1 }.to change{a}.from(3).to(4)
+      end
+
+      it "aliases #should_not with #to_not on the proc" do
+        a = 3
+        expect { nil }.to_not change{a}
+      end
+    end
 
   end
 end

data/spec/spec/example/subject_spec.rb

@@ -48,8 +48,8 @@ module Spec
       end
 
       describe "defined in a top level group" do
-        it "is available in a nested group (subclass)" do
-          klass = Class.new do
+        before(:each) do
+          @group = Class.new do
             extend  Spec::Example::Subject::ExampleGroupMethods
             include Spec::Example::Subject::ExampleMethods
             class << self
@@ -65,11 +65,21 @@ module Spec
               [1,2,3]
             }
           end
+        end
+
+        it "is available in a nested group (subclass)" do
+          nested_group = Class.new(@group)
           
-          subclass = Class.new(klass)
-          
-          object = subclass.new
-          object.subject.should == [1,2,3]
+          example = nested_group.new
+          example.subject.should == [1,2,3]
+        end
+
+        it "is available in a doubly nested group (subclass)" do
+          nested_group = Class.new(@group)
+          doubly_nested_group = Class.new(nested_group)
+
+          example = doubly_nested_group.new
+          example.subject.should == [1,2,3]
         end
       end
     end

data/spec/spec/matchers/change_spec.rb

@@ -12,13 +12,13 @@ describe "should change(actual, message)" do
   end
 
   it "should pass when actual is modified by the block" do
-    lambda {@instance.some_value = 6}.should change(@instance, :some_value)
+    expect {@instance.some_value = 6}.to change(@instance, :some_value)
   end
 
   it "should fail when actual is not modified by the block" do
-    lambda do
-      lambda {}.should change(@instance, :some_value)
-    end.should fail_with("some_value should have changed, but is still 5")
+    expect do
+      expect {}.to change(@instance, :some_value)
+    end.to fail_with("some_value should have changed, but is still 5")
   end
   
   it "provides a #description" do
@@ -33,13 +33,13 @@ describe "should_not change(actual, message)" do
   end
 
   it "should pass when actual is not modified by the block" do
-    lambda { }.should_not change(@instance, :some_value)
+    expect { }.to_not change(@instance, :some_value)
   end
 
   it "should fail when actual is not modified by the block" do
-    lambda do
-      lambda {@instance.some_value = 6}.should_not change(@instance, :some_value)
-    end.should fail_with("some_value should not have changed, but did change from 5 to 6")
+    expect do
+      expect {@instance.some_value = 6}.to_not change(@instance, :some_value)
+    end.to fail_with("some_value should not have changed, but did change from 5 to 6")
   end
 end
 
@@ -50,19 +50,19 @@ describe "should change { block }" do
   end
 
   it "should pass when actual is modified by the block" do
-    lambda {@instance.some_value = 6}.should change { @instance.some_value }
+    expect {@instance.some_value = 6}.to change { @instance.some_value }
   end
 
   it "should fail when actual is not modified by the block" do
-    lambda do
-      lambda {}.should change{ @instance.some_value }
-    end.should fail_with("result should have changed, but is still 5")
+    expect do
+      expect {}.to change{ @instance.some_value }
+    end.to fail_with("result should have changed, but is still 5")
   end
   
   it "should warn if passed a block using do/end instead of {}" do
-    lambda do
-      lambda {}.should change do; end
-    end.should raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/)
+    expect do
+      expect {}.to change do; end
+    end.to raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/)
   end
   
   it "provides a #description" do
@@ -77,19 +77,19 @@ describe "should_not change { block }" do
   end
 
   it "should pass when actual is modified by the block" do
-    lambda {}.should_not change{ @instance.some_value }
+    expect {}.to_not change{ @instance.some_value }
   end
 
   it "should fail when actual is not modified by the block" do
-    lambda do
-      lambda {@instance.some_value = 6}.should_not change { @instance.some_value }
-    end.should fail_with("result should not have changed, but did change from 5 to 6")
+    expect do
+      expect {@instance.some_value = 6}.to_not change { @instance.some_value }
+    end.to fail_with("result should not have changed, but did change from 5 to 6")
   end
   
   it "should warn if passed a block using do/end instead of {}" do
-    lambda do
-      lambda {}.should_not change do; end
-    end.should raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/)
+    expect do
+      expect {}.to_not change do; end
+    end.to raise_error(Spec::Matchers::MatcherError, /block passed to should or should_not/)
   end
 end
 
@@ -100,19 +100,19 @@ describe "should change(actual, message).by(expected)" do
   end
 
   it "should pass when attribute is changed by expected amount" do
-    lambda { @instance.some_value += 1 }.should change(@instance, :some_value).by(1)
+    expect { @instance.some_value += 1 }.to change(@instance, :some_value).by(1)
   end
 
   it "should fail when the attribute is changed by unexpected amount" do
-    lambda do
-      lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by(1)
-    end.should fail_with("some_value should have been changed by 1, but was changed by 2")
+    expect do
+      expect { @instance.some_value += 2 }.to change(@instance, :some_value).by(1)
+    end.to fail_with("some_value should have been changed by 1, but was changed by 2")
   end
 
   it "should fail when the attribute is changed by unexpected amount in the opposite direction" do
-    lambda do
-      lambda { @instance.some_value -= 1 }.should change(@instance, :some_value).by(1)
-    end.should fail_with("some_value should have been changed by 1, but was changed by -1")
+    expect do
+      expect { @instance.some_value -= 1 }.to change(@instance, :some_value).by(1)
+    end.to fail_with("some_value should have been changed by 1, but was changed by -1")
   end
 end
 
@@ -123,19 +123,19 @@ describe "should change{ block }.by(expected)" do
   end
 
   it "should pass when attribute is changed by expected amount" do
-    lambda { @instance.some_value += 1 }.should change{@instance.some_value}.by(1)
+    expect { @instance.some_value += 1 }.to change{@instance.some_value}.by(1)
   end
 
   it "should fail when the attribute is changed by unexpected amount" do
-    lambda do
-      lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by(1)
-    end.should fail_with("result should have been changed by 1, but was changed by 2")
+    expect do
+      expect { @instance.some_value += 2 }.to change{@instance.some_value}.by(1)
+    end.to fail_with("result should have been changed by 1, but was changed by 2")
   end
 
   it "should fail when the attribute is changed by unexpected amount in the opposite direction" do
-    lambda do
-      lambda { @instance.some_value -= 1 }.should change{@instance.some_value}.by(1)
-    end.should fail_with("result should have been changed by 1, but was changed by -1")
+    expect do
+      expect { @instance.some_value -= 1 }.to change{@instance.some_value}.by(1)
+    end.to fail_with("result should have been changed by 1, but was changed by -1")
   end
 end
 
@@ -146,17 +146,17 @@ describe "should change(actual, message).by_at_least(expected)" do
   end
 
   it "should pass when attribute is changed by greater than the expected amount" do
-    lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by_at_least(1)
+    expect { @instance.some_value += 2 }.to change(@instance, :some_value).by_at_least(1)
   end
   
   it "should pass when attribute is changed by the expected amount" do
-    lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by_at_least(2)
+    expect { @instance.some_value += 2 }.to change(@instance, :some_value).by_at_least(2)
   end  
 
   it "should fail when the attribute is changed by less than the expected amount" do
-    lambda do
-      lambda { @instance.some_value += 1 }.should change(@instance, :some_value).by_at_least(2)
-    end.should fail_with("some_value should have been changed by at least 2, but was changed by 1")
+    expect do
+      expect { @instance.some_value += 1 }.to change(@instance, :some_value).by_at_least(2)
+    end.to fail_with("some_value should have been changed by at least 2, but was changed by 1")
   end
 
 end
@@ -168,17 +168,17 @@ describe "should change{ block }.by_at_least(expected)" do
   end
 
   it "should pass when attribute is changed by greater than expected amount" do
-    lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by_at_least(1)
+    expect { @instance.some_value += 2 }.to change{@instance.some_value}.by_at_least(1)
   end
   
   it "should pass when attribute is changed by the expected amount" do
-    lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by_at_least(2)
+    expect { @instance.some_value += 2 }.to change{@instance.some_value}.by_at_least(2)
   end  
 
   it "should fail when the attribute is changed by less than the unexpected amount" do
-    lambda do
-      lambda { @instance.some_value += 1 }.should change{@instance.some_value}.by_at_least(2)
-    end.should fail_with("result should have been changed by at least 2, but was changed by 1")
+    expect do
+      expect { @instance.some_value += 1 }.to change{@instance.some_value}.by_at_least(2)
+    end.to fail_with("result should have been changed by at least 2, but was changed by 1")
   end
 end
 
@@ -190,17 +190,17 @@ describe "should change(actual, message).by_at_most(expected)" do
   end
 
   it "should pass when attribute is changed by less than the expected amount" do
-    lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by_at_most(3)
+    expect { @instance.some_value += 2 }.to change(@instance, :some_value).by_at_most(3)
   end
   
   it "should pass when attribute is changed by the expected amount" do
-    lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by_at_most(2)
+    expect { @instance.some_value += 2 }.to change(@instance, :some_value).by_at_most(2)
   end  
 
   it "should fail when the attribute is changed by greater than the expected amount" do
-    lambda do
-      lambda { @instance.some_value += 2 }.should change(@instance, :some_value).by_at_most(1)
-    end.should fail_with("some_value should have been changed by at most 1, but was changed by 2")
+    expect do
+      expect { @instance.some_value += 2 }.to change(@instance, :some_value).by_at_most(1)
+    end.to fail_with("some_value should have been changed by at most 1, but was changed by 2")
   end
 
 end
@@ -212,17 +212,17 @@ describe "should change{ block }.by_at_most(expected)" do
   end
 
   it "should pass when attribute is changed by less than expected amount" do
-    lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by_at_most(3)
+    expect { @instance.some_value += 2 }.to change{@instance.some_value}.by_at_most(3)
   end
   
   it "should pass when attribute is changed by the expected amount" do
-    lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by_at_most(2)
+    expect { @instance.some_value += 2 }.to change{@instance.some_value}.by_at_most(2)
   end  
 
   it "should fail when the attribute is changed by greater than the unexpected amount" do
-    lambda do
-      lambda { @instance.some_value += 2 }.should change{@instance.some_value}.by_at_most(1)
-    end.should fail_with("result should have been changed by at most 1, but was changed by 2")
+    expect do
+      expect { @instance.some_value += 2 }.to change{@instance.some_value}.by_at_most(1)
+    end.to fail_with("result should have been changed by at most 1, but was changed by 2")
   end
 end
 
@@ -233,13 +233,13 @@ describe "should change(actual, message).from(old)" do
   end
 
   it "should pass when attribute is == to expected value before executing block" do
-    lambda { @instance.some_value = "astring" }.should change(@instance, :some_value).from("string")
+    expect { @instance.some_value = "astring" }.to change(@instance, :some_value).from("string")
   end
 
   it "should fail when attribute is not == to expected value before executing block" do
-    lambda do
-      lambda { @instance.some_value = "knot" }.should change(@instance, :some_value).from("cat")
-    end.should fail_with("some_value should have initially been \"cat\", but was \"string\"")
+    expect do
+      expect { @instance.some_value = "knot" }.to change(@instance, :some_value).from("cat")
+    end.to fail_with("some_value should have initially been \"cat\", but was \"string\"")
   end
 end
 
@@ -250,13 +250,13 @@ describe "should change{ block }.from(old)" do
   end
 
   it "should pass when attribute is == to expected value before executing block" do
-    lambda { @instance.some_value = "astring" }.should change{@instance.some_value}.from("string")
+    expect { @instance.some_value = "astring" }.to change{@instance.some_value}.from("string")
   end
 
   it "should fail when attribute is not == to expected value before executing block" do
-    lambda do
-      lambda { @instance.some_value = "knot" }.should change{@instance.some_value}.from("cat")
-    end.should fail_with("result should have initially been \"cat\", but was \"string\"")
+    expect do
+      expect { @instance.some_value = "knot" }.to change{@instance.some_value}.from("cat")
+    end.to fail_with("result should have initially been \"cat\", but was \"string\"")
   end
 end
 
@@ -267,13 +267,13 @@ describe "should change(actual, message).to(new)" do
   end
   
   it "should pass when attribute is == to expected value after executing block" do
-    lambda { @instance.some_value = "cat" }.should change(@instance, :some_value).to("cat")
+    expect { @instance.some_value = "cat" }.to change(@instance, :some_value).to("cat")
   end
 
   it "should fail when attribute is not == to expected value after executing block" do
-    lambda do
-      lambda { @instance.some_value = "cat" }.should change(@instance, :some_value).from("string").to("dog")
-    end.should fail_with("some_value should have been changed to \"dog\", but is now \"cat\"")
+    expect do
+      expect { @instance.some_value = "cat" }.to change(@instance, :some_value).from("string").to("dog")
+    end.to fail_with("some_value should have been changed to \"dog\", but is now \"cat\"")
   end
 end
 
@@ -284,13 +284,13 @@ describe "should change{ block }.to(new)" do
   end
   
   it "should pass when attribute is == to expected value after executing block" do
-    lambda { @instance.some_value = "cat" }.should change{@instance.some_value}.to("cat")
+    expect { @instance.some_value = "cat" }.to change{@instance.some_value}.to("cat")
   end
 
   it "should fail when attribute is not == to expected value after executing block" do
-    lambda do
-      lambda { @instance.some_value = "cat" }.should change{@instance.some_value}.from("string").to("dog")
-    end.should fail_with("result should have been changed to \"dog\", but is now \"cat\"")
+    expect do
+      expect { @instance.some_value = "cat" }.to change{@instance.some_value}.from("string").to("dog")
+    end.to fail_with("result should have been changed to \"dog\", but is now \"cat\"")
   end
 end
 
@@ -301,23 +301,23 @@ describe "should change(actual, message).from(old).to(new)" do
   end
   
   it "should pass when #to comes before #from" do
-    lambda { @instance.some_value = "cat" }.should change(@instance, :some_value).to("cat").from("string")
+    expect { @instance.some_value = "cat" }.to change(@instance, :some_value).to("cat").from("string")
   end
 
   it "should pass when #from comes before #to" do
-    lambda { @instance.some_value = "cat" }.should change(@instance, :some_value).from("string").to("cat")
+    expect { @instance.some_value = "cat" }.to change(@instance, :some_value).from("string").to("cat")
   end
   
   it "should show the correct messaging when #after and #to are different" do
-    lambda do
-      lambda { @instance.some_value = "cat" }.should change(@instance, :some_value).from("string").to("dog")
-    end.should fail_with("some_value should have been changed to \"dog\", but is now \"cat\"")
+    expect do
+      expect { @instance.some_value = "cat" }.to change(@instance, :some_value).from("string").to("dog")
+    end.to fail_with("some_value should have been changed to \"dog\", but is now \"cat\"")
   end
   
   it "should show the correct messaging when #before and #from are different" do
-    lambda do
-      lambda { @instance.some_value = "cat" }.should change(@instance, :some_value).from("not_string").to("cat")
-    end.should fail_with("some_value should have initially been \"not_string\", but was \"string\"")
+    expect do
+      expect { @instance.some_value = "cat" }.to change(@instance, :some_value).from("not_string").to("cat")
+    end.to fail_with("some_value should have initially been \"not_string\", but was \"string\"")
   end
 end
 
@@ -328,11 +328,11 @@ describe "should change{ block }.from(old).to(new)" do
   end
   
   it "should pass when #to comes before #from" do
-    lambda { @instance.some_value = "cat" }.should change{@instance.some_value}.to("cat").from("string")
+    expect { @instance.some_value = "cat" }.to change{@instance.some_value}.to("cat").from("string")
   end
 
   it "should pass when #from comes before #to" do
-    lambda { @instance.some_value = "cat" }.should change{@instance.some_value}.from("string").to("cat")
+    expect { @instance.some_value = "cat" }.to change{@instance.some_value}.from("string").to("cat")
   end
 end
 
@@ -342,8 +342,8 @@ describe Spec::Matchers::Change do
     @instance.some_value = "string"
     def @instance.send(*args); raise "DOH! Library developers shouldn't use #send!" end
     
-    lambda {
-      lambda { @instance.some_value = "cat" }.should change(@instance, :some_value)
-    }.should_not raise_error
+    expect {
+      expect { @instance.some_value = "cat" }.to change(@instance, :some_value)
+    }.to_not raise_error
   end
 end