opal-connect-rspec 0.5.0

data/rspec-core/spec/rspec/core/random_spec.rb

@@ -0,0 +1,47 @@
+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/rspec-core/spec/rspec/core/reporter_spec.rb

@@ -0,0 +1,198 @@
+require "spec_helper"
+
+module RSpec::Core
+  RSpec.describe Reporter do
+    include FormatterSupport
+
+    let(:config)   { Configuration.new }
+    let(:reporter) { Reporter.new config }
+    let(:start_time) { Time.now }
+    let(:example) { super() }
+
+    describe "finish" do
+      let(:formatter) { double("formatter") }
+
+      %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
+
+      it "dumps the failure summary after the deprecation summary so failures don't scroll off the screen and get missed" do
+        formatter = instance_double("RSpec::Core::Formatter::ProgressFormatter")
+        reporter.register_listener(formatter, :dump_summary, :deprecation_summary)
+
+        expect(formatter).to receive(:deprecation_summary).ordered
+        expect(formatter).to receive(:dump_summary).ordered
+
+        reporter.finish
+      end
+    end
+
+    describe 'start' do
+      before { config.start_time = start_time }
+
+      it 'notifies the formatter of start with example count' do
+        formatter = double("formatter")
+        reporter.register_listener formatter, :start
+
+        expect(formatter).to receive(:start) do |notification|
+          expect(notification.count).to eq 3
+          expect(notification.load_time).to eq 5
+        end
+
+        reporter.start 3, (start_time + 5)
+      end
+    end
+
+    context "given one formatter" do
+      it "passes messages to that formatter" do
+        formatter = double("formatter", :example_started => nil)
+        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) }
+
+        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
+      before do
+        config.start_time = start_time
+      end
+
+      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
+
+      it "captures the load time so it can report it later" do
+        formatter = instance_double("ProgressFormatter")
+        reporter.register_listener formatter, :dump_summary
+        reporter.start 3, (start_time + 5)
+
+        expect(formatter).to receive(:dump_summary) do |notification|
+          expect(notification.load_time).to eq(5)
+        end
+
+        reporter.finish
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,14 @@
+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

data/rspec-core/spec/rspec/core/resources/formatter_specs.rb

@@ -0,0 +1,58 @@
+# Deliberately named _specs.rb to avoid being loaded except when specified
+
+RSpec.describe "pending spec with no implementation" do
+  it "is pending"
+end
+
+RSpec.describe "pending command with block format" do
+  context "with content that would fail" do
+    it "is pending" do
+      pending
+      expect(1).to eq(2)
+    end
+  end
+
+  context "with content that would pass" do
+    it "fails" do
+      pending
+      expect(1).to eq(1)
+    end
+  end
+end
+
+RSpec.describe "passing spec" do
+  it "passes" do
+    expect(1).to eq(1)
+  end
+end
+
+RSpec.describe "failing spec" do
+  it "fails" do
+    expect(1).to eq(2)
+  end
+end
+
+RSpec.describe "a failing spec with odd backtraces" do
+  it "fails with a backtrace that has no file" do
+    require 'erb'
+
+    ERB.new("<%= raise 'foo' %>").result
+  end
+
+  it "fails with a backtrace containing an erb file" do
+    e = Exception.new
+
+    def e.backtrace
+      ["/foo.html.erb:1:in `<main>': foo (RuntimeError)",
+        "   from /lib/ruby/1.9.1/erb.rb:753:in `eval'"]
+    end
+
+    def e.message
+      # Redefining message steps around this behaviour
+      # on JRuby: http://jira.codehaus.org/browse/JRUBY-5637
+      self.class.name
+    end
+
+    raise e
+  end
+end

data/rspec-core/spec/rspec/core/resources/utf8_encoded.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+module Custom
+  class ExampleUTF8ClassNameVarietà
+    def self.è
+      così = :però
+      così
+    end
+  end
+end

