rspec 1.1.12 → 1.2.0

data/spec/spec/example/example_group_spec.rb

@@ -7,9 +7,7 @@ module Spec
 
       module Foo
         module Bar
-          def self.loaded?
-            true
-          end
+          def self.loaded?; true; end
         end
       end
       include Foo
@@ -18,11 +16,23 @@ module Spec
         Bar.should be_loaded
       end
 
-      @@foo = 1
+      @@class_variable = "a class variable"
 
-      it "should allow class variables to be defined" do
-        @@foo.should == 1
+      it "can access class variables in examples in Ruby 1.8" do
+        with_ruby 1.8 do
+          @@class_variable.should == "a class variable"
+        end
+      end
+      
+      it "can NOT access class variables in examples in Ruby 1.9" do
+        with_ruby 1.9 do
+          lambda do
+            @@class_variable.should == "a class variable"
+          end.should raise_error(NameError)
+        end
       end
+      
+      
     end
 
     class ExampleClassVariablePollutionSpec < ExampleGroup
@@ -30,7 +40,7 @@ module Spec
 
       it "should not retain class variables from other Example classes" do
         proc do
-          @@foo
+          @@class_variable
         end.should raise_error
       end
     end
@@ -74,7 +84,7 @@ module Spec
           options.backtrace_tweaker = mock("backtrace_tweaker", :null_object => true)
           @reporter = FakeReporter.new(options)
           options.reporter = reporter
-          @example_group = Class.new(ExampleGroup) do
+          @example_group = Class.new(ExampleGroupDouble) do
             describe("example")
             it "does nothing" do
             end
@@ -89,7 +99,7 @@ module Spec
         end
 
         it "should not run when there are no examples" do
-          example_group = Class.new(ExampleGroup) do
+          example_group = Class.new(ExampleGroupDouble) do
             describe("Foobar")
           end
           example_group.examples.should be_empty
@@ -164,7 +174,7 @@ module Spec
           describe "when specified_examples matches entire ExampleGroup" do
             before do
               examples_that_were_run = @examples_that_were_run
-              @example_group = Class.new(ExampleGroup) do
+              @example_group = Class.new(ExampleGroupDouble) do
                 describe("the ExampleGroup")
                 it("should be run") do
                   examples_that_were_run << 'should be run'
@@ -186,7 +196,7 @@ module Spec
           describe ExampleGroup, "#run when specified_examples matches only Example description" do
             before do
               examples_that_were_run = @examples_that_were_run
-              @example_group = Class.new(ExampleGroup) do
+              @example_group = Class.new(ExampleGroupDouble) do
                 describe("example")
                 it("should be run") do
                   examples_that_were_run << 'should be run'
@@ -204,7 +214,7 @@ module Spec
           describe ExampleGroup, "#run when specified_examples does not match an Example description" do
             before do
               examples_that_were_run = @examples_that_were_run
-              @example_group = Class.new(ExampleGroup) do
+              @example_group = Class.new(ExampleGroupDouble) do
                 describe("example")
                 it("should be something else") do
                   examples_that_were_run << 'should be something else'
@@ -222,7 +232,7 @@ module Spec
           describe ExampleGroup, "#run when specified_examples matches an Example description" do
             before do
               examples_that_were_run = @examples_that_were_run
-              @example_group = Class.new(ExampleGroup) do
+              @example_group = Class.new(ExampleGroupDouble) do
                 describe("example")
                 it("should be run") do
                   examples_that_were_run << 'should be run'
@@ -234,22 +244,18 @@ module Spec
               options.parse_example "should be run"
             end
 
-            it "should run only the example, when there is only one" do
+            it "should run only the example" do
               example_group.run(options)
               examples_that_were_run.should == ["should be run"]
             end
-
-            it "should run only the one example" do
-              example_group.run(options)
-              examples_that_were_run.should == ["should be run"]          end
           end
         end
 
         describe ExampleGroup, "#run with success" do
           before do
-            @special_example_group = Class.new(ExampleGroup)
+            @special_example_group = Class.new(ExampleGroupDouble)
             ExampleGroupFactory.register(:special, @special_example_group)
-            @not_special_example_group = Class.new(ExampleGroup)
+            @not_special_example_group = Class.new(ExampleGroupDouble)
             ExampleGroupFactory.register(:not_special, @not_special_example_group)
           end
 
