rspec 1.0.0 → 1.3.1

data/spec/spec/matchers/handler_spec.rb

@@ -1,88 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module ExampleExpectations
-  
-  class ArbitraryMatcher
-    def initialize(*args, &block)
-      if args.last.is_a? Hash
-        @expected = args.last[:expected]
-      end
-      if block_given?
-        @expected = block.call
-      end
-      @block = block
-    end
-    
-    def matches?(target)
-      @target = target
-      return @expected == target
-    end
-    
-    def with(new_value)
-      @expected = new_value
-      self
-    end
-    
-    def failure_message
-      "expected #{@expected}, got #{@target}"
-    end
-    
-    def negative_failure_message
-      "expected not #{@expected}, got #{@target}"
-    end
-  end
-  
-  class PositiveOnlyMatcher < ArbitraryMatcher
-    undef negative_failure_message
-  end
-  
-  def arbitrary_matcher(*args, &block)
-    ArbitraryMatcher.new(*args, &block)
-  end
-  
-  def positive_only_matcher(*args, &block)
-    PositiveOnlyMatcher.new(*args, &block)
-  end
-  
-end
-
-module Spec
-  module Expectations
-    describe ExpectationMatcherHandler, ".handle_matcher" do
-      it "should ask the matcher if it matches" do
-        matcher = mock("matcher")
-        actual = Object.new
-        matcher.should_receive(:matches?).with(actual).and_return(true)
-        ExpectationMatcherHandler.handle_matcher(actual, matcher)
-      end
-    end
-    
-    describe ExpectationMatcherHandler do
-      include ExampleExpectations
-      
-      it "should handle submitted args" do
-        5.should arbitrary_matcher(:expected => 5)
-        5.should arbitrary_matcher(:expected => "wrong").with(5)
-        lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
-        lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
-        5.should_not arbitrary_matcher(:expected => 4)
-        5.should_not arbitrary_matcher(:expected => 5).with(4)
-        lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
-        lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
-      end
-
-      it "should handle the submitted block" do
-        5.should arbitrary_matcher { 5 }
-        5.should arbitrary_matcher(:expected => 4) { 5 }
-        5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
-      end
-  
-      it "should explain when matcher does not support should_not" do
-        lambda {
-          5.should_not positive_only_matcher(:expected => 5)
-        }.should fail_with(/Matcher does not support should_not.\n/)
-      end
-
-    end
-  end
-end

data/spec/spec/matchers/matcher_methods_spec.rb

@@ -1,78 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Matchers
-    context %Q{The Spec::Matchers module gets included in the execution context of every spec.
-This module should provide the following methods, each of which returns a Matcher object.} do
-      it "be_true" do
-        be_true.should be_an_instance_of(Be)
-      end
-      it "be_false" do
-        be_false.should be_an_instance_of(Be)
-      end
-      it "be_nil" do
-        be_nil.should be_an_instance_of(Be)
-      end
-      it "be_arbitrary_predicate" do
-        be_arbitrary_predicate.should be_an_instance_of(Be)
-      end
-      it "be_close" do
-        be_close(1,2).should be_an_instance_of(BeClose)
-      end
-      it "change" do
-        change("target", :message).should be_an_instance_of(Change)
-      end
-      it "eql" do
-        eql(:expected).should be_an_instance_of(Eql)
-      end
-      it "equal" do
-        equal(:expected).should be_an_instance_of(Equal)
-      end
-      it "have" do
-        have(0).should be_an_instance_of(Have)
-      end
-      it "have_exactly" do
-        have_exactly(0).should be_an_instance_of(Have)
-      end
-      it "have_at_least" do
-        have_at_least(0).should be_an_instance_of(Have)
-      end
-      it "have_at_most" do
-        have_at_most(0).should be_an_instance_of(Have)
-      end
-      it "include" do
-        include(:value).should be_an_instance_of(Include)
-      end
-      it "match" do
-        match(:value).should be_an_instance_of(Match)
-      end
-      it "raise_error" do
-        raise_error.should be_an_instance_of(RaiseError)
-        raise_error(NoMethodError).should be_an_instance_of(RaiseError)
-        raise_error(NoMethodError, "message").should be_an_instance_of(RaiseError)
-      end
-      it "satisfy" do
-        satisfy{}.should be_an_instance_of(Satisfy)
-      end
-      it "throw_symbol" do
-        throw_symbol.should be_an_instance_of(ThrowSymbol)
-        throw_symbol(:sym).should be_an_instance_of(ThrowSymbol)
-      end
-      it "respond_to" do
-        respond_to(:sym).should be_an_instance_of(RespondTo)
-      end
-    end
-    
-    describe "Spec::Matchers#method_missing" do
-      it "should convert be_xyz to Be(:be_xyz)" do
-        Be.should_receive(:new).with(:be_whatever)
-        be_whatever
-      end
-
-      it "should convert have_xyz to Has(:have_xyz)" do
-        Has.should_receive(:new).with(:have_whatever)
-        have_whatever
-      end
-    end
-  end
-end

