rspec 1.1.11 → 1.1.12

data/spec/spec/mocks/bug_report_11545_spec.rb

@@ -1,13 +1,11 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 class LiarLiarPantsOnFire
-  include Spec::MetaClass
-  extend Spec::MetaClass
-  def respond_to?(sym)
+  def respond_to?(sym, incl_private=false)
     true
   end
   
-  def self.respond_to?(sym)
+  def self.respond_to?(sym, incl_private=false)
     true
   end
 end
@@ -28,6 +26,7 @@ describe 'should_receive' do
   end
   
   it 'should cleanup after itself' do
-    LiarLiarPantsOnFire.metaclass.instance_methods.should_not include("something")
+    (class << LiarLiarPantsOnFire; self; end).instance_methods.should_not include("something")
   end
 end
+

data/spec/spec/mocks/bug_report_496.rb

@@ -1,16 +1,18 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-class BaseClass
-end
+module BugReport496
+  class BaseClass
+  end
 
-class SubClass < BaseClass
-end
+  class SubClass < BaseClass
+  end
 
-describe "a message expectation on a base class object" do
-  it "should correctly pick up message sent to it subclass" do
-    pending("fix for http://rspec.lighthouseapp.com/projects/5645-rspec/tickets/496") do
-      BaseClass.should_receive(:new).once
-      SubClass.new
+  describe "a message expectation on a base class object" do
+    it "should correctly pick up message sent to it subclass" do
+      pending("fix for http://rspec.lighthouseapp.com/projects/5645/tickets/496") do
+        BaseClass.should_receive(:new).once
+        SubClass.new
+      end
     end
   end
 end

data/spec/spec/mocks/bug_report_600_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module BugReport600
+  class ExampleClass
+    def self.method_that_uses_define_method
+      define_method "defined_method" do |attributes|
+        load_address(address, attributes)
+      end
+    end
+  end
+ 
+  describe "stubbing a class method" do
+    it "should work" do
+      ExampleClass.should_receive(:define_method).with("defined_method")
+      ExampleClass.method_that_uses_define_method
+    end
+
+    it "should restore the original method" do
+      ExampleClass.method_that_uses_define_method
+    end
+  end
+end

data/spec/spec/mocks/hash_including_matcher_spec.rb

@@ -27,6 +27,32 @@ module Spec
               hash_including(:a => anything, :b => 2).should == {:a => "1", :b => 2}
             end
           end