@@ -317,7 +323,7 @@ module Spec
             @special_example_group.before(:all) { fiddle << "Example.before(:all, :type => :special)" }
             @special_example_group.prepend_before(:all) { fiddle << "Example.prepend_before(:all, :type => :special)" }
 
-            example_group = Class.new(ExampleGroup) do
+            example_group = Class.new(ExampleGroupDouble) do
               describe("I'm not special", :type => :not_special)
               it "does nothing"
             end
@@ -434,47 +440,6 @@ module Spec
             example_group.included_modules.should_not include(mod3)
           end
 
-          it "should include any predicate_matchers included using configuration" do
-            $included_predicate_matcher_found = false
-            Spec::Runner.configuration.predicate_matchers[:do_something] = :does_something?
-            example_group = Class.new(ExampleGroup) do
-              describe('example')
-              it "should respond to do_something" do
-                $included_predicate_matcher_found = respond_to?(:do_something)
-              end
-            end
-            example_group.run(options)
-            $included_predicate_matcher_found.should be(true)
-          end
-
-          it "should use a mock framework set up in config" do
-            mod = Module.new do
-              def self.included(mod)
-                $included_module = mod
-              end
-
-              def teardown_mocks_for_rspec
-                $torn_down = true
-              end
-            end
-
-            begin
-              $included_module = nil
-              $torn_down = true
-              Spec::Runner.configuration.mock_with mod
-
-              example_group = Class.new(ExampleGroup) do
-                describe('example')
-                it "does nothing"
-              end
-              example_group.run(options)
-
-              $included_module.should_not be_nil
-              $torn_down.should == true
-            ensure
-              Spec::Runner.configuration.mock_with :rspec
-            end
-          end
         end
 
         describe ExampleGroup, "#run with pending example that has a failing assertion" do
@@ -534,7 +499,7 @@ module Spec
           end
 
           it "should supply before(:all) as description" do
-            @reporter.should_receive(:failure) do |example, error|
+            @reporter.should_receive(:example_failed) do |example, error|
               example.description.should eql("before(:all)")
               error.message.should eql("before(:all) failure")
             end
@@ -647,28 +612,16 @@ module Spec
       end
     end
 
-    class ExampleSubclass < ExampleGroup
-    end
-
     describe ExampleGroup, "subclasses" do
-      after do
-        ExampleGroupFactory.reset
-      end
-
       it "should have access to the described_type" do
-        example_group = Class.new(ExampleSubclass) do
-          describe(Array)
-        end
+        example_group = Class.new(ExampleGroupDouble).describe(Array)
         example_group.__send__(:described_type).should == Array
       end
 
       it "should concat descriptions when nested" do
-        example_group = Class.new(ExampleSubclass) do
-          describe(Array)
-          $nested_group = describe("when empty") do
-          end
-        end
-        $nested_group.description.to_s.should == "Array when empty"
+        example_group = Class.new(ExampleGroupDouble).describe(Array)
+        nested_group = example_group.describe("when empty") do; end
+        nested_group.description.to_s.should == "Array when empty"
       end
     end
   end

data/spec/spec/example/example_matcher_spec.rb

@@ -3,52 +3,52 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 module Spec
   module Example
     describe ExampleMatcher, "#matches?" do
-      def match_description(description)
+      def match_examples(examples)
         simple_matcher do |actual, matcher|
           matcher.failure_message = "expected matcher.matches?(#{description.inspect}) to return true, got false"
           matcher.negative_failure_message = "expected matcher.matches?(#{description.inspect}) to return false, got true"
-          actual.matches?(description)
+          actual.matches?(examples)
         end
       end
       
       it "should match correct example_group and example" do
         matcher = ExampleMatcher.new("example_group", "example")
-        matcher.should match_description("example_group example")
+        matcher.should match_examples(["example_group example"])
       end
       
       it "should not match wrong example" do
         matcher = ExampleMatcher.new("example_group", "other example")
-        matcher.should_not match_description("example_group example")
+        matcher.should_not match_examples(["example_group example"])
       end
       
       it "should not match wrong example_group" do
         matcher = ExampleMatcher.new("other example_group", "example")
-        matcher.should_not match_description("example_group example")
+        matcher.should_not match_examples(["example_group example"])
       end
       
       it "should match example only" do
         matcher = ExampleMatcher.new("example_group", "example")