data/spec/spec/matchers/raise_error_spec.rb

@@ -1,147 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "should raise_error" do
-  it "should pass if anything is raised" do
-    lambda {raise}.should raise_error
-  end
-  
-  it "should fail if nothing is raised" do
-    lambda {
-      lambda {}.should raise_error
-    }.should fail_with("expected Exception but nothing was raised")
-  end
-end
-
-describe "should_not raise_error" do
-  it "should pass if nothing is raised" do
-    lambda {}.should_not raise_error
-  end
-  
-  it "should fail if anything is raised" do
-    lambda {
-      lambda {raise}.should_not raise_error
-    }.should fail_with("expected no Exception, got RuntimeError")
-  end
-end
-
-describe "should raise_error(NamedError)" do
-  it "should pass if named error is raised" do
-    lambda { non_existent_method }.should raise_error(NameError)
-  end
-  
-  it "should fail if nothing is raised" do
-    lambda {
-      lambda { }.should raise_error(NameError)
-    }.should fail_with("expected NameError but nothing was raised")
-  end
-  
-  it "should fail if another error is raised" do
-    lambda {
-      lambda { raise }.should raise_error(NameError)
-    }.should fail_with("expected NameError, got RuntimeError")
-  end
-end
-
-describe "should_not raise_error(NamedError)" do
-  it "should pass if nothing is raised" do
-    lambda { }.should_not raise_error(NameError)
-  end
-  
-  it "should pass if another error is raised" do
-    lambda { raise }.should_not raise_error(NameError)
-  end
-  
-  it "should fail if named error is raised" do
-    lambda {
-      lambda { non_existent_method }.should_not raise_error(NameError)
-    }.should fail_with(/expected no NameError, got #<NameError: undefined/)
-  end  
-end
-
-describe "should raise_error(NamedError, error_message) with String" do
-  it "should pass if named error is raised with same message" do
-    lambda { raise "example message" }.should raise_error(RuntimeError, "example message")
-  end
-  
-  it "should fail if nothing is raised" do
-    lambda {
-      lambda {}.should raise_error(RuntimeError, "example message")
-    }.should fail_with("expected RuntimeError with \"example message\" but nothing was raised")
-  end
-  
-  it "should fail if incorrect error is raised" do
-    lambda {
-      lambda { raise }.should raise_error(NameError, "example message")
-    }.should fail_with("expected NameError with \"example message\", got RuntimeError")
-  end
-  
-  it "should fail if correct error is raised with incorrect message" do
-    lambda {
-      lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, "example message")
-    }.should fail_with(/expected RuntimeError with \"example message\", got #<RuntimeError: not the example message/)
-  end
-end
-
-describe "should_not raise_error(NamedError, error_message) with String" do
-  it "should pass if nothing is raised" do
-    lambda {}.should_not raise_error(RuntimeError, "example message")
-  end
-  
-  it "should pass if a different error is raised" do
-    lambda { raise }.should_not raise_error(NameError, "example message")
-  end
-  
-  it "should pass if same error is raised with different message" do
-    lambda { raise RuntimeError.new("not the example message") }.should_not raise_error(RuntimeError, "example message")
-  end
-  
-  it "should fail if named error is raised with same message" do
-    lambda {
-      lambda { raise "example message" }.should_not raise_error(RuntimeError, "example message")
-    }.should fail_with("expected no RuntimeError with \"example message\", got #<RuntimeError: example message>")
-  end
-end
-
-describe "should raise_error(NamedError, error_message) with Regexp" do
-  it "should pass if named error is raised with matching message" do
-    lambda { raise "example message" }.should raise_error(RuntimeError, /ample mess/)
-  end
-  
-  it "should fail if nothing is raised" do
-    lambda {
-      lambda {}.should raise_error(RuntimeError, /ample mess/)
-    }.should fail_with("expected RuntimeError with message matching /ample mess/ but nothing was raised")
-  end
-  
-  it "should fail if incorrect error is raised" do
-    lambda {
-      lambda { raise }.should raise_error(NameError, /ample mess/)
-    }.should fail_with("expected NameError with message matching /ample mess/, got RuntimeError")
-  end
-  
-  it "should fail if correct error is raised with incorrect message" do
-    lambda {
-      lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, /less than ample mess/)
-    }.should fail_with("expected RuntimeError with message matching /less than ample mess/, got #<RuntimeError: not the example message>")
-  end
-end
-
-describe "should_not raise_error(NamedError, error_message) with Regexp" do
-  it "should pass if nothing is raised" do
-    lambda {}.should_not raise_error(RuntimeError, /ample mess/)
-  end
-  
-  it "should pass if a different error is raised" do
-    lambda { raise }.should_not raise_error(NameError, /ample mess/)
-  end
-  
-  it "should pass if same error is raised with non-matching message" do
-    lambda { raise RuntimeError.new("non matching message") }.should_not raise_error(RuntimeError, /ample mess/)
-  end
-  
-  it "should fail if named error is raised with matching message" do
-    lambda {
-      lambda { raise "example message" }.should_not raise_error(RuntimeError, /ample mess/)
-    }.should fail_with("expected no RuntimeError with message matching /ample mess/, got #<RuntimeError: example message>")
-  end
-end

