rspec-core 2.0.0.beta.7 → 2.0.0.beta.8

data/spec/rspec/core/example_spec.rb

@@ -1,44 +1,41 @@
 require 'spec_helper'
 
 describe Rspec::Core::Example, :parent_metadata => 'sample' do
+  let(:example_group) do
+    Rspec::Core::ExampleGroup.describe('group description')
+  end
 
-  before do
-    example_group = stub('example_group', 
-      :metadata => Rspec::Core::Metadata.new.process(
-        'group description',
-        :caller => ['foo_spec.rb:37']
-      )
-    ).as_null_object 
-    @example = Rspec::Core::Example.new(example_group, 'example description', {}, (lambda {}))
+  let(:example) do
+    example_group.example('example description')
   end
 
   describe "attr readers" do
     it "should have one for the parent example group" do
-      @example.should respond_to(:example_group)
+      example.should respond_to(:example_group)
     end
 
     it "should have one for it's description" do
-      @example.should respond_to(:description)
+      example.should respond_to(:description)
     end
 
     it "should have one for it's metadata" do
-      @example.should respond_to(:metadata)
+      example.should respond_to(:metadata)
     end
 
     it "should have one for it's block" do
-      @example.should respond_to(:example_block)
+      example.should respond_to(:example_block)
     end
   end
 
   describe '#inspect' do
     it "should return 'group description - description'" do
-      @example.inspect.should == 'group description example description'
+      example.inspect.should == 'group description example description'
     end
   end
 
   describe '#to_s' do
     it "should return #inspect" do
-      @example.to_s.should == @example.inspect
+      example.to_s.should == example.inspect
     end
   end
 
@@ -60,9 +57,34 @@ describe Rspec::Core::Example, :parent_metadata => 'sample' do
   end
 
   describe "#run" do
-    pending "should run after(:each) when the example fails"
+    it "runs after(:each) when the example passes" do
+      after_run = false
+      group = Rspec::Core::ExampleGroup.describe do
+        after(:each) { after_run = true }
+        example('example') { 1.should == 1 }
+      end
+      group.run_all
+      after_run.should be_true, "expected after(:each) to be run"
+    end
 
-    pending "should run after(:each) when the example raises an Exception" 
-  end
+    it "runs after(:each) when the example fails" do
+      after_run = false
+      group = Rspec::Core::ExampleGroup.describe do
+        after(:each) { after_run = true }
+        example('example') { 1.should == 2 }
+      end
+      group.run_all
+      after_run.should be_true, "expected after(:each) to be run"
+    end
 
+    it "runs after(:each) when the example raises an Exception" do
+      after_run = false
+      group = Rspec::Core::ExampleGroup.describe do
+        after(:each) { after_run = true }
+        example('example') { raise "this error" } 
+      end
+      group.run_all
+      after_run.should be_true, "expected after(:each) to be run"
+    end
+  end
 end

data/spec/rspec/core/formatters/helpers_spec.rb

@@ -5,9 +5,10 @@ describe Rspec::Core::Formatters::Helpers do
   let(:helper) { helper = Object.new.extend(Rspec::Core::Formatters::Helpers) }
 
   describe "format seconds" do
-    pending "uses passed in precision if specified" do
-      # can't get regex right to handle this case where we don't want it to consume all zeroes
-      helper.format_seconds(0.00005, 2).should == "0.00"
+    it "uses passed in precision if specified" do
+      pending("get regex right to handle this case where we don't want it to consume all zeroes") do
+        helper.format_seconds(0.00005, 2).should == "0.00"
+      end
     end
     
     context "sub second times" do
@@ -35,4 +36,4 @@ describe Rspec::Core::Formatters::Helpers do
   end
 
   
-end
+end

