rspec 1.1.11 → 1.1.12

data/spec/spec/example/example_group_methods_spec.rb

@@ -16,12 +16,8 @@ module Spec
             describe("ExampleGroup")
             it "does nothing"
           end
-          class << example_group
-            public :include
-          end
-          @result = nil
         end
-
+        
         after(:each) do
           ExampleGroup.reset
         end
@@ -29,95 +25,88 @@ module Spec
         ["describe","context"].each do |method|
           describe "##{method}" do
             describe "when creating an ExampleGroup" do
-              attr_reader :child_example_group
-              before do
-                @child_example_group = @example_group.send method, "Another ExampleGroup" do
-                  it "should pass" do
-                    true.should be_true
-                  end
+              before(:each) do
+                @parent_example_group = Class.new(ExampleGroup) do
+                  example "first example" do; end
+                end
+                @child_example_group = @parent_example_group.__send__ method, "Child" do
+                  example "second example" do; end
                 end
               end
 
               it "should create a subclass of the ExampleGroup when passed a block" do
-                child_example_group.superclass.should == @example_group
-                @options.example_groups.should include(child_example_group)
+                @child_example_group.superclass.should == @parent_example_group
+                options.example_groups.should include(@child_example_group)
               end
 
               it "should not inherit examples" do
-                child_example_group.examples.length.should == 1
+                @child_example_group.should have(1).examples
+              end
+              
+              it "records the spec path" do
+                @child_example_group.spec_path.should =~ /#{__FILE__}:#{__LINE__ - 15}/
               end
             end
 
             describe "when creating a SharedExampleGroup" do
-              attr_reader :name, :shared_example_group
-              before do
-                @name = "A Shared ExampleGroup"
-                @shared_example_group = @example_group.send method, name, :shared => true do
-                  it "should pass" do
-                    true.should be_true
-                  end
-                end
+              before(:each) do
+                @shared_example_group = @example_group.__send__ method, "A Shared ExampleGroup", :shared => true do; end
               end
 
-              after do
-                SharedExampleGroup.shared_example_groups.delete_if do |registered_shared_example_group|
-                  registered_shared_example_group == shared_example_group
-                end
+              after(:each) do
+                SharedExampleGroup.instance_eval{@shared_example_groups}.delete @shared_example_group
               end
 
               it "should create a SharedExampleGroup" do
-                SharedExampleGroup.find_shared_example_group(name).should == shared_example_group
+                @shared_example_group.should_not be_nil
+                SharedExampleGroup.find("A Shared ExampleGroup").should == @shared_example_group
               end
             end
 
           end
         end
-    
-        describe "#it" do
-          it "should should create an example instance" do
-            lambda {
-              @example_group.it("")
-            }.should change { @example_group.examples.length }.by(1)
+        
+        [:specify, :it].each do |method|
+          describe "##{method.to_s}" do
+            it "should should create an example" do
+              lambda {
+                @example_group.__send__(method, "")
+              }.should change { @example_group.examples.length }.by(1)
+            end
           end
         end
+        
+        [:xit, :xspecify].each do |method|
+          describe "##{method.to_s}" do
+            before(:each) do
+              Kernel.stub!(:warn)
+            end
 
-        describe "#xit and #xspecify" do
-          before(:each) do
-            Kernel.stub!(:warn)
-          end
-
-          it "should NOT create an example instance" do
-            lambda {
-              @example_group.xit("")
-            }.should_not change(@example_group.examples, :length)
-
-            lambda {
-              @example_group.xspecify("")
-            }.should_not change(@example_group.examples, :length)
-          end
+            it "should NOT create an example" do
+              lambda {
+                @example_group.__send__(method,"")
+              }.should_not change(@example_group.examples, :length)
+            end
 
-          it "should warn that it is disabled" do
-            Kernel.should_receive(:warn).with("Example disabled: foo").twice
-            @example_group.xit("foo")
-            @example_group.xspecify("foo")
+            it "should warn that the example is disabled" do
+              Kernel.should_receive(:warn).with("Example disabled: foo")
+              @example_group.__send__(method,"foo")
+            end
           end
         end
+        
 
         describe "#examples" do
           it "should have Examples" do
             example_group = Class.new(ExampleGroup) do
-              describe('example')
-              it "should pass" do
-                1.should == 1
-              end
+              it "should exist" do; end
             end
             example_group.examples.length.should == 1
-            example_group.examples.first.description.should == "should pass"
+            example_group.examples.first.description.should == "should exist"
           end
 
           it "should not include methods that begin with test (only when TU interop is loaded)" do
             example_group = Class.new(ExampleGroup) do
