rspec-core 2.11.1 → 3.11.0

data/lib/rspec/core/mocking/with_rr.rb

@@ -1,27 +0,0 @@
-require 'rr'
-
-RSpec.configuration.backtrace_clean_patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
-
-module RSpec
-  module Core
-    module MockFrameworkAdapter
-      
-      def self.framework_name; :rr end
-
-      include RR::Extensions::InstanceMethods
-
-      def setup_mocks_for_rspec
-        RR::Space.instance.reset
-      end
-
-      def verify_mocks_for_rspec
-        RR::Space.instance.verify_doubles
-      end
-
-      def teardown_mocks_for_rspec
-        RR::Space.instance.reset
-      end
-
-    end
-  end
-end

data/lib/rspec/core/mocking/with_rspec.rb

@@ -1,23 +0,0 @@
-require 'rspec/mocks'
-
-module RSpec
-  module Core
-    module MockFrameworkAdapter
-      
-      def self.framework_name; :rspec end
-      
-      def setup_mocks_for_rspec
-        RSpec::Mocks::setup(self)
-      end
-
-      def verify_mocks_for_rspec
-        RSpec::Mocks::verify
-      end
-
-      def teardown_mocks_for_rspec
-        RSpec::Mocks::teardown
-      end
-
-    end
-  end
-end

data/lib/rspec/core/subject.rb