data/spec/rspec/core/let_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe "#let" do
+  let(:counter) do
+    Class.new do
+      def initialize
+        @count = 0
+      end
+      def count
+        @count += 1
+      end
+    end.new
+  end
+
+  it "generates an instance method" do
+    counter.count.should == 1
+  end
+
+  it "caches the value" do
+    counter.count.should == 1
+    counter.count.should == 2
+  end
+end
+
+describe "#let!" do
+  let!(:creator) do
+    class Creator
+      @count = 0
+      def self.count
+        @count += 1
+      end
+    end
+  end
+
+  it "evaluates the value non-lazily" do
+    lambda { Creator.count }.should_not raise_error
+  end
+
+  it "does not interfere between tests" do 
+    Creator.count.should == 1
+  end
+end

data/spec/rspec/core/pending_example_spec.rb

@@ -1,19 +1,85 @@
 require 'spec_helper'
 
-Rspec::Matchers.define :be_pending do
+Rspec::Matchers.define :be_pending_with do |message|
   match do |example|
-    example.metadata[:pending]
+    example.metadata[:pending] && example.metadata[:execution_result][:pending_message] == message
+  end
+
+  failure_message_for_should do |example|
+    "expected example to pending with #{message.inspect}, got #{example.metadata[:execution_result][:pending_message].inspect}"
   end
 end
 
 describe "an example" do
   context "with no block" do
-    it "is listed as pending" do
-      group = Rspec::Core::ExampleGroup.create('group') do
+    it "is listed as pending with 'Not Yet Implemented'" do
+      group = Rspec::Core::ExampleGroup.describe('group') do
         it "has no block" 
       end
-      group.run(stub('reporter').as_null_object)
-      group.examples.first.should be_pending
+      example = group.examples.first
+      example.run(group.new, stub.as_null_object)
+      example.should be_pending_with('Not Yet Implemented')
+    end
+  end
+
+  context "with no args" do
+    it "is listed as pending with 'No reason given'" do
+      group = Rspec::Core::ExampleGroup.describe('group') do
+        it "does something" do
+          pending
+        end
+      end
+      example = group.examples.first
+      example.run(group.new, stub.as_null_object)
+      example.should be_pending_with('No reason given')
+    end
+  end
+
+  context "with a message" do
+    it "is listed as pending with the supplied message" do
+      group = Rspec::Core::ExampleGroup.describe('group') do
+        it "does something" do
+          pending("just because")
+        end
+      end
+      example = group.examples.first
+      example.run(group.new, stub.as_null_object)
+      example.should be_pending_with('just because')
     end
   end
+
+  context "with a block" do
+    context "that fails" do
+      it "is listed as pending with the supplied message" do
+        group = Rspec::Core::ExampleGroup.describe('group') do
+          it "does something" do
+            pending("just because") do
+              3.should == 4
+            end
+          end
+        end
+        example = group.examples.first
+        example.run(group.new, stub.as_null_object)
+        example.should be_pending_with('just because')
+      end
+    end
+
+    context "that passes" do
+      it "raises a PendingExampleFixedError" do
+        group = Rspec::Core::ExampleGroup.describe('group') do
+          it "does something" do
+            pending("just because") do
+              3.should == 3
+            end
+          end
+        end
+        example = group.examples.first
+        example.run(group.new, stub.as_null_object)
+        example.metadata[:pending].should be_false
+        example.metadata[:execution_result][:status].should == 'failed'
+        example.metadata[:execution_result][:exception_encountered].should be_a(Rspec::Core::PendingExampleFixedError)
+      end
+    end
+  end
+
 end

data/spec/rspec/core/shared_example_group_spec.rb

@@ -17,7 +17,7 @@ module Rspec::Core
     end
 
     it "should raise an ArgumentError when adding a second shared example group with the same name" do
-      group = ExampleGroup.create('example group')
+      group = ExampleGroup.describe('example group')
       group.share_examples_for('really important business value') { }
       lambda do
         group.share_examples_for('really important business value') { }
@@ -35,14 +35,8 @@ module Rspec::Core
 
     describe "including shared example_groups using #it_should_behave_like" do
 
-      def cleanup_shared_example_groups
-        original_shared_example_groups = Rspec::Core.world.shared_example_groups
-        yield if block_given?
-        Rspec::Core.world.shared_example_groups.replace(original_shared_example_groups)
-      end
-
       it "should make any shared example_group available at the correct level", :ruby => 1.8 do
