rspec-core 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/core/pending_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec::Core::Pending do
-  it 'only defines methods that are part of the DSL' do
-    expect(RSpec::Core::Pending.instance_methods(false).map(&:to_sym)).to \
-      match_array([:pending, :skip])
-  end
-end

data/spec/rspec/core/project_initializer_spec.rb

@@ -1,73 +0,0 @@
-require "spec_helper"
-require 'rspec/core/project_initializer'
-
-module RSpec::Core
-  RSpec.describe ProjectInitializer, :isolated_directory => true do
-
-    describe "#run" do
-      context "with no args" do
-        let(:command_line_config) { ProjectInitializer.new }
-
-        before do
-          allow(command_line_config).to receive(:puts)
-          allow(command_line_config).to receive_messages(:gets => 'no')
-        end
-
-        context "with no .rspec file" do
-          it "says it's creating .rspec " do
-            expect(command_line_config).to receive(:puts).with(/create\s+\.rspec/)
-            command_line_config.run
-          end
-
-          it "generates a .rspec" do
-            command_line_config.run
-            expect(File.read('.rspec')).to match(/--color/m)
-          end
-        end
-
-        context "with a .rspec file" do
-          it "says .rspec exists" do
-            FileUtils.touch('.rspec')
-            expect(command_line_config).to receive(:puts).with(/exist\s+\.rspec/)
-            command_line_config.run
-          end
-
-          it "doesn't create a new one" do
-            File.open('.rspec', 'w') {|f| f << '--color'}
-            command_line_config.run
-            expect(File.read('.rspec')).to eq('--color')
-          end
-        end
-
-        context "with no spec/spec_helper.rb file" do
-          it "says it's creating spec/spec_helper.rb " do
-            expect(command_line_config).to receive(:puts).with(/create\s+spec\/spec_helper.rb/)
-            command_line_config.run
-          end
-
-          it "generates a spec/spec_helper.rb" do
-            command_line_config.run
-            expect(File.read('spec/spec_helper.rb')).to match(/RSpec\.configure do \|config\|/m)
-          end
-        end
-
-        context "with a spec/spec_helper.rb file" do
-          before { FileUtils.mkdir('spec') }
-
-          it "says spec/spec_helper.rb exists" do
-            FileUtils.touch('spec/spec_helper.rb')
-            expect(command_line_config).to receive(:puts).with(/exist\s+spec\/spec_helper.rb/)
-            command_line_config.run
-          end
-
-          it "doesn't create a new one" do
-            random_content = "content #{rand}"
-            File.open('spec/spec_helper.rb', 'w') {|f| f << random_content}
-            command_line_config.run
-            expect(File.read('spec/spec_helper.rb')).to eq(random_content)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/core/rake_task_spec.rb

