dchelimsky-rspec 1.1.10 → 1.1.11

data/spec/spec/example/example_methods_spec.rb

@@ -145,14 +145,129 @@ module Spec
         end
       end
 
-      describe "#__full_description" do
+      describe "#full_description" do
         it "should return the full description of the ExampleGroup and Example" do
           example_group = Class.new(ExampleGroup).describe("An ExampleGroup") do
             it "should do something" do
             end
           end
           example = example_group.examples.first
-          example.__full_description.should == "An ExampleGroup should do something"
+          example.full_description.should == "An ExampleGroup should do something"
+        end
+      end
+      
+      describe "#subject" do
+        it "should return an instance variable named after the described type" do
+          example_group = describe(Array) do
+            example {}
+          end
+          example = example_group.examples.first
+          example.subject.should == []
+        end
+        
+        it "should not barf on a module (as opposed to a class)" do
+          example_group = Class.new(ExampleGroup).describe(ObjectSpace) do
+            example {}
+          end
+          example_group.examples.first.subject.should be_nil
+        end
+        
+        it "should not barf on a string" do
+          example_group = describe('foo') do
+            example {}
+          end
+          example_group.examples.first.subject.should be_nil
+        end
+      end
+
+      describe "#should" do
+        with_sandboxed_options do
+          class Thing
+            def ==(other)
+              true
+            end
+          end
+          
+          describe "in an ExampleGroup with the ivar defined in before" do
+            attr_reader :example, :success
+
+            before(:each) do
+              example_group = describe(Thing, "1") do
+                before(:each) { @spec_example_thing = 'expected' }
+                it { should eql('expected') }
+              end
+              @example = example_group.examples.first
+              @success = example_group.run
+            end
+
+            it "should create an example using the description from the matcher" do
+              example.description.should == 'should eql "expected"'
+            end
+
+            it "should test the matcher returned from the block" do
+              success.should be_true
+            end
+          end
+
+          describe "in an ExampleGroup with the subject defined using #subject" do
+            it "should create an example using the description from the matcher" do
+              example_group = describe(Thing, "2") do
+                subject {'this is the subject'}
+                it { should eql('this is the subject') }
+              end
+              example = example_group.examples.first
+              example_group.run
+              example.description.should =~ /should eql "this is the subject"/
+            end
+          end
+          
+          describe "in an ExampleGroup using an implicit ivar" do
+            it "should create an example using the description from the matcher" do
+              example_group = describe(Thing, "3") do
+                it { should == Thing.new }
+              end
+              example = example_group.examples.first
+              success = example_group.run
+              example.description.should =~ /should == #<Spec::Example::Thing/
+              success.should be_true
+            end
+          end
+          
+          after(:each) do
+            ExampleGroup.reset
+          end
+          
+        end
+      end
+
+      describe "#should_not" do
+        with_sandboxed_options do
+
+          attr_reader :example_group, :example, :success
+
+          before do
+            @example_group = Class.new(ExampleGroup) do
+              def subject; @actual; end
+              before(:each) { @actual = 'expected' }
+              it { should_not eql('unexpected') }
+            end
+            @example = @example_group.examples.first
+
+            @success = example_group.run
+          end
+
+          it "should create an example using the description from the matcher" do
+            example.description.should == 'should not eql "unexpected"'
+          end
+
+          it "should test the matcher returned from the block" do
+            success.should be_true
+          end
+
+          after do
+            ExampleGroup.reset
+          end
+
         end
       end
     end

data/spec/spec/example/shared_example_group_spec.rb

@@ -17,46 +17,25 @@ module Spec
         after(:each) do
           @formatter.rspec_verify
           @example_group = nil