-        group = ExampleGroup.create('fake group')
+        group = ExampleGroup.describe('fake group')
         block = lambda {
           def self.class_helper; end
           def extra_helper; end
@@ -54,163 +48,153 @@ module Rspec::Core
       end
 
       it "should make any shared example_group available at the correct level", :ruby => 1.9 do
-        group = ExampleGroup.create('fake group')
-        block = lambda {
+        group = ExampleGroup.describe
+        shared_examples_for(:shared_example_group) do
           def self.class_helper; end
           def extra_helper; end
-        }
-        Rspec::Core.world.stub(:shared_example_groups).and_return({ :shared_example_group => block })
+        end
         group.it_should_behave_like :shared_example_group
         group.instance_methods.should include(:extra_helper)
         group.singleton_methods.should include(:class_helper)
       end
 
       it "raises when named shared example_group can not be found" do
-        cleanup_shared_example_groups do
-          group = ExampleGroup.create("example_group")
-          lambda do
-            group.it_should_behave_like("a group that does not exist")
-          end.should raise_error(/Could not find shared example group named/)
-        end
+        group = ExampleGroup.describe("example_group")
+        lambda do
+          group.it_should_behave_like("a group that does not exist")
+        end.should raise_error(/Could not find shared example group named/)
       end
 
       it "adds examples to current example_group using it_should_behave_like" do
-        cleanup_shared_example_groups do
-          group = ExampleGroup.create("example_group") do
-            it("i was already here") {}
-          end
+        group = ExampleGroup.describe("example_group") do
+          it("i was already here") {}
+        end
 
-          group.examples.size.should == 1
+        group.examples.size.should == 1
 
-          group.share_examples_for('shared example_group') do
-            it("shared example") {}
-            it("shared example 2") {}
-          end
+        group.share_examples_for('shared example_group') do
+          it("shared example") {}
+          it("shared example 2") {}
+        end
 
-          group.it_should_behave_like("shared example_group")
+        group.it_should_behave_like("shared example_group")
 
-          group.examples.size.should == 3
-        end
+        group.examples.size.should == 3
       end
 
       it "adds examples to from two shared groups" do
-        cleanup_shared_example_groups do
-          group = ExampleGroup.create("example_group") do
-            it("i was already here") {}
-          end
+        group = ExampleGroup.describe("example_group") do
+          it("i was already here") {}
+        end
 
-          group.examples.size.should == 1
+        group.examples.size.should == 1
 
-          group.share_examples_for('test 2 shared groups') do
-            it("shared example") {}
-            it("shared example 2") {}
-          end
+        group.share_examples_for('test 2 shared groups') do
+          it("shared example") {}
+          it("shared example 2") {}
+        end
 
-          group.share_examples_for('test 2 shared groups 2') do
-            it("shared example 3") {}
-          end
+        group.share_examples_for('test 2 shared groups 2') do
+          it("shared example 3") {}
+        end
 
-          group.it_should_behave_like("test 2 shared groups")
-          group.it_should_behave_like("test 2 shared groups 2")
+        group.it_should_behave_like("test 2 shared groups")
+        group.it_should_behave_like("test 2 shared groups 2")
 
-          group.examples.size.should == 4
-        end
+        group.examples.size.should == 4
       end
 
-      share_as('Cornucopia') do
-        it "is plentiful" do
-          5.should == 4
-        end
-      end
 
       it "adds examples to current example_group using include", :compat => 'rspec-1.2' do
-        group = ExampleGroup.create('group') { include Cornucopia }
+        share_as('Cornucopia') do
+          it "is plentiful" do
+            5.should == 4
+          end
+        end
+        group = ExampleGroup.describe('group') { include Cornucopia }
         group.examples.length.should == 1
         group.examples.first.metadata[:description].should == "is plentiful"
       end
 
       it "adds examples to current example_group using it_should_behave_like with a module" do
-        cleanup_shared_example_groups do
-          group = ExampleGroup.create("example_group")  {}
+        group = ExampleGroup.describe("example_group")  {}
 
-          shared_foo = group.share_as(:FooShared) do
-            it("shared example") {}
-          end
+        shared_foo = group.share_as(:FooShared) do
+          it("shared example") {}
+        end
 
-          group.it_should_behave_like(::FooShared) 
+        group.it_should_behave_like(::FooShared) 
 
-          group.examples.size.should == 1
-        end
+        group.examples.size.should == 1
       end
 
       describe "running shared examples" do
         module ::RunningSharedExamplesJustForTesting; end
 
-        share_examples_for("it runs shared examples") do
-          include ::RunningSharedExamplesJustForTesting
+        before(:each) do
+          share_examples_for("it runs shared examples") do
+            include ::RunningSharedExamplesJustForTesting
+
+            class << self
+              def magic
+                $magic ||= {}
+              end
+
+              def count(scope)
+                @counters ||= {
+                  :before_all  => 0,
+                  :before_each => 0,
+                  :after_each  => 0,
+                  :after_all   => 0
+                }
+                @counters[scope] += 1
+              end
+            end
 
-          class << self
             def magic
               $magic ||= {}
             end
 
             def count(scope)
-              @counters ||= {
-                :before_all  => 0,
-                :before_each => 0,
-                :after_each  => 0,
-                :after_all   => 0
-              }
-              @counters[scope] += 1
+              self.class.count(scope)
             end
-          end
-
-          def magic
-            $magic ||= {}
-          end
 
-          def count(scope)
-            self.class.count(scope)
+            before(:all)  { magic[:before_all]  = "before all #{count(:before_all)}" }
+            before(:each) { magic[:before_each] = "before each #{count(:before_each)}" }
+            after(:each)  { magic[:after_each]  = "after each #{count(:after_each)}" }
+            after(:all)   { magic[:after_all]   = "after all #{count(:after_all)}" }
           end
-
-          before(:all)  { magic[:before_all]  = "before all #{count(:before_all)}" }
-          before(:each) { magic[:before_each] = "before each #{count(:before_each)}" }
-          after(:each)  { magic[:after_each]  = "after each #{count(:after_each)}" }
-          after(:all)   { magic[:after_all]   = "after all #{count(:after_all)}" }
         end
 
         let(:group) do
-          group = ExampleGroup.create("example group") do
+          group = ExampleGroup.describe("example group") do
             it_should_behave_like "it runs shared examples"
             it "has one example" do; end
             it "has another example" do; end
+            it "includes modules, included into shared example_group, into current example_group", :compat => 'rspec-1.2' do
+              raise "FAIL" unless running_example.example_group.included_modules.include?(RunningSharedExamplesJustForTesting)
+            end
           end
         end
 
-        before { group.run(stub('reporter').as_null_object) }
+        before { group.run_all }
 
         it "runs before(:all) only once from shared example_group", :compat => 'rspec-1.2' do
           group.magic[:before_all].should eq("before all 1")
         end
 
         it "runs before(:each) from shared example_group", :compat => 'rspec-1.2' do
-          group.magic[:before_each].should eq("before each 2")
+          group.magic[:before_each].should eq("before each 3")
         end
 
         it "runs after(:each) from shared example_group", :compat => 'rspec-1.2' do
-          group.magic[:after_each].should eq("after each 2")
+          group.magic[:after_each].should eq("after each 3")
         end
 
-        it "runs after(:all) only once from shared example_group", :compat => 'rspec-1.2' do
+        it "runs after(:all) only once from shared example_group", :pending => true, :compat => 'rspec-1.2' do
           group.magic[:after_all].should eq("after all 1")
         end
 
-        it_should_behave_like "it runs shared examples"
-
-        it "includes modules, included into shared example_group, into current example_group", :compat => 'rspec-1.2' do
-          running_example.example_group.included_modules.should include(RunningSharedExamplesJustForTesting)
-        end
-
         it "makes methods defined in the shared example_group available in consuming example_group", :compat => 'rspec-1.2' do
           group.magic.should be_a(Hash)
         end