dchelimsky-rspec 1.1.11 → 1.1.11.1

data/spec/spec/example/example_group_class_definition_spec.rb

@@ -3,8 +3,12 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 module Spec
   module Example
     class ExampleGroupSubclass < ExampleGroup
-      class << self
-        attr_accessor :examples_ran
+      def self.examples_ran
+        @examples_ran
+      end
+
+      def self.examples_ran=(examples_ran)
+        @examples_ran = examples_ran
       end
 
       @@class_variable = :class_variable

data/spec/spec/example/example_group_factory_spec.rb

@@ -146,7 +146,8 @@ module Spec
           end
           Spec::Runner.options.example_groups.should_not include(example_group)
         end
-
+        
+        
         after(:each) do
           Spec::Example::ExampleGroupFactory.reset
         end

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,93 +25,84 @@ 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
             end
 
             describe "when creating a SharedExampleGroup" do
-              attr_reader :name, :shared_example_group
               before(:each) 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
+                @shared_example_group = @example_group.__send__ method, "A Shared ExampleGroup", :shared => true do; end
               end
 
               after(:each) do
-                SharedExampleGroup.clear
+                SharedExampleGroup.instance_eval{@shared_example_groups}.delete @shared_example_group
               end
 
               it "should create a SharedExampleGroup" do
-                SharedExampleGroup.find(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
@@ -138,7 +125,6 @@ module Spec
 
           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
@@ -158,20 +144,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}
+            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
@@ -179,12 +166,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
@@ -198,7 +184,7 @@ module Spec
                 1.should == 1
               end
             end
-            example_group.examples.length.should == 1
+            example_group.should have(1).examples
             example_group.run.should be_true
           end
 
@@ -208,7 +194,7 @@ module Spec
                 1.should == 2
               end
             end
-            example_group.examples.length.should == 1
+            example_group.should have(1).examples
             example_group.run.should be_false
           end
         end
@@ -221,7 +207,7 @@ module Spec
             end
           end
 
-          describe "#set_description(String)" do
+          describe "given a String" do
             before(:each) do
               example_group.set_description("abc")
             end
@@ -235,7 +221,7 @@ module Spec
             end
           end
 
-          describe "#set_description(Type)" do
+          describe "given a Class" do
             before(:each) do
               example_group.set_description(ExampleGroup)
             end
@@ -249,7 +235,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
@@ -263,7 +249,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
@@ -273,7 +259,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
@@ -375,7 +361,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
 
@@ -384,7 +374,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",
@@ -415,64 +405,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
             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
             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
-              class_methods = Module.new do
-                define_method :mod1_method do
-                  mod1_method_called = true
-                end
-              end
-
-              metaclass.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
+            mod_method_called = false
+            mod = Module.new do
               class_methods = Module.new do
-                define_method :mod2_method do
-                  mod2_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
 
-            @example_group.include mod1, mod2
+            @example_group.__send__ :include, mod
 
-            @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") {}
@@ -485,58 +460,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
+            success.should be_true
             Object.const_defined?(:FOO).should == false
           end
         end
 
         describe '#register' do
+          after(:each) do
+            example_group.unregister
+          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 {}
+            example_group.register
             options.example_groups.should include(example_group)
           end
         end
 
         describe '#unregister' do
-          before do
-            options.example_groups.should include(example_group)
+          before(:each) do
+            example_group.register
           end
-
           it "should remove ExampleGroup from set of ExampleGroups to be run" do
             example_group.unregister
             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
             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
+            end
           end
         end
 
@@ -544,13 +515,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
 
@@ -576,7 +545,35 @@ 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
+
       end
     end
   end
-end
+end

data/spec/spec/example/example_group_spec.rb

@@ -449,10 +449,8 @@ module Spec
 
           it "should use a mock framework set up in config" do
             mod = Module.new do
-              class << self
-                def included(mod)
-                  $included_module = mod
-                end
+              def self.included(mod)
+                $included_module = mod
               end
 
               def teardown_mocks_for_rspec
@@ -661,7 +659,7 @@ module Spec
         example_group = Class.new(ExampleSubclass) do
           describe(Array)
         end
-        example_group.send(:described_type).should == Array
+        example_group.__send__(:described_type).should == Array
       end
 
       it "should concat descriptions when nested" do

data/spec/spec/example/example_methods_spec.rb

@@ -134,14 +134,40 @@ module Spec
         end
       end
 
-      describe "#implementation_backtrace" do
-        it "returns the backtrace of where the implementation was defined" do
-          example_group = Class.new(ExampleGroup) do
-            it "should use ExampleMethods callbacks" do
+      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
+        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
-          example = example_group.examples.first
-          example.implementation_backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-4}")
         end
       end
 
@@ -157,26 +183,37 @@ module Spec
       end
       
       describe "#subject" do
-        it "should return an instance variable named after the described type" do
-          example_group = describe(Array) do
-            example {}
+        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
-          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 {}
+      
+          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
-          example_group.examples.first.subject.should be_nil
-        end
-        
-        it "should not barf on a string" do
-          example_group = describe('foo') do
-            example {}
+      
+          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.should be_true
           end
-          example_group.examples.first.subject.should be_nil
         end
       end