dchelimsky-rspec 1.1.10

data/spec/spec/example/nested_example_group_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Example
+    describe 'Nested Example Groups' do
+      parent = self
+      
+      def count
+        @count ||= 0
+        @count = @count + 1
+        @count
+      end
+
+      before(:all) do
+        count.should == 1
+      end
+
+      before(:all) do
+        count.should == 2
+      end
+
+      before(:each) do
+        count.should == 3
+      end
+
+      before(:each) do
+        count.should == 4
+      end
+
+      it "should run before(:all), before(:each), example, after(:each), after(:all) in order" do
+        count.should == 5
+      end
+
+      after(:each) do
+        count.should == 7
+      end
+
+      after(:each) do
+        count.should == 6
+      end
+
+      after(:all) do
+        count.should == 9
+      end
+
+      after(:all) do
+        count.should == 8
+      end
+
+      describe 'nested example group' do
+        self.superclass.should == parent
+        
+        it "should run all before and after callbacks" do
+          count.should == 5
+        end
+      end
+    end
+
+    describe "Nested Example Groups" do
+      describe "description options", :other_options => "other options" do
+        it "should have a spec_path" do
+          self.class.description_options[:spec_path].should match(/#{__FILE__}/)
+        end
+
+        it "should pass other options" do
+          self.class.description_options[:other_options].should == "other options"
+        end
+      end
+    end
+  end
+end

data/spec/spec/example/pending_module_spec.rb

@@ -0,0 +1,145 @@
+module Spec
+  module Example
+    describe Pending do
+      
+      it 'should raise an ExamplePendingError if no block is supplied' do
+        lambda {
+          include Pending
+          pending "TODO"
+        }.should raise_error(ExamplePendingError, /TODO/)
+      end
+      
+      it 'should raise an ExamplePendingError if a supplied block fails as expected' do
+        lambda {
+          include Pending
+          pending "TODO" do
+            raise "oops"
+          end
+        }.should raise_error(ExamplePendingError, /TODO/)
+      end
+      
+      it 'should raise an ExamplePendingError if a supplied block fails as expected with a mock' do
+        lambda {
+          include Pending
+          pending "TODO" do
+            m = mock('thing')
+            m.should_receive(:foo)
+            m.rspec_verify
+          end
+        }.should raise_error(ExamplePendingError, /TODO/)
+      end
+      
+      it 'should raise a PendingExampleFixedError if a supplied block starts working' do
+        lambda {
+          include Pending
+          pending "TODO" do
+            # success!
+          end
+        }.should raise_error(PendingExampleFixedError, /TODO/)
+      end
+      
+      it "should have the correct file and line number for pending given with a block which fails" do
+        file = __FILE__
+        line_number = __LINE__ + 3
+        begin
+          include Pending
+          pending do
+            raise
+          end
+        rescue => error
+          error.pending_caller.should == "#{file}:#{line_number}"
+        end
+      end
+      
+      it "should have the correct file and line number for pending given with no block" do
+        file = __FILE__
+        line_number = __LINE__ + 3
+        begin
+          include Pending
+          pending("TODO")
+        rescue => error
+          error.pending_caller.should == "#{file}:#{line_number}"
+        end
+      end
+    end
+    
+    describe ExamplePendingError do
+      it "should have the caller (from two calls from initialization)" do
+        two_calls_ago = caller[0]
+        ExamplePendingError.new("a message").pending_caller.should == two_calls_ago
+      end
+      
+      it "should keep the trace information from initialization" do
+        two_calls_ago = caller[0]
+        obj = ExamplePendingError.new("a message")
+        obj.pending_caller
+        def another_caller(obj)
+          obj.pending_caller
+        end
+        
+        another_caller(obj).should == two_calls_ago
+      end
+      
+      it "should have the message provided" do
+        ExamplePendingError.new("a message").message.should == "a message"
+      end
+
+      it "should use a 'ExamplePendingError' as it's default message" do
+        ExamplePendingError.new.message.should == "Spec::Example::ExamplePendingError"
+      end
+    end
+    
+    describe NotYetImplementedError do
+      def rspec_root
+        File.expand_path(__FILE__.gsub("/spec/spec/example/pending_module_spec.rb", "/lib"))
+      end
+      
+      it "should have the root rspec path" do
+        NotYetImplementedError::RSPEC_ROOT_LIB.should == rspec_root
+      end
+      
+      it "should always have the error 'Not Yet Implemented'" do
+        NotYetImplementedError.new([]).message.should == "Not Yet Implemented"
+      end
+      
+      describe "pending_caller" do
+        it "should select an element out of the backtrace" do
+          error = NotYetImplementedError.new(["foo/bar.rb:18"])
+          
+          error.pending_caller.should == "foo/bar.rb:18"
+        end
+        
+        it "should actually report the element from the backtrace" do
+          error = NotYetImplementedError.new(["bar.rb:18"])
+          
+          error.pending_caller.should == "bar.rb:18"
+        end
+        
+        it "should not use an element with the rspec root path" do
+          error = NotYetImplementedError.new(["#{rspec_root}:8"])
+          
+          error.pending_caller.should be_nil
+        end
+        
+        it "should select the first line in the backtrace which isn't in the rspec root" do
+          error = NotYetImplementedError.new([
+            "#{rspec_root}/foo.rb:2",
+            "#{rspec_root}/foo/bar.rb:18",
+            "path1.rb:22",
+            "path2.rb:33"
+          ])
+          
+          error.pending_caller.should == "path1.rb:22"
+        end
+        
+        it "should cache the caller" do
+          backtrace = mock('backtrace')
+          backtrace.should_receive(:detect).once
+          
+          error = NotYetImplementedError.new(backtrace)
+          error.pending_caller.should == error.pending_caller
+        end
+      end
+    end
+  end
+end

data/spec/spec/example/predicate_matcher_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Example
+    class Fish
+      def can_swim?(distance_in_yards)
+        distance_in_yards < 1000
+      end
+    end
+    
+    describe "predicate_matcher[method_on_object] = matcher_method" do
+      predicate_matchers[:swim] = :can_swim?
+      it "should match matcher_method if method_on_object returns true" do
+        swim(100).matches?(Fish.new).should be_true
+      end
+      it "should not match matcher_method if method_on_object returns false" do
+        swim(10000).matches?(Fish.new).should be_false
+      end
+    end
+  end
+end

data/spec/spec/example/shared_example_group_spec.rb

@@ -0,0 +1,281 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Example
+    describe ExampleGroup, "with :shared => true" do
+      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
+
+        after(:each) do
+          @formatter.rspec_verify
+          @example_group = nil
+          Spec::Example::SharedExampleGroup.shared_example_groups.clear
+        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
+
+        def non_shared_example_group()
+          @non_shared_example_group ||= Class.new(ExampleGroup).describe("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
+
+        it "should return all shared example_groups" do
+          b1 = make_shared_example_group("b1", :shared => true) {}
+          b2 = make_shared_example_group("b2", :shared => true) {}
+
+          b1.should_not be(nil)
+          b2.should_not be(nil)
+
+          SharedExampleGroup.find_shared_example_group("b1").should equal(b1)
+          SharedExampleGroup.find_shared_example_group("b2").should equal(b2)
+        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 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 complain when adding a second shared example_group with the same description" do
+          describe "shared example_group", :shared => true do
+          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 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.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
+
+        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
+
+        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
+
+          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 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
+            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
+          end
+        
+          example_group = describe "one thing" do
+            it_should_behave_like AllThings
+          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 }
+          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_example_ran.should be_true
+        end
+
+        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_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_setup_ran.should be_true
+          shared_teardown_ran.should be_true
+        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
+
+          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 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
+
+          mod1_method_called = false
+          mod1 = Module.new do
+            define_method :mod1_method do
+              mod1_method_called = true
+            end
+          end
+
+          mod2_method_called = false
+          mod2 = Module.new do
+            define_method :mod2_method do
+              mod2_method_called = true
+            end
+          end
+
+          shared_example_group.__send__ :include, mod2
+
+          example_group.it_should_behave_like("shared example_group")
+          example_group.include mod1
+
+          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
+
+        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
+
+        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
+end