data/rspec-core/spec/rspec/core/rspec_matchers_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module RSpec::Matchers
+  def __method_with_super
+    super
+  end
+
+  module ModThatIncludesMatchers
+    include RSpec::Matchers
+  end
+
+  RSpec.configure do |c|
+    c.include RSpec::Matchers, :include_rspec_matchers => true
+    c.include ModThatIncludesMatchers, :include_mod_that_includes_rspec_matchers => true
+  end
+
+  RSpec.describe self do
+    shared_examples_for "a normal module with a method that supers" do
+      it "raises the expected error (and not SystemStackError)" do
+        expect { __method_with_super }.to raise_error(NoMethodError) # there is no __method_with_super in an ancestor
+      end
+    end
+
+    it_behaves_like "a normal module with a method that supers"
+
+    context "when RSpec::Matchers has been included in an example group" do
+      include RSpec::Matchers
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when a module that includes RSpec::Matchers has been included in an example group" do
+      include RSpec::Matchers::ModThatIncludesMatchers
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when RSpec::Matchers is included via configuration", :include_rspec_matchers => true do
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when RSpec::Matchers is included in a module that is included via configuration", :include_mod_that_includes_rspec_matchers => true do
+      it_behaves_like "a normal module with a method that supers"
+    end
+  end
+end
+

data/rspec-core/spec/rspec/core/ruby_project_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module RSpec
+  module Core
+    RSpec.describe RubyProject do
+
+      describe "#determine_root" do
+
+        context "with ancestor containing spec directory" do
+          it "returns ancestor containing the spec directory" do
+            allow(RubyProject).to receive(:ascend_until).and_return('foodir')
+            expect(RubyProject.determine_root).to eq("foodir")
+          end
+        end
+
+        context "without ancestor containing spec directory" do
+          it "returns current working directory" do
+            allow(RubyProject).to receive(:find_first_parent_containing).and_return(nil)
+            expect(RubyProject.determine_root).to eq(".")
+          end
+        end
+
+      end
+    end
+  end
+end

data/rspec-core/spec/rspec/core/runner_spec.rb

