rspec 1.3.0 → 2.0.0

data/resources/rake/examples_with_rcov.rake

@@ -1,9 +0,0 @@
-require 'rake'
-require 'spec/rake/spectask'
-
-desc "Run all examples with RCov"
-Spec::Rake::SpecTask.new('examples_with_rcov') do |t|
-  t.spec_files = FileList['examples/**/*.rb']
-  t.rcov = true
-  t.rcov_opts = ['--exclude', 'examples']
-end

data/resources/rake/failing_examples_with_html.rake

@@ -1,9 +0,0 @@
-require 'rake'
-require 'spec/rake/spectask'
-
-desc "Generate HTML report for failing examples"
-Spec::Rake::SpecTask.new('failing_examples_with_html') do |t|
-  t.spec_files = FileList['failing_examples/**/*.rb']
-  t.spec_opts = ["--format", "html:doc/reports/tools/failing_examples.html", "--diff"]
-  t.fail_on_error = false
-end

data/resources/rake/verify_rcov.rake

@@ -1,7 +0,0 @@
-require 'rake'
-require 'spec/rake/verify_rcov'
-
-RCov::VerifyTask.new(:verify_rcov => 'spec:rcov') do |t|
-  t.threshold = 100.0
-  t.index_html = 'coverage/index.html'
-end

data/spec/README.jruby

@@ -1,15 +0,0 @@
-= Running specs on JRuby =
-
-svn co http://svn.codehaus.org/jruby/trunk jruby
-cd jruby/jruby
-ant clean
-ant
-# put JRuby's bin dir on your PATH
-jruby -S gem install rake --no-ri --no-rdoc
-jruby -S gem install diff-lcs
-jruby -S gem install syntax
-cd ../testsuites/rspec
-mkdir target
-jruby -S rake checkout_code
-cd target/rspec
-jruby bin/spec spec -c

data/spec/autotest/autotest_helper.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-begin
-  require 'autotest'
-rescue LoadError
-  raise "You must install ZenTest to use autotest"
-end
-require 'autotest/rspec'
-require 'autotest/autotest_matchers'

data/spec/autotest/autotest_matchers.rb

@@ -1,38 +0,0 @@
-module Spec
-  module Matchers
-    class AutotestMappingMatcher
-      def initialize(specs)
-        @specs = specs
-      end
-  
-      def to(file)
-        @file = file
-        self
-      end
-  
-      def matches?(autotest)
-        @autotest = prepare(autotest)
-        @actual = autotest.test_files_for(@file)
-        @actual == @specs
-      end
-  
-      def failure_message
-        "expected #{@autotest.class} to map #{@specs.inspect} to #{@file.inspect}\ngot #{@actual.inspect}"
-      end
-  
-    private
-
-      def prepare(autotest)
-        find_order = @specs.dup << @file
-        autotest.instance_eval { @find_order = find_order }
-        autotest
-      end
-
-    end
-    
-    def map_specs(specs)
-      AutotestMappingMatcher.new(specs)
-    end
-    
-  end
-end

data/spec/autotest/discover_spec.rb

@@ -1,8 +0,0 @@
-require 'autotest/autotest_helper'
-
-describe Autotest::Rspec, "discovery" do
-  it "adds the rspec autotest plugin" do
-    Autotest.should_receive(:add_discovery)
-    load File.expand_path("../../../lib/autotest/discover.rb", __FILE__)
-  end
-end  

data/spec/autotest/failed_results_re_spec.rb

