rspec 0.7.5.1 → 0.8.0

data/spec/spec/mocks/twice_counts_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    context "TwiceCounts" do
+      setup do
+        @mock = Mock.new("test mock", {
+          :auto_verify => false
+        })
+      end
+
+      specify "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.__verify
+        end.should_raise(MockExpectationError)
+      end
+      
+      specify "twice should fail when call count is lower than expected" do
+        @mock.should_receive(:random_call).twice
+        @mock.random_call
+        lambda do
+          @mock.__verify
+        end.should_raise(MockExpectationError)
+      end
+      
+      specify "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(MockExpectationError)
+      end
+      
+      specify "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(MockExpectationError)
+      end
+      
+      specify "twice should pass when called twice" do
+        @mock.should_receive(:random_call).twice
+        @mock.random_call
+        @mock.random_call
+        @mock.__verify
+      end
+      
+      specify "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.__verify
+      end
+      
+      specify "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.__verify
+      end
+    end
+  end
+end

data/spec/spec/runner/command_line_spec.rb

@@ -0,0 +1,32 @@
+require 'stringio'
+context "CommandLine" do
+  specify "should run directory" do
+    file = File.dirname(__FILE__) + '/../../../examples'
+    err = StringIO.new
+    out = StringIO.new
+    Spec::Runner::CommandLine.run([file], err, out, false, true)
+    
+    out.rewind
+    out.read.should =~ /60 specifications, 0 failures/n
+  end
+
+  specify "should run file" do
+    file = File.dirname(__FILE__) + '/../../../examples/io_processor_spec.rb'
+    err = StringIO.new
+    out = StringIO.new
+    Spec::Runner::CommandLine.run([file], err, out, false, true)
+    
+    out.rewind
+    out.read.should =~ /2 specifications, 0 failures/n
+  end
+
+  specify "should raise when file does not exist" do
+    file = File.dirname(__FILE__) + '/doesntexist'
+    err = StringIO.new
+    out = StringIO.new
+
+    lambda {
+      Spec::Runner::CommandLine.run([file], err, out, false, true)
+    }.should_raise
+  end
+end

data/spec/spec/runner/context_matching_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Runner
+    context "ContextMatching" do
+
+      setup do
+        @formatter = Spec::Mocks::Mock.new("formatter")
+        @context = Context.new("context") {}
+        @context_eval = @context.instance_eval { @context_eval_module }
+      end
+
+      specify "run all specs when spec is not specified" do
+        @context_eval.specify("spec1") {}
+        @context_eval.specify("spec2") {}
+        @context.run_single_spec("context")
+        @context.number_of_specs.should_equal(2)
+      end
+
+      specify "should only run specified specs when specified" do
+        @context_eval.specify("spec1") {}
+        @context_eval.specify("spec2") {}
+        @context.run_single_spec("context spec1")
+        @context.number_of_specs.should_equal(1)
+      end
+    end
+  end
+end