@@ -0,0 +1,309 @@
+require 'spec_helper'
+require 'rspec/core/drb'
+
+module RSpec::Core
+  RSpec.describe Runner do
+    describe 'invocation' do
+      before do
+        # Simulate invoking the suite like exe/rspec does.
+        allow(RSpec::Core::Runner).to receive(:run)
+        RSpec::Core::Runner.invoke
+      end
+
+      it 'does not autorun after having been invoked' do
+        expect(RSpec::Core::Runner).not_to receive(:at_exit)
+        RSpec::Core::Runner.autorun
+      end
+
+      it 'prints a warning when autorun is attempted' do
+        expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
+        RSpec::Core::Runner.autorun
+      end
+    end
+
+    describe 'at_exit' do
+      it 'sets an at_exit hook if none is already set' do
+        allow(RSpec::Core::Runner).to receive(:autorun_disabled?).and_return(false)
+        allow(RSpec::Core::Runner).to receive(:installed_at_exit?).and_return(false)
+        allow(RSpec::Core::Runner).to receive(:running_in_drb?).and_return(false)
+        allow(RSpec::Core::Runner).to receive(:invoke)
+        expect(RSpec::Core::Runner).to receive(:at_exit)
+        RSpec::Core::Runner.autorun
+      end
+
+      it 'does not set the at_exit hook if it is already set' do
+        allow(RSpec::Core::Runner).to receive(:autorun_disabled?).and_return(false)
+        allow(RSpec::Core::Runner).to receive(:installed_at_exit?).and_return(true)
+        allow(RSpec::Core::Runner).to receive(:running_in_drb?).and_return(false)
+        expect(RSpec::Core::Runner).to receive(:at_exit).never
+        RSpec::Core::Runner.autorun
+      end
+    end
+
+    # This is intermittently slow because this method calls out to the network
+    # interface.
+    describe ".running_in_drb?", :slow do
+      it "returns true if drb server is started with 127.0.0.1" do
+        allow(::DRb).to receive(:current_server).and_return(double(:uri => "druby://127.0.0.1:0000/"))
+
+        expect(RSpec::Core::Runner.running_in_drb?).to be_truthy
+      end
+
+      it "returns true if drb server is started with localhost" do
+        allow(::DRb).to receive(:current_server).and_return(double(:uri => "druby://localhost:0000/"))
+
+        expect(RSpec::Core::Runner.running_in_drb?).to be_truthy
+      end
+
+      it "returns true if drb server is started with another local ip address" do
+        allow(::DRb).to receive(:current_server).and_return(double(:uri => "druby://192.168.0.1:0000/"))
+        allow(::IPSocket).to receive(:getaddress).and_return("192.168.0.1")
+
+        expect(RSpec::Core::Runner.running_in_drb?).to be_truthy
+      end
+
+      it "returns false if no drb server is running" do
+        allow(::DRb).to receive(:current_server).and_raise(::DRb::DRbServerNotFound)
+
+        expect(RSpec::Core::Runner.running_in_drb?).to be_falsey
+      end
+    end
+
+    describe ".invoke" do
+      let(:runner) { RSpec::Core::Runner }
+
+      it "runs the specs via #run" do
+        allow(runner).to receive(:exit)
+        expect(runner).to receive(:run)
+        runner.invoke
+      end
+
+      it "doesn't exit on success" do
+        allow(runner).to receive(:run) { 0 }
+        expect(runner).to_not receive(:exit)
+        runner.invoke
+      end
+
+      it "exits with #run's status on failure" do
+        allow(runner).to receive(:run) { 123 }
+        expect(runner).to receive(:exit).with(123)
+        runner.invoke
+      end
+    end
+
+    describe ".run" do
+      let(:err) { StringIO.new }
+      let(:out) { StringIO.new }
+
+      context "with --drb or -X" do
+        before(:each) do
+          @options = RSpec::Core::ConfigurationOptions.new(%w[--drb --drb-port 8181 --color])
+          allow(RSpec::Core::ConfigurationOptions).to receive(:new) { @options }
+        end
+
+        def run_specs
+          RSpec::Core::Runner.run(%w[ --drb ], err, out)
+        end
+
+        context 'and a DRb server is running' do
+          it "builds a DRbRunner and runs the specs" do
+            drb_proxy = double(RSpec::Core::DRbRunner, :run => true)
+            expect(drb_proxy).to receive(:run).with(err, out)
+
+            expect(RSpec::Core::DRbRunner).to receive(:new).and_return(drb_proxy)
+
+            run_specs
+          end
+        end
+
+        context 'and a DRb server is not running' do
+          before(:each) do
+            expect(RSpec::Core::DRbRunner).to receive(:new).and_raise(DRb::DRbConnError)
+          end
+
+          it "outputs a message" do
+            allow(RSpec.configuration).to receive(:files_to_run) { [] }
+            expect(err).to receive(:puts).with(
+              "No DRb server is running. Running in local process instead ..."
+            )
+            run_specs
+          end
+
+          it "builds a runner instance and runs the specs" do
+            process_proxy = double(RSpec::Core::Runner, :run => 0)
+            expect(process_proxy).to receive(:run).with(err, out)
+
+            expect(RSpec::Core::Runner).to receive(:new).and_return(process_proxy)
+
+            run_specs
+          end
+        end
+      end
+    end
+
+    context "when run" do
+      let(:out)    { StringIO.new         }
+      let(:err)    { StringIO.new         }
+      let(:config) { RSpec.configuration  }
+      let(:world)  { RSpec.world          }
+
+      before do
+        allow(config.hooks).to receive(:run)
+      end
+
+      it "configures streams before command line options" do
+        allow(RSpec).to receive(:deprecate)  # remove this and should_receive when ordered
+        stdout = StringIO.new
+        allow(config).to receive(:load_spec_files)
+        allow(config).to receive(:reporter).and_return(double.as_null_object)
+        config.output_stream = $stdout
+
+        # this is necessary to ensure that color works correctly on windows
+        expect(config).to receive(:error_stream=).ordered
+        expect(config).to receive(:output_stream=).ordered
+        expect(config).to receive(:force).at_least(:once).ordered
+
+        runner = build_runner
+        runner.setup err, stdout
+      end
+
+      it "assigns submitted ConfigurationOptions to @options" do
+        config_options = ConfigurationOptions.new(%w[--color])
+        runner         = Runner.new(config_options)
+        expect(runner.instance_exec { @options }).to be(config_options)
+      end
+
+      describe "#run" do
+        it 'supports a test-queue like subclass that can perform setup once and run different sets of example groups multiple times' do
+          order = []
+
+          RSpec.describe("group 1") do
+            before { order << :group_1 }
+            example("passing") { expect(1).to eq(1) }
+          end
+
+          RSpec.describe("group 2") do
+            before { order << :group_2 }
+            example("failed") { expect(1).to eq(2) }
+          end
+
+          subclass = Class.new(Runner) do
+            define_method :run_specs do |example_groups|
+              set_1, set_2 = example_groups.partition { |g| g.description.include?('1') }
+              order << :start_set_1
+              super(set_1)
+              order << :start_set_2
+              super(set_2)
+            end
+          end
+
+          expect(config).to receive(:load_spec_files).once
+          subclass.new(ConfigurationOptions.new([]), config, world).run(err, out)
+          expect(order).to eq([:start_set_1, :group_1, :start_set_2, :group_2])
+        end
+
+        it 'reports the expected example count accurately, even when subclasses filter example groups' do
+          RSpec.describe("group 1") do
+            example("1") { }
+
+            context "nested" do
+              4.times { example { } }
+            end
+          end
+
+          RSpec.describe("group 2") do
+            example("2") { }
+            example("3") { }
+
+            context "nested" do
+              4.times { example { } }
+            end
+          end
+
+          subclass = Class.new(Runner) do
+            define_method :run_specs do |example_groups|
+              super(example_groups.select { |g| g.description == 'group 2' })
+            end
+          end
+
+          my_formatter = instance_double(Formatters::BaseFormatter).as_null_object
+          config.output_stream = out
+          config.deprecation_stream = err
+          config.reporter.register_listener(my_formatter, :start)
+
+          allow(config).to receive(:load_spec_files)
+          subclass.new(ConfigurationOptions.new([]), config, world).run(err, out)
+
+          expect(my_formatter).to have_received(:start) do |notification|
+            expect(notification.count).to eq(6)
+          end
+        end
+
+        context "running files" do
+          include_context "spec files"
+
+          it "returns 0 if spec passes" do
+            runner = build_runner passing_spec_filename
+            expect(runner.run(err, out)).to eq 0
+          end
+
+          it "returns 1 if spec fails" do
+            runner = build_runner failing_spec_filename
+            expect(runner.run(err, out)).to eq 1
+          end
+
+          it "returns 2 if spec fails and --failure-exit-code is 2" do
+            runner = build_runner failing_spec_filename, "--failure-exit-code", "2"
+            expect(runner.run(err, out)).to eq 2
+          end
+        end
+
+        context "running hooks" do
+          before { allow(config).to receive :load_spec_files }
+
+          it "runs before suite hooks" do
+            expect(config.hooks).to receive(:run).with(:before, :suite, instance_of(SuiteHookContext))
+            runner = build_runner
+            runner.run err, out
+          end
+
+          it "runs after suite hooks" do
+            expect(config.hooks).to receive(:run).with(:after, :suite, instance_of(SuiteHookContext))
+            runner = build_runner
+            runner.run err, out
+          end
+
+          it "runs after suite hooks even after an error" do
+            expect(config.hooks).to receive(:run).with(:before, :suite, instance_of(SuiteHookContext)).and_raise "this error"
+            expect(config.hooks).to receive(:run).with(:after , :suite, instance_of(SuiteHookContext))
+            expect do
+              runner = build_runner
+              runner.run err, out
+            end.to raise_error("this error")
+          end
+        end
+      end
+
+      describe "#run with custom output" do
+        before { allow(config).to receive_messages :files_to_run => [] }
+
+        let(:output_file) { File.new("#{Dir.tmpdir}/runner_spec_output.txt", 'w') }
+
+        it "doesn't override output_stream" do
+          config.output_stream = output_file
+          runner = build_runner
+          runner.run err, nil
+          expect(runner.instance_exec { @configuration.output_stream }).to eq output_file
+        end
+      end
+
+      def build_runner *args
+        Runner.new build_config_options(*args)
+      end
+
+      def build_config_options *args
+        ConfigurationOptions.new args
+      end
+    end
+  end
+end