rspec 1.0.8 → 1.1.0

data/spec/spec/dsl/composite_proc_builder_spec.rb

@@ -1,44 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module DSL
-    describe CompositeProcBuilder do
-      before(:each) do
-        @klass = Class.new do
-          attr_reader :an_attribute
-
-          def an_attribute_setter
-            @an_attribute = :the_value
-          end
-        end
-
-        @parent = @klass.new
-        @builder = CompositeProcBuilder.new {}
-      end
-
-      it "calls all of its child procs" do
-        @builder << proc {:proc1}
-        @builder << proc {:proc2}
-        @builder.proc.call.should == [:proc1, :proc2]
-      end
-
-      it "evals procs in the caller's instance" do
-        the_proc = proc do
-          @an_attribute = :the_value
-        end
-        the_proc.class.should == Proc
-        @builder << the_proc
-        @parent.instance_eval &@builder.proc
-        @parent.an_attribute.should == :the_value
-      end
-
-      it "binds unbound methods to the parent" do
-        unbound_method = @klass.instance_method(:an_attribute_setter)
-        unbound_method.class.should == UnboundMethod
-        @builder << unbound_method
-        @parent.instance_eval &@builder.proc
-        @parent.an_attribute.should == :the_value
-      end
-    end
-  end
-end

data/spec/spec/dsl/configuration_spec.rb

@@ -1,55 +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 rr" do
-        @config.mock_with(:rr)
-        @config.mock_framework.should =~ /\/plugins\/mock_frameworks\/rr$/
-      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.modules_for(nil).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,89 +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) do
-        @description = Description.new(Behaviour, :a => "b", :spec_path => "blah")
-      end
-
-      it "should provide its options" do
-        @description[:a].should == "b"
-      end
-      
-      it "should wrap spec path using File.expand_path" do
-        @description[:spec_path].should == File.expand_path("blah")
-      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
-        example = @example_class.new("example") {raise(error)}
-        @reporter.should_receive(:example_finished).with(equal(example), error, "example", false)
-        run(example)
-      end
-    end
-  end
-end

data/spec/spec/dsl/example_instance_spec.rb

@@ -1,160 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Spec
-  module DSL
-    describe Example, " instance" do
-      predicate_matchers[:is_a] = [:is_a?]
-      
-      before(:each) 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(equal(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(equal(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(equal(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(equal(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=NonStandardError.new
-        example=Example.new("example") do
-          raise(error)
-        end
-        @reporter.should_receive(:example_finished).with(equal(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(equal(example), 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 NonStandardError}
-        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 NonStandardError}
-        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(NonStandardError.new("in body"))
-        end
-        after_each=lambda do
-          raise("in after_each")
-        end
-        @reporter.should_receive(:example_finished) do |example, error, location|
-          example.should equal(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(NonStandardError.new("in before_each")) }
-        @reporter.should_receive(:example_finished) do |name, error, location|
-          name.should equal(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(NonStandardError.new("in after_each")) }
-        @reporter.should_receive(:example_finished) do |name, error, location|
-          name.should equal(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 |example, error, location|
-          example.description.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 |example, error, location|
-          example.description.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 |example, error, location|
-          example.description.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) do |example, error, location|
-          example.description.should == "should == 5"
-        end
-        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