rspec 1.0.0 → 1.3.1

data/spec/spec/dsl/configuration_spec.rb

@@ -1,50 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module DSL
-    describe Configuration do
-      before(:each) do
-        @config = Configuration.new
-        @behaviour = mock("behaviour")
-      end
-
-      it "should default mock framework to rspec" do
-        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/
-      end
-
-      it "should let you set rspec mocking explicitly" do
-        @config.mock_with(:rspec)
-        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rspec$/
-      end
-
-      it "should let you set mocha" do
-        @config.mock_with(:mocha)
-        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/mocha$/
-      end
-
-      it "should let you set flexmock" do
-        @config.mock_with(:flexmock)
-        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/flexmock$/
-      end
-      
-      it "should let you set an arbitrary adapter module" do
-        adapter = Module.new
-        @config.mock_with(adapter)
-        @config.mock_framework.should == adapter
-      end
-      
-      it "should let you define modules to be included" do
-        mod = Module.new
-        @config.include mod
-        @config.included_modules.should include(mod)
-      end
-      
-      [:prepend_before, :append_before, :prepend_after, :append_after].each do |m|
-        it "should delegate ##{m} to Behaviour class" do
-          Behaviour.should_receive(m).with(:whatever)
-          @config.__send__(m, :whatever)
-        end
-      end
-    end
-  end
-end

data/spec/spec/dsl/description_spec.rb

@@ -1,81 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module DSL
-    describe Description, " constructed with a single String" do 
-      before(:each) {@description = Description.new("abc")}
-      
-      it "should provide that string as its name" do
-        @description.description.should == "abc"
-      end
-      it "should provide nil as its type" do
-        @description.described_type.should be_nil
-      end
-      it "should respond to []" do
-        @description[:key].should be_nil
-      end
-      it "should respond to []=" do
-        @description[:key] = :value
-        @description[:key].should == :value
-      end
-      it "should return for == when value matches description" do
-        @description.should == "abc"
-      end
-      it "should return for == when value is other description that matches description" do
-        @description.should == Description.new("abc")
-      end
-    end
-    
-    describe Description, " constructed with a Type" do 
-      before(:each) {@description = Description.new(Behaviour)}
-
-      it "should provide a String representation of that type (fully qualified) as its name" do
-        @description.description.should == "Spec::DSL::Behaviour"
-      end
-      it "should provide that type (fully qualified) as its type" do
-        @description.described_type.should == Spec::DSL::Behaviour
-      end
-    end
-    
-    describe Description, " constructed with a Type and a String" do 
-      before(:each) {@description = Description.new(Behaviour, " behaving")}
-      
-      it "should include the type and second String in its name" do
-        @description.description.should == "Spec::DSL::Behaviour behaving"
-      end
-      it "should provide that type (fully qualified) as its type" do
-        @description.described_type.should == Spec::DSL::Behaviour
-      end
-    end
-
-    describe Description, "constructed with a Type and a String not starting with a space" do 
-      before(:each) {@description = Description.new(Behaviour, "behaving")}
-
-      it "should include the type and second String with a space in its name" do
-        @description.description.should == "Spec::DSL::Behaviour behaving"
-      end
-    end
-
-    describe Description, "constructed with a Type and a String starting with a ." do 
-      before(:each) {@description = Description.new(Behaviour, ".behaving")}
-
-      it "should include the type and second String with a space in its name" do
-        @description.description.should == "Spec::DSL::Behaviour.behaving"
-      end
-    end
-
-    describe Description, "constructed with a Type and a String starting with a #" do 
-      before(:each) {@description = Description.new(Behaviour, "#behaving")}
-
-      it "should include the type and second String with a space in its name" do
-        @description.description.should == "Spec::DSL::Behaviour#behaving"
-      end
-    end
-
-    describe Description, " constructed with options" do before(:each) {@description = Description.new(Behaviour, :a => "b")}
-      it "should provide its options" do
-        @description[:a].should == "b"
-      end
-    end
-  end
-end