@@ -1,31 +0,0 @@
-require 'autotest/autotest_helper'
-
-describe "failed_results_re" do
-  it "should match a failure" do
-    re = Autotest::Rspec.new.failed_results_re
-    re =~ "1)\n'this example' FAILED\nreason\n/path.rb:37:\n\n"
-    $1.should == "this example"
-    $2.should == "reason\n/path.rb:37:"
-  end
-
-  it "should match a failure when matcher outputs multiple lines" do
-    re = Autotest::Rspec.new.failed_results_re
-    re =~ "1)\n'other example' FAILED\n\nreason line 1\nreason line 2\n\n(additional info)\n/path.rb:37:\n\n"
-    $1.should == "other example"
-    $2.should == "reason line 1\nreason line 2\n\n(additional info)\n/path.rb:37:"
-  end
-
-  it "should match an Error" do
-    re = Autotest::Rspec.new.failed_results_re
-    re =~ "1)\nRuntimeError in 'this example'\nreason\n/path.rb:37:\n\n"
-    $1.should == "this example"
-    $2.should == "reason\n/path.rb:37:"
-  end
-
-  it "should match an Error that doesn't end in Error" do
-    re = Autotest::Rspec.new.failed_results_re
-    re =~ "1)\nInvalidArgument in 'this example'\nreason\n/path.rb:37:\n\n"
-    $1.should == "this example"
-    $2.should == "reason\n/path.rb:37:"
-  end
-end

data/spec/autotest/rspec_spec.rb

