rspec 1.1.8 → 1.1.9

data/spec/spec/example/example_methods_spec.rb

@@ -22,116 +22,113 @@ module Spec
       end
 
       describe "lifecycle" do
-        before do
-          @original_rspec_options = Spec::Runner.options
-          @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
-          Spec::Runner.use @options
-          @options.formatters << mock("formatter", :null_object => true)
-          @options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
-          @reporter = FakeReporter.new(@options)
-          @options.reporter = @reporter
-
-          ExampleMethods.before_all_parts.should == []
-          ExampleMethods.before_each_parts.should == []
-          ExampleMethods.after_each_parts.should == []
-          ExampleMethods.after_all_parts.should == []
-          def ExampleMethods.count
-            @count ||= 0
-            @count = @count + 1
-            @count
+        with_sandboxed_options do
+          before do
+            @options.formatters << mock("formatter", :null_object => true)
+            @options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
+            @reporter = FakeReporter.new(@options)
+            @options.reporter = @reporter
+            
+            ExampleGroup.before_all_parts.should == []
+            ExampleGroup.before_each_parts.should == []
+            ExampleGroup.after_each_parts.should == []
+            ExampleGroup.after_all_parts.should == []
+            def ExampleGroup.count
+              @count ||= 0
+              @count = @count + 1
+              @count
+            end
           end
-        end
-
-        after do
-          Spec::Runner.use @original_rspec_options
-          ExampleMethods.instance_variable_set("@before_all_parts", [])
-          ExampleMethods.instance_variable_set("@before_each_parts", [])
-          ExampleMethods.instance_variable_set("@after_each_parts", [])
-          ExampleMethods.instance_variable_set("@after_all_parts", [])
-        end
 
-        it "should pass before and after callbacks to all ExampleGroup subclasses" do
-          ExampleMethods.before(:suite) do
-            ExampleMethods.count.should == 1
+          after do
+            ExampleGroup.instance_variable_set("@before_all_parts", [])
+            ExampleGroup.instance_variable_set("@before_each_parts", [])
+            ExampleGroup.instance_variable_set("@after_each_parts", [])
+            ExampleGroup.instance_variable_set("@after_all_parts", [])
           end
 
-          ExampleMethods.before(:all) do
-            ExampleMethods.count.should == 2
-          end
+          it "should pass before and after callbacks to all ExampleGroup subclasses" do
+            ExampleGroup.before(:suite) do
+              ExampleGroup.count.should == 1
+            end
 
-          ExampleMethods.before(:each) do
-            ExampleMethods.count.should == 3
-          end
+            ExampleGroup.before(:all) do
+              ExampleGroup.count.should == 2
+            end
 
-          ExampleMethods.after(:each) do
-            ExampleMethods.count.should == 4
-          end
+            ExampleGroup.before(:each) do
+              ExampleGroup.count.should == 3
+            end
 
-          ExampleMethods.after(:all) do
-            ExampleMethods.count.should == 5
-          end
+            ExampleGroup.after(:each) do
+              ExampleGroup.count.should == 4
+            end
 
-          ExampleMethods.after(:suite) do
-            ExampleMethods.count.should == 6
-          end
+            ExampleGroup.after(:all) do
+              ExampleGroup.count.should == 5
+            end
 
-          @example_group = Class.new(ExampleGroup) do
-            it "should use ExampleMethods callbacks" do
+            ExampleGroup.after(:suite) do
+              ExampleGroup.count.should == 6
             end
-          end
-          @options.run_examples
-          ExampleMethods.count.should == 7
-        end
 
-        describe "eval_block" do
-          before(:each) do
-            @example_group = Class.new(ExampleGroup)
-          end
-          
-          describe "with a given description" do
-            it "should provide the given description" do
-              @example = @example_group.it("given description") { 2.should == 2 }
-              @example.eval_block
-              @example.description.should == "given description"
+            Class.new(ExampleGroup) do
+              it "should use ExampleMethods callbacks" do end
             end
+            @options.run_examples
+            ExampleGroup.count.should == 7
           end
 