data/spec/spec/dsl/example_class_spec.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module DSL
-    describe Example, " class" do
-
-      def run(example)
-        example.run(@reporter, nil, nil, nil, Object.new)
-      end
-
-      before do
-        @reporter = stub("reporter", :example_started => nil, :example_finished => nil)
-        @example_class = Example.dup
-      end
-      
-      it "should report errors in example" do
-        error = Exception.new
-        @reporter.should_receive(:example_finished).with("example", error, "example", false)
-
-        run(@example_class.new("example") {raise(error)})
-      end
-    end
-  end
-end

data/spec/spec/dsl/example_instance_spec.rb

@@ -1,162 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module DSL
-    describe Example, " instance" do
-      # TODO - this should be
-      #   predicate_matchers :is_a
-      def is_a(error)
-        be_is_a(error)
-      end
-      
-      before do
-        @reporter = stub("reporter", :example_started => nil, :example_finished => nil)
-      end
-      
-      it "should send reporter example_started" do
-        example=Example.new("example") {}
-        @reporter.should_receive(:example_started).with("example")
-        example.run(@reporter, nil, nil, false, nil)
-      end
-
-      it "should report its name for dry run" do
-        example=Example.new("example") {}
-        @reporter.should_receive(:example_finished).with("example")
-        example.run(@reporter, nil, nil, true, nil) #4th arg indicates dry run
-      end
-
-      it "should report success" do
-        example=Example.new("example") {}
-        @reporter.should_receive(:example_finished).with("example", nil, nil, false)
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "should report failure due to failure" do
-        example=Example.new("example") do
-          (2+2).should == 5
-        end
-        @reporter.should_receive(:example_finished).with("example", is_a(Spec::Expectations::ExpectationNotMetError), "example", false)
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "should report failure due to error" do
-        error=RuntimeError.new
-        example=Example.new("example") do
-          raise(error)
-        end
-        @reporter.should_receive(:example_finished).with("example", error, "example", false)
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "should run example in scope of supplied object" do
-        scope_class = Class.new
-        example=Example.new("should pass") do
-          self.instance_of?(Example).should == false
-          self.instance_of?(scope_class).should == true
-        end
-        @reporter.should_receive(:example_finished).with("should pass", nil, nil, false)
-        example.run(@reporter, nil, nil, nil, scope_class.new)
-      end
-
-      it "should not run example block if before_each fails" do
-        example_ran = false
-        example=Example.new("should pass") {example_ran = true}
-        before_each = lambda {raise "Setup error"}
-        example.run(@reporter, before_each, nil, nil, Object.new)
-        example_ran.should == false
-      end
-
-      it "should run after_each block if before_each fails" do
-        after_each_ran = false
-        example=Example.new("should pass") {}
-        before_each = lambda {raise "Setup error"}
-        after_each = lambda {after_each_ran = true}
-        example.run(@reporter, before_each, after_each, nil, Object.new)
-        after_each_ran.should == true
-      end
-
-      it "should run after_each block when example fails" do
-        example=Example.new("example") do
-          raise("in body")
-        end
-        after_each=lambda do
-          raise("in after_each")
-        end
-        @reporter.should_receive(:example_finished) do |example, error, location|
-          example.should eql("example")
-          location.should eql("example")
-          error.message.should eql("in body")
-        end
-        example.run(@reporter, nil, after_each, nil, nil)
-      end
-
-      it "should report failure location when in before_each" do
-        example=Example.new("example") {}
-        before_each=lambda { raise("in before_each") }
-        @reporter.should_receive(:example_finished) do |name, error, location|
-          name.should eql("example")
-          error.message.should eql("in before_each")
-          location.should eql("before(:each)")
-        end
-        example.run(@reporter, before_each, nil, nil, nil)
-      end
-
-      it "should report failure location when in after_each" do
-        example = Example.new("example") {}
-        after_each = lambda { raise("in after_each") }
-        @reporter.should_receive(:example_finished) do |name, error, location|
-          name.should eql("example")
-          error.message.should eql("in after_each")
-          location.should eql("after(:each)")
-        end
-        example.run(@reporter, nil, after_each, nil, nil)
-      end
-
-      it "should accept an options hash following the example name" do
-        example = Example.new("name", :key => 'value')
-      end
-
-      it "should report NO NAME when told to use generated description with --dry-run" do
-        example = Example.new(:__generate_description) {
-          5.should == 5
-        }
-        @reporter.should_receive(:example_finished) do |desc, error, location|
-          desc.should == "NO NAME (Because of --dry-run)"
-        end
-        example.run(@reporter, lambda{}, lambda{}, true, Object.new)
-      end
-
-      it "should report NO NAME when told to use generated description with no expectations" do
-        example = Example.new(:__generate_description) {}
-        @reporter.should_receive(:example_finished) do |desc, error, location|
-          desc.should == "NO NAME (Because there were no expectations)"
-        end
-        example.run(@reporter, lambda{}, lambda{}, false, Object.new)
-      end
-
-      it "should report NO NAME when told to use generated description and matcher fails" do
-        example = Example.new(:__generate_description) do
-          5.should "" # Has no matches? method..
-        end
-        @reporter.should_receive(:example_finished) do |desc, error, location|
-          desc.should == "NO NAME (Because of Error raised in matcher)"
-        end
-        example.run(@reporter, nil, nil, nil, Object.new)
-      end
-
-      it "should report generated description when told to and it is available" do
-        example = Example.new(:__generate_description) {
-          5.should == 5
-        }
-        @reporter.should_receive(:example_finished).with("should == 5", :anything, :anything, false)
-        example.run(@reporter, nil, nil, nil, Object.new)
-      end
-
-      it "should unregister description_generated callback (lest a memory leak should build up)" do
-        example = Example.new("something")
-        Spec::Matchers.should_receive(:unregister_description_generated).with(is_a(Proc))
-        example.run(@reporter, nil, nil, nil, Object.new)
-      end
-    end
-  end
-end