-          Spec::Example::SharedExampleGroup.shared_example_groups.clear
-        end
-
-        def make_shared_example_group(name, opts=nil, &block)
-          example_group = SharedExampleGroup.new(name, :shared => true, &block)
-          SharedExampleGroup.add_shared_example_group(example_group)
-          example_group
-        end
-
-        def non_shared_example_group()
-          @non_shared_example_group ||= Class.new(ExampleGroup).describe("example_group")
-        end
-
-        it "should accept an optional options hash" do
-          lambda { Class.new(ExampleGroup).describe("context") }.should_not raise_error(Exception)
-          lambda { Class.new(ExampleGroup).describe("context", :shared => true) }.should_not raise_error(Exception)
-        end
-
-        it "should return all shared example_groups" do
-          b1 = make_shared_example_group("b1", :shared => true) {}
-          b2 = make_shared_example_group("b2", :shared => true) {}
-
-          b1.should_not be(nil)
-          b2.should_not be(nil)
-
-          SharedExampleGroup.find_shared_example_group("b1").should equal(b1)
-          SharedExampleGroup.find_shared_example_group("b2").should equal(b2)
-        end
-
-        it "should register as shared example_group" do
-          example_group = make_shared_example_group("example_group") {}
-          SharedExampleGroup.shared_example_groups.should include(example_group)
+          Spec::Example::SharedExampleGroup.clear
         end
+        
+        describe "#register" do
+          it "creates a new shared example group with the submitted args" do
+            block = lambda {}
+            group = SharedExampleGroup.new("shared group") do end
+            Spec::Example::SharedExampleGroup.should_receive(:new).with("share me", &block).and_return(group)
+            Spec::Example::SharedExampleGroup.register("share me", &block)
+          end
 
-        it "should not be shared when not configured as shared" do
-          example_group = non_shared_example_group
-          SharedExampleGroup.shared_example_groups.should_not include(example_group)
+          it "registers the shared example group" do
+            lambda do
+              Spec::Example::SharedExampleGroup.register "share me" do end
+            end.should change {Spec::Example::SharedExampleGroup.count}.by(1)
+          end
         end
 
-        it "should complain when adding a second shared example_group with the same description" do
+        it "complains when adding a second shared example_group with the same description" do
           describe "shared example_group", :shared => true do
           end
           lambda do
@@ -64,14 +43,17 @@ module Spec
             end
           end.should raise_error(ArgumentError)
         end
-
-        it "should NOT complain when adding the same shared example_group instance again" do
-          shared_example_group = Class.new(ExampleGroup).describe("shared example_group", :shared => true)
-          SharedExampleGroup.add_shared_example_group(shared_example_group)
-          SharedExampleGroup.add_shared_example_group(shared_example_group)
+        
+        it "does NOT add the same group twice" do
+          lambda do
+            2.times do
+              describe "shared example_group which gets loaded twice", :shared => true do
+              end
+            end
+          end.should change {Spec::Example::SharedExampleGroup.count}.by(1)
         end
 
-        it "should NOT complain when adding the same shared example_group again (i.e. file gets reloaded)" do
+        it "does NOT complain when adding the same shared example_group again (i.e. file gets reloaded)" do
           lambda do
             2.times do
               describe "shared example_group which gets loaded twice", :shared => true do
@@ -80,42 +62,36 @@ module Spec
           end.should_not raise_error(ArgumentError)
         end
 