-              describe('example')
               def test_any_args(*args)
                 true.should be_true
               end
@@ -135,12 +124,11 @@ module Spec
               end
             end
             example_group.examples.length.should == 1
-            example_group.run.should be_true
+            example_group.run(options).should be_true
           end
 
           it "should include methods that begin with should and has an arity of 0 in suite" do
             example_group = Class.new(ExampleGroup) do
-              describe('example')
               def shouldCamelCase
                 true.should be_true
               end
@@ -160,20 +148,21 @@ module Spec
                 raise "This is not a real example"
               end
             end
-            example_group = example_group.dup
-            example_group.examples.length.should == 4
-            descriptions = example_group.examples.collect {|example| example.description}.sort
-            descriptions.should include("shouldCamelCase")
-            descriptions.should include("should_any_args")
-            descriptions.should include("should_something")
-            descriptions.should include("should_not_something")
-            descriptions.should_not include("should")
-            descriptions.should_not include("should_not")
+            example_group.should have(4).examples
+            descriptions = example_group.examples.collect {|example| example.description.to_s}
+            descriptions.should include(
+              "shouldCamelCase",
+              "should_any_args",
+              "should_something",
+              "should_not_something")
+            descriptions.should_not include(
+              "should",
+              "should_not"
+            )
           end
 
           it "should not include methods that begin with test_ and has an arity > 0 in suite" do
             example_group = Class.new(ExampleGroup) do
-              describe('example')
               def test_invalid(foo)
                 1.should == 1
               end
@@ -181,12 +170,11 @@ module Spec
                 1.should == 1
               end
             end
-            example_group.examples.length.should == 0
+            example_group.should have(:no).examples
           end
 
           it "should not include methods that begin with should_ and has an arity > 0 in suite" do
             example_group = Class.new(ExampleGroup) do
-              describe('example')
               def should_invalid(foo)
                 1.should == 2
               end
@@ -200,8 +188,8 @@ module Spec
                 1.should == 1
               end
             end
-            example_group.examples.length.should == 1
-            example_group.run.should be_true
+            example_group.should have(1).examples
+            example_group.run(options).should be_true
           end
 
           it "should run should_methods" do
@@ -210,8 +198,8 @@ module Spec
                 1.should == 2
               end
             end
-            example_group.examples.length.should == 1
-            example_group.run.should be_false
+            example_group.should have(1).examples
+            example_group.run(options).should be_false
           end
         end
 
@@ -223,7 +211,7 @@ module Spec
             end
           end
 
-          describe "#set_description(String)" do
+          describe "given a String" do
             before(:each) do
               example_group.set_description("abc")
             end
@@ -237,7 +225,7 @@ module Spec
             end
           end
 
-          describe "#set_description(Type)" do
+          describe "given a Class" do
             before(:each) do
               example_group.set_description(ExampleGroup)
             end
@@ -251,7 +239,7 @@ module Spec
             end
           end
 
-          describe "#set_description(String, Type)" do
+          describe "given a String and a Class" do
             before(:each) do
               example_group.set_description("behaving", ExampleGroup)
             end
@@ -265,7 +253,7 @@ module Spec
             end
           end
 
-          describe "#set_description(Type, String not starting with a space)" do
+          describe "given a Class and a String (starting with an alpha char)" do
             before(:each) do
               example_group.set_description(ExampleGroup, "behaving")
             end
@@ -275,7 +263,7 @@ module Spec
             end
           end
 
-          describe "#set_description(Type, String starting with .)" do
+          describe "given a Class and a String (starting with a '.')" do
             before(:each) do
               example_group.set_description(ExampleGroup, ".behaving")
             end
@@ -285,27 +273,27 @@ module Spec
             end
           end
 
-          describe "#set_description(Type, String containing .)" do
+          describe "#set_description(Class, String starting with #)" do
             before(:each) do
-              example_group.set_description(ExampleGroup, "calling a.b")
+              example_group.set_description(ExampleGroup, "#behaving")
             end
 
-            specify ".description should return the Type then space then String" do
-              example_group.description.should == "Spec::Example::ExampleGroup calling a.b"
+            specify "should return the Class then String" do
+              example_group.description.should == "Spec::Example::ExampleGroup#behaving"
             end
           end
 
-          describe "#set_description(Type, String starting with .)" do
+          describe "#set_description(Class, String containing .)" do
             before(:each) do
-              example_group.set_description(ExampleGroup, ".behaving")
+              example_group.set_description(ExampleGroup, "calling a.b")
             end
 
-            specify "should return the Type then String" do
-              example_group.description.should == "Spec::Example::ExampleGroup.behaving"
+            specify ".description should return the Type then space then String" do
+              example_group.description.should == "Spec::Example::ExampleGroup calling a.b"
             end
           end
 