@@ -1,126 +0,0 @@
-require 'autotest/autotest_helper'
-
-describe Autotest::Rspec do
-  describe "adding spec.opts --options" do 
-    before(:each) do
-      @rspec_autotest = Autotest::Rspec.new
-    end
-
-    it "should return the command line option to add spec.opts if the options file exists" do
-      File.stub!(:exist?).and_return true
-      @rspec_autotest.add_options_if_present.should == "-O spec/spec.opts "
-    end
-
-    it "should return an empty string if no spec.opts exists" do
-      File.stub!(:exist?).and_return false
-      Autotest::Rspec.new.add_options_if_present.should == ""
-    end
-  end  
-
-  describe "commands" do
-    before(:each) do
-      @rspec_autotest = Autotest::Rspec.new
-      @rspec_autotest.stub!(:ruby).and_return "ruby"
-      @rspec_autotest.stub!(:add_options_if_present).and_return "-O spec/spec.opts"
-    
-      @ruby = @rspec_autotest.ruby
-      @spec_cmd = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec'))
-      @options = @rspec_autotest.add_options_if_present
-      files = %w[file_one file_two]
-      @files_to_test = {
-        files[0] => [],
-        files[1] => []
-      }
-      # this is not the inner representation of Autotest!
-      @rspec_autotest.files_to_test = @files_to_test
-      @to_test = files.map { |f| File.expand_path(f) }.join ' '
-    end
-  
-    it "should make the appropriate test command" do
-      cmd = @rspec_autotest.make_test_cmd(@files_to_test)
-      (cmd =~ /#{@ruby} #{@spec_cmd} --autospec (.*) #{@options}/).should be_true
-      $1.should =~ /#{File.expand_path('file_one')}/
-      $1.should =~ /#{File.expand_path('file_two')}/
-    end
-
-    it "should return a blank command for no files" do
-      @rspec_autotest.make_test_cmd({}).should == ''
-    end
-  end
-
-  describe "mappings" do
-  
-    before(:each) do
-      @lib_file = "lib/something.rb"
-      @spec_file = "spec/something_spec.rb"
-      @rspec_autotest = Autotest::Rspec.new
-      @rspec_autotest.hook :initialize
-    end
-  
-    it "should find the spec file for a given lib file" do
-      @rspec_autotest.should map_specs([@spec_file]).to(@lib_file)
-    end
-  
-    it "should find the spec file if given a spec file" do
-      @rspec_autotest.should map_specs([@spec_file]).to(@spec_file)
-    end
-  
-    it "should ignore files in spec dir that aren't specs" do
-      @rspec_autotest.should map_specs([]).to("spec/spec_helper.rb")
-    end
-  
-    it "should ignore untracked files (in @file)"  do
-      @rspec_autotest.should map_specs([]).to("lib/untracked_file")
-    end
-  end
-
-  describe "consolidating failures" do
-    before(:each) do
-      @rspec_autotest = Autotest::Rspec.new
-    
-      @spec_file = "spec/autotest/some_spec.rb"
-      @rspec_autotest.instance_variable_set("@files", {@spec_file => Time.now})
-      @rspec_autotest.stub!(:find_files_to_test).and_return true
-    end
-  
-    it "should return no failures if no failures were given in the output" do
-      @rspec_autotest.consolidate_failures([[]]).should == {}
-    end
-  
-    it "should return a hash with the spec filename => spec name for each failure or error" do
-      @rspec_autotest.stub!(:test_files_for).and_return "spec/autotest/some_spec.rb"
-      failures = [
-        [
-          "false should be false", 
-          "expected: true,\n     got: false (using ==)\n#{@spec_file}:203:"
-        ]
-      ]
-      @rspec_autotest.consolidate_failures(failures).should == {
-        @spec_file => ["false should be false"]
-      }
-    end
-  
-    it "should not include the subject file" do
-      subject_file = "lib/autotest/some.rb"
-      @rspec_autotest.stub!(:test_files_for).and_return "spec/autotest/some_spec.rb"
-      failures = [
-        [
-          "false should be false", 
-          "expected: true,\n     got: false (using ==)\n#{subject_file}:143:\n#{@spec_file}:203:"
-        ]
-      ]
-      @rspec_autotest.consolidate_failures(failures).keys.should_not include(subject_file)
-    end
-  end
-  
-  describe "normalizing file names" do
-    it "should ensure that a single file appears in files_to_test only once" do
-      @rspec_autotest = Autotest::Rspec.new
-      @files_to_test = {}
-      ['filename.rb', './filename.rb', File.expand_path('filename.rb')].each do |file|
-        @files_to_test[file] = []
-      end
-      @rspec_autotest.normalize(@files_to_test).should have(1).file
-    end
-  end
-end

data/spec/ruby_forker.rb

@@ -1,13 +0,0 @@
-require 'rbconfig'
-
-module RubyForker
-  # Forks a ruby interpreter with same type as ourself.
-  # juby will fork jruby, ruby will fork ruby etc.
-  def ruby(args, stderr=nil)
-    config       = ::Config::CONFIG
-    interpreter  = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
-    cmd = "#{interpreter} #{args}"
-    cmd << " 2> #{stderr}" unless stderr.nil?
-    `#{cmd}`
-  end
-end

data/spec/spec/dsl/main_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module DSL
-    describe Main do
-      before(:each) do
-        @main = Class.new do; include Spec::DSL::Main; end
-      end
-
-      [:describe, :context].each do |method|
-        describe "##{method}" do
-          it "should delegate to Spec::Example::ExampleGroupFactory.create_example_group" do
-            block = lambda {|a,b|}
-            Spec::Example::ExampleGroupFactory.should_receive(:create_example_group).with(
-              "The ExampleGroup", hash_including(:location), &block
-            )
-            @main.__send__ method, "The ExampleGroup", &block
-          end
-          
-          it "raises with no description" do
-            block = lambda {|a,b|}
-            lambda do
-              @main.__send__ method, &block
-            end.should raise_error(ArgumentError, /No description supplied for example group declared on #{__FILE__}:#{__LINE__ - 1}/)
-          end
-        end
-      end
-      
-      [:share_examples_for, :shared_examples_for].each do |method|
-        describe "##{method}" do
-          it "should create a shared ExampleGroup" do
-            block = lambda {|a,b|}
-            Spec::Example::ExampleGroupFactory.should_receive(:create_shared_example_group).with(
-              "shared group", hash_including(:location), &block
-            )
-            @main.__send__ method, "shared group", &block
-          end
-        end
-      end
-
-      describe "#describe; with RUBY_VERSION = 1.9" do
-        it "includes an enclosing module into the block's scope" do
-          Spec::Ruby.stub!(:version).and_return("1.9")
-
-          module Foo; module Bar; end; end
-          
-          Foo::Bar.should_receive(:included).with do |*args|
-            included_by = args.last
-            included_by.description.should == "this example group"
-          end
-          
-          module Foo
-            module Bar
-              describe("this example group") do; end
-            end
-          end
-        end
-      end
-
-    
-      describe "#share_as" do
-        def self.next_group_name
-          @group_number ||= 0
-          @group_number += 1
-          "Group#{@group_number}"
-        end
-        
-        def group_name
-          @group_name ||= self.class.next_group_name
-        end
-        
-        it "registers a shared ExampleGroup" do
-          block = lambda {|a,b|}
-          Spec::Example::ExampleGroupFactory.should_receive(:create_shared_example_group).with(
-            group_name, hash_including(:location), &block
-          )
-          @main.share_as group_name, &block
-        end
-      
-        it "creates a constant that points to a Module" do
-          group = @main.share_as group_name do end
-          Object.const_get(group_name).should equal(group)
-        end
-      
-        it "complains if you pass it a not-constantizable name" do
-          lambda do
-            @group = @main.share_as "Non Constant" do end
-          end.should raise_error(NameError, /The first argument to share_as must be a legal name for a constant/)
-        end
-      
-      end
-    end
-  end
-end
-  

data/spec/spec/example/example_group_class_definition_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Example
-    class ExampleGroupSubclass < ExampleGroup
-      class << self
-        attr_accessor :examples_ran
-      end
-
-      @@class_variable = :class_variable
-      CONSTANT = :constant
-
-      before(:each) do
-        @instance_variable = :instance_variable
-      end
-      
-      after(:all) do
-        self.class.examples_ran = true
-      end
-
-      def a_method
-        22
-      end
-
-      it "can access instance variables defined before(:each)" do
-        @instance_variable.should == :instance_variable
-      end
-
-      it "can access class variables (Ruby 1.8 only)" do
-        with_ruby 1.8 do
-          @@class_variable.should == :class_variable
-        end
-      end
-
-      it "can access constants" do
-        CONSTANT.should == :constant
-      end
-
-      it "can access methods defined in the Example Group" do
-        a_method.should == 22
-      end
-      
-    end
-
-    describe ExampleGroupSubclass do
-      it "should run" do
-        ExampleGroupSubclass.examples_ran.should be_true
-      end
-    end
-  end
-end

data/spec/spec/example/example_group_factory_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Example
-    describe ExampleGroupFactory do
-      describe "#get" do
-        attr_reader :example_group
-        before(:each) do
-          @example_group_class = Class.new(ExampleGroupDouble)
-          ExampleGroupFactory.register(:registered_type, @example_group_class)
-        end
-
-        after(:each) do
-          ExampleGroupFactory.reset
-        end
-
-        it "should return the default ExampleGroup type for nil" do
-          ExampleGroupFactory[nil].should == ExampleGroup
-        end
-
-        it "should return the default ExampleGroup for an unregistered non-nil value" do
-          ExampleGroupFactory[:does_not_exist].should == ExampleGroup
-        end
-
-        it "should return custom type if registered" do
-          ExampleGroupFactory[:registered_type].should == @example_group_class
-        end
-
-        it "should get the custom type after setting the default" do
-          @alternate_example_group_class = Class.new(ExampleGroupDouble)
-          ExampleGroupFactory.default(@alternate_example_group_class)
-          ExampleGroupFactory[:registered_type].should == @example_group_class
-        end
-      end
-
-      describe "#create_example_group" do
-        attr_reader :parent_example_group
-        before do
-          @parent_example_group = Class.new(ExampleGroupDouble) do
-            def initialize(*args, &block)
-              ;
-            end
-          end
-        end
-
-        it "should create a uniquely named class" do
-          example_group = Spec::Example::ExampleGroupFactory.create_example_group("example_group") {}
-          example_group.name.should =~ /Spec::Example::ExampleGroup::Subclass_\d+/
-        end
-
-        it "should create a Spec::Example::Example subclass by default" do
-          example_group = Spec::Example::ExampleGroupFactory.create_example_group("example_group") {}
-          example_group.superclass.should == Spec::Example::ExampleGroup
-        end
-
-        it "should raise when no description is given" do
-          lambda {
-            Spec::Example::ExampleGroupFactory.create_example_group do; end
-          }.should raise_error(ArgumentError)
-        end
-
-        it "should raise when no block is given" do
-          lambda { Spec::Example::ExampleGroupFactory.create_example_group "foo" }.should raise_error(ArgumentError)
-        end
-
-        it "should run registered ExampleGroups" do
-          example_group = Spec::Example::ExampleGroupFactory.create_example_group "The ExampleGroup" do end
-          Spec::Runner.options.example_groups.should include(example_group)
-        end
-
-        it "should not run unregistered ExampleGroups" do
-          example_group = Spec::Example::ExampleGroupFactory.create_example_group "The ExampleGroup" do Spec::Runner.options.remove_example_group self; end
-          Spec::Runner.options.example_groups.should_not include(example_group)
-        end
-
-        describe "with :type => :default" do
-          it "should create a Spec::Example::ExampleGroup" do
-            example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-            "example_group", :type => :default
-            ) {}
-            example_group.superclass.should == Spec::Example::ExampleGroup
-          end
-        end
-
-        describe "with :type => :something_other_than_default" do
-          it "should create the specified type" do
-            Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group)
-            non_default_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-              "example_group", :type => :something_other_than_default
-            ) {}
-            non_default_example_group.superclass.should == parent_example_group
-          end
-        end
-
-        it "should create a type indicated by :location" do
-          Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group)
-          custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-            "example_group", :location => "./spec/something_other_than_default/some_spec.rb"
-          ) {}
-          custom_example_group.superclass.should == parent_example_group
-        end
-
-        it "should create a type indicated by :location (with location generated by caller on windows)" do
-          Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group)
-          custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-            "example_group",
-            :location => "./spec\\something_other_than_default\\some_spec.rb"
-          ) {}
-          custom_example_group.superclass.should == parent_example_group
-        end
-
-        it "should create a type indicated by location for a path-like key" do
-          Spec::Example::ExampleGroupFactory.register('path/to/custom/', parent_example_group)
-          custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-            "example_group", :location => "./spec/path/to/custom/some_spec.rb"
-          ) {}
-          custom_example_group.superclass.should == parent_example_group
-        end
-
-        it "should use the longest key that matches when creating a type indicated by location" do
-          longer = Class.new parent_example_group
-          Spec::Example::ExampleGroupFactory.register(:longer, longer)
-          long = Class.new parent_example_group
-          Spec::Example::ExampleGroupFactory.register(:long, long)
-          custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-            "example_group", :location => "./spec/longer/some_spec.rb"
-          ) {}
-          custom_example_group.superclass.should == longer
-        end
-
-        describe "with :shared => true" do
-          def shared_example_group
-            @shared_example_group ||= Spec::Example::ExampleGroupFactory.create_example_group(
-              "name", :location => '/blah/spec/models/blah.rb', :type => :controller, :shared => true
-            ) {}
-          end
-
-          it "should create and register a Spec::Example::SharedExampleGroup" do
-            shared_example_group.should be_an_instance_of(Spec::Example::SharedExampleGroup)
-            SharedExampleGroup.should include(shared_example_group)
-          end
-        end
-
-        it "should favor the :type over the :location" do
-          Spec::Example::ExampleGroupFactory.register(:something_other_than_default, parent_example_group)
-          custom_example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-            "name", :location => '/blah/spec/models/blah.rb', :type => :something_other_than_default
-          ) {}
-          custom_example_group.superclass.should == parent_example_group
-        end
-
-        it "should register ExampleGroup by default" do
-          example_group = Spec::Example::ExampleGroupFactory.create_example_group("The ExampleGroup") do
-          end
-          Spec::Runner.options.example_groups.should include(example_group)
-        end
-
-        it "should enable unregistering of ExampleGroups" do
-          example_group = Spec::Example::ExampleGroupFactory.create_example_group("The ExampleGroup") do
-            Spec::Runner.options.remove_example_group self
-          end
-          Spec::Runner.options.example_groups.should_not include(example_group)
-        end
-
-        after(:each) do
-          Spec::Example::ExampleGroupFactory.reset
-        end
-      end
-
-      describe "#create_shared_example_group" do
-        it "registers a new shared example group" do
-          shared_example_group = Spec::Example::ExampleGroupFactory.create_shared_example_group("something shared") {}
-          shared_example_group.should be_an_instance_of(Spec::Example::SharedExampleGroup)
-          SharedExampleGroup.should include(shared_example_group)
-        end
-      end
-
-    end
-  end
-end