rspec 1.3.0 → 2.0.0

data/spec/spec/rake/spectask_spec.rb

@@ -1,150 +0,0 @@
-require 'spec_helper'
-require 'spec/rake/spectask'
-
-module Spec
-  module Rake
-
-    class MockTask
-      class << self
-        attr_accessor :last_instance, :last_cmd
-      end
-
-      def self.tasks
-        @tasks ||= {}
-      end
-      
-      def self.reset_tasks
-        @tasks = {}
-      end
-      
-      def self.task(name)
-        tasks[name]
-      end
-      
-      def self.register_task(name, block)
-        tasks[name] = block
-      end
-
-      def initialize(name, &block)
-        MockTask.register_task(name, block)
-        MockTask.last_instance = block
-      end
-      
-      def self.create_task(name, &block)
-        new(name, &block)
-      end
-    end
-
-    class SpecTask
-      def task(name, &block)
-        MockTask.create_task(name, &block)
-      end
-
-      def system(cmd)
-        MockTask.last_cmd = cmd
-        true
-      end
-
-      def default_ruby_path
-        RUBY
-      end
-    end
-    
-    describe SpecTask do
-
-      before(:each) do
-        MockTask.reset_tasks
-      end
-
-      it "should execute rake's ruby path by default" do
-        task = SpecTask.new
-        MockTask.last_instance.call
-        MockTask.last_cmd.should match(/^#{task.default_ruby_path} /)
-      end
-
-      it "should execute the command with system if ruby_cmd is specified" do
-        task = SpecTask.new {|t| t.ruby_cmd = "path_to_multiruby"}
-        task.should_receive(:system).and_return(true)
-        MockTask.last_instance.call
-      end
-
-      it "should execute the ruby_cmd path if specified" do
-        SpecTask.new {|t| t.ruby_cmd = "path_to_multiruby"}
-        MockTask.last_instance.call
-        MockTask.last_cmd.should match(/^path_to_multiruby /)
-      end
-      
-      it "should produce a deprecation warning if the out option is used" do
-        SpecTask.new {|t| t.out = "somewhere_over_the_rainbow"}
-        STDERR.should_receive(:puts).with("The Spec::Rake::SpecTask#out attribute is DEPRECATED and will be removed in a future version. Use --format FORMAT:WHERE instead.")
-        MockTask.last_instance.call
-      end
-      
-      it "should produce an error if failure_message is set and the command fails" do
-        task = SpecTask.new {|t| t.failure_message = "oops"; t.fail_on_error = false}
-        STDERR.should_receive(:puts).with("oops")
-        task.stub(:system).and_return(false)
-        MockTask.last_instance.call
-      end
-      
-      it "should raise if fail_on_error is set and the command fails" do
-        task = SpecTask.new
-        task.stub(:system).and_return(false)
-        lambda {MockTask.last_instance.call}.should raise_error
-      end
-      
-      it "should not raise if fail_on_error is not set and the command fails" do
-        task = SpecTask.new {|t| t.fail_on_error = false}
-        task.stub(:system).and_return(false)
-        lambda {MockTask.last_instance.call}.should_not raise_error
-      end
-      
-      context "with ENV['SPEC'] set" do
-        before(:each) do
-          @orig_env_spec = ENV['SPEC']
-          ENV['SPEC'] = 'foo.rb'
-        end
-        after(:each) do
-          ENV['SPEC'] = @orig_env_spec
-        end
-        it "should use the provided file list" do
-          task = SpecTask.new
-          task.spec_file_list.should == ["foo.rb"]
-        end
-      end
-      
-      context "with the rcov option" do
-        
-        it "should create a clobber_rcov task" do
-          MockTask.stub!(:create_task)
-          MockTask.should_receive(:create_task).with(:clobber_rcov)
-          SpecTask.new(:rcov) {|t| t.rcov = true}
-        end
-
-        it "should setup the clobber_rcov task to remove the rcov directory" do
-          task = SpecTask.new(:rcov) {|t| t.rcov = true; t.rcov_dir = "path_to_rcov_directory"}
-          task.should_receive(:rm_r).with("path_to_rcov_directory")
-          MockTask.task(:clobber_rcov).call
-        end
-
-        it "should make the clobber task depend on clobber_rcov" do
-          MockTask.stub!(:create_task)
-          MockTask.should_receive(:create_task).with(:clobber => [:clobber_rcov])
-          SpecTask.new(:rcov) {|t| t.rcov = true}
-        end
-
-        it "should make the rcov task depend on clobber_rcov" do
-          MockTask.stub!(:create_task)
-          MockTask.should_receive(:create_task).with(:rcov => :clobber_rcov)
-          SpecTask.new(:rcov) {|t| t.rcov = true}
-        end
-        
-        it "creates an rcov options list" do
-          MockTask.stub!(:create_task)
-          task = SpecTask.new(:rcov) {|t| t.rcov = true, t.rcov_opts = ['a','b']}
-          task.rcov_option_list.should == "a b"
-        end
-      end
-    end
-  end
-end

data/spec/spec/runner/class_and_argument_parser_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Runner
-    describe ClassAndArgumentsParser, ".parse" do
-      
-      it "should use a single : to separate class names from arguments" do
-        ClassAndArgumentsParser.parse('Foo').should == ['Foo', nil]
-        ClassAndArgumentsParser.parse('Foo:arg').should == ['Foo', 'arg']
-        ClassAndArgumentsParser.parse('Foo::Bar::Zap:arg').should == ['Foo::Bar::Zap', 'arg']
-        ClassAndArgumentsParser.parse('Foo:arg1,arg2').should == ['Foo', 'arg1,arg2']
-        ClassAndArgumentsParser.parse('Foo::Bar::Zap:arg1,arg2').should == ['Foo::Bar::Zap', 'arg1,arg2']
-        ClassAndArgumentsParser.parse('Foo::Bar::Zap:drb://foo,drb://bar').should == ['Foo::Bar::Zap', 'drb://foo,drb://bar']
-      end
-
-      it "should raise an error when passed an empty string" do
-        lambda do
-          ClassAndArgumentsParser.parse('')
-        end.should raise_error("Couldn't parse \"\"")
-      end      
-    end
-  end
-end

data/spec/spec/runner/command_line_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Runner
-    describe CommandLine, ".run" do
-      with_sandboxed_options do
-        attr_reader :err, :out
-        before do
-          @err = options.error_stream
-          @out = options.output_stream
-        end
-
-        it "should run directory" do
-          file = File.dirname(__FILE__) + '/../../../examples/passing'
-          run_with(OptionParser.parse([file,"-p","**/*_spec.rb,**/*_example.rb"], @err, @out))
-
-          @out.rewind
-          @out.read.should =~ /\d+ examples, 0 failures, 3 pending/n
-        end
-
-        it "should run file" do
-          file = File.dirname(__FILE__) + '/../../../examples/failing/predicate_example.rb'
-          run_with(OptionParser.parse([file], @err, @out))
-
-          @out.rewind
-          @out.read.should =~ /3 examples, 2 failures/n
-        end
-
-        it "should raise when file does not exist" do
-          file = File.dirname(__FILE__) + '/doesntexist'
-
-          lambda {
-            Spec::Runner::CommandLine.run(OptionParser.parse([file], @err, @out))
-          }.should raise_error
-        end
-
-        it "should return true when in --generate-options mode" do
-          # NOTE - this used to say /dev/null but jruby hangs on that for some reason
-          Spec::Runner::CommandLine.run(
-            OptionParser.parse(['--generate-options', '/tmp/foo'], @err, @out)
-          ).should be_true
-        end
-
-        it "should exit if Interrupt exception occurrs during the spec" do
-          example_group = Class.new(::Spec::Example::ExampleGroup) do
-            describe("example_group")
-            it "no error" do
-            end
-
-            it "should interrupt" do
-              raise Interrupt, "I'm interrupting"
-            end
-          end
-
-          options = ::Spec::Runner::Options.new(@err, @out)
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-          options.add_example_group(example_group)
-
-          expect {
-            Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-          }.to raise_error(SystemExit)
-        end
-
-        it "should exit if Interrupt exception occurrs during an after(:each)" do
-          example_group = Class.new(::Spec::Example::ExampleGroup) do
-            describe("example_group")
-            it "no error" do
-            end
-
-            after do
-              raise Interrupt, "I'm interrupting"
-            end
-          end
-
-          options = ::Spec::Runner::Options.new(@err, @out)
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-          options.add_example_group(example_group)
-
-          expect {
-            Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-          }.to raise_error(SystemExit)
-        end
-
-        it "should heckle when options have heckle_runner" do
-          example_group = Class.new(::Spec::Example::ExampleGroup).describe("example_group") do
-            it "no error" do
-            end
-          end
-          options = ::Spec::Runner::Options.new(@err, @out)
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-          options.add_example_group example_group
-
-          heckle_runner = mock("heckle_runner")
-          heckle_runner.should_receive(:heckle_with)
-          $rspec_mocks.__send__(:mocks).delete(heckle_runner)
-
-          options.heckle_runner = heckle_runner
-          options.add_example_group(example_group)
-
-          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-          heckle_runner.rspec_verify
-        end
-
-        it "should run examples backwards if options.reverse is true" do
-          options = ::Spec::Runner::Options.new(@err, @out)
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-          options.reverse = true
-
-          b1 = Class.new(Spec::Example::ExampleGroup)
-          b2 = Class.new(Spec::Example::ExampleGroup)
-
-          b2.should_receive(:run).ordered
-          b1.should_receive(:run).ordered
-
-          options.add_example_group(b1)
-          options.add_example_group(b2)
-
-          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-        end
-
-        it "should pass its ExampleGroup to the reporter" do
-          example_group = describe("example_group") do
-            it "should" do
-            end
-          end
-          options = ::Spec::Runner::Options.new(@err, @out)
-          options.add_example_group(example_group)
-
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-          options.reporter.should_receive(:add_example_group).with(Spec::Example::ExampleGroupProxy.new(example_group))
-
-          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
-        end
-
-        it "runs only selected Examples when options.examples is set" do
-          options = ::Spec::Runner::Options.new(@err, @out)
-          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-
-          options.examples << "example group expected example"
-          expected_example_was_run = false
-          unexpected_example_was_run = false
-          example_group = describe("example group") do
-            it "expected example" do
-              expected_example_was_run = true
-            end
-            it "unexpected example" do
-              unexpected_example_was_run = true
-            end
-          end
-
-          options.reporter.should_receive(:add_example_group).with(Spec::Example::ExampleGroupProxy.new(example_group))
-
-          options.add_example_group example_group
-          run_with(options)
-
-          expected_example_was_run.should be_true
-          unexpected_example_was_run.should be_false
-        end
-      end
-    end
-  end
-end

data/spec/spec/runner/configuration_spec.rb

@@ -1,320 +0,0 @@
-require 'spec_helper'
-
-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 =~ /^spec\/adapters\/mock_frameworks\/rspec$/
-            end
-
-            it "should set rspec mocking explicitly" do
-              config.mock_with(:rspec)
-              config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/rspec$/
-            end
-
-            it "should set mocha" do
-              config.mock_with(:mocha)
-              config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/mocha$/
-            end
-
-            it "should set flexmock" do
-              config.mock_with(:flexmock)
-              config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/flexmock$/
-            end
-
-            it "should set rr" do
-              config.mock_with(:rr)
-              config.mock_framework.should =~ /^spec\/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 do # default is :each
-                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
-
-          describe "#ignore_backtrace_patterns" do
-            it "adds patterns to ignore in backtrace" do
-              config.ignore_backtrace_patterns /custom_pattern/, /shoulda/, /spork/
-              config.ignored_backtrace_patterns.should include(/custom_pattern/)
-              config.ignored_backtrace_patterns.should include(/shoulda/)
-              config.ignored_backtrace_patterns.should include(/spork/)
-            end
-          end
-          
-          describe "#predicate_matchers (DEPRECATED)" do
-            it "is deprecated" do
-              Spec.should_receive(:deprecate)
-              config.predicate_matchers[:foo] = :bar?
-            end
-          end
-
-        end
-      end
-    end
-  end
-end