data/spec/spec/mocks/failing_mock_argument_constraints_spec.rb

@@ -1,73 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Mocks
-    describe "FailingMockArgumentConstraints" do
-      before do
-        @mock = mock("test mock")
-        @reporter = Mock.new("reporter", :null_object => true)
-      end
-      
-      after do
-        @mock.rspec_reset
-      end
-      
-      it "should reject goose when expecting a duck" do
-        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:abs, :div))
-        lambda { @mock.random_call("I don't respond to :abs or :div") }.should raise_error(MockExpectationError)
-      end
-      
-      it "should reject non boolean" do
-        @mock.should_receive(:random_call).with(:boolean)
-        lambda do
-          @mock.random_call("false")
-        end.should raise_error(MockExpectationError)
-      end
-      
-      it "should reject non numeric" do
-        @mock.should_receive(:random_call).with(:numeric)
-        lambda do
-          @mock.random_call("1")
-        end.should raise_error(MockExpectationError)
-      end
-      
-      it "should reject non string" do
-        @mock.should_receive(:random_call).with(:string)
-        lambda do
-          @mock.random_call(123)
-        end.should raise_error(MockExpectationError)
-      end
-      
-      it "should fail if regexp does not match submitted string" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        lambda { @mock.random_call("abc") }.should raise_error(MockExpectationError)
-      end
-      
-      it "should fail if regexp does not match submitted regexp" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        lambda { @mock.random_call(/bcde/) }.should raise_error(MockExpectationError)
-      end
-      
-      it "should fail for a hash w/ wrong values" do
-        @mock.should_receive(:random_call).with(:a => "b", :c => "d")
-        lambda do
-          @mock.random_call(:a => "b", :c => "e")
-        end.should raise_error(MockExpectationError, /Mock 'test mock' expected :random_call with \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\) but received it with \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
-      end
-      
-      it "should fail for a hash w/ wrong keys" do
-        @mock.should_receive(:random_call).with(:a => "b", :c => "d")
-        lambda do
-          @mock.random_call("a" => "b", "c" => "d")
-        end.should raise_error(MockExpectationError, /Mock 'test mock' expected :random_call with \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\) but received it with \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
-      end
-      
-      it "should match against a Matcher" do
-        lambda do
-          @mock.should_receive(:msg).with(equal(3))
-          @mock.msg(37)
-        end.should raise_error(MockExpectationError, "Mock 'test mock' expected :msg with (equal 3) but received it with (37)")
-      end
-    end
-  end
-end

data/spec/spec/mocks/passing_mock_argument_constraints_spec.rb

