newbamboo-rspec 1.1.12

data/spec/spec/runner/configuration_spec.rb

@@ -0,0 +1,301 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Runner
+    describe Configuration do
+      with_sandboxed_options do
+        with_sandboxed_config do
+          describe "#mock_with" do
+            it "should default mock framework to rspec" do
+              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/rspec$/
+            end
+
+            it "should set rspec mocking explicitly" do
+              config.mock_with(:rspec)
+              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/rspec$/
+            end
+
+            it "should set mocha" do
+              config.mock_with(:mocha)
+              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/mocha$/
+            end
+
+            it "should set flexmock" do
+              config.mock_with(:flexmock)
+              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/flexmock$/
+            end
+
+            it "should set rr" do
+              config.mock_with(:rr)
+              config.mock_framework.should =~ /\/adapters\/mock_frameworks\/rr$/
+            end
+
+            it "should set an arbitrary adapter module" do
+              adapter = Module.new
+              config.mock_with(adapter)
+              config.mock_framework.should == adapter
+            end
+          end
+
+          describe "#include" do
+          
+            before(:each) do
+              @example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) {}
+              Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class)
+            end
+
+            it "should include the submitted module in ExampleGroup subclasses" do
+              mod = Module.new
+              config.include mod
+              Class.new(@example_group_class).included_modules.should include(mod)
+            end
+
+            it "should scope modules to be included for a specific type" do
+              mod = Module.new
+              config.include mod, :type => :foobar
+              Class.new(@example_group_class).included_modules.should include(mod)
+            end
+
+            it "should not include modules in a type they are not intended for" do
+              mod = Module.new
+              @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble)
+              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
+
+              config.include mod, :type => :foobar
+
+              Class.new(@other_example_group_class).included_modules.should_not include(mod)
+            end
+            
+            it "accepts an Array of types" do
+              mod = Module.new
+              @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble)
+              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
+
+              config.include mod, :type => [:foobar, :baz]
+
+              Class.new(@example_group_class).included_modules.should include(mod)
+              Class.new(@other_example_group_class).included_modules.should include(mod)
+            end
+
+          end
+      
+          describe "#extend" do
+        
+            before(:each) do
+              @example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) {}
+              Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class)
+            end
+
+            it "should extend all groups" do
+              mod = Module.new
+              ExampleGroup.should_receive(:extend).with(mod)
+              Spec::Runner.configuration.extend mod
+            end
+      
+            it "should extend specified groups" do
+              mod = Module.new
+              @example_group_class.should_receive(:extend).with(mod)
+              Spec::Runner.configuration.extend mod, :type => :foobar
+            end
+      
+            it "should not extend non-specified groups" do
+              @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble)
+              Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class)
+
+              mod = Module.new
+              @other_example_group_class.should_not_receive(:extend)          
+
+              Spec::Runner.configuration.extend mod, :type => :foobar
+            end
+        
+          end
+        end
+      
+        describe "ordering methods: " do
+        
+          before(:each) do
+            @special_example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe("special_example_group")
+            @special_child_example_group = Class.new(@special_example_group).describe("special_child_example_group")
+            @nonspecial_example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe("nonspecial_example_group")
+            Spec::Example::ExampleGroupFactory.register(:special, @special_example_group)
+            Spec::Example::ExampleGroupFactory.register(:special_child, @special_child_example_group)
+            Spec::Example::ExampleGroupFactory.register(:non_special, @nonspecial_example_group)
+            @example_group = @special_child_example_group.describe "Special Example Group"
+            @unselected_example_group = Class.new(@nonspecial_example_group).describe "Non Special Example Group"
+          end
+
+          describe "#prepend_before" do
+            it "prepends the before block on all instances of the passed in type" do
+              order = []
+              config.prepend_before(:all) do
+                order << :prepend__before_all
+              end
+              config.prepend_before(:all, :type => :special) do
+                order << :special_prepend__before_all
+              end
+              config.prepend_before(:all, :type => :special_child) do
+                order << :special_child_prepend__before_all
+              end
+              config.prepend_before(:each) do
+                order << :prepend__before_each
+              end
+              config.prepend_before(:each, :type => :special) do
+                order << :special_prepend__before_each
+              end
+              config.prepend_before(:each, :type => :special_child) do
+                order << :special_child_prepend__before_each
+              end
+              config.prepend_before(:all, :type => :non_special) do
+                order << :special_prepend__before_all
+              end
+              config.prepend_before(:each, :type => :non_special) do
+                order << :special_prepend__before_each
+              end
+              @example_group.it "calls prepend_before" do
+              end
+      
+              @example_group.run(options)
+              order.should == [
+                :prepend__before_all,
+                :special_prepend__before_all,
+                :special_child_prepend__before_all,
+                :prepend__before_each,
+                :special_prepend__before_each,
+                :special_child_prepend__before_each
+              ]
+            end
+          end
+
+          describe "#append_before" do
+
+            it "calls append_before on the type" do
+              order = []
+              config.append_before(:all) do
+                order << :append_before_all
+              end
+              config.append_before(:all, :type => :special) do
+                order << :special_append_before_all
+              end
+              config.append_before(:all, :type => :special_child) do
+                order << :special_child_append_before_all
+              end
+              config.append_before(:each) do
+                order << :append_before_each
+              end
+              config.append_before(:each, :type => :special) do
+                order << :special_append_before_each
+              end
+              config.append_before(:each, :type => :special_child) do
+                order << :special_child_append_before_each
+              end
+              config.append_before(:all, :type => :non_special) do
+                order << :special_append_before_all
+              end
+              config.append_before(:each, :type => :non_special) do
+                order << :special_append_before_each
+              end
+              @example_group.it "calls append_before" do
+              end
+
+              @example_group.run(options)
+              order.should == [
+                :append_before_all,
+                :special_append_before_all,
+                :special_child_append_before_all,
+                :append_before_each,
+                :special_append_before_each,
+                :special_child_append_before_each
+              ]
+            end
+          end
+
+          describe "#prepend_after" do
+
+            it "prepends the after block on all instances of the passed in type" do
+              order = []
+              config.prepend_after(:all) do
+                order << :prepend__after_all
+              end
+              config.prepend_after(:all, :type => :special) do
+                order << :special_prepend__after_all
+              end
+              config.prepend_after(:all, :type => :special) do
+                order << :special_child_prepend__after_all
+              end
+              config.prepend_after(:each) do
+                order << :prepend__after_each
+              end
+              config.prepend_after(:each, :type => :special) do
+                order << :special_prepend__after_each
+              end
+              config.prepend_after(:each, :type => :special) do
+                order << :special_child_prepend__after_each
+              end
+              config.prepend_after(:all, :type => :non_special) do
+                order << :special_prepend__after_all
+              end
+              config.prepend_after(:each, :type => :non_special) do
+                order << :special_prepend__after_each
+              end
+              @example_group.it "calls prepend_after" do
+              end
+
+              @example_group.run(options)
+              order.should == [
+                :special_child_prepend__after_each,
+                :special_prepend__after_each,
+                :prepend__after_each,
+                :special_child_prepend__after_all,
+                :special_prepend__after_all,
+                :prepend__after_all
+              ]
+            end
+          end
+
+          describe "#append_after" do
+
+            it "calls append_after on the type" do
+              order = []
+              config.append_after(:all) do
+                order << :append__after_all
+              end
+              config.append_after(:all, :type => :special) do
+                order << :special_append__after_all
+              end
+              config.append_after(:all, :type => :special_child) do
+                order << :special_child_append__after_all
+              end
+              config.append_after(:each) do
+                order << :append__after_each
+              end
+              config.append_after(:each, :type => :special) do
+                order << :special_append__after_each
+              end
+              config.append_after(:each, :type => :special_child) do
+                order << :special_child_append__after_each
+              end
+              config.append_after(:all, :type => :non_special) do
+                order << :non_special_append_after_all
+              end
+              config.append_after(:each, :type => :non_special) do
+                order << :non_special_append_after_each
+              end
+              @example_group.it "calls append_after" do
+              end
+
+              @example_group.run(options)
+              order.should == [
+                :special_child_append__after_each,
+                :special_append__after_each,
+                :append__after_each,
+                :special_child_append__after_all,
+                :special_append__after_all,
+                :append__after_all
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec/runner/drb_command_line_spec.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Runner
+    describe DrbCommandLine, "without running local server" do
+      unless jruby?
+        it "should print error when there is no running local server" do
+          err = StringIO.new
+          out = StringIO.new
+          DrbCommandLine.run(OptionParser.parse(['--version'], err, out))
+
+          err.rewind
+          err.read.should =~ /No server is running/
+        end
+      end    
+    end
+
+    describe "with local server" do
+
+      class ::CommandLineForSpec
+        def self.run(argv, stderr, stdout)
+          orig_options = Spec::Runner.options
+          tmp_options = OptionParser.parse(argv, stderr, stdout)
+          Spec::Runner.use tmp_options
+          Spec::Runner::CommandLine.run(tmp_options)
+        ensure
+          Spec::Runner.use orig_options
+        end
+      end
+      
+      unless jruby?
+        before(:all) do
+          DRb.start_service("druby://127.0.0.1:8989", ::CommandLineForSpec)
+          @@drb_example_file_counter = 0
+        end
+
+        before(:each) do
+          create_dummy_spec_file
+          @@drb_example_file_counter = @@drb_example_file_counter + 1
+        end
+
+        after(:each) do
+          File.delete(@dummy_spec_filename)
+        end
+
+        after(:all) do
+          DRb.stop_service
+        end
+
+        it "should run against local server" do
+          out = run_spec_via_druby(['--version'])
+          out.should =~ /rspec \d+\.\d+\.\d+.*/n
+        end
+
+        it "should output green colorized text when running with --colour option" do
+          out = run_spec_via_druby(["--colour", @dummy_spec_filename])
+          out.should =~ /\e\[32m/n
+        end
+
+        it "should output red colorized text when running with -c option" do
+          out = run_spec_via_druby(["-c", @dummy_spec_filename])
+          out.should =~ /\e\[31m/n
+        end
+
+        def create_dummy_spec_file
+          @dummy_spec_filename = File.expand_path(File.dirname(__FILE__)) + "/_dummy_spec#{@@drb_example_file_counter}.rb"
+          File.open(@dummy_spec_filename, 'w') do |f|
+            f.write %{
+              describe "DUMMY CONTEXT for 'DrbCommandLine with -c option'" do
+                it "should be output with green bar" do
+                  true.should be_true
+                end
+
+                it "should be output with red bar" do
+                  violated("I want to see a red bar!")
+                end
+              end
+            }
+          end
+        end
+
+        def run_spec_via_druby(argv)
+          err, out = StringIO.new, StringIO.new
+          out.instance_eval do
+            def tty?; true end
+          end
+          options = ::Spec::Runner::Options.new(err, out)
+          options.argv = argv
+          Spec::Runner::DrbCommandLine.run(options)
+          out.rewind; out.read
+        end
+      end
+      
+    end
+
+  end
+end

data/spec/spec/runner/example_group_runner_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Runner
+    describe ExampleGroupRunner do
+      before(:each) do
+        err = StringIO.new('')
+        out = StringIO.new('')
+        @options = Options.new(err, out)
+        @runner = Spec::Runner::ExampleGroupRunner.new(@options)
+      end
+
+      after(:each) do
+        Spec::Expectations.differ = nil
+      end
+
+      describe "#load_files" do
+        it "should load UTF-8 encoded files" do
+          file = File.expand_path(File.dirname(__FILE__) + "/resources/utf8_encoded.rb")
+          @options.files << file
+          @runner.load_files(@options.files_to_load).should == @options.files_to_load
+        end
+      end
+    end
+    
+    describe BehaviourRunner do
+      it "is DEPRECATED (use ExampleGroupRunner)" do
+        Kernel.should_receive(:warn).with(/DEPRECATED/)
+        BehaviourRunner.new(nil)
+      end
+    end
+  end
+end

data/spec/spec/runner/examples.txt

@@ -0,0 +1,2 @@
+Sir, if you were my husband, I would poison your drink.
+Madam, if you were my wife, I would drink it.

data/spec/spec/runner/failed.txt

@@ -0,0 +1,3 @@
+heckler_spec.rb
+command_line_spec.rb
+reporter_spec.rb

data/spec/spec/runner/formatter/base_formatter_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + "/../../../spec_helper"
+
+module Spec
+  module Runner
+    module Formatter
+      describe BaseFormatter do
+        subject {BaseFormatter.new(nil, nil)}
+        
+        it {should respond_to(:start            ).with(1).argument }
+        it {should respond_to(:add_example_group).with(1).argument }
+        it {should respond_to(:example_passed   ).with(1).argument }
+        it {should respond_to(:example_started  ).with(1).argument }
+        it {should respond_to(:example_failed   ).with(3).arguments}
+        it {should respond_to(:example_pending  ).with(3).arguments}
+        it {should respond_to(:start_dump       ).with(0).arguments}
+        it {should respond_to(:dump_failure     ).with(2).arguments}
+        it {should respond_to(:dump_summary     ).with(4).arguments}
+        it {should respond_to(:dump_pending     ).with(0).arguments}
+        it {should respond_to(:close            ).with(0).arguments}
+      end
+    end
+  end
+end

data/spec/spec/runner/formatter/base_text_formatter_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'spec/runner/formatter/base_text_formatter'
+require 'fileutils'
+
+module Spec
+  module Runner
+    module Formatter
+      describe BaseTextFormatter do
+        
+        before :all do
+          @sandbox = "spec/sandbox"
+        end
+
+        it "should create the directory contained in WHERE if it does not exist" do
+          FileUtils.should_receive(:mkdir_p).with(@sandbox)
+          File.stub!(:open)
+          BaseTextFormatter.new({},"#{@sandbox}/temp.rb")
+        end
+
+      end
+    end
+  end
+end

data/spec/spec/runner/formatter/failing_example_groups_formatter_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'spec/runner/formatter/failing_example_groups_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      describe FailingExampleGroupsFormatter do
+        attr_reader :example_group, :formatter, :io
+
+        before(:each) do
+          @io = StringIO.new
+          options = mock('options')
+          @formatter = FailingExampleGroupsFormatter.new(options, io)
+          @example_group = Class.new(::Spec::Example::ExampleGroup)
+        end
+        
+        it "should add example name for each failure" do
+          formatter.add_example_group(Class.new(::Spec::Example::ExampleGroupDouble).describe("b 1"))
+          formatter.example_failed("e 1", nil, Spec::Runner::Reporter::Failure.new(nil, RuntimeError.new))
+          formatter.add_example_group(Class.new(::Spec::Example::ExampleGroupDouble).describe("b 2"))
+          formatter.example_failed("e 2", nil, Spec::Runner::Reporter::Failure.new(nil, RuntimeError.new))
+          formatter.example_failed("e 3", nil, Spec::Runner::Reporter::Failure.new(nil, RuntimeError.new))
+          io.string.should include("b 1")
+          io.string.should include("b 2")
+        end
+
+        it "should delimit ExampleGroup superclass descriptions with :" do
+          parent_example_group = Class.new(example_group).describe("Parent")
+          child_example_group = Class.new(parent_example_group).describe("#child_method")
+          grand_child_example_group = Class.new(child_example_group).describe("GrandChild")
+
+          formatter.add_example_group(grand_child_example_group)
+          formatter.example_failed("failure", nil, ::Spec::Runner::Reporter::Failure.new(nil, RuntimeError.new))
+          io.string.should == "Parent#child_method GrandChild\n"
+        end
+
+        it "should remove druby url, which is used by Spec::Distributed" do
+          @formatter.add_example_group(Class.new(::Spec::Example::ExampleGroupDouble).describe("something something (druby://99.99.99.99:99)"))
+          @formatter.example_failed("e 1", nil, ::Spec::Runner::Reporter::Failure.new(nil, RuntimeError.new))
+          io.string.should == "something something\n"
+        end
+      end
+    end
+  end
+end

data/spec/spec/runner/formatter/failing_examples_formatter_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'spec/runner/formatter/failing_examples_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      describe FailingExamplesFormatter do
+        before(:each) do
+          @io = StringIO.new
+          options = mock('options')
+          @formatter = FailingExamplesFormatter.new(options, @io)
+        end
+
+        it "should add example name for each failure" do
+          example_group_1 = Class.new(::Spec::Example::ExampleGroupDouble).describe("A")
+          example_group_2 = Class.new(example_group_1).describe("B")
+
+          @formatter.add_example_group(example_group_1)
+          @formatter.example_failed(example_group_1.it("a1"){}, nil, ::Spec::Runner::Reporter::Failure.new(nil, RuntimeError.new))
+          @formatter.add_example_group(example_group_2)
+          @formatter.example_failed(example_group_2.it("b2"){}, nil, ::Spec::Runner::Reporter::Failure.new(nil, RuntimeError.new))
+          @formatter.example_failed(example_group_2.it("b3"){}, nil, ::Spec::Runner::Reporter::Failure.new(nil, RuntimeError.new))
+          @io.string.should eql(<<-EOF
+A a1
+A B b2
+A B b3
+EOF
+)
+        end
+      end
+    end
+  end
+end