-        matcher.should match_description("example")
+        matcher.should match_examples(["example"])
       end
 
       it "should match example_group only" do
         matcher = ExampleMatcher.new("example_group", "example")
-        matcher.should match_description("example_group")
+        matcher.should match_examples(["example_group"])
       end
 
       it "should match example_group ending with before(:all)" do
         matcher = ExampleMatcher.new("example_group", "example")
-        matcher.should match_description("example_group before(:all)")
+        matcher.should match_examples(["example_group before(:all)"])
       end
       
       it "should escape regexp chars" do
         matcher = ExampleMatcher.new("(con|text)", "[example]")
-        matcher.should_not match_description("con p")
+        matcher.should_not match_examples(["con p"])
       end
       
       it "should match when example_group is modularized" do
         matcher = ExampleMatcher.new("MyModule::MyClass", "example")
-        matcher.should match_description("MyClass example")
+        matcher.should match_examples(["MyClass example"])
       end      
     end
 

data/spec/spec/example/example_methods_spec.rb

@@ -1,288 +1,154 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
+class Thing
+  attr_reader :arg
+  def initialize(arg=nil)
+    @arg = arg || :default
+  end
+  def ==(other)
+    @arg == other.arg
+  end
+  def eql?(other)
+    @arg == other.arg
+  end
+end
+
 module Spec
   module Example
-    module ModuleThatIsReopened
-    end
-
-    module ExampleMethods
-      include ModuleThatIsReopened
-    end
+    describe ExampleMethods do
+      module ModuleThatIsReopened; end
 
-    module ModuleThatIsReopened
-      def module_that_is_reopened_method
+      module Spec::Example::ExampleMethods
+        include ModuleThatIsReopened
       end
-    end
 
-    describe ExampleMethods do
+      module ModuleThatIsReopened
+        def module_that_is_reopened_method; end
+      end
+      
       describe "with an included module that is reopened" do
         it "should have repoened methods" do
           method(:module_that_is_reopened_method).should_not be_nil
         end
       end
 
-      describe "lifecycle" do
-        with_sandboxed_options do
-          with_sandboxed_config 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
-            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
-
-          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"
-              end
-            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"
-              end
-            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
-            
-              def extract_error(&blk)
-                begin
-                  blk.call
-                rescue Exception => e
-                  return e
-                end
-              
-                nil
-              end
-            
-              it "should use the proper file and line number for the NotYetImplementedError" do
-                file = __FILE__
-                line_number = __LINE__ + 3
-              
-                error = extract_error do
-                  @example = @example_group.it
-                  @example.eval_block
-                end
-              
-                error.pending_caller.should =~ /#{file}:#{line_number}/
-              end
-            end
-          end
-        end
-      end
-
       describe "#backtrace" do        
-        with_sandboxed_options do
-          it "returns the backtrace from where the example was defined" do
-            example_group = Class.new(ExampleGroup) do
-              example "of something" do; end
-            end
-            
-            example = example_group.examples.first
-            example.backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-4}")
-          end
+        it "returns the backtrace from where the example was defined" do
+          example = ExampleGroup.dup.new "name"
+          example.backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-1}")
         end
       end
       
       describe "#implementation_backtrace (deprecated)" do
-        with_sandboxed_options do
-          before(:each) do
-            Kernel.stub!(:warn)
-          end
-
-          it "sends a deprecation warning" do
-            example_group = Class.new(ExampleGroup) {}
-            example = example_group.example("") {}
-            Kernel.should_receive(:warn).with(/#implementation_backtrace.*deprecated.*#backtrace instead/m)
-            example.implementation_backtrace
-          end
-          
-          it "returns the backtrace from where the example was defined" do
-            example_group = Class.new(ExampleGroup) do
-              example "of something" do; end
-            end
-            
-            example = example_group.examples.first
-            example.backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-4}")
-          end
+        before(:each) do
+          Kernel.stub!(:warn)
         end
-      end
 