-        it "should NOT complain when adding the same shared example_group in same file with different absolute path" do
-          shared_example_group_1 = Class.new(ExampleGroup).describe(
+        it "does NOT complain when adding the same shared example_group in same file with different absolute path" do
+          SharedExampleGroup.register(
             "shared example_group",
             :shared => true,
             :spec_path => "/my/spec/a/../shared.rb"
           )
-          shared_example_group_2 = Class.new(ExampleGroup).describe(
+          SharedExampleGroup.register(
             "shared example_group",
             :shared => true,
             :spec_path => "/my/spec/b/../shared.rb"
           )
-
-          SharedExampleGroup.add_shared_example_group(shared_example_group_1)
-          SharedExampleGroup.add_shared_example_group(shared_example_group_2)
         end
 
-        it "should complain when adding a different shared example_group with the same name in a different file with the same basename" do
-          shared_example_group_1 = Class.new(ExampleGroup).describe(
+        it "complains when adding a different shared example_group with the same name in a different file with the same basename" do
+          SharedExampleGroup.register(
             "shared example_group",
             :shared => true,
             :spec_path => "/my/spec/a/shared.rb"
           )
-          shared_example_group_2 = Class.new(ExampleGroup).describe(
-            "shared example_group",
-            :shared => true,
-            :spec_path => "/my/spec/b/shared.rb"
-          )
-
-          SharedExampleGroup.add_shared_example_group(shared_example_group_1)
           lambda do
-            SharedExampleGroup.add_shared_example_group(shared_example_group_2)
+            SharedExampleGroup.register(
+              "shared example_group",
+              :shared => true,
+              :spec_path => "/my/spec/b/shared.rb"
+            )
           end.should raise_error(ArgumentError, /already exists/)
         end
 
-        it "should add examples to current example_group using it_should_behave_like" do
-          shared_example_group = make_shared_example_group("shared example_group") do
+        it "adds examples to current example_group using it_should_behave_like" do
+          shared_example_group = SharedExampleGroup.register("shared example_group") do
             it("shared example") {}
             it("shared example 2") {}
           end
@@ -126,12 +102,12 @@ module Spec
           example_group.number_of_examples.should == 3
         end
 
-        it "should add examples to from two shared groups" do
-          shared_example_group_1 = make_shared_example_group("shared example_group 1") do
+        it "adds examples to from two shared groups" do
+          shared_example_group_1 = SharedExampleGroup.register("shared example_group 1") do
             it("shared example 1") {}
           end
 
-          shared_example_group_1 = make_shared_example_group("shared example_group 2") do
+          shared_example_group_1 = SharedExampleGroup.register("shared example_group 2") do
             it("shared example 2") {}
           end
 
@@ -141,7 +117,7 @@ module Spec
           example_group.number_of_examples.should == 3
         end
 
-        it "should add examples to current example_group using include" do
+        it "adds examples to current example_group using include" do
           shared_example_group = describe "all things", :shared => true do
             it "should do stuff" do end
           end
@@ -153,7 +129,7 @@ module Spec
           example_group.number_of_examples.should == 1
         end
 
-        it "should add examples to current example_group using it_should_behave_like with a module" do
+        it "adds examples to current example_group using it_should_behave_like with a module" do
           AllThings = describe "all things", :shared => true do
             it "should do stuff" do end
           end
@@ -165,9 +141,9 @@ module Spec
           example_group.number_of_examples.should == 1
         end
 
-        it "should run shared examples" do
+        it "runs shared examples" do
           shared_example_ran = false
-          shared_example_group = make_shared_example_group("shared example_group") do
+          shared_example_group = SharedExampleGroup.register("shared example_group") do
             it("shared example") { shared_example_ran = true }
           end
 
@@ -180,12 +156,12 @@ module Spec
           shared_example_ran.should be_true
         end
 
-        it "should run setup and teardown from shared example_group" do
+        it "runs before(:each) and after(:each) from shared example_group" do
           shared_setup_ran = false
           shared_teardown_ran = false
-          shared_example_group = make_shared_example_group("shared example_group") do
-            before { shared_setup_ran = true }
-            after { shared_teardown_ran = true }
+          shared_example_group = SharedExampleGroup.register("shared example_group") do
+            before(:each) { shared_setup_ran = true }
+            after(:each)  { shared_teardown_ran = true }
             it("shared example") { shared_example_ran = true }
           end
 
@@ -202,9 +178,9 @@ module Spec
         it "should run before(:all) and after(:all) only once from shared example_group" do
           shared_before_all_run_count = 0
           shared_after_all_run_count = 0
-          shared_example_group = make_shared_example_group("shared example_group") do
+          shared_example_group = SharedExampleGroup.register("shared example_group") do
             before(:all) { shared_before_all_run_count += 1}
-            after(:all) { shared_after_all_run_count += 1}
+            after(:all)  { shared_after_all_run_count += 1}
             it("shared example") { shared_example_ran = true }
           end
 
@@ -221,7 +197,7 @@ module Spec
         it "should include modules, included into shared example_group, into current example_group" do
           @formatter.should_receive(:add_example_group).with(any_args)
 
-          shared_example_group = make_shared_example_group("shared example_group") do
+          shared_example_group = SharedExampleGroup.register("shared example_group") do
             it("shared example") { shared_example_ran = true }
           end
 
@@ -254,7 +230,7 @@ module Spec
         end
 
         it "should make methods defined in the shared example_group available in consuming example_group" do
-          shared_example_group = make_shared_example_group("shared example_group xyz") do
+          shared_example_group = SharedExampleGroup.register("shared example_group xyz") do
             def a_shared_helper_method
               "this got defined in a shared example_group"
             end

data/spec/spec/matchers/be_spec.rb

@@ -7,7 +7,7 @@ describe "should be_predicate" do
   end
 
   it "should pass when actual returns true for :predicates? (present tense)" do
-    actual = stub("actual", :exists? => true)
+    actual = stub("actual", :exists? => true, :exist? => true)
     actual.should be_exist
   end
 
@@ -21,7 +21,23 @@ describe "should be_predicate" do
   it "should fail when actual does not respond to :predicate?" do
     lambda {
       Object.new.should be_happy
-    }.should raise_error(NameError)
+    }.should raise_error(NameError, /happy\?/)
+  end
+  
+  it "should fail on error other than NameError" do
+    actual = stub("actual")
+    actual.should_receive(:foo?).and_raise("aaaah")
+    lambda {
+      actual.should be_foo
+    }.should raise_error(/aaaah/)
+  end
+  
+  it "should fail on error other than NameError (with the present tense predicate)" do
+    actual = Object.new
+    actual.should_receive(:foos?).and_raise("aaaah")
+    lambda {
+      actual.should be_foo
+    }.should raise_error(/aaaah/)
   end
 end
 
@@ -121,7 +137,7 @@ describe "should be_nil" do
   it "should fail when actual is not nil" do
     lambda {
       :not_nil.should be_nil
-    }.should fail_with("expected nil, got :not_nil")
+    }.should fail_with("expected nil? to return true, got false")
   end
 end
 
@@ -133,7 +149,7 @@ describe "should_not be_nil" do
   it "should fail when actual is nil" do
     lambda {
       nil.should_not be_nil
-    }.should fail_with("expected not nil, got nil")
+    }.should fail_with("expected nil? to return false, got true")
   end
 end
 