@@ -1,146 +0,0 @@
-require "spec_helper"
-require "rspec/core/rake_task"
-require 'tempfile'
-
-module RSpec::Core
-  RSpec.describe RakeTask do
-    let(:task) { RakeTask.new }
-
-    def ruby
-      FileUtils::RUBY
-    end
-
-    def spec_command
-      task.__send__(:spec_command)
-    end
-
-    context "with a name passed to the constructor" do
-      let(:task) { RakeTask.new(:task_name) }
-
-      it "correctly sets the name" do
-        expect(task.name).to eq :task_name
-      end
-    end
-
-    context "with args passed to the rake task" do
-      it "correctly passes along task arguments" do
-        task = RakeTask.new(:rake_task_args, :files) do |t, args|
-          expect(args[:files]).to eq "first_spec.rb"
-        end
-
-        expect(task).to receive(:run_task) { true }
-        expect(Rake.application.invoke_task("rake_task_args[first_spec.rb]")).to be_truthy
-      end
-    end
-
-    context "default" do
-      it "renders rspec" do
-        expect(spec_command).to match(/^#{ruby} -S rspec/)
-      end
-    end
-
-    context "with ruby options" do
-      it "renders them before -S" do
-          task.ruby_opts = "-w"
-          expect(spec_command).to match(/^#{ruby} -w -S rspec/)
-      end
-    end
-
-    context "with rspec_opts" do
-      it "adds the rspec_opts" do
-        task.rspec_opts = "-Ifoo"
-        expect(spec_command).to match(/rspec.*-Ifoo/)
-      end
-    end
-
-    context 'with custom exit status' do
-      it 'returns the correct status on exit', :slow do
-        with_isolated_stderr do
-          expect($stderr).to receive(:puts) { |cmd| expect(cmd).to match(/-e "exit\(2\);".* failed/) }
-          expect(task).to receive(:exit).with(2)
-          task.ruby_opts = '-e "exit(2);" ;#'
-          task.run_task false
-        end
-      end
-    end
-
-    def specify_consistent_ordering_of_files_to_run(pattern, task)
-      orderings = [
-        %w[ a/1.rb a/2.rb a/3.rb ],
-        %w[ a/2.rb a/1.rb a/3.rb ],
-        %w[ a/3.rb a/2.rb a/1.rb ]
-      ].map do |files|
-        expect(FileList).to receive(:[]).with(pattern) { files }
-        task.__send__(:files_to_run)
-      end
-
-      expect(orderings.uniq.size).to eq(1)
-    end
-
-    context "with SPEC env var set" do
-      it "sets files to run" do
-        with_env_vars 'SPEC' => 'path/to/file' do
-          expect(task.__send__(:files_to_run)).to eq(["path/to/file"])
-        end
-      end
-
-      it "sets the files to run in a consistent order, regardless of the underlying FileList ordering" do
-        with_env_vars 'SPEC' => 'a/*.rb' do
-          specify_consistent_ordering_of_files_to_run('a/*.rb', task)
-        end
-      end
-    end
-
-    it "sets the files to run in a consistent order, regardless of the underlying FileList ordering" do
-      task = RakeTask.new(:consistent_file_order) do |t|
-        t.pattern = 'a/*.rb'
-      end
-
-      # since the config block is deferred til task invocation, must fake
-      # calling the task so the expected pattern is picked up
-      expect(task).to receive(:run_task) { true }
-      expect(Rake.application.invoke_task(task.name)).to be_truthy
-
-      specify_consistent_ordering_of_files_to_run('a/*.rb', task)
-    end
-
-    context "with paths with quotes or spaces" do
-      it "escapes the quotes and spaces" do
-        task.pattern = File.join(Dir.tmpdir, "*spec.rb")
-        ["first_spec.rb", "second_\"spec.rb", "third_\'spec.rb", "fourth spec.rb"].each do |file_name|
-          FileUtils.touch(File.join(Dir.tmpdir, file_name))
-        end
-        expect(task.__send__(:files_to_run).sort).to eq([
-          File.join(Dir.tmpdir, "first_spec.rb"),
-          File.join(Dir.tmpdir, "fourth\\ spec.rb"),
-          File.join(Dir.tmpdir, "second_\\\"spec.rb"),
-          File.join(Dir.tmpdir, "third_\\\'spec.rb")
-        ])
-      end
-    end
-
-    context "with paths including symlinked directories" do
-      it "finds the files" do
-        project_dir = File.join(Dir.tmpdir, "project")
-        FileUtils.rm_rf project_dir
-
-        foos_dir = File.join(project_dir, "spec/foos")
-        FileUtils.mkdir_p foos_dir
-        FileUtils.touch(File.join(foos_dir, "foo_spec.rb"))
-
-        bars_dir = File.join(Dir.tmpdir, "shared/spec/bars")
-        FileUtils.mkdir_p bars_dir
-        FileUtils.touch(File.join(bars_dir, "bar_spec.rb"))
-
-        FileUtils.ln_s bars_dir, File.join(project_dir, "spec/bars")
-
-        FileUtils.cd(project_dir) do
-          expect(RakeTask.new.__send__(:files_to_run).sort).to eq([
-            "./spec/bars/bar_spec.rb",
-            "./spec/foos/foo_spec.rb"
-          ])
-        end
-      end
-    end
-  end
-end

data/spec/rspec/core/random_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Core
-    RSpec.describe RandomNumberGenerator do
-      it 'is a random number generator' do
-        random = described_class.new
-
-        expect([Fixnum, Bignum]).to include random.seed.class
-        expect(random.rand).to be_a Float
-
-        rands = []
-        100.times do
-          rands << random.rand
-        end
-
-        expect(rands.uniq.count).to be > 90
-      end
-
-      it 'produces the same results given the same seed' do
-        seed = rand(999)
-
-        random = described_class.new(seed)
-
-        expect(random.seed).to eq seed
-
-        expected = []
-        5.times do
-          expected << random.rand(999)
-        end
-
-        10.times do
-          random = described_class.new(seed)
-
-          expect(random.seed).to eq seed
-
-          actual = []
-          5.times do
-            actual << random.rand(999)
-          end
-
-          expect(actual).to eq expected
-        end
-      end
-    end
-  end
-end

data/spec/rspec/core/reporter_spec.rb

@@ -1,155 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core
-  RSpec.describe Reporter do
-    let(:config)   { Configuration.new }
-    let(:reporter) { Reporter.new config }
-
-    describe "finish" do
-      let(:formatter) { double("formatter") }
-      let(:example)   { double("example") }
-
-      %w[start_dump dump_pending dump_failures dump_summary close].map(&:to_sym).each do |message|
-        it "sends #{message} to the formatter(s) that respond to message" do
-          reporter.register_listener formatter, message
-          expect(formatter.as_null_object).to receive(message)
-          reporter.finish
-        end
-
-        it "doesnt notify formatters about messages they dont implement" do
-          expect { reporter.finish }.to_not raise_error
-        end
-      end
-    end
-
-    context "given one formatter" do
-      it "passes messages to that formatter" do
-        formatter = double("formatter", :example_started => nil)
-        example = double("example")
-        reporter.register_listener formatter, :example_started
-
-        expect(formatter).to receive(:example_started) do |notification|
-          expect(notification.example).to eq example
-        end
-
-        reporter.example_started(example)
-      end
-
-      it "passes example_group_started and example_group_finished messages to that formatter in that order" do
-        order = []
-
-        formatter = double("formatter")
-        allow(formatter).to receive(:example_group_started)  { |n| order << "Started: #{n.group.description}" }
-        allow(formatter).to receive(:example_group_finished) { |n| order << "Finished: #{n.group.description}" }
-
-        reporter.register_listener formatter, :example_group_started, :example_group_finished
-
-        group = ExampleGroup.describe("root")
-        group.describe("context 1") do
-          example("ignore") {}
-        end
-        group.describe("context 2") do
-          example("ignore") {}
-        end
-
-        group.run(reporter)
-
-        expect(order).to eq([
-           "Started: root",
-           "Started: context 1",
-           "Finished: context 1",
-           "Started: context 2",
-           "Finished: context 2",
-           "Finished: root"
-        ])
-      end
-    end
-
-    context "given an example group with no examples" do
-      it "does not pass example_group_started or example_group_finished to formatter" do
-        formatter = double("formatter")
-        expect(formatter).not_to receive(:example_group_started)
-        expect(formatter).not_to receive(:example_group_finished)
-
-        reporter.register_listener formatter, :example_group_started, :example_group_finished
-
-        group = ExampleGroup.describe("root")
-
-        group.run(reporter)
-      end
-    end
-
-    context "given multiple formatters" do
-      it "passes messages to all formatters" do
-        formatters = (1..2).map { double("formatter", :example_started => nil) }
-        example = double("example")
-
-        formatters.each do |formatter|
-          expect(formatter).to receive(:example_started) do |notification|
-            expect(notification.example).to eq example
-          end
-          reporter.register_listener formatter, :example_started
-        end
-
-        reporter.example_started(example)
-      end
-    end
-
-    describe "#report" do
-      it "supports one arg (count)" do
-        reporter.report(1) {}
-      end
-
-      it "yields itself" do
-        yielded = nil
-        reporter.report(3) { |r| yielded = r }
-        expect(yielded).to eq(reporter)
-      end
-    end
-
-    describe "#register_listener" do
-      let(:listener) { double("listener", :start => nil) }
-
-      before { reporter.register_listener listener, :start }
-
-      it 'will register the listener to specified notifications' do
-        expect(reporter.registered_listeners :start).to eq [listener]
-      end
-
-      it 'will match string notification names' do
-        reporter.register_listener listener, "stop"
-        expect(reporter.registered_listeners :stop).to eq [listener]
-      end
-
-      it 'will send notifications when a subscribed event is triggered' do
-        expect(listener).to receive(:start) do |notification|
-          expect(notification.count).to eq 42
-        end
-        reporter.start 42
-      end
-
-      it 'will ignore duplicated listeners' do
-        reporter.register_listener listener, :start
-        expect(listener).to receive(:start).once
-        reporter.start 42
-      end
-    end
-
-    describe "timing" do
-      it "uses RSpec::Core::Time as to not be affected by changes to time in examples" do
-        formatter = double(:formatter)
-        reporter.register_listener formatter, :dump_summary
-        reporter.start 1
-        allow(Time).to receive_messages(:now => ::Time.utc(2012, 10, 1))
-
-        duration = nil
-        allow(formatter).to receive(:dump_summary) do |notification|
-          duration = notification.duration
-        end
-
-        reporter.finish
-        expect(duration).to be < 0.2
-      end
-    end
-  end
-end

data/spec/rspec/core/resources/a_spec.rb

@@ -1 +0,0 @@
-# Empty - used by ../options_spec.rb

data/spec/rspec/core/resources/custom_example_group_runner.rb

@@ -1,14 +0,0 @@
-module Custom
-  class ExampleGroupRunner
-    attr_reader :options, :arg
-    def initialize(options, arg)
-      @options, @arg = options, arg
-    end
-
-    def load_files(files)
-    end
-
-    def run
-    end
-  end
-end