-          describe "#set_description(Type, String containing .)" do
+          describe "#set_description(Class, String containing #)" do
             before(:each) do
               example_group.set_description(ExampleGroup, "is #1")
             end
@@ -377,7 +365,11 @@ module Spec
           end
 
           it "should return an Array of the description args from each class in the hierarchy" do
-            child_example_group = Class.new(example_group)
+            parent_example_group = Class.new(ExampleGroup) do
+              describe("Parent")
+            end
+            
+            child_example_group = Class.new(parent_example_group)
             child_example_group.describe("Child", ExampleGroup)
             child_example_group.description.should_not be_empty
 
@@ -386,7 +378,7 @@ module Spec
             grand_child_example_group.description.should_not be_empty
 
             grand_child_example_group.description_parts.should == [
-              "ExampleGroup",
+              "Parent",
               "Child",
               Spec::Example::ExampleGroup,
               "GrandChild",
@@ -417,64 +409,49 @@ module Spec
         describe "#remove_after" do
           it "should unregister a given after(:each) block" do
             after_all_ran = false
-            @example_group.it("example") {}
             proc = Proc.new { after_all_ran = true }
-            ExampleGroup.after(:each, &proc)
-            @example_group.run
+
+            example_group = Class.new(ExampleGroup) do
+              specify("example") {}
+              after(:each, &proc)
+            end
+
+            example_group.run(options)
             after_all_ran.should be_true
 
             after_all_ran = false
-            ExampleGroup.remove_after(:each, &proc)
-            @example_group.run
+            example_group.remove_after(:each, &proc)
+            example_group.run(options)
             after_all_ran.should be_false
           end
         end
 
         describe "#include" do
           it "should have accessible class methods from included module" do
-            mod1_method_called = false
-            mod1 = Module.new do
-              extend Spec::MetaClass
+            mod_method_called = false
+            mod = Module.new do
               class_methods = Module.new do
-                define_method :mod1_method do
-                  mod1_method_called = true
+                define_method :mod_method do
+                  mod_method_called = true
                 end
               end
 
-              metaclass.class_eval do
+              self.class.class_eval do
                 define_method(:included) do |receiver|
                   receiver.extend class_methods
                 end
               end
             end
 
-            mod2_method_called = false
-            mod2 = Module.new do
-              extend Spec::MetaClass
-              class_methods = Module.new do
-                define_method :mod2_method do
-                  mod2_method_called = true
-                end
-              end
-
-              metaclass.class_eval do
-                define_method(:included) do |receiver|
-                  receiver.extend class_methods
-                end
-              end
-            end
+            @example_group.__send__ :include, mod
 
-            @example_group.include mod1, mod2
-
-            @example_group.mod1_method
-            @example_group.mod2_method
-            mod1_method_called.should be_true
-            mod2_method_called.should be_true
+            @example_group.mod_method
+            mod_method_called.should be_true
           end
         end
 
         describe "#number_of_examples" do
-          it "should count number of specs" do
+          it "should count number of examples" do
             proc do
               @example_group.it("one") {}
               @example_group.it("two") {}
@@ -487,58 +464,54 @@ module Spec
         describe "#class_eval" do
           it "should allow constants to be defined" do
             example_group = Class.new(ExampleGroup) do
-              describe('example')
               FOO = 1
               it "should reference FOO" do
                 FOO.should == 1
               end
             end
-            example_group.run
+            success = example_group.run(options)
+            success.should be_true
             Object.const_defined?(:FOO).should == false
           end
         end
 
         describe '#register' do
+          after(:each) do
+            Spec::Runner.options.remove_example_group example_group
+          end
           it "should add ExampleGroup to set of ExampleGroups to be run" do
-            options.example_groups.delete(example_group)
-            options.example_groups.should_not include(example_group)
-          
-            example_group.register {}
+            Spec::Runner.options.add_example_group example_group
             options.example_groups.should include(example_group)
           end
         end
 
         describe '#unregister' do
-          before do
-            options.example_groups.should include(example_group)
+          before(:each) do
+            Spec::Runner.options.add_example_group example_group
           end
-
           it "should remove ExampleGroup from set of ExampleGroups to be run" do
-            example_group.unregister
+            Spec::Runner.options.remove_example_group example_group
             options.example_groups.should_not include(example_group)
           end
         end
-
-        describe "#registration_backtrace" do
-          it "returns the backtrace of where the ExampleGroup was registered" do
-            example_group = Class.new(ExampleGroup)
-            example_group.registration_backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-1}")
-          end
-        end
       
         describe "#run" do