-      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"
+        it "sends a deprecation warning" do
+          Kernel.should_receive(:warn).with(/#implementation_backtrace.*deprecated.*#backtrace instead/m)
+          example = ExampleGroup.dup.new "name"
+          example.implementation_backtrace
         end
-      end
-      
-      describe "#subject" do
-        with_sandboxed_options do
-          it "should return an instance variable named after the described type" do
-            example_group = Class.new(ExampleGroup).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 = Class.new(ExampleGroup).describe('foo') do
-              example {}
-            end
-            example_group.examples.first.subject.should be_nil
-          end
-      
-          it "should interact with the same scope as the before block" do
-            example_group = Class.new(ExampleGroup) do
-              subject { @foo = 'foo'}
-              example { should == @foo}
-              it { should == 'foo'}
-            end
-            example_group.run(options).should be_true
-          end
+        
+        it "returns the backtrace from where the example was defined" do
+          example = ExampleGroup.dup.new "name"
+          example.implementation_backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-1}")
         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
+      describe "#subject" do
+        before(:each) do
+          @example_group = ExampleGroupDouble
+        end
 
-            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(options)
-            end
+        it "should return an instance of the described class" do
+          group = Class.new(ExampleGroupDouble).describe(Array)
+          example = group.new("")
+          example.subject.should == []
+        end
+    
+        it "should return a Module" do
+          group = Class.new(ExampleGroupDouble).describe(Enumerable)
+          example = group.new("")
+          example.subject.should == Enumerable
+        end
 
-            it "should create an example using the description from the matcher" do
-              example.description.should == 'should eql "expected"'
-            end
+        it "should return a string" do
+          group = Class.new(ExampleGroupDouble).describe('foo')
+          example = group.new("")
+          example.subject.should == 'foo'
+        end
 
-            it "should test the matcher returned from the block" do
-              success.should be_true
-            end
-          end
+        it "should return a number" do
+          group = Class.new(ExampleGroupDouble).describe(15)
+          example = group.new("")
+          example.subject.should == 15
+        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(options)
-              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(options)
-              example.description.should =~ /should == #<Spec::Example::Thing/
-              success.should be_true
-            end
+      describe "#should" do
+        before(:each) do
+          @example_group = Class.new(ExampleGroupDouble)
+          @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
+        end
+        
+        context "in an ExampleGroup with an implicit subject" do
+          it "delegates matcher to the implied subject" do
+            @example_group.describe(::Thing)
+            @example_group.example { should == ::Thing.new(:default) }
+            @example_group.example { should eql(::Thing.new(:default)) }
+            @example_group.run(@options).should be_true
           end
-          
-          after(:each) do
-            ExampleGroup.reset
+        end
+        
+        context "in an ExampleGroup using an explicit subject" do
+          it "delegates matcher to the declared subject" do
+            @example_group.describe(::Thing)
+            @example_group.subject { ::Thing.new(:other) }
+            @example_group.example { should == ::Thing.new(:other) }
+            @example_group.example { should eql(::Thing.new(:other)) }
+            @example_group.run(@options).should be_true
           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(options)
-          end
-
-          it "should create an example using the description from the matcher" do
-            example.description.should == 'should not eql "unexpected"'
-          end
+        before(:each) do
+          @example_group = Class.new(ExampleGroupDouble)
+        end
 
-          it "should test the matcher returned from the block" do
-            success.should be_true
+        context "in an ExampleGroup with an implicit subject" do
+          it "delegates matcher to the implied subject" do
+            @example_group.describe(::Thing)
+            @example_group.example { should_not == ::Thing.new(:other) }
+            @example_group.example { should_not eql(::Thing.new(:other)) }
+            @example_group.run(::Spec::Runner::Options.new(StringIO.new, StringIO.new)).should be_true
           end
-
-          after do
-            ExampleGroup.reset
+        end
+        
+        context "in an ExampleGroup using an explicit subject" do
+          it "delegates matcher to the declared subject" do
+            @example_group.describe(::Thing)
+            @example_group.subject { ::Thing.new(:other) }
+            @example_group.example { should_not == ::Thing.new(:default) }
+            @example_group.example { should_not eql(::Thing.new(:default)) }
+            @example_group.run(::Spec::Runner::Options.new(StringIO.new, StringIO.new)).should be_true
           end
-
         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 = ExampleGroupDouble.new "name", :this => 'that' do; end
+        example.options[:this].should == 'that'
+      end
+    end
+    
+    describe "#set_instance_variables_from_hash" do
+      it "preserves the options" do
+        example = ExampleGroupDouble.new "name", :this => 'that' do; end
+        example.set_instance_variables_from_hash({:@_options => {}})
         example.options[:this].should == 'that'
       end
     end