@@ -195,7 +211,15 @@ describe "should be ===" do
   end
 
   it "should fail when === operator returns false" do
-    lambda { Hash.should be === "not a hash" }.should fail_with(%[expected === "not a hash", got Hash])
+    lambda { Hash.should be === "not a hash" }.should fail_with(%[expected === not a hash, got Hash])
+  end
+end
+
+describe "should_not with operators" do
+  it "should coach user to stop using operators with should_not" do
+    lambda {
+      5.should_not be < 6
+    }.should raise_error(/not only FAILED,\nit reads really poorly./m)
   end
 end
 
@@ -206,11 +230,11 @@ describe "should be" do
   end
 
   it "should fail if actual is false" do
-    lambda {false.should be}.should fail_with("expected if to be satisfied, got false")
+    lambda {false.should be}.should fail_with("expected true, got false")
   end
 
   it "should fail if actual is nil" do
-    lambda {nil.should be}.should fail_with("expected if to be satisfied, got nil")
+    lambda {nil.should be}.should fail_with("expected true, got nil")
   end
 end
 
@@ -223,6 +247,15 @@ describe "should be(value)" do
   end
 end
 
+describe "'should be' with operator" do
+  it "should include 'be' in the description" do
+    (be > 6).description.should =~ /be > 6/
+    (be >= 6).description.should =~ /be >= 6/
+    (be <= 6).description.should =~ /be <= 6/
+    (be < 6).description.should =~ /be < 6/
+  end
+end
+
 
 describe "arbitrary predicate with DelegateClass" do
   it "should access methods defined in the delegating class (LH[#48])" do

data/spec/spec/matchers/description_generation_spec.rb

@@ -151,3 +151,17 @@ describe "Matchers should be able to generate their own descriptions" do
     end.new
   end
 end
+
+describe "a Matcher with no description" do
+  def matcher
+     Class.new do
+       def matches?(ignore); true; end
+       def failure_message; ""; end
+     end.new
+  end
+  
+  it "should provide a helpful message when used in a string-less example block" do
+    5.should matcher
+    Spec::Matchers.generated_description.should =~ /When you call.*description method/m
+  end
+end

data/spec/spec/matchers/throw_symbol_spec.rb

@@ -2,52 +2,94 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 module Spec
   module Matchers
-    describe ThrowSymbol, "(constructed with no Symbol)" do
-      before(:each) { @matcher = ThrowSymbol.new }
+    describe ThrowSymbol do
+      describe "with no args" do
+        before(:each) { @matcher = ThrowSymbol.new }
 