+          
+          describe "when passed only keys or keys mixed with key/value pairs" do
+            it "should match if the key is present" do
+              hash_including(:a).should == {:a => 1, :b => 2}
+            end
+            
+            it "should match if more keys are present" do
+              hash_including(:a, :b).should == {:a => 1, :b => 2, :c => 3}
+            end
+
+            it "should match a string against a given key" do
+              hash_including(:a).should == {:a => "1", :b => 2}
+            end
+
+            it "should match if passed one key and one key/value pair" do
+              hash_including(:a, :b => 2).should == {:a => 1, :b => 2}
+            end
+            
+            it "should match if passed many keys and one key/value pair" do
+              hash_including(:a, :b, :c => 3).should == {:a => 1, :b => 2, :c => 3, :d => 4}
+            end
+            
+            it "should match if passed many keys and many key/value pairs" do
+              hash_including(:a, :b, :c => 3, :e => 5).should == {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
+            end
+          end
         end
         
         describe "failing" do
@@ -34,11 +60,22 @@ module Spec
             hash_including(:a => 1).should_not == 1
           end
 
-
           it "should not match a hash with a missing key" do
             hash_including(:a => 1).should_not == {:b => 2}
           end
-
+          
+          it "should not match a hash with a missing key" do
+            hash_including(:a).should_not == {:b => 2}
+          end
+          
+          it "should not match an empty hash with a given key" do
+            hash_including(:a).should_not == {}
+          end
+          
+          it "should not match a hash with a missing key when one pair is matching" do
+            hash_including(:a, :b => 2).should_not == {:b => 2}
+          end
+          
           it "should not match a hash with an incorrect value" do
             hash_including(:a => 1, :b => 2).should_not == {:a => 1, :b => 3}
           end

data/spec/spec/mocks/hash_not_including_matcher_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    module ArgumentConstraints
+      describe HashNotIncludingConstraint do
+        
+        it "should describe itself properly" do
+          HashNotIncludingConstraint.new(:a => 5).description.should == "hash_not_including(:a=>5)"
+        end      
+
+        describe "passing" do
+          it "should match a hash without the specified key" do
+            hash_not_including(:c).should == {:a => 1, :b => 2}
+          end
+          
+          it "should match a hash with the specified key, but different value" do
+            hash_not_including(:b => 3).should == {:a => 1, :b => 2}
+          end
+                    
+          it "should match a hash without the specified key, given as anything()" do
+            hash_not_including(:c => anything).should == {:a => 1, :b => 2}
+          end
+
+          it "should match an empty hash" do
+            hash_not_including(:a).should == {}
+          end
+          
+          it "should match a hash without any of the specified keys" do
+            hash_not_including(:a, :b, :c).should == { :d => 7}
+          end
+          
+        end
+        
+        describe "failing" do
+          it "should not match a non-hash" do
+            hash_not_including(:a => 1).should_not == 1
+          end
+          
+          it "should not match a hash with a specified key" do
+            hash_not_including(:b).should_not == {:b => 2}
+          end
+          
+          it "should not match a hash with the specified key/value pair" do
+            hash_not_including(:b => 2).should_not == {:a => 1, :b => 2}
+          end
+          
+          it "should not match a hash with the specified key" do
+            hash_not_including(:a, :b => 3).should_not == {:a => 1, :b => 2}
+          end
+          
+          it "should not match a hash with one of the specified keys" do
+            hash_not_including(:a, :b).should_not == {:b => 2}
+          end
+          
+          it "should not match a hash with some of the specified keys" do
+            hash_not_including(:a, :b, :c).should_not == {:a => 1, :b => 2}
+          end
+          
+          it "should not match a hash with one key/value pair included" do
+            hash_not_including(:a, :b, :c, :d => 7).should_not == { :d => 7}
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec/mocks/mock_spec.rb

@@ -3,7 +3,6 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 module Spec
   module Mocks
     describe Mock do
-
       before(:each) do
         @mock = mock("test mock")
       end
@@ -227,7 +226,7 @@ module Spec
       it "should yield 0 args to blocks that take a variable number of arguments" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield
         a = nil
-        @mock.yield_back {|*a|}
+        @mock.yield_back {|*x| a = x}
         a.should == []
         @mock.rspec_verify
       end
@@ -245,7 +244,7 @@ module Spec
       it "should yield one arg to blocks that take a variable number of arguments" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99)
         a = nil
-        @mock.yield_back {|*a|}
+        @mock.yield_back {|*x| a = x}
         a.should == [99]
         @mock.rspec_verify
       end
@@ -264,7 +263,7 @@ module Spec
       it "should yield many args to blocks that take a variable number of arguments" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99, 27, "go")
         a = nil
-        @mock.yield_back {|*a|}
+        @mock.yield_back {|*x| a = x}
         a.should == [99, 27, "go"]
         @mock.rspec_verify
       end
@@ -283,7 +282,7 @@ module Spec
       it "should yield single value" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield(99)
         a = nil
-        @mock.yield_back {|a|}
+        @mock.yield_back {|x| a = x}
         a.should == 99
         @mock.rspec_verify
       end
@@ -302,7 +301,7 @@ module Spec
       it "should yield two values" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
         a, b = nil
-        @mock.yield_back {|a,b|}
+        @mock.yield_back {|x,y| a=x; b=y}
         a.should == 'wha'
         b.should == 'zup'
         @mock.rspec_verify

data/spec/spec/mocks/nil_expectation_warning_spec.rb

@@ -6,7 +6,7 @@ module Spec
     describe "an expectation set on nil" do
       
       it "should issue a warning with file and line number information" do