data/spec/spec/dsl/example_should_raise_spec.rb

@@ -1,137 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module DSL
-    describe Example, " declared with {:should_raise => ...}" do
-      before(:each) do
-        @reporter = mock("reporter")
-        @reporter.stub!(:example_started)
-      end
-  
-      def verify_error(error, message=nil)
-        error.should be_an_instance_of(Spec::Expectations::ExpectationNotMetError)
-        unless message.nil?
-          return error.message.should =~ message if Regexp === message
-          return error.message.should == message
-        end
-      end
-
-      it "true} should pass when there is an ExpectationNotMetError" do
-        example = Spec::DSL:: Example.new("example", :should_raise => true) do
-          raise Spec::Expectations::ExpectationNotMetError
-        end
-        @reporter.should_receive(:example_finished) do |description, error|
-          error.should be_nil
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "true} should fail if nothing is raised" do
-        example = Spec::DSL:: Example.new("example", :should_raise => true) {}
-        @reporter.should_receive(:example_finished) do |example_name, error|
-          verify_error(error, /example block expected Exception but nothing was raised/)
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "NameError} should pass when there is a NameError" do
-        example = Spec::DSL:: Example.new("example", :should_raise => NameError) do
-          raise NameError
-        end
-        @reporter.should_receive(:example_finished) do |example_name, error|
-          error.should be_nil
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "NameError} should fail when there is no error" do
-        example = Spec::DSL:: Example.new("example", :should_raise => NameError) do
-          #do nothing
-        end
-        @reporter.should_receive(:example_finished) do |example_name, error|
-          verify_error(error,/example block expected NameError but nothing was raised/)
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "NameError} should fail when there is the wrong error" do
-        example = Spec::DSL:: Example.new("example", :should_raise => NameError) do
-          raise RuntimeError
-        end
-        @reporter.should_receive(:example_finished) do |example_name, error|
-          verify_error(error, /example block expected NameError but raised.+RuntimeError/)
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "[NameError]} should pass when there is a NameError" do
-        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError]) do
-          raise NameError
-        end
-        @reporter.should_receive(:example_finished) do |description, error|
-          error.should be_nil
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "[NameError]} should fail when there is no error" do
-        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError]) do
-        end
-        @reporter.should_receive(:example_finished) do |description, error|
-          verify_error(error, /example block expected NameError but nothing was raised/)
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "[NameError]} should fail when there is the wrong error" do
-        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError]) do
-          raise RuntimeError
-        end
-        @reporter.should_receive(:example_finished) do |description, error|
-          verify_error(error, /example block expected NameError but raised.+RuntimeError/)
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "[NameError, 'message'} should pass when there is a NameError with the right message" do
-        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError, 'expected']) do
-          raise NameError, 'expected'
-        end
-        @reporter.should_receive(:example_finished) do |description, error|
-          error.should be_nil
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "[NameError, 'message'} should pass when there is a NameError with a message matching a regex" do
-        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError, /xpec/]) do
-          raise NameError, 'expected'
-        end
-        @reporter.should_receive(:example_finished) do |description, error|
-          error.should be_nil
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "[NameError, 'message'} should fail when there is a NameError with the wrong message" do
-        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError, 'expected']) do
-          raise NameError, 'wrong message'
-        end
-        @reporter.should_receive(:example_finished) do |description, error|
-          verify_error(error, /example block expected #<NameError: expected> but raised #<NameError: wrong message>/)
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-
-      it "[NameError, 'message'} should fail when there is a NameError with a message not matching regexp" do
-        example = Spec::DSL:: Example.new("spec", :should_raise => [NameError, /exp/]) do
-          raise NameError, 'wrong message'
-        end
-        @reporter.should_receive(:example_finished) do |description, error|
-          verify_error(error, /example block expected #<NameError: \(\?-mix:exp\)> but raised #<NameError: wrong message>/)
-        end
-        example.run(@reporter, nil, nil, nil, nil)
-      end
-    end
-  end
-end

data/spec/spec/dsl/predicate_matcher_spec.rb

@@ -1,21 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module DSL
-    class Fish
-      def can_swim?(distance_in_yards)
-        distance_in_yards < 1000
-      end
-    end
-    
-    describe "predicate_matcher[method_on_object] = matcher_method" do
-      predicate_matchers[:swim] = :can_swim?
-      it "should match matcher_method if method_on_object returns true" do
-        swim(100).matches?(Fish.new).should be_true
-      end
-      it "should not match matcher_method if method_on_object returns false" do
-        swim(10000).matches?(Fish.new).should be_false
-      end
-    end
-  end
-end

data/spec/spec/dsl/shared_behaviour_spec.rb

@@ -1,208 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module DSL
-    describe Behaviour, ", with :shared => true" do
-      
-      before do
-        @formatter = Spec::Mocks::Mock.new("formatter", :null_object => true)
-        @behaviour = behaviour_class.new("behaviour") {}
-      end
-
-      after do
-        @formatter.rspec_verify
-        @behaviour_class = nil
-        $shared_behaviours.clear unless $shared_behaviours.nil?
-      end
-
-      def behaviour_class
-        unless @behaviour_class
-          @behaviour_class = Behaviour.dup
-          # dup copies the class instance vars
-          @behaviour_class.instance_variable_set(:@shared_behaviours, nil)
-        end
-        @behaviour_class
-      end
-
-      def make_shared_behaviour(name, opts, &block)
-        behaviour = behaviour_class.new(name, opts, &block)
-        behaviour_class.add_shared_behaviour(behaviour)
-        behaviour
-      end
-
-      it "should accept an optional options hash" do
-        lambda { behaviour_class.new("context") {} }.should_not raise_error(Exception)
-        lambda { behaviour_class.new("context", :shared => true) {} }.should_not raise_error(Exception)
-      end
-
-      it "should return all shared behaviours" do
-        make_shared_behaviour("b1", :shared => true) {}
-        make_shared_behaviour("b2", :shared => true) {}
-        
-        behaviour_class.find_shared_behaviour("b1").should_not be_nil
-        behaviour_class.find_shared_behaviour("b2").should_not be_nil
-      end
-
-      it "should be shared when configured as shared" do
-        behaviour = make_shared_behaviour("context", :shared => true) {}
-        behaviour.should be_shared
-      end
-
-      it "should not be shared when not configured as shared" do
-        @behaviour.should_not be_shared
-      end
-
-      it "should raise if run when shared" do
-        behaviour = make_shared_behaviour("context", :shared => true) {}
-        $spec_ran = false
-        behaviour.it("test") {$spec_ran = true}
-        lambda { behaviour.run(@formatter) }.should raise_error
-        $spec_ran.should be_false
-      end
-
-      it "should contain examples when shared" do
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
-        shared_behaviour.it("shared example") {}
-        shared_behaviour.number_of_examples.should == 1
-      end
-
-      it "should complain when adding a second shared behaviour with the same description" do
-        make_shared_behaviour("shared behaviour", :shared => true) {}
-        lambda { make_shared_behaviour("shared behaviour", :shared => true) {} }.should raise_error(ArgumentError)
-      end
-
-      it "should NOT complain when adding a the same shared behaviour again (i.e. file gets reloaded)" do
-        behaviour = behaviour_class.new("shared behaviour", :shared => true) {}
-        behaviour_class.add_shared_behaviour(behaviour)
-        behaviour_class.add_shared_behaviour(behaviour)
-      end
-
-      it "should add examples to current behaviour when calling it_should_behave_like" do
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
-        shared_behaviour.it("shared example") {}
-        shared_behaviour.it("shared example 2") {}
-
-        @behaviour.it("example") {}
-        @behaviour.number_of_examples.should == 1
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.number_of_examples.should == 3
-      end
-
-      it "should run shared examples" do
-        shared_example_ran = false
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        example_ran = false
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.it("example") {example_ran = true}
-        @behaviour.run(@formatter)
-        example_ran.should be_true
-        shared_example_ran.should be_true
-      end
-
-      it "should run setup and teardown from shared behaviour" do
-        shared_setup_ran = false
-        shared_teardown_ran = false
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
-        shared_behaviour.before { shared_setup_ran = true }
-        shared_behaviour.after { shared_teardown_ran = true }
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        example_ran = false
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.it("example") {example_ran = true}
-        @behaviour.run(@formatter)
-        example_ran.should be_true
-        shared_setup_ran.should be_true
-        shared_teardown_ran.should be_true
-      end
-
-      it "should run before(:all) and after(:all) only once from shared behaviour" do
-        shared_before_all_run_count = 0
-        shared_after_all_run_count = 0
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
-        shared_behaviour.before(:all) { shared_before_all_run_count += 1}
-        shared_behaviour.after(:all) { shared_after_all_run_count += 1}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        example_ran = false
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.it("example") {example_ran = true}
-        @behaviour.run(@formatter)
-        example_ran.should be_true
-        shared_before_all_run_count.should == 1
-        shared_after_all_run_count.should == 1
-      end
-
-      it "should include modules, included into shared behaviour, into current behaviour" do
-        @formatter.should_receive(:add_behaviour).with :any_args
-        @formatter.should_receive(:example_finished).twice.with :any_args
-
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-
-        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
-
-        shared_behaviour.include mod2
-
-        @behaviour.it_should_behave_like("shared behaviour")
-        @behaviour.include mod1
-
-        @behaviour.it("test") do
-          mod1_method
-          mod2_method
-        end
-        @behaviour.run(@formatter)
-        mod1_method_called.should be_true
-        mod2_method_called.should be_true
-      end
-      
-      it "should make methods defined in the shared behaviour available in consuming behaviour" do
-        shared_behaviour = make_shared_behaviour("shared behaviour xyz", :shared => true) do
-          def a_shared_helper_method
-            "this got defined in a shared behaviour"
-          end
-        end
-        @behaviour.it_should_behave_like("shared behaviour xyz")
-        success = false
-        @behaviour.it("should access a_shared_helper_method") do
-          a_shared_helper_method
-          success = true
-        end
-        @behaviour.run(@formatter)
-        success.should be_true
-      end
-
-      it "should error if told to inherit from a class" do
-        shared_behaviour = make_shared_behaviour("shared behaviour", :shared => true) {}
-        shared_behaviour.it("shared example") { shared_example_ran = true }
-        lambda { shared_behaviour.inherit Object }.should raise_error(ArgumentError)
-      end
-      
-      it "should raise when named shared behaviour can not be found" do
-        begin
-          @behaviour.it_should_behave_like("non-existent shared behaviour")
-          violated
-        rescue => e
-          e.message.should == "Shared Behaviour 'non-existent shared behaviour' can not be found"
-        end
-      end
-    end
-  end
-end