merb-core 1.0.15 → 1.1.0.pre

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/spec/spec/mocks/stub_spec.rb

@@ -0,0 +1,188 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    describe "A method stub" do
+      before(:each) do
+        @class = Class.new do
+          def self.existing_class_method
+            :original_value
+          end
+
+          def existing_instance_method
+            :original_value
+          end
+        end
+        @instance = @class.new
+        @stub = Object.new
+      end
+
+      it "should return expected value when expected message is received" do
+        @instance.stub!(:msg).and_return(:return_value)
+        @instance.msg.should equal(:return_value)
+        @instance.rspec_verify
+      end
+
+      it "should ignore when expected message is received" do
+        @instance.stub!(:msg)
+        @instance.msg
+        lambda do
+          @instance.rspec_verify
+        end.should_not raise_error
+      end
+
+      it "should ignore when message is received with args" do
+        @instance.stub!(:msg)
+        @instance.msg(:an_arg)
+        lambda do
+          @instance.rspec_verify
+        end.should_not raise_error
+      end
+
+      it "should ignore when expected message is not received" do
+        @instance.stub!(:msg)
+        lambda do
+          @instance.rspec_verify
+        end.should_not raise_error
+      end
+
+      it "should handle multiple stubbed methods" do
+        @instance.stub!(:msg1 => 1, :msg2 => 2)
+        @instance.msg1.should == 1
+        @instance.msg2.should == 2
+      end
+      
+      it "should clear itself when verified" do
+        @instance.stub!(:this_should_go).and_return(:blah)
+        @instance.this_should_go.should == :blah
+        @instance.rspec_verify
+        lambda do
+          @instance.this_should_go
+        end.should raise_error(NameError)
+      end
+
+      it "should return values in order to consecutive calls" do
+        return_values = ["1",2,Object.new]
+        @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
+        @instance.msg.should == return_values[0]
+        @instance.msg.should == return_values[1]
+        @instance.msg.should == return_values[2]
+      end
+
+      it "should keep returning last value in consecutive calls" do
+        return_values = ["1",2,Object.new]
+        @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
+        @instance.msg.should == return_values[0]
+        @instance.msg.should == return_values[1]
+        @instance.msg.should == return_values[2]
+        @instance.msg.should == return_values[2]
+        @instance.msg.should == return_values[2]
+      end
+
+      it "should revert to original instance method if there is one" do
+        @instance.existing_instance_method.should equal(:original_value)
+        @instance.stub!(:existing_instance_method).and_return(:mock_value)
+        @instance.existing_instance_method.should equal(:mock_value)
+        @instance.rspec_verify
+        @instance.existing_instance_method.should equal(:original_value)
+      end
+      
+      it "should revert to original class method if there is one" do
+        @class.existing_class_method.should equal(:original_value)
+        @class.stub!(:existing_class_method).and_return(:mock_value)
+        @class.existing_class_method.should equal(:mock_value)
+        @class.rspec_verify
+        @class.existing_class_method.should equal(:original_value)
+      end
+
+      it "should yield a specified object" do
+        @instance.stub!(:method_that_yields).and_yield(:yielded_obj)
+        current_value = :value_before
+        @instance.method_that_yields {|val| current_value = val}
+        current_value.should == :yielded_obj
+        @instance.rspec_verify
+      end
+
+      it "should yield multiple times with multiple calls to and_yield" do
+        @instance.stub!(:method_that_yields_multiple_times).and_yield(:yielded_value).
+                                                       and_yield(:another_value)
+        current_value = []
+        @instance.method_that_yields_multiple_times {|val| current_value << val}
+        current_value.should == [:yielded_value, :another_value]
+        @instance.rspec_verify
+      end
+      
+      it "should yield a specified object and return another specified object" do
+        yielded_obj = mock("my mock")
+        yielded_obj.should_receive(:foo).with(:bar)
+        @instance.stub!(:method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz)
+        @instance.method_that_yields_and_returns { |o| o.foo :bar }.should == :baz
+      end
+
+      it "should throw when told to" do
+        @mock.stub!(:something).and_throw(:up)
+        lambda do
+          @mock.something
+        end.should throw_symbol(:up)
+      end
+      
+      it "should override a pre-existing stub" do
+        @stub.stub!(:existing_instance_method).and_return(:updated_stub_value)
+        @stub.existing_instance_method.should == :updated_stub_value
+      end
+      
+      it "should limit " do
+        @stub.stub!(:foo).with("bar")
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+    end
+    
+    describe "A method stub with args" do
+      before(:each) do
+        @stub = Object.new
+        @stub.stub!(:foo).with("bar")
+      end
+
+      it "should not complain if not called" do
+      end
+
+      it "should not complain if called with arg" do
+        @stub.foo("bar")
+      end
+
+      it "should complain if called with no arg" do
+        lambda do
+          @stub.foo
+        end.should raise_error
+      end
+
+      it "should complain if called with other arg" do
+        lambda do
+          @stub.foo("other")
+        end.should raise_error
+      end
+
+      it "should not complain if also mocked w/ different args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+
+      it "should complain if also mocked w/ different args AND called w/ a 3rd set of args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+        lambda do
+          @stub.foo("other")
+        end.should raise_error
+      end
+      
+      it "should support options" do
+        @stub.stub!(:foo, :expected_from => "bar")
+      end
+    end
+
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/spec/spec/mocks/twice_counts_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+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/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/spec/spec/package/bin_spec_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../../ruby_forker'
+
+describe "The bin/spec script" do
+  include RubyForker
+  
+  it "should have no warnings" do
+    pending "Hangs on JRuby" if PLATFORM =~ /java/
+    spec_path = "#{File.dirname(__FILE__)}/../../../bin/spec"
+
+    output = ruby "-w #{spec_path} --help 2>&1"
+    output.should_not =~ /warning/n
+  end
+  
+  it "should show the help w/ no args" do
+    pending "Hangs on JRuby" if PLATFORM =~ /java/
+    spec_path = "#{File.dirname(__FILE__)}/../../../bin/spec"
+
+    output = ruby "-w #{spec_path} 2>&1"
+    output.should =~ /^Usage: spec/
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/spec/spec/runner/class_and_argument_parser_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+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/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/spec/spec/runner/command_line_spec.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+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/pure'
+          run_with(OptionParser.parse([file,"-p","**/*.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__) + '/../../../failing_examples/predicate_example.rb'
+          run_with(OptionParser.parse([file], @err, @out))
+
+          @out.rewind
+          @out.read.should =~ /2 examples, 1 failure/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 dump even if Interrupt exception is occurred" 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.reporter.should_receive(:dump)
+          options.add_example_group(example_group)
+
+          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+        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(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(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/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/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 Config::CONFIG['ruby_install_name'] == '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 Config::CONFIG['ruby_install_name'] == '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/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/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/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/spec/spec/runner/failed.txt

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

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/spec/spec/runner/formatter/base_formatter_spec.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + "/../../../spec_helper"
+
+module Spec
+  module Runner
+    module Formatter
+      describe BaseFormatter do
+        before :each do
+          @options, @where = nil, nil
+          @formatter = BaseFormatter.new(@options, @where)
+        end
+        
+        class HaveInterfaceMatcher
+          def initialize(method)
+            @method = method
+          end
+          
+          attr_reader :object
+          attr_reader :method
+          
+          def matches?(object)
+            @object = object
+            object.respond_to?(@method)
+          end
+          
+          def with(arity)
+            WithArity.new(self, @method, arity)
+          end
+          
+          class WithArity
+            def initialize(matcher, method, arity)
+              @have_matcher = matcher
+              @method = method
+              @arity  = arity
+            end
+            
+            def matches?(an_object)
+              @have_matcher.matches?(an_object) && real_arity == @arity
+            end
+            
+            def failure_message
+              "#{@have_matcher} should have method :#{@method} with #{argument_arity}, but it had #{real_arity}"
+            end
+            
+            def arguments
+              self
+            end
+            
+            alias_method :argument, :arguments
+            
+          private
+            
+            def real_arity
+              @have_matcher.object.method(@method).arity
+            end
+            
+            def argument_arity
+              if @arity == 1
+                "1 argument"
+              else
+                "#{@arity} arguments"
+              end
+            end
+          end
+        end
+        
+        def have_interface_for(method)
+          HaveInterfaceMatcher.new(method)
+        end
+        
+        it "should have start as an interface with one argument"do
+          @formatter.should have_interface_for(:start).with(1).argument
+        end
+        
+        it "should have add_example_group as an interface with one argument" do
+          @formatter.should have_interface_for(:add_example_group).with(1).argument
+        end
+        
+        it "should have example_started as an interface with one argument" do
+          @formatter.should have_interface_for(:example_started).with(1).argument
+        end
+        
+        it "should have example_failed as an interface with three arguments" do
+          @formatter.should have_interface_for(:example_failed).with(3).arguments
+        end
+        
+        it "should have example_pending as an interface with three arguments" do
+          @formatter.should have_interface_for(:example_pending).with(3).arguments
+        end
+        
+        it "should have start_dump as an interface with zero arguments" do
+          @formatter.should have_interface_for(:start_dump).with(0).arguments
+        end
+        
+        it "should have dump_failure as an interface with two arguments" do
+          @formatter.should have_interface_for(:dump_failure).with(2).arguments
+        end
+        
+        it "should have dump_summary as an interface with two arguments" do
+          @formatter.should have_interface_for(:dump_failure).with(2).arguments
+        end
+
+        it "should have dump_pending as an interface with zero arguments" do
+          @formatter.should have_interface_for(:dump_pending).with(0).arguments
+        end
+
+        it "should have close  as an interface with zero arguments" do
+          @formatter.should have_interface_for(:close).with(0).arguments
+        end
+      end
+    end
+  end
+end