-        expected_warning = "An expectation of :foo was set on nil. Called from #{__FILE__}:#{__LINE__+3}. Use allow_message_expectations_on_nil to disable warnings."
+        expected_warning = %r%An expectation of :foo was set on nil. Called from #{__FILE__}:#{__LINE__+3}(:in `block \(2 levels\) in <module:Mocks>')?. Use allow_message_expectations_on_nil to disable warnings.%
         Kernel.should_receive(:warn).with(expected_warning)
 
         nil.should_receive(:foo)
@@ -43,7 +43,7 @@ module Spec
                         nil.foo
                       end
                               
-        example_group.run.should be_true
+        example_group.run(Spec::Runner.options).should be_true
                   
       end
 

data/spec/spec/mocks/passing_mock_argument_constraints_spec.rb

@@ -26,13 +26,28 @@ module Spec
         @mock.random_call(false)
       end
 
-      it "should accept fixnum as an_instance_of(Numeric)" do
-        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
+      it "should accept fixnum as kind_of(Numeric)" do
+        @mock.should_receive(:random_call).with(kind_of(Numeric))
         @mock.random_call(1)
       end
 
       it "should accept float as an_instance_of(Numeric)" do
-        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
+        @mock.should_receive(:random_call).with(kind_of(Numeric))
+        @mock.random_call(1.5)
+      end
+      
+      it "accepts fixnum as instance_of(Fixnum)" do
+        @mock.should_receive(:random_call).with(instance_of(Fixnum))
+        @mock.random_call(1)
+      end
+
+      it "should NOT accept fixnum as instance_of(Numeric)" do
+        @mock.should_not_receive(:random_call).with(instance_of(Numeric))
+        @mock.random_call(1)
+      end
+
+      it "should NOT accept float as instance_of(Numeric)" do
+        @mock.should_not_receive(:random_call).with(instance_of(Numeric))
         @mock.random_call(1.5)
       end
 

data/spec/spec/mocks/stub_spec.rb

@@ -137,6 +137,12 @@ module Spec
         @stub.foo("bar")
         @stub.foo("baz")
       end
