opal-rspec 0.6.2 → 0.7.0.rc.1

data/rspec-core/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/rspec-core/spec/rspec/core/reporter_spec.rb

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

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

data/rspec-core/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

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

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

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

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

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

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