-          describe "with no given description" do
-            it "should provide the generated description" do
-              @example = @example_group.it { 2.should == 2 }
-              @example.eval_block
-              @example.description.should == "should == 2"
+          describe "eval_block" do
+            before(:each) do
+              @example_group = Class.new(ExampleGroup)
             end
-          end
           
-          describe "with no implementation" do
-            it "should raise an NotYetImplementedError" do
-              lambda {
-                @example = @example_group.it
+            describe "with a given description" do
+              it "should provide the given description" do
+                @example = @example_group.it("given description") { 2.should == 2 }
                 @example.eval_block
-              }.should raise_error(Spec::Example::NotYetImplementedError, "Not Yet Implemented")
+                @example.description.should == "given description"
+              end
             end
-            
-            def extract_error(&blk)
-              begin
-                blk.call
-              rescue Exception => e
-                return e
+
+            describe "with no given description" do
+              it "should provide the generated description" do
+                @example = @example_group.it { 2.should == 2 }
+                @example.eval_block
+                @example.description.should == "should == 2"
               end
-              
-              nil
             end
+          
+            describe "with no implementation" do
+              it "should raise an NotYetImplementedError" do
+                lambda {
+                  @example = @example_group.it
+                  @example.eval_block
+                }.should raise_error(Spec::Example::NotYetImplementedError, "Not Yet Implemented")
+              end
             
-            it "should use the proper file and line number for the NotYetImplementedError" do
-              file = __FILE__
-              line_number = __LINE__ + 3
+              def extract_error(&blk)
+                begin
+                  blk.call
+                rescue Exception => e
+                  return e
+                end
               
-              error = extract_error do
-                @example = @example_group.it
-                @example.eval_block
+                nil
               end
+            
+              it "should use the proper file and line number for the NotYetImplementedError" do
+                file = __FILE__
+                line_number = __LINE__ + 3
               
-              error.pending_caller.should == "#{file}:#{line_number}"
+                error = extract_error do
+                  @example = @example_group.it
+                  @example.eval_block
+                end
+              
+                error.pending_caller.should == "#{file}:#{line_number}"
+              end
             end
           end
         end
@@ -159,5 +156,14 @@ module Spec
         end
       end
     end
+
+    describe "#options" do
+      it "should expose the options hash" do
+        example_group = Class.new(ExampleGroup)
+        example = example_group.example "name", :this => 'that' do; end
+        example.options[:this].should == 'that'
+      end
+    end
+
   end
 end

data/spec/spec/example/shared_example_group_spec.rb

@@ -3,262 +3,278 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 module Spec
   module Example
     describe ExampleGroup, "with :shared => true" do
-      include SandboxedOptions
-      attr_reader :formatter, :example_group
-      before(:each) do
-        @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
-        options.formatters << formatter
-        @example_group = Class.new(ExampleGroup).describe("example_group")
-        class << example_group
-          public :include
+      with_sandboxed_options do
+        attr_reader :formatter, :example_group
+        before(:each) do
+          @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
+          options.formatters << formatter
+          @example_group = Class.new(ExampleGroup).describe("example_group")
+          class << example_group
+            public :include
+          end
         end
-      end
 
-      after(:each) do
-        @formatter.rspec_verify
-        @example_group = nil
-        $shared_example_groups.clear unless $shared_example_groups.nil?
-      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
+        after(:each) do
+          @formatter.rspec_verify
+          @example_group = nil
+          Spec::Example::SharedExampleGroup.shared_example_groups.clear
+        end
 
-      def non_shared_example_group()
-        @non_shared_example_group ||= Class.new(ExampleGroup).describe("example_group")
-      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
 
-      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
+        def non_shared_example_group()
+          @non_shared_example_group ||= Class.new(ExampleGroup).describe("example_group")
+        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) {}
+        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
 
-        b1.should_not be(nil)
-        b2.should_not be(nil)
+        it "should return all shared example_groups" do
+          b1 = make_shared_example_group("b1", :shared => true) {}
+          b2 = make_shared_example_group("b2", :shared => true) {}
 
-        SharedExampleGroup.find_shared_example_group("b1").should equal(b1)
-        SharedExampleGroup.find_shared_example_group("b2").should equal(b2)
-      end
+          b1.should_not be(nil)
+          b2.should_not be(nil)
 