@@ -1,92 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Mocks
-    describe "a mock, in handling arguments" do
-      before(:each) do
-        @mock = Mock.new("test mock")
-      end
-      
-      after(:each) do
-        @mock.rspec_verify
-      end
-
-      it "should accept true as boolean" do
-        @mock.should_receive(:random_call).with(:boolean)
-        @mock.random_call(true)
-      end
-      
-      it "should accept false as boolean" do
-        @mock.should_receive(:random_call).with(:boolean)
-        @mock.random_call(false)
-      end
-
-      it "should accept fixnum as numeric" do
-        @mock.should_receive(:random_call).with(:numeric)
-        @mock.random_call(1)
-      end
-
-      it "should accept float as numeric" do
-        @mock.should_receive(:random_call).with(:numeric)
-        @mock.random_call(1.5)
-      end
-
-      it "should accept string as anything" do
-        @mock.should_receive(:random_call).with("a", :anything, "c")
-        @mock.random_call("a", "whatever", "c")
-      end
-
-      it "should match duck type with one method" do
-        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:length))
-        @mock.random_call([])
-      end
-
-      it "should match duck type with two methods" do
-        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:abs, :div))
-        @mock.random_call(1)
-      end
-
-      it "should match non special symbol" do
-        @mock.should_receive(:random_call).with(:some_symbol)
-        @mock.random_call(:some_symbol)
-      end
-
-      it "should match string" do
-        @mock.should_receive(:random_call).with(:string)
-        @mock.random_call("a string")
-      end
-
-      it "should match string against regexp" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        @mock.random_call("abcde")
-      end
-
-      it "should match regexp against regexp" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        @mock.random_call(/bcd/)
-      end
-      
-      it "should match against a hash submitted and received by value" do
-        @mock.should_receive(:random_call).with(:a => "a", :b => "b")
-        @mock.random_call(:a => "a", :b => "b")
-      end
-      
-      it "should match against a hash submitted by reference and received by value" do
-        opts = {:a => "a", :b => "b"}
-        @mock.should_receive(:random_call).with(opts)
-        @mock.random_call(:a => "a", :b => "b")
-      end
-      
-      it "should match against a hash submitted by value and received by reference" do
-        opts = {:a => "a", :b => "b"}
-        @mock.should_receive(:random_call).with(:a => "a", :b => "b")
-        @mock.random_call(opts)
-      end
-      
-      it "should match against a Matcher" do
-        @mock.should_receive(:msg).with(equal(37))
-        @mock.msg(37)
-      end
-    end
-  end
-end

data/spec/spec/runner/behaviour_runner_spec.rb

@@ -1,118 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module Runner
-    describe BehaviourRunner do
-
-      it "should only run behaviours with at least one example" do
-        desired_context = mock("desired context")
-        desired_context.should_receive(:run)
-        desired_context.should_receive(:retain_examples_matching!)
-        desired_context.should_receive(:number_of_examples).twice.and_return(1)
-        desired_context.should_receive(:shared?).and_return(false)
-
-        other_context = mock("other context")
-        other_context.should_receive(:run).never
-        other_context.should_receive(:retain_examples_matching!)
-        other_context.should_receive(:number_of_examples).and_return(0)
-
-        reporter = mock("reporter")
-        options = Options.new
-        options.reporter = reporter
-        options.examples = ["desired context legal spec"]
-
-        runner = Spec::Runner::BehaviourRunner.new(options)
-        runner.add_behaviour(desired_context)
-        runner.add_behaviour(other_context)
-        reporter.should_receive(:start)
-        reporter.should_receive(:end)
-        reporter.should_receive(:dump)
-        runner.run([], false)
-      end
-
-      it "should dump even if Interrupt exception is occurred" do
-        behaviour = Spec::DSL::Behaviour.new("context") do
-          it "no error" do
-          end
-
-          it "should interrupt" do
-            raise Interrupt
-          end
-        end
-        
-        reporter = mock("reporter")
-        reporter.should_receive(:start)
-        reporter.should_receive(:add_behaviour).with("context")
-        reporter.should_receive(:example_started).twice
-        reporter.should_receive(:example_finished).twice
-        reporter.should_receive(:rspec_verify)
-        reporter.should_receive(:rspec_reset)
-        reporter.should_receive(:end)
-        reporter.should_receive(:dump)
-
-        options = Options.new
-        options.reporter = reporter
-        runner = Spec::Runner::BehaviourRunner.new(options)
-        runner.add_behaviour(behaviour)
-        runner.run([], false)
-      end
-
-      it "should heckle when options have heckle_runner" do
-        context = mock("context", :null_object => true)
-        context.should_receive(:number_of_examples).twice.and_return(1)
-        context.should_receive(:run).and_return(0)
-        context.should_receive(:shared?).and_return(false)
-
-        reporter = mock("reporter")
-        reporter.should_receive(:start).with(1)
-        reporter.should_receive(:end)
-        reporter.should_receive(:dump).and_return(0)
-
-        heckle_runner = mock("heckle_runner")
-        heckle_runner.should_receive(:heckle_with)
-
-        options = Options.new
-        options.reporter = reporter
-        options.heckle_runner = heckle_runner
-
-        runner = Spec::Runner::BehaviourRunner.new(options)
-        runner.add_behaviour(context)
-        runner.run([], false)
-      end
-
-      it "should run specs backward if options.reverse is true" do
-        options = Options.new
-        options.reverse = true
-
-        reporter = mock("reporter")
-        reporter.should_receive(:start).with(3)
-        reporter.should_receive(:end)
-        reporter.should_receive(:dump).and_return(0)
-        options.reporter = reporter
-
-        runner = Spec::Runner::BehaviourRunner.new(options)
-        c1 = mock("c1")
-        c1.should_receive(:number_of_examples).twice.and_return(1)
-        c1.should_receive(:shared?).and_return(false)
-
-        c2 = mock("c2")
-        c2.should_receive(:number_of_examples).twice.and_return(2)
-        c2.should_receive(:shared?).and_return(false)
-        c2.should_receive(:run) do
-          c1.should_receive(:run)
-        end
-
-        runner.add_behaviour(c1)
-        runner.add_behaviour(c2)
-    
-        runner.run([], false)
-      end
-      
-      it "should yield global configuration" do
-        Spec::Runner.configure do |config|
-          config.should equal(Spec::Runner.configuration)
-        end
-      end
-    end
-  end
-end