-          it "should add_example_group if there are any examples to run" do
-            example_group = Class.new(ExampleGroup) do
-              it "should do something" do end
+          describe "given an example group with at least one example" do
+            it "should call add_example_group" do
+              example_group = Class.new(ExampleGroup) do
+                example("anything") {}
+              end
+              reporter.should_receive(:add_example_group)
+              example_group.run(options)
             end
-            reporter.should_receive(:add_example_group)
-            example_group.run
           end
 
-          it "should NOT add_example_group if there are no examples to run" do
-            example_group = Class.new(ExampleGroup) do end
-            reporter.should_not_receive(:add_example_group)
-            example_group.run
+          describe "given an example group with no examples" do
+            it "should NOT call add_example_group" do
+              example_group = Class.new(ExampleGroup) do end
+              reporter.should_not_receive(:add_example_group)
+              example_group.run(options)
+            end
           end
         end
 
@@ -546,13 +519,11 @@ module Spec
           it "should call new and matches? on the class used for matching examples" do 
             example_group = Class.new(ExampleGroup) do
               it "should do something" do end
-              class << self
-                def specified_examples
-                  ["something"]
-                end
-                def to_s
-                  "TestMatcher"
-                end
+              def self.specified_examples
+                ["something"]
+              end
+              def self.to_s
+                "TestMatcher"
               end
             end
 
@@ -560,12 +531,12 @@ module Spec
             matcher.should_receive(:matches?).with(["something"]).any_number_of_times
           
             matcher_class = Class.new
-            matcher_class.should_receive(:new).with("TestMatcher", "should do something").twice.and_return(matcher)
+            matcher_class.should_receive(:new).with("TestMatcher", "should do something").and_return(matcher)
 
             begin 
               ExampleGroupMethods.matcher_class = matcher_class
 
-              example_group.run
+              example_group.run(options)
             ensure 
               ExampleGroupMethods.matcher_class = ExampleMatcher
             end
@@ -578,7 +549,86 @@ module Spec
             group.options[:this].should == 'hash'
           end
         end
+
+        describe "#backtrace" do        
+          it "returns the backtrace from where the example group was defined" do
+            example_group = Class.new(ExampleGroup).describe("foo") do
+              example "bar" do; end
+            end
+            example_group.backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-3}")
+          end
+        end
+
+        describe "#example_group_backtrace (deprecated)" do        
+          before(:each) do
+            Kernel.stub!(:warn)
+          end
+          it "sends a deprecation warning" do
+            example_group = Class.new(ExampleGroup) {}
+            Kernel.should_receive(:warn).with(/#example_group_backtrace.*deprecated.*#backtrace instead/m)
+            example_group.example_group_backtrace
+          end
+
+          it "returns the backtrace from where the example group was defined" do
+            example_group = Class.new(ExampleGroup).describe("foo") do
+              example "bar" do; end
+            end
+            example_group.example_group_backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-3}")
+          end
+        end
+        
+        describe "#before" do
+          it "stores before(:each) blocks" do
+            example_group = Class.new(ExampleGroup) {}
+            block = lambda {}
+            example_group.before(:each, &block)
+            example_group.before_each_parts.should include(block)
+          end
+
+          it "stores before(:all) blocks" do
+            example_group = Class.new(ExampleGroup) {}
+            block = lambda {}
+            example_group.before(:all, &block)
+            example_group.before_all_parts.should include(block)
+          end
+
+          it "stores before(:suite) blocks" do
+            example_group = Class.new(ExampleGroup) {}
+            parts = []
+            ExampleGroupMethods.stub!(:before_suite_parts).and_return(parts)
+            block = lambda {}
+            example_group.before(:suite, &block)
+            example_group.before_suite_parts.should include(block)
+          end
+        end
+
+        
+        describe "#after" do
+          it "stores after(:each) blocks" do
+            example_group = Class.new(ExampleGroup) {}
+            block = lambda {}
+            example_group.after(:each, &block)
+            example_group.after_each_parts.should include(block)
+          end
+
+          it "stores after(:all) blocks" do
+            example_group = Class.new(ExampleGroup) {}
+            block = lambda {}
+            example_group.after(:all, &block)
+            example_group.after_all_parts.should include(block)
+          end
+
+          it "stores after(:suite) blocks" do
+            example_group = Class.new(ExampleGroup) {}
+            parts = []
+            ExampleGroupMethods.stub!(:after_suite_parts).and_return(parts)
+            block = lambda {}
+            example_group.after(:suite, &block)
+            example_group.after_suite_parts.should include(block)
+          end
+        end
+
       end
     end
   end
-end
+end