-      it "should register as shared example_group" do
-        example_group = make_shared_example_group("example_group") {}
-        SharedExampleGroup.shared_example_groups.should include(example_group)
-      end
+          SharedExampleGroup.find_shared_example_group("b1").should equal(b1)
+          SharedExampleGroup.find_shared_example_group("b2").should equal(b2)
+        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)
-      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)
+        end
 
-      it "should complain when adding a second shared example_group with the same description" do
-        describe "shared example_group", :shared => true do
+        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)
         end
-        lambda do
+
+        it "should complain when adding a second shared example_group with the same description" do
           describe "shared example_group", :shared => true do
           end
-        end.should raise_error(ArgumentError)
-      end
+          lambda do
+            describe "shared example_group", :shared => true do
+            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)
-      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)
+        end
 
-      it "should 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
+        it "should 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
+              end
             end
-          end
-        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(
-          "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)
-        SharedExampleGroup.add_shared_example_group(shared_example_group_2)
-      end
+          end.should_not raise_error(ArgumentError)
+        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(
-          "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
+        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(
+            "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)
           SharedExampleGroup.add_shared_example_group(shared_example_group_2)
-        end.should raise_error(ArgumentError, /already exists/)
-      end
+        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("shared example") {}
-          it("shared example 2") {}
+        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(
+            "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)
+          end.should raise_error(ArgumentError, /already exists/)
         end
 
-        example_group.it("example") {}
-        example_group.number_of_examples.should == 1
-        example_group.it_should_behave_like("shared example_group")
-        example_group.number_of_examples.should == 3
-      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("shared example") {}
+            it("shared example 2") {}
+          end
 
-      it "should add examples to current example_group using include" do
-        shared_example_group = describe "all things", :shared => true do
-          it "should do stuff" do end
+          example_group.it("example") {}
+          example_group.number_of_examples.should == 1
+          example_group.it_should_behave_like("shared example_group")
+          example_group.number_of_examples.should == 3
         end
-        
-        example_group = describe "one thing" do
-          include shared_example_group
-        end
-        
-        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
-        AllThings = describe "all things", :shared => true do
-          it "should do stuff" do 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("shared example 1") {}
+          end
+
+          shared_example_group_1 = make_shared_example_group("shared example_group 2") do
+            it("shared example 2") {}
+          end
+
+          example_group.it("example") {}
+          example_group.number_of_examples.should == 1
+          example_group.it_should_behave_like("shared example_group 1", "shared example_group 2")
+          example_group.number_of_examples.should == 3
         end
+
+        it "should add examples to current example_group using include" do
+          shared_example_group = describe "all things", :shared => true do
+            it "should do stuff" do end
+          end
         
-        example_group = describe "one thing" do
-          it_should_behave_like AllThings
-        end
+          example_group = describe "one thing" do
+            include shared_example_group
+          end
         
-        example_group.number_of_examples.should == 1
-      end
+          example_group.number_of_examples.should == 1
+        end
 
-      it "should run shared examples" do
-        shared_example_ran = false
-        shared_example_group = make_shared_example_group("shared example_group") do
-          it("shared example") { shared_example_ran = true }
+        it "should add 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
+        
+          example_group = describe "one thing" do
+            it_should_behave_like AllThings
+          end
+        
+          example_group.number_of_examples.should == 1
         end
 
-        example_ran = false
+        it "should run shared examples" do
+          shared_example_ran = false
+          shared_example_group = make_shared_example_group("shared example_group") do
+            it("shared example") { shared_example_ran = true }
+          end
 
-        example_group.it_should_behave_like("shared example_group")
-        example_group.it("example") {example_ran = true}
-        example_group.run
-        example_ran.should be_true
-        shared_example_ran.should be_true
-      end
+          example_ran = false
 
-      it "should run setup and teardown 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 }
-          it("shared example") { shared_example_ran = true }
+          example_group.it_should_behave_like("shared example_group")
+          example_group.it("example") {example_ran = true}
+          example_group.run
+          example_ran.should be_true
+          shared_example_ran.should be_true
         end
 
-        example_ran = false
+        it "should run setup and teardown 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 }
+            it("shared example") { shared_example_ran = true }
+          end
 
-        example_group.it_should_behave_like("shared example_group")
-        example_group.it("example") {example_ran = true}
-        example_group.run
-        example_ran.should be_true
-        shared_setup_ran.should be_true
-        shared_teardown_ran.should be_true
-      end
+          example_ran = false
 
-      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
-          before(:all) { shared_before_all_run_count += 1}
-          after(:all) { shared_after_all_run_count += 1}
-          it("shared example") { shared_example_ran = true }
+          example_group.it_should_behave_like("shared example_group")
+          example_group.it("example") {example_ran = true}
+          example_group.run
+          example_ran.should be_true
+          shared_setup_ran.should be_true
+          shared_teardown_ran.should be_true
         end
 
-        example_ran = false
-
-        example_group.it_should_behave_like("shared example_group")
-        example_group.it("example") {example_ran = true}
-        example_group.run
-        example_ran.should be_true
-        shared_before_all_run_count.should == 1
-        shared_after_all_run_count.should == 1
-      end
+        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
+            before(:all) { shared_before_all_run_count += 1}
+            after(:all) { shared_after_all_run_count += 1}
+            it("shared example") { shared_example_ran = true }
+          end
 
-      it "should include modules, included into shared example_group, into current example_group" do
-        @formatter.should_receive(:add_example_group).with(any_args)
+          example_ran = false
 
-        shared_example_group = make_shared_example_group("shared example_group") do
-          it("shared example") { shared_example_ran = true }
+          example_group.it_should_behave_like("shared example_group")
+          example_group.it("example") {example_ran = true}
+          example_group.run
+          example_ran.should be_true
+          shared_before_all_run_count.should == 1
+          shared_after_all_run_count.should == 1
         end
 
-        mod1_method_called = false
-        mod1 = Module.new do
-          define_method :mod1_method do
-            mod1_method_called = true
+        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
+            it("shared example") { shared_example_ran = true }
           end
-        end
 
-        mod2_method_called = false
-        mod2 = Module.new do
-          define_method :mod2_method do
-            mod2_method_called = true
+          mod1_method_called = false
+          mod1 = Module.new do
+            define_method :mod1_method do
+              mod1_method_called = true
+            end
           end
-        end
 
-        shared_example_group.include mod2
+          mod2_method_called = false
+          mod2 = Module.new do
+            define_method :mod2_method do
+              mod2_method_called = true
+            end
+          end
 
-        example_group.it_should_behave_like("shared example_group")
-        example_group.include mod1
+          shared_example_group.__send__ :include, mod2
 
-        example_group.it("test") do
-          mod1_method
-          mod2_method
-        end
-        example_group.run
-        mod1_method_called.should be_true
-        mod2_method_called.should be_true
-      end
+          example_group.it_should_behave_like("shared example_group")
+          example_group.include mod1
 
-      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
-          def a_shared_helper_method
-            "this got defined in a shared example_group"
+          example_group.it("test") do
+            mod1_method
+            mod2_method
           end
+          example_group.run
+          mod1_method_called.should be_true
+          mod2_method_called.should be_true
         end
-        example_group.it_should_behave_like("shared example_group xyz")
-        success = false
-        example_group.it("should access a_shared_helper_method") do
-          a_shared_helper_method
-          success = true
+
+        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
+            def a_shared_helper_method
+              "this got defined in a shared example_group"
+            end
+          end
+          example_group.it_should_behave_like("shared example_group xyz")
+          success = false
+          example_group.it("should access a_shared_helper_method") do
+            a_shared_helper_method
+            success = true
+          end
+          example_group.run
+          success.should be_true
         end
-        example_group.run
-        success.should be_true
-      end
 
-      it "should raise when named shared example_group can not be found" do
-        lambda {
-          example_group.it_should_behave_like("non-existent shared example group")
-          violated
-        }.should raise_error("Shared Example Group 'non-existent shared example group' can not be found")
+        it "should raise when named shared example_group can not be found" do
+          lambda {
+            example_group.it_should_behave_like("non-existent shared example group")
+            violated
+          }.should raise_error("Shared Example Group 'non-existent shared example group' can not be found")
+        end
       end
     end
   end