rspec 1.3.2 → 2.0.0.a2

data/spec/spec/mocks/stubbed_message_expectations_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe "Example with stubbed and then called message" do
-      it "fails if the message is expected and then subsequently not called again" do
-        mock_obj = mock("mock", :msg => nil)
-        mock_obj.msg
-        mock_obj.should_receive(:msg)
-        lambda { mock_obj.rspec_verify }.should raise_error(Spec::Mocks::MockExpectationError)
-      end
-
-      it "outputs arguments of all similar calls" do
-        m = mock('mock', :foo => true)
-        m.should_receive(:foo).with('first')
-        m.foo('second')
-        m.foo('third')
-        lambda do
-          m.rspec_verify
-        end.should raise_error(%Q|Mock "mock" received :foo with unexpected arguments\n  expected: ("first")\n       got: (["second"], ["third"])|)
-        m.rspec_reset
-      end
-    end
-    
-  end
-end

data/spec/spec/mocks/twice_counts_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe "TwiceCounts" do
-      before(:each) do
-        @mock = mock("test mock")
-      end
-
-      it "twice should fail when call count is higher than expected" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-      
-      it "twice should fail when call count is lower than expected" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
-      end
-      
-      it "twice should fail when called twice with wrong args on the first call" do
-        @mock.should_receive(:random_call).twice.with("1", 1)
-        lambda do
-          @mock.random_call(1, "1")
-        end.should raise_error(MockExpectationError)
-        @mock.rspec_reset
-      end
-      
-      it "twice should fail when called twice with wrong args on the second call" do
-        @mock.should_receive(:random_call).twice.with("1", 1)
-        @mock.random_call("1", 1)
-        lambda do
-          @mock.random_call(1, "1")
-        end.should raise_error(MockExpectationError)
-        @mock.rspec_reset
-      end
-      
-      it "twice should pass when called twice" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call
-        @mock.random_call
-        @mock.rspec_verify
-      end
-      
-      it "twice should pass when called twice with specified args" do
-        @mock.should_receive(:random_call).twice.with("1", 1)
-        @mock.random_call("1", 1)
-        @mock.random_call("1", 1)
-        @mock.rspec_verify
-      end
-      
-      it "twice should pass when called twice with unspecified args" do
-        @mock.should_receive(:random_call).twice
-        @mock.random_call("1")
-        @mock.random_call(1)
-        @mock.rspec_verify
-      end
-    end
-  end
-end

data/spec/spec/mocks/unstub_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe Mock do
-      context "unstubbing a mock object with a stub" do
-        it "should remove the stub" do
-          a_mock = mock 'an object', :foo => :bar
-
-          a_mock.unstub! :foo
-          a_mock.should_not respond_to(:foo)
-        end
-      end
-
-      context "unstubbing a real object with a stub" do
-        before do
-          @obj = Object.new
-        end
-
-        it "should raise a NoMethodError if the message is called after unstubbing" do
-          @obj.stub!(:foo).and_return :bar
-          @obj.unstub!(:foo)
-
-          lambda {
-            @obj.foo
-          }.should raise_error(NoMethodError)
-        end
-
-        it "should only clear the stub specified" do
-          @obj.stub!(:foo).and_return :bar
-          @obj.stub!(:other).and_return :baz
-
-          @obj.unstub!(:foo)
-
-          @obj.other.should == :baz
-        end
-
-        it "should no longer respond_to? the method" do
-          @obj.stub!(:foo).and_return :bar
-          @obj.unstub!(:foo)
-
-          @obj.should_not respond_to(:foo)
-        end
-
-        it "should unstub using a string (should convert the string to a symbol)" do
-          @obj.stub!(:foo)
-
-          @obj.unstub!("foo")
-
-          @obj.should_not respond_to(:foo)
-        end
-
-        it "should restore a previous method definition" do
-          def @obj.foo
-            :a_result
-          end
-
-          @obj.stub!(:foo).and_return :stubbed_result
-          @obj.unstub!(:foo)
-
-          @obj.foo.should == :a_result
-        end
-
-        it "should have unstub as an alias of unstub!" do
-          @obj.stub!(:foo).and_return :bar
-
-          @obj.unstub(:foo)
-
-          lambda {
-            @obj.foo
-          }.should raise_error(NoMethodError)
-        end
-
-        it "should raise a MockExpectationError if it is not stubbed" do
-          lambda {
-            @obj.unstub!(:foo)
-          }.should raise_error(MockExpectationError, "The method `foo` was not stubbed or was already unstubbed")
-        end
-
-        it "should raise a MockExpectationError if it was already unstubbed" do
-          @obj.stub!(:foo)
-          @obj.unstub!(:foo)
-
-          lambda {
-            @obj.unstub!(:foo)
-          }.should raise_error(MockExpectationError, "The method `foo` was not stubbed or was already unstubbed")
-        end
-
-        it "should use the correct message name in the error" do
-          @obj.stub!(:bar)
-          @obj.unstub!(:bar)
-
-          lambda {
-            @obj.unstub!(:bar)
-          }.should raise_error(MockExpectationError, "The method `bar` was not stubbed or was already unstubbed")
-        end
-
-        it "should raise a MockExpectationError if the method is defined, but not stubbed" do
-          def @obj.meth; end
-
-          lambda {
-            @obj.unstub!(:meth)
-          }.should raise_error(MockExpectationError)
-        end
-
-        it "should be able to restub a after unstubbing" do
-          @obj.stub!(:foo).and_return :bar
-
-          @obj.unstub!(:foo)
-
-          @obj.stub!(:foo).and_return :baz
-
-          @obj.foo.should == :baz
-        end
-
-        it "should remove only the first stub if multiple stubs have been defined" do
-          @obj.stub!(:foo).and_return :first
-          @obj.stub!(:foo).and_return :second
-
-          @obj.unstub!(:foo)
-
-          @obj.foo.should == :first
-        end
-      end
-    end
-  end
-end

data/spec/spec/package/bin_spec_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'ruby_forker'
-
-describe "The bin/spec script" do
-  include RubyForker
-  
-  it "should have no warnings" do
-    output = ruby "-w -Ilib bin/spec --help"
-    output.should_not =~ /warning/n
-  end
-  
-  it "should show the help w/ no args" do
-    output = ruby "-w -Ilib bin/spec"
-    output.should =~ /^Usage: spec/
-  end
-end

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