@@ -1,219 +0,0 @@
-module RSpec
-  module Core
-    module Subject
-      module ExampleMethods
-        # Returns the example group's `subject`.
-        #
-        # @note `subject` was contributed by Joe Ferris to support the one-liner
-        #   syntax embraced by shoulda matchers:
-        #
-        #       describe Widget do
-        #         it { should validate_presence_of(:name) }
-        #       end
-        #
-        #   While the examples below demonstrate how to use `subject`
-        #   explicitly in examples, we recommend that you define a method with
-        #   an intention revealing name instead.
-        #
-        # @example
-        #
-        #   # explicit declaration of subject
-        #   describe Person do
-        #     subject { Person.new(:birthdate => 19.years.ago) }
-        #     it "should be eligible to vote" do
-        #       subject.should be_eligible_to_vote
-        #       # ^ ^ explicit reference to subject not recommended
-        #     end
-        #   end
-        #
-        #   # implicit subject => { Person.new }
-        #   describe Person do
-        #     it "should be eligible to vote" do
-        #       subject.should be_eligible_to_vote
-        #       # ^ ^ explicit reference to subject not recommended
-        #     end
-        #   end
-        #
-        #   # one-liner syntax - should is invoked on subject
-        #   describe Person do
-        #     it { should be_eligible_to_vote }
-        #   end
-        #
-        # @see ExampleGroupMethods#subject
-        # @see #should
-        def subject
-          if defined?(@original_subject)
-            @original_subject
-          else
-            @original_subject = instance_eval(&self.class.subject)
-          end
-        end
-
-        # When `should` is called with no explicit receiver, the call is
-        # delegated to the object returned by `subject`. Combined with an
-        # implicit subject this supports very concise expressions.
-        #
-        # @example
-        #
-        #   describe Person do
-        #     it { should be_eligible_to_vote }
-        #   end
-        #
-        # @see #subject
-        def should(matcher=nil, message=nil)
-          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(subject, matcher, message)
-        end
-
-        # Just like `should`, `should_not` delegates to the subject (implicit or
-        # explicit) of the example group.
-        #
-        # @example
-        #
-        #   describe Person do
-        #     it { should_not be_eligible_to_vote }
-        #   end
-        #
-        # @see #subject
-        def should_not(matcher=nil, message=nil)
-          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(subject, matcher, message)
-        end
-
-        private
-
-        def _attribute_chain(attribute)
-          attribute.to_s.split('.')
-        end
-
-        def _nested_attribute(subject, attribute)
-          _attribute_chain(attribute).inject(subject) do |inner_subject, attr|
-            inner_subject.send(attr)
-          end
-        end
-      end
-
-      module ExampleGroupMethods
-        # Creates a nested example group named by the submitted `attribute`,
-        # and then generates an example using the submitted block.
-        #
-        # @example
-        #
-        #   # This ...
-        #   describe Array do
-        #     its(:size) { should eq(0) }
-        #   end
-        #
-        #   # ... generates the same runtime structure as this:
-        #   describe Array do
-        #     describe "size" do
-        #       it "should eq(0)" do
-        #         subject.size.should eq(0)
-        #       end
-        #     end
-        #   end
-        #
-        # The attribute can be a `Symbol` or a `String`. Given a `String`
-        # with dots, the result is as though you concatenated that `String`
-        # onto the subject in an expression.
-        #
-        # @example
-        #
-        #   describe Person do
-        #     subject do
-        #       Person.new.tap do |person|
-        #         person.phone_numbers << "555-1212"
-        #       end
-        #     end
-        #
-        #     its("phone_numbers.first") { should eq("555-1212") }
-        #   end
-        #
-        # When the subject is a `Hash`, you can refer to the Hash keys by
-        # specifying a `Symbol` or `String` in an array.
-        #
-        # @example
-        #
-        #   describe "a configuration Hash" do
-        #     subject do
-        #       { :max_users => 3,
-        #         'admin' => :all_permissions }
-        #     end
-        #
-        #     its([:max_users]) { should eq(3) }
-        #     its(['admin']) { should eq(:all_permissions) }
-        #
-        #     # You can still access to its regular methods this way:
-        #     its(:keys) { should include(:max_users) }
-        #     its(:count) { should eq(2) }
-        #   end
-        def its(attribute, &block)
-          describe(attribute) do
-            example do
-              self.class.class_eval do
-                define_method(:subject) do
-                  if defined?(@_subject)
-                    @_subject
-                  else
-                    @_subject = Array === attribute ? super()[*attribute] : _nested_attribute(super(), attribute)
-                  end
-                end
-              end
-              instance_eval(&block)
-            end
-          end
-        end
-
-        # Declares a `subject` for an example group which can then be the
-        # implicit receiver (through delegation) of calls to `should`.
-        #
-        # Given a `name`, defines a method with that name which returns the
-        # `subject`. This lets you declare the subject once and access it
-        # implicitly in one-liners and explicitly using an intention revealing
-        # name.
-        #
-        # @param [String,Symbol] name used to define an accessor with an
-        #   intention revealing name
-        # @param block defines the value to be returned by `subject` in examples
-        #
-        # @example
-        #
-        #   describe CheckingAccount, "with $50" do
-        #     subject { CheckingAccount.new(Money.new(50, :USD)) }
-        #     it { should have_a_balance_of(Money.new(50, :USD)) }
-        #     it { should_not be_overdrawn }
-        #   end
-        #
-        #   describe CheckingAccount, "with a non-zero starting balance" do
-        #     subject(:account) { CheckingAccount.new(Money.new(50, :USD)) }
-        #     it { should_not be_overdrawn }
-        #     it "has a balance equal to the starting balance" do
-        #       account.balance.should eq(Money.new(50, :USD))
-        #     end
-        #   end
-        #
-        # @see ExampleMethods#subject
-        # @see ExampleMethods#should
-        def subject(name=nil, &block)
-          define_method(name) { subject } if name
-          block ? @explicit_subject_block = block : explicit_subject || implicit_subject
-        end
-
-        attr_reader :explicit_subject_block
-
-        private
-
-        def explicit_subject
-          group = self
-          while group.respond_to?(:explicit_subject_block)
-            return group.explicit_subject_block if group.explicit_subject_block
-            group = group.superclass
-          end
-        end
-
-        def implicit_subject
-          described = described_class || description
-          Class === described ? proc { described.new } : proc { described }
-        end
-      end
-    end
-  end
-end