data/spec/spec/runner/context_runner_spec.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "ContextRunner" do
+  specify "should call run on context" do
+    context1 = mock("context1", {
+     :null_object => true
+    })
+    context2 = mock("context2", {
+     :null_object => true
+    })
+    context1.should_receive(:run)
+    context1.should_receive(:number_of_specs).and_return(0)
+    context2.should_receive(:run)
+    context2.should_receive(:number_of_specs).and_return(0)
+    reporter = mock("reporter")
+    reporter.should_receive(:start).with(0)
+    reporter.should_receive(:end)
+    reporter.should_receive(:dump)
+
+    options = OpenStruct.new
+    options.reporter = reporter
+    runner = Spec::Runner::ContextRunner.new(options)
+    runner.add_context(context1)
+    runner.add_context(context2)
+    runner.run(false)
+  end
+
+  specify "should support single spec" do
+    desired_context = mock("desired context")
+    desired_context.should_receive(:matches?).at_least(:once).and_return(true)
+    desired_context.should_receive(:run)
+    desired_context.should_receive(:run_single_spec)
+    desired_context.should_receive(:number_of_specs).and_return(1)
+    other_context = mock("other context")
+    other_context.should_receive(:matches?).and_return(false)
+    other_context.should_receive(:run).never
+    other_context.should_receive(:number_of_specs).never
+    reporter = mock("reporter")
+    options = OpenStruct.new
+    options.reporter = reporter
+    options.spec_name = "desired context legal spec"
+
+    runner = Spec::Runner::ContextRunner.new(options)
+    runner.add_context(desired_context)
+    runner.add_context(other_context)
+    reporter.should_receive(:start)
+    reporter.should_receive(:end)
+    reporter.should_receive(:dump)
+    runner.run(false)
+  end
+
+  specify "should dump even if Interrupt exception is occurred" do
+    context = Spec::Runner::Context.new("context") do
+      specify "no error" do
+      end
+
+      specify "should interrupt" do
+        raise Interrupt
+      end
+    end
+
+    reporter = mock("reporter")
+    reporter.should_receive(:start)
+    reporter.should_receive(:add_context).with("context")
+    reporter.should_receive(:spec_started).with("no error")
+    reporter.should_receive(:spec_started).with("should interrupt")
+    reporter.should_receive(:spec_finished).twice
+    reporter.should_receive(:end)
+    reporter.should_receive(:dump)
+
+    options = OpenStruct.new
+    options.reporter = reporter
+    runner = Spec::Runner::ContextRunner.new(options)
+    runner.add_context(context)
+    runner.run(false)
+  end
+
+  specify "should heckle when options have heckle_runner" do
+    context = mock("context", :null_object => true)
+    context.should_receive(:number_of_specs).and_return(0)
+    context.should_receive(:run).and_return(0)
+
+    reporter = mock("reporter")
+    reporter.should_receive(:start).with(0)
+    reporter.should_receive(:end)
+    reporter.should_receive(:dump).and_return(0)
+
+    heckle_runner = mock("heckle_runner")
+    heckle_runner.should_receive(:heckle_with)
+
+    options = OpenStruct.new
+    options.reporter = reporter
+    options.heckle_runner = heckle_runner
+
+    runner = Spec::Runner::ContextRunner.new(options)
+    runner.add_context(context)
+    runner.run(false)
+
+  end
+end

data/spec/spec/runner/context_spec.rb