-      it "should match if any Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_true
+        it "should match if any Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :sym }).should be_true
+        end
+        it "should match if any Symbol is thrown with an arg" do
+          @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+        end
+        it "should not match if no Symbol is thrown" do
+          @matcher.matches?(lambda{ }).should be_false
+        end
+        it "should provide a failure message" do
+          @matcher.matches?(lambda{})
+          @matcher.failure_message.should == "expected a Symbol but nothing was thrown"
+        end
+        it "should provide a negative failure message" do
+          @matcher.matches?(lambda{ throw :sym})
+          @matcher.negative_failure_message.should == "expected no Symbol, got :sym"
+        end
       end
-      it "should not match if no Symbol is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
-      end
-      it "should provide a failure message" do
-        @matcher.matches?(lambda{})
-        @matcher.failure_message.should == "expected a Symbol but nothing was thrown"
-      end
-      it "should provide a negative failure message" do
-        @matcher.matches?(lambda{ throw :sym})
-        @matcher.negative_failure_message.should == "expected no Symbol, got :sym"
-      end
-    end
     
-    describe ThrowSymbol, "(constructed with a Symbol)" do
-      before(:each) { @matcher = ThrowSymbol.new(:sym) }
+      describe "with a symbol" do
+        before(:each) { @matcher = ThrowSymbol.new(:sym) }
       
-      it "should match if correct Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_true
-      end
-      it "should not match if no Symbol is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
+        it "should match if correct Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :sym }).should be_true
+        end
+        it "should match if correct Symbol is thrown with an arg" do
+          @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+        end
+        it "should not match if no Symbol is thrown" do
+          @matcher.matches?(lambda{ }).should be_false
+        end
+        it "should not match if correct Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym }).should be_false
+        end
+        it "should provide a failure message when no Symbol is thrown" do
+          @matcher.matches?(lambda{})
+          @matcher.failure_message.should == "expected :sym but nothing was thrown"
+        end
+        it "should provide a failure message when wrong Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym })
+          @matcher.failure_message.should == "expected :sym, got :other_sym"
+        end
+        it "should provide a negative failure message" do
+          @matcher.matches?(lambda{ throw :sym })
+          @matcher.negative_failure_message.should == "expected :sym not to be thrown"
+        end
+        it "should only match NameErrors raised by uncaught throws" do
+          @matcher.matches?(lambda{ sym }).should be_false
+        end
       end
-      it "should not match if correct Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym }).should be_false
-        @matcher.failure_message.should == "expected :sym, got :other_sym"
-      end
-      it "should provide a failure message when no Symbol is thrown" do
-        @matcher.matches?(lambda{})
-        @matcher.failure_message.should == "expected :sym but nothing was thrown"
-      end
-      it "should provide a failure message when wrong Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym })
-        @matcher.failure_message.should == "expected :sym, got :other_sym"
-      end
-      it "should provide a negative failure message" do
-        @matcher.matches?(lambda{ throw :sym })
-        @matcher.negative_failure_message.should == "expected :sym not to be thrown"
-      end
-      it "should only match NameErrors raised by uncaught throws" do
-        @matcher.matches?(lambda{ sym }).should be_false
+  
+      describe "with a symbol and an arg" do
+        before(:each) { @matcher = ThrowSymbol.new(:sym, "a") }
+    
+        it "should match if correct Symbol and args are thrown" do
+          @matcher.matches?(lambda{ throw :sym, "a" }).should be_true
+        end
+        it "should not match if nothing is thrown" do
+          @matcher.matches?(lambda{ }).should be_false
+        end
+        it "should not match if other Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
+        end
+        it "should not match if no arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym }).should be_false
+        end
+        it "should not match if wrong arg is thrown" do
+          @matcher.matches?(lambda{ throw :sym, "b" }).should be_false
+        end
+        it "should provide a failure message when no Symbol is thrown" do
+          @matcher.matches?(lambda{})
+          @matcher.failure_message.should == %q[expected :sym with "a" but nothing was thrown]
+        end
+        it "should provide a failure message when wrong Symbol is thrown" do
+          @matcher.matches?(lambda{ throw :other_sym })
+          @matcher.failure_message.should == %q[expected :sym with "a", got :other_sym]
+        end
+        it "should provide a negative failure message" do
+          @matcher.matches?(lambda{ throw :sym })
+          @matcher.negative_failure_message.should == %q[expected :sym with "a" not to be thrown]
+        end
+        it "should only match NameErrors raised by uncaught throws" do
+          @matcher.matches?(lambda{ sym }).should be_false
+        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