data/spec/spec/runner/context_matching_spec.rb

@@ -1,27 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module DSL
-    describe "ContextMatching" do
-
-      before(:each) do
-        @formatter = Spec::Mocks::Mock.new("formatter")
-        @behaviour = Behaviour.new("context") {}
-      end
-
-      it "run all specs when spec is not specified" do
-        @behaviour.it("spec1") {}
-        @behaviour.it("spec2") {}
-        @behaviour.retain_examples_matching!(["context"])
-        @behaviour.number_of_examples.should == 2
-      end
-
-      it "should only run specified examples when specified" do
-        @behaviour.it("spec1") {}
-        @behaviour.it("spec2") {}
-        @behaviour.retain_examples_matching!(["context spec1"])
-        @behaviour.number_of_examples.should == 1
-      end
-    end
-  end
-end

data/spec/spec/runner/execution_context_spec.rb

@@ -1,31 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe "ExecutionContext" do
-  
-  it "should provide duck_type()" do
-    dt = duck_type(:length)
-    dt.should be_an_instance_of(Spec::Mocks::DuckTypeArgConstraint)
-    dt.matches?([]).should be_true
-  end
-
-  it "should violate when violated()" do
-    lambda do
-      violated
-    end.should raise_error(Spec::Expectations::ExpectationNotMetError)
-  end
-
-  it "should provide mock()" do
-    mock("thing").should be_an_instance_of(Spec::Mocks::Mock)
-  end
-
-  it "should provide stub()" do
-    thing_stub = stub("thing").should be_an_instance_of(Spec::Mocks::Mock)
-  end
-  
-  it "should add method stubs to stub()" do
-    thing_stub = stub("thing", :a => "A", :b => "B")
-    thing_stub.a.should == "A"
-    thing_stub.b.should == "B"
-  end
-
-end

data/spec/spec/runner/extensions/kernel_spec.rb

@@ -1,36 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper.rb'
-
-describe Kernel, "when extended by rspec" do
-  it "should respond to :describe" do
-    Object.new.should respond_to(:describe)
-    Object.new.should respond_to(:context)
-  end
-end
-
-describe Kernel, " when creating behaviours with describe" do
-
-  it "should fail when no block given" do
-    lambda { describe "foo" }.should raise_error(ArgumentError)
-  end
-
-  it "should fail when no description given" do
-    lambda { describe do; end }.should raise_error(ArgumentError)
-  end
-end
-
-describe Kernel, "#respond_to" do
-  before(:each) do
-    @kernel_impersonator = Class.new do
-      include Kernel
-    end.new
-  end
-  
-  it "should return a Spec::Matchers::RespondTo" do
-    @kernel_impersonator.respond_to.should be_an_instance_of(Spec::Matchers::RespondTo)
-  end
-  
-  it "should pass the submitted names to the RespondTo instance" do
-    Spec::Matchers::RespondTo.should_receive(:new).with(:a,'b','c?')
-    @kernel_impersonator.respond_to(:a,'b','c?')
-  end
-end