@@ -0,0 +1,405 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Runner
+    context "Context" do
+      
+      setup do
+        @formatter = Spec::Mocks::Mock.new "formatter", :register_as_spec_listener => false
+        @context = Context.new("context") {}
+        @context_eval = @context.instance_eval { @context_eval_module }
+      end
+
+      teardown do
+        @formatter.__verify
+      end
+      
+      specify "should add itself to formatter on run" do
+        @formatter.should_receive(:add_context).with "context"
+        @context.run(@formatter)
+      end
+      
+      specify "should run spec on run" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with "test", :anything, :anything
+        $spec_ran = false
+        @context_eval.specify("test") {$spec_ran = true}
+        @context.run(@formatter)
+        $spec_ran.should be_true
+      end
+         
+      specify "should not run spec on dry run" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with "test"
+        $spec_ran = false
+        @context_eval.specify("test") {$spec_ran = true}
+        @context.run(@formatter, true)
+        $spec_ran.should be_false
+      end
+
+      specify "should not run context_setup or context_teardown on dry run" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with "test"
+        
+        context_setup_ran = false
+        context_teardown_ran = false
+        @context_eval.context_setup { context_setup_ran = true }
+        @context_eval.context_teardown { context_teardown_ran = true }
+        @context_eval.specify("test") {true}
+        @context.run(@formatter, true)
+        context_setup_ran.should be_false
+        context_teardown_ran.should be_false
+      end
+
+      specify "should not run context if context_setup fails" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_finished).with :any_args
+        
+        spec_ran = false
+        @context_eval.context_setup { raise "help" }
+        @context_eval.specify("test") {spec_ran = true}
+        @context.run(@formatter)
+        spec_ran.should be_false
+      end
+
+      specify "should run context_teardown if any spec fails" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_finished).with :any_args
+        
+        context_teardown_ran = false
+        @context_eval.context_setup { raise "context_setup error" }
+        @context_eval.context_teardown { context_teardown_ran = true }
+        @context.run(@formatter)
+        context_teardown_ran.should be_true
+      end
+
+      specify "should run context_teardown if any context_setup fails" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with :any_args
+        
+        context_teardown_ran = false
+        @context_eval.context_teardown { context_teardown_ran = true }
+        @context_eval.specify("test") {raise "spec error" }
+        @context.run(@formatter)
+        context_teardown_ran.should be_true
+      end
+
+
+      specify "should supply context_setup as spec name if failure in context_setup" do
+        @formatter.should_receive(:add_context).with :any_args
+
+        @formatter.should_receive(:spec_finished) do |name, error, location|
+          name.should_eql("context_setup")
+          error.message.should_eql("in context_setup")
+          location.should_eql("context_setup")
+        end
+        
+        @context_eval.context_setup { raise "in context_setup" }
+        @context_eval.specify("test") {true}
+        @context.run(@formatter)
+      end
+
+      specify "should provide context_teardown as spec name if failure in context_teardown" do
+        @formatter.should_receive(:add_context).with :any_args
+
+        @formatter.should_receive(:spec_finished) do |name, error, location|
+          name.should_eql("context_teardown")
+          error.message.should_eql("in context_teardown")
+          location.should_eql("context_teardown")
+        end
+        
+        @context_eval.context_teardown { raise "in context_teardown" }
+        @context.run(@formatter)
+      end
+
+      specify "should run superclass context_setup and context_setup block only once per context" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_started).with "test2"
+        @formatter.should_receive(:spec_finished).twice.with :any_args
+
+        super_class_context_setup_run_count = 0
+        super_class = Class.new do
+          define_method :context_setup do
+            super_class_context_setup_run_count += 1
+          end
+        end
+        # using @context.inherit_context_eval_module_from here, but other examples use @context_eval.inherit
+        # - inherit_context_eval_module_from is used by Spec::Rails to avoid confusion with Ruby's #include method
+        @context.inherit_context_eval_module_from super_class
+
+        context_setup_run_count = 0
+        @context_eval.context_setup {context_setup_run_count += 1}
+        @context_eval.specify("test") {true}
+        @context_eval.specify("test2") {true}
+        @context.run(@formatter)
+        super_class_context_setup_run_count.should_be 1
+        context_setup_run_count.should_be 1
+      end
+      
+      specify "should run superclass setup method and setup block" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with :any_args
+
+        super_class_setup_ran = false
+        super_class = Class.new do
+          define_method :setup do
+            super_class_setup_ran = true
+          end
+        end
+        @context_eval.inherit super_class
+
+        setup_ran = false
+        @context_eval.setup {setup_ran = true}
+        @context_eval.specify("test") {true}
+        @context.run(@formatter)
+        super_class_setup_ran.should be_true
+        setup_ran.should be_true
+      end
+
+      specify "should run superclass context_teardown method and context_teardown block only once" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_started).with "test2"
+        @formatter.should_receive(:spec_finished).twice.with :any_args
+
+        super_class_context_teardown_run_count = 0
+        super_class = Class.new do
+          define_method :context_teardown do
+            super_class_context_teardown_run_count += 1
+          end
+        end
+        @context_eval.inherit super_class
+
+        context_teardown_run_count = 0
+        @context_eval.context_teardown {context_teardown_run_count += 1}
+        @context_eval.specify("test") {true}
+        @context_eval.specify("test2") {true}
+        @context.run(@formatter)
+        super_class_context_teardown_run_count.should_be 1
+        context_teardown_run_count.should_be 1
+        @formatter.__verify
+      end
+
+      specify "context_teardown should have access to all instance variables defined in context_setup" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with :any_args
+
+        context_instance_value_in = "Hello there"
+        context_instance_value_out = ""
+        @context_eval.context_setup { @instance_var = context_instance_value_in }
+        @context_eval.context_teardown { context_instance_value_out = @instance_var }
+        @context_eval.specify("test") {true}
+        @context.run(@formatter)
+        context_instance_value_in.should == context_instance_value_out
+      end
+
+      specify "should copy instance variables from context_setup's execution context into spec's execution context" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with :any_args
+
+        context_instance_value_in = "Hello there"
+        context_instance_value_out = ""
+        @context_eval.context_setup { @instance_var = context_instance_value_in }
+        @context_eval.specify("test") {context_instance_value_out = @instance_var}
+        @context.run(@formatter)
+        context_instance_value_in.should == context_instance_value_out
+      end
+
+      specify "should call context_setup before any setup" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with :any_args
+
+        fiddle = []
+        super_class = Class.new do
+          define_method :setup do
+            fiddle << "superclass setup"
+          end
+        end
+        @context_eval.inherit super_class
+
+        @context_eval.context_setup { fiddle << "context_setup" }
+        @context_eval.setup { fiddle << "setup" }
+        @context_eval.specify("test") {true}
+        @context.run(@formatter)
+        fiddle.first.should == "context_setup"
+        fiddle.last.should == "setup"
+      end
+
+      specify "should call context_teardown after any teardown" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with :any_args
+
+        fiddle = []
+        super_class = Class.new do
+          define_method :teardown do
+            fiddle << "superclass teardown"
+          end
+        end
+        @context_eval.inherit super_class
+
+        @context_eval.context_teardown { fiddle << "context_teardown" }
+        @context_eval.teardown { fiddle << "teardown" }
+        @context_eval.specify("test") {true}
+        @context.run(@formatter)
+        fiddle.first.should == "superclass teardown"
+        fiddle.last.should == "context_teardown"
+      end
+
+
+      specify "should run superclass teardown method and teardown block" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with :any_args
+
+        super_class_teardown_ran = false
+        super_class = Class.new do
+          define_method :teardown do
+            super_class_teardown_ran = true
+          end
+        end
+        @context_eval.inherit super_class
+
+        teardown_ran = false
+        @context_eval.teardown {teardown_ran = true}
+        @context_eval.specify("test") {true}
+        @context.run(@formatter)
+        super_class_teardown_ran.should be_true
+        teardown_ran.should be_true
+        @formatter.__verify
+      end
+
+      specify "should have accessible methods from inherited superclass" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with :any_args
+
+        helper_method_ran = false
+        super_class = Class.new do
+          define_method :helper_method do
+            helper_method_ran = true
+          end
+        end
+        @context_eval.inherit super_class
+
+        @context_eval.specify("test") {helper_method}
+        @context.run(@formatter)
+        helper_method_ran.should be_true
+      end
+
+      specify "should have accessible class methods from inherited superclass" do
+        class_method_ran = false
+        super_class = Class.new
+        (class << super_class; self; end).class_eval do
+          define_method :class_method do
+            class_method_ran = true
+          end
+        end
+        @context_eval.inherit super_class
+        @context.class_method
+        class_method_ran.should be_true
+
+        lambda {@context.foobar}.should_raise(NoMethodError)
+      end
+
+      specify "should include inherited class methods" do
+        class_method_ran = false
+        super_class = Class.new
+        class << super_class
+          def super_class_class_method; end
+        end
+        @context_eval.inherit super_class
+
+        @context.methods.should_include("super_class_class_method")
+      end
+
+      specify "should have accessible instance methods from included module" do
+        @formatter.should_receive(:add_context).with :any_args
+        @formatter.should_receive(:spec_started).with "test"
+        @formatter.should_receive(:spec_finished).with :any_args
+
+        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
+
+        @context_eval.include mod1
+        @context_eval.include mod2
+
+        @context_eval.specify("test") do
+          mod1_method
+          mod2_method
+        end
+        @context.run(@formatter)
+        mod1_method_called.should be_true
+        mod2_method_called.should be_true
+      end
+      
+      specify "should have accessible class methods from included module" do
+        mod1_method_called = false
+        mod1 = Module.new do
+          class_methods = Module.new do
+              define_method :mod1_method do
+                mod1_method_called = true
+              end
+          end
+          
+          (class << self; self; end).class_eval do
+            define_method(:included) do |receiver|
+              receiver.extend class_methods
+            end
+          end
+        end
+
+        mod2_method_called = false
+        mod2 = Module.new do
+          class_methods = Module.new do
+              define_method :mod2_method do
+                mod2_method_called = true
+              end
+          end
+          
+          (class << self; self; end).class_eval do
+            define_method(:included) do |receiver|
+              receiver.extend class_methods
+            end
+          end
+        end
+
+        @context_eval.include mod1
+        @context_eval.include mod2
+
+        @context_eval.mod1_method
+        @context_eval.mod2_method
+        mod1_method_called.should_be true
+        mod2_method_called.should_be true
+      end
+      
+      specify "should count number of specs" do
+        @context_eval.specify("one") {}
+        @context_eval.specify("two") {}
+        @context_eval.specify("three") {}
+        @context_eval.specify("four") {}
+        @context.number_of_specs.should_be 4
+      end
+    end
+  end
+end