data/spec/autotest/discover_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-describe "autotest/discover.rb" do
-  context "with ./.rspec present" do
-    it "adds 'rspec2' to the list of discoveries" do
-      File.stub(:exist?).with("./.rspec") { true }
-      Autotest.should_receive(:add_discovery)
-      load File.expand_path("../../../lib/autotest/discover.rb", __FILE__)
-    end
-  end
-
-  context "with ./.rspec absent" do
-    it "does not add 'rspec2' to the list of discoveries" do
-      File.stub(:exist?) { false }
-      Autotest.should_not_receive(:add_discovery)
-      load File.expand_path("../../../lib/autotest/discover.rb", __FILE__)
-    end
-  end
-end

data/spec/autotest/failed_results_re_spec.rb

@@ -1,45 +0,0 @@
-require "spec_helper"
-
-describe "failed_results_re for autotest" do
-  def run_example
-    group = RSpec::Core::ExampleGroup.describe("group")
-    group.example("example") { yield }
-    io = StringIO.new
-    formatter = RSpec::Core::Formatters::BaseTextFormatter.new(io)
-    reporter = RSpec::Core::Reporter.new(formatter)
-
-    group.run(reporter)
-    reporter.report(1, nil) {}
-    io.string
-  end
-
-  shared_examples "autotest failed_results_re" do
-    it "matches a failure" do
-      output = run_example { fail }
-      output.should match(Autotest::Rspec2.new.failed_results_re)
-      output.should include(__FILE__.sub(File.expand_path('.'),'.'))
-    end
-
-    it "does not match when there are no failures" do
-      output = run_example { } # pass
-      output.should_not match(Autotest::Rspec2.new.failed_results_re)
-      output.should_not include(__FILE__.sub(File.expand_path('.'),'.'))
-    end
-  end
-
-  context "with color enabled" do
-    before do
-      RSpec.configuration.stub(:color_enabled? => true)
-    end
-
-    include_examples "autotest failed_results_re"
-  end
-
-  context "with color disabled " do
-    before do
-      RSpec.configuration.stub(:color_enabled? => false)
-    end
-
-    include_examples "autotest failed_results_re"
-  end
-end

data/spec/autotest/rspec_spec.rb