+
+      it "calculates return value by executing block passed to #and_return" do
+        @mock.stub!(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
+        @mock.something("a","b","c").should == "cba"
+        @mock.rspec_verify
+      end
     end
     
     describe "A method stub with args" do

data/spec/spec/mocks/stubbed_message_expectations_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    describe "Example with stubbed and then called message" do
+      it "should fail if the message is expected and then subsequently not called again" do
+        mock_obj = mock("mock", :msg => nil)
+        mock_obj.msg
+        mock_obj.should_receive(:msg)
+        lambda { mock_obj.rspec_verify }.should raise_error(Spec::Mocks::MockExpectationError)
+      end
+    end
+  end
+end

data/spec/spec/runner/command_line_spec.rb

@@ -11,19 +11,19 @@ module Spec
         end
       
         it "should run directory" do
-          file = File.dirname(__FILE__) + '/../../../examples/pure'
-          run_with(OptionParser.parse([file,"-p","**/*.rb"], @err, @out))
+          file = File.dirname(__FILE__) + '/../../../examples/passing'
+          run_with(OptionParser.parse([file,"-p","**/*_spec.rb,**/*_example.rb"], @err, @out))
 
           @out.rewind
           @out.read.should =~ /\d+ examples, 0 failures, 3 pending/n
         end
 
         it "should run file" do
-          file = File.dirname(__FILE__) + '/../../../failing_examples/predicate_example.rb'
+          file = File.dirname(__FILE__) + '/../../../examples/failing/predicate_example.rb'
           run_with(OptionParser.parse([file], @err, @out))
 
           @out.rewind
-          @out.read.should =~ /2 examples, 1 failure/n
+          @out.read.should =~ /3 examples, 2 failures/n
         end
 
         it "should raise when file does not exist" do

data/spec/spec/runner/configuration_spec.rb

@@ -0,0 +1,301 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Runner
+    describe Configuration do
+      with_sandboxed_options do
+        with_sandboxed_config do
+          describe "#mock_with" do
+            it "should default mock framework to rspec" do
+              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/rspec$/
+            end
+
+            it "should set rspec mocking explicitly" do
+              config.mock_with(:rspec)
+              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/rspec$/
+            end
+
+            it "should set mocha" do
+              config.mock_with(:mocha)
+              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/mocha$/
+            end
+
+            it "should set flexmock" do
+              config.mock_with(:flexmock)
+              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/flexmock$/
+            end
+
+            it "should set rr" do
+              config.mock_with(:rr)
+              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/rr$/
+            end
+
+            it "should set an arbitrary adapter module" do
+              adapter = Module.new
+              config.mock_with(adapter)
+              config.mock_framework.should == adapter
+            end
+          end
+
+          describe "#include" do
+          
+            before(:each) do
+              @example_group_class = Class.new(ExampleGroup) {}
+              Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class)
+            end
+
+            it "should include the submitted module in ExampleGroup subclasses" do
+              mod = Module.new
+              config.include mod
+              Class.new(@example_group_class).included_modules.should include(mod)
+            end
+
+            it "should scope modules to be included for a specific type" do
+              mod = Module.new
+              config.include mod, :type => :foobar
+              Class.new(@example_group_class).included_modules.should include(mod)
+            end
+
+            it "should not include modules in a type they are not intended for" do
+              mod = Module.new
+              @other_example_group_class = Class.new(ExampleGroup)
+              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
+
+              config.include mod, :type => :foobar
+
+              Class.new(@other_example_group_class).included_modules.should_not include(mod)
+            end
+            
+            it "accepts an Array of types" do
+              mod = Module.new
+              @other_example_group_class = Class.new(ExampleGroup)
+              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
+
+              config.include mod, :type => [:foobar, :baz]
+
+              Class.new(@example_group_class).included_modules.should include(mod)
+              Class.new(@other_example_group_class).included_modules.should include(mod)
+            end
+
+          end
+      
+          describe "#extend" do
+        
+            before(:each) do
+              @example_group_class = Class.new(ExampleGroup) {}
+              Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class)
+            end
+
+            it "should extend all groups" do
+              mod = Module.new
+              ExampleGroup.should_receive(:extend).with(mod)
+              Spec::Runner.configuration.extend mod
+            end
+      
+            it "should extend specified groups" do
+              mod = Module.new
+              @example_group_class.should_receive(:extend).with(mod)
+              Spec::Runner.configuration.extend mod, :type => :foobar
+            end
+      
+            it "should not extend non-specified groups" do
+              @other_example_group_class = Class.new(ExampleGroup)
+              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
+
+              mod = Module.new
+              @other_example_group_class.should_not_receive(:extend)          
+
+              Spec::Runner.configuration.extend mod, :type => :foobar
+            end
+        
+          end
+        end
+      
+        describe "ordering methods: " do
+        
+          before(:each) do
+            @special_example_group = Class.new(ExampleGroup).describe("special_example_group")
+            @special_child_example_group = Class.new(@special_example_group).describe("special_child_example_group")
+            @nonspecial_example_group = Class.new(ExampleGroup).describe("nonspecial_example_group")
+            Spec::Example::ExampleGroupFactory.register(:special, @special_example_group)
+            Spec::Example::ExampleGroupFactory.register(:special_child, @special_child_example_group)
+            Spec::Example::ExampleGroupFactory.register(:non_special, @nonspecial_example_group)
+            @example_group = @special_child_example_group.describe "Special Example Group"
+            @unselected_example_group = Class.new(@nonspecial_example_group).describe "Non Special Example Group"
+          end
+
+          describe "#prepend_before" do
+            it "prepends the before block on all instances of the passed in type" do
+              order = []
+              config.prepend_before(:all) do
+                order << :prepend__before_all
+              end
+              config.prepend_before(:all, :type => :special) do
+                order << :special_prepend__before_all
+              end
+              config.prepend_before(:all, :type => :special_child) do
+                order << :special_child_prepend__before_all
+              end
+              config.prepend_before(:each) do
+                order << :prepend__before_each
+              end
+              config.prepend_before(:each, :type => :special) do
+                order << :special_prepend__before_each
+              end
+              config.prepend_before(:each, :type => :special_child) do
+                order << :special_child_prepend__before_each
+              end
+              config.prepend_before(:all, :type => :non_special) do
+                order << :special_prepend__before_all
+              end
+              config.prepend_before(:each, :type => :non_special) do
+                order << :special_prepend__before_each
+              end
+              @example_group.it "calls prepend_before" do
+              end
+      
+              @example_group.run(options)
+              order.should == [
+                :prepend__before_all,
+                :special_prepend__before_all,
+                :special_child_prepend__before_all,
+                :prepend__before_each,
+                :special_prepend__before_each,
+                :special_child_prepend__before_each
+              ]
+            end
+          end
+
+          describe "#append_before" do
+
+            it "calls append_before on the type" do
+              order = []
+              config.append_before(:all) do
+                order << :append_before_all
+              end
+              config.append_before(:all, :type => :special) do
+                order << :special_append_before_all
+              end
+              config.append_before(:all, :type => :special_child) do
+                order << :special_child_append_before_all
+              end
+              config.append_before(:each) do
+                order << :append_before_each
+              end
+              config.append_before(:each, :type => :special) do
+                order << :special_append_before_each
+              end
+              config.append_before(:each, :type => :special_child) do
+                order << :special_child_append_before_each
+              end
+              config.append_before(:all, :type => :non_special) do
+                order << :special_append_before_all
+              end
+              config.append_before(:each, :type => :non_special) do
+                order << :special_append_before_each
+              end
+              @example_group.it "calls append_before" do
+              end
+
+              @example_group.run(options)
+              order.should == [
+                :append_before_all,
+                :special_append_before_all,
+                :special_child_append_before_all,
+                :append_before_each,
+                :special_append_before_each,
+                :special_child_append_before_each
+              ]
+            end
+          end
+
+          describe "#prepend_after" do
+
+            it "prepends the after block on all instances of the passed in type" do
+              order = []
+              config.prepend_after(:all) do
+                order << :prepend__after_all
+              end
+              config.prepend_after(:all, :type => :special) do
+                order << :special_prepend__after_all
+              end
+              config.prepend_after(:all, :type => :special) do
+                order << :special_child_prepend__after_all
+              end
+              config.prepend_after(:each) do
+                order << :prepend__after_each
+              end
+              config.prepend_after(:each, :type => :special) do
+                order << :special_prepend__after_each
+              end
+              config.prepend_after(:each, :type => :special) do
+                order << :special_child_prepend__after_each
+              end
+              config.prepend_after(:all, :type => :non_special) do
+                order << :special_prepend__after_all
+              end
+              config.prepend_after(:each, :type => :non_special) do
+                order << :special_prepend__after_each
+              end
+              @example_group.it "calls prepend_after" do
+              end
+
+              @example_group.run(options)
+              order.should == [
+                :special_child_prepend__after_each,
+                :special_prepend__after_each,
+                :prepend__after_each,
+                :special_child_prepend__after_all,
+                :special_prepend__after_all,
+                :prepend__after_all
+              ]
+            end
+          end
+
+          describe "#append_after" do
+
+            it "calls append_after on the type" do
+              order = []
+              config.append_after(:all) do
+                order << :append__after_all
+              end
+              config.append_after(:all, :type => :special) do
+                order << :special_append__after_all
+              end
+              config.append_after(:all, :type => :special_child) do
+                order << :special_child_append__after_all
+              end
+              config.append_after(:each) do
+                order << :append__after_each
+              end
+              config.append_after(:each, :type => :special) do
+                order << :special_append__after_each
+              end
+              config.append_after(:each, :type => :special_child) do
+                order << :special_child_append__after_each
+              end
+              config.append_after(:all, :type => :non_special) do
+                order << :non_special_append_after_all
+              end
+              config.append_after(:each, :type => :non_special) do
+                order << :non_special_append_after_each
+              end
+              @example_group.it "calls append_after" do
+              end
+
+              @example_group.run(options)
+              order.should == [
+                :special_child_append__after_each,
+                :special_append__after_each,
+                :append__after_each,
+                :special_child_append__after_all,
+                :special_append__after_all,
+                :append__after_all
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end