@@ -1,123 +0,0 @@
-require "spec_helper"
-
-describe Autotest::Rspec2 do
-  let(:rspec_autotest) { Autotest::Rspec2.new }
-  let(:spec_cmd) { File.expand_path("../../../exe/rspec", __FILE__) }
-  let(:ruby_cmd) { "ruby" }
-
-  before do
-    File.stub(:exist?) { false }
-  end
-
-  it "uses autotest's prefix" do
-    rspec_autotest.prefix = "this is the prefix "
-    rspec_autotest.
-      make_test_cmd({'a' => 'b'}).should match(/this is the prefix/)
-  end
-
-  describe "commands" do
-    before do
-      rspec_autotest.stub(:ruby => ruby_cmd)
-      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 "makes the appropriate test command" do
-      actual_command = rspec_autotest.make_test_cmd(@files_to_test)
-      expected_command = /#{ruby_cmd}.*'#{spec_cmd}' (.*)/
-
-      actual_command.should match(expected_command)
-
-      actual_command =~ expected_command
-      $1.should =~ /#{File.expand_path('file_one')}/
-      $1.should =~ /#{File.expand_path('file_two')}/
-    end
-
-    it "returns a blank command for no files" do
-      rspec_autotest.make_test_cmd({}).should eq('')
-    end
-
-    it "quotes the paths of files to test" do
-      cmd = rspec_autotest.make_test_cmd(@files_to_test)
-      @files_to_test.keys.each do |file_to_test|
-        cmd.should match(/'#{File.expand_path(file_to_test)}'/)
-      end
-    end
-
-    it "gives '--tty' to #{Autotest::Rspec2::RSPEC_EXECUTABLE}, not '--autotest'" do
-      cmd = rspec_autotest.make_test_cmd(@files_to_test)
-      cmd.should match(' --tty ')
-      cmd.should_not match(' --autotest ')
-    end
-  end
-
-  describe "mappings" do
-    before do
-      @lib_file = "lib/something.rb"
-      @spec_file = "spec/something_spec.rb"
-      rspec_autotest.hook :initialize
-    end
-
-    it "finds the spec file for a given lib file" do
-      rspec_autotest.should map_specs([@spec_file]).to(@lib_file)
-    end
-
-    it "finds the spec file if given a spec file" do
-      rspec_autotest.should map_specs([@spec_file]).to(@spec_file)
-    end
-
-    it "ignores files in spec dir that aren't specs" do
-      rspec_autotest.should map_specs([]).to("spec/spec_helper.rb")
-    end
-
-    it "ignores untracked files (in @file)"  do
-      rspec_autotest.should map_specs([]).to("lib/untracked_file")
-    end
-  end
-
-  describe "consolidating failures" do
-    let(:subject_file) { "lib/autotest/some.rb" }
-    let(:spec_file)    { "spec/autotest/some_spec.rb" }
-
-    it "returns no failures if no failures were given in the output" do
-      rspec_autotest.consolidate_failures([[]]).should eq({})
-    end
-
-    it "returns a hash with the spec filename => spec name for each failure or error" do
-      failures = [ [ "false should be false", spec_file ] ]
-      rspec_autotest.consolidate_failures(failures).should eq({
-        spec_file => ["false should be false"]
-      })
-    end
-
-    context "when subject file appears before the spec file in the backtrace" do
-      let(:failures) do
-        [ [ "false should be false", "#{subject_file}:143:\n#{spec_file}:203:" ] ]
-      end
-
-      it "excludes the subject file" do
-        rspec_autotest.consolidate_failures(failures).keys.should_not include(subject_file)
-      end
-
-      it "includes the spec file" do
-        rspec_autotest.consolidate_failures(failures).keys.should include(spec_file)
-      end
-    end
-  end
-
-  describe "normalizing file names" do
-    it "ensures that a single file appears in files_to_test only once" do
-      @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/command_line/order_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-describe 'command line', :ui do
-  let(:stderr) { StringIO.new }
-  let(:stdout) { StringIO.new }
-
-  before :all do
-    write_file 'spec/order_spec.rb', """
-      describe 'group 1' do
-        specify('group 1 example 1')  {}
-        specify('group 1 example 2')  {}
-        specify('group 1 example 3')  {}
-        specify('group 1 example 4')  {}
-        specify('group 1 example 5')  {}
-        specify('group 1 example 6')  {}
-        specify('group 1 example 5')  {}
-        specify('group 1 example 7')  {}
-        specify('group 1 example 8')  {}
-        specify('group 1 example 9')  {}
-        specify('group 1 example 10') {}
-
-        describe 'group 1-1' do
-          specify('group 1-1 example 1')  {}
-          specify('group 1-1 example 2')  {}
-          specify('group 1-1 example 3')  {}
-          specify('group 1-1 example 4')  {}
-          specify('group 1-1 example 5')  {}
-          specify('group 1-1 example 6')  {}
-          specify('group 1-1 example 7')  {}
-          specify('group 1-1 example 8')  {}
-          specify('group 1-1 example 9')  {}
-          specify('group 1-1 example 10') {}
-        end
-
-        describe('group 1-2')  { specify('example') {} }
-        describe('group 1-3')  { specify('example') {} }
-        describe('group 1-4')  { specify('example') {} }
-        describe('group 1-5')  { specify('example') {} }
-        describe('group 1-6')  { specify('example') {} }
-        describe('group 1-7')  { specify('example') {} }
-        describe('group 1-8')  { specify('example') {} }
-        describe('group 1-9')  { specify('example') {} }
-        describe('group 1-10') { specify('example') {} }
-      end
-
-      describe('group 2')  { specify('example') {} }
-      describe('group 3')  { specify('example') {} }
-      describe('group 4')  { specify('example') {} }
-      describe('group 5')  { specify('example') {} }
-      describe('group 6')  { specify('example') {} }
-      describe('group 7')  { specify('example') {} }
-      describe('group 8')  { specify('example') {} }
-      describe('group 9')  { specify('example') {} }
-      describe('group 10') { specify('example') {} }
-    """
-  end
-
-  describe '--order rand' do
-    it 'runs the examples and groups in a different order each time' do
-      run_command 'tmp/aruba/spec/order_spec.rb --order rand -f doc'
-      RSpec.configuration.seed = srand && srand # reset seed in same process
-      run_command 'tmp/aruba/spec/order_spec.rb --order rand -f doc'
-
-      stdout.string.should match(/Randomized with seed \d+/)
-
-      top_level_groups      {|first_run, second_run| first_run.should_not eq(second_run)}
-      nested_groups         {|first_run, second_run| first_run.should_not eq(second_run)}
-      examples('group 1')   {|first_run, second_run| first_run.should_not eq(second_run)}
-      examples('group 1-1') {|first_run, second_run| first_run.should_not eq(second_run)}
-    end
-  end
-
-  describe '--order rand:SEED' do
-    it 'runs the examples and groups in the same order each time' do
-      2.times { run_command 'tmp/aruba/spec/order_spec.rb --order rand:123 -f doc' }
-
-      stdout.string.should match(/Randomized with seed 123/)
-
-      top_level_groups      {|first_run, second_run| first_run.should eq(second_run)}
-      nested_groups         {|first_run, second_run| first_run.should eq(second_run)}
-      examples('group 1')   {|first_run, second_run| first_run.should eq(second_run)}
-      examples('group 1-1') {|first_run, second_run| first_run.should eq(second_run)}
-    end
-  end
-
-  describe '--seed SEED' do
-    it "forces '--order rand' and runs the examples and groups in the same order each time" do
-      2.times { run_command 'tmp/aruba/spec/order_spec.rb --seed 123 -f doc' }
-
-      stdout.string.should match(/Randomized with seed \d+/)
-
-      top_level_groups      {|first_run, second_run| first_run.should eq(second_run)}
-      nested_groups         {|first_run, second_run| first_run.should eq(second_run)}
-      examples('group 1')   {|first_run, second_run| first_run.should eq(second_run)}
-      examples('group 1-1') {|first_run, second_run| first_run.should eq(second_run)}
-    end
-  end
-
-  describe '--order default on CLI with --order rand in .rspec' do
-    it "overrides --order rand with --order default" do
-      write_file '.rspec', '--order rand'
-
-      run_command 'tmp/aruba/spec/order_spec.rb --order default -f doc'
-
-      stdout.string.should_not match(/Randomized/)
-
-      stdout.string.should match(
-        /group 1.*group 1 example 1.*group 1 example 2.*group 1-1.*group 1-2.*group 2.*/m
-      )
-    end
-  end
-
-  def examples(group)
-    yield split_in_half(stdout.string.scan(/^\s+#{group} example.*$/))
-  end
-
-  def top_level_groups
-    yield example_groups_at_level(0)
-  end
-
-  def nested_groups
-    yield example_groups_at_level(2)
-  end
-
-  def example_groups_at_level(level)
-    split_in_half(stdout.string.scan(/^\s{#{level*2}}group.*$/))
-  end
-
-  def split_in_half(array)
-    length, midpoint = array.length, array.length / 2
-    return array.slice(0, midpoint), array.slice(midpoint, length)
-  end
-
-  def run_command(cmd)
-    RSpec::Core::Runner.run(cmd.split, stderr, stdout)
-  end
-end