opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,278 @@
+require "spec_helper"
+require 'rspec/core/drb'
+
+RSpec.describe RSpec::Core::DRbRunner, :isolated_directory => true, :isolated_home => true, :type => :drb, :unless => RUBY_PLATFORM == 'java' do
+  let(:config) { RSpec::Core::Configuration.new }
+  let(:out)    { StringIO.new }
+  let(:err)    { StringIO.new }
+
+  include_context "spec files"
+
+  def runner(*args)
+    RSpec::Core::DRbRunner.new(config_options(*args))
+  end
+
+  def config_options(*args)
+    RSpec::Core::ConfigurationOptions.new(args)
+  end
+
+  context "without server running" do
+    it "raises an error" do
+      expect { runner.run(err, out) }.to raise_error(DRb::DRbConnError)
+    end
+
+    after { DRb.stop_service }
+  end
+
+  describe "--drb-port" do
+    def with_RSPEC_DRB_set_to(val)
+      with_env_vars('RSPEC_DRB' => val) { yield }
+    end
+
+    context "without RSPEC_DRB environment variable set" do
+      it "defaults to 8989" do
+        with_RSPEC_DRB_set_to(nil) do
+          expect(runner.drb_port).to eq(8989)
+        end
+      end
+
+      it "sets the DRb port" do
+        with_RSPEC_DRB_set_to(nil) do
+          expect(runner("--drb-port", "1234").drb_port).to eq(1234)
+          expect(runner("--drb-port", "5678").drb_port).to eq(5678)
+        end
+      end
+    end
+
+    context "with RSPEC_DRB environment variable set" do
+      context "without config variable set" do
+        it "uses RSPEC_DRB value" do
+          with_RSPEC_DRB_set_to('9000') do
+            expect(runner.drb_port).to eq("9000")
+          end
+        end
+      end
+
+      context "and config variable set" do
+        it "uses configured value" do
+          with_RSPEC_DRB_set_to('9000') do
+            expect(runner(*%w[--drb-port 5678]).drb_port).to eq(5678)
+          end
+        end
+      end
+    end
+  end
+
+  context "with server running", :slow do
+    class SimpleDRbSpecServer
+      def self.run(argv, err, out)
+        options = RSpec::Core::ConfigurationOptions.new(argv)
+        config  = RSpec::Core::Configuration.new
+        RSpec.configuration = config
+        RSpec::Core::Runner.new(options, config).run(err, out)
+      end
+    end
+
+    before(:all) do
+      @drb_port = '8990'
+      @drb_example_file_counter = 0
+      DRb::start_service("druby://127.0.0.1:#{@drb_port}", SimpleDRbSpecServer)
+    end
+
+    after(:all) do
+      DRb::stop_service
+    end
+
+    it "returns 0 if spec passes" do
+      result = runner("--drb-port", @drb_port, passing_spec_filename).run(err, out)
+      expect(result).to be(0)
+    end
+
+    it "returns 1 if spec fails" do
+      result = runner("--drb-port", @drb_port, failing_spec_filename).run(err, out)
+      expect(result).to be(1)
+    end
+
+    it "outputs colorized text when running with --color option" do
+      failure_symbol = "\e[#{RSpec::Core::Formatters::ConsoleCodes.console_code_for(:red)}mF"
+      allow(out).to receive_messages(:tty? => true)
+      runner(failing_spec_filename, "--color", "--drb-port", @drb_port).run(err, out)
+      expect(out.string).to include(failure_symbol)
+    end
+  end
+end
+
+RSpec.describe RSpec::Core::DRbOptions, :isolated_directory => true, :isolated_home => true do
+  include ConfigOptionsHelper
+
+  describe "DRB args" do
+    def drb_argv_for(args)
+      options = config_options_object(*args)
+      RSpec::Core::DRbRunner.new(options, RSpec.configuration).drb_argv
+    end
+
+    def drb_filter_manager_for(args)
+      configuration = RSpec::Core::Configuration.new
+      RSpec::Core::DRbRunner.new(config_options_object(*args), configuration).drb_argv
+      configuration.filter_manager
+    end
+
+    it "preserves extra arguments" do
+      allow(File).to receive(:exist?) { false }
+      expect(drb_argv_for(%w[ a --drb b --color c ])).to match_array %w[ --color a b c ]
+    end
+
+    %w(--color --fail-fast --profile --backtrace --tty).each do |option|
+      it "includes #{option}" do
+        expect(drb_argv_for([option])).to include(option)
+      end
+    end
+
+    it "includes --failure-exit-code" do
+      expect(drb_argv_for(%w[--failure-exit-code 2])).to include("--failure-exit-code", "2")
+    end
+
+    it "includes --options" do
+      expect(drb_argv_for(%w[--options custom.opts])).to include("--options", "custom.opts")
+    end
+
+    it "includes --order" do
+      expect(drb_argv_for(%w[--order random])).to include('--order', 'random')
+    end
+
+    context "with --example" do
+      it "includes --example" do
+        expect(drb_argv_for(%w[--example foo])).to include("--example", "foo")
+      end
+
+      it "unescapes characters which were escaped upon storing --example originally" do
+        expect(drb_argv_for(["--example", "foo\\ bar"])).to include("--example", "foo bar")
+      end
+    end
+
+    context "with tags" do
+      it "includes the inclusion tags" do
+        expect(drb_argv_for ["--tag", "tag"]).to eq(["--tag", "tag"])
+      end
+
+      it "includes the inclusion tags with values" do
+        expect(drb_argv_for ["--tag", "tag:foo"]).to eq(["--tag", "tag:foo"])
+      end
+
+      it "leaves inclusion tags intact" do
+        rules = drb_filter_manager_for(%w[ --tag tag ]).inclusions.rules
+        expect(rules).to eq( {:tag=>true} )
+      end
+
+      it "leaves inclusion tags with values intact" do
+        rules = drb_filter_manager_for(%w[ --tag tag:foo ]).inclusions.rules
+        expect(rules).to eq( {:tag=>'foo'} )
+      end
+
+      it "includes the exclusion tags" do
+        expect(drb_argv_for ["--tag", "~tag"]).to eq(["--tag", "~tag"])
+      end
+
+      it "includes the exclusion tags with values" do
+        expect(drb_argv_for ["--tag", "~tag:foo"]).to eq(["--tag", "~tag:foo"])
+      end
+
+      it "leaves exclusion tags intact" do
+        rules = drb_filter_manager_for(%w[ --tag ~tag ]).exclusions.rules
+        expect(rules).to eq( {:tag => true} )
+      end
+
+      it "leaves exclusion tags with values intact" do
+        rules = drb_filter_manager_for(%w[ --tag ~tag:foo ]).exclusions.rules
+        expect(rules).to eq( {:tag => 'foo'} )
+      end
+    end
+
+    context "with formatters" do
+      it "includes the formatters" do
+        expect(drb_argv_for ["--format", "d"]).to eq(["--format", "d"])
+      end
+
+      it "leaves formatters intact" do
+        coo = config_options_object("--format", "d")
+        RSpec::Core::DRbRunner.new(coo, RSpec::Core::Configuration.new).drb_argv
+        expect(coo.options[:formatters]).to eq([["d"]])
+      end
+
+      it "leaves output intact" do
+        coo = config_options_object("--format", "p", "--out", "foo.txt", "--format", "d")
+        RSpec::Core::DRbRunner.new(coo, RSpec::Core::Configuration.new).drb_argv
+        expect(coo.options[:formatters]).to eq([["p","foo.txt"],["d"]])
+      end
+    end
+
+    context "with --out" do
+      it "combines with formatters" do
+        argv = drb_argv_for(%w[--format h --out report.html])
+        expect(argv).to  eq(%w[--format h --out report.html])
+      end
+    end
+
+    context "with -I libs" do
+      it "includes -I" do
+        expect(drb_argv_for(%w[-I a_dir])).to eq(%w[-I a_dir])
+      end
+
+      it "includes multiple paths" do
+        argv = drb_argv_for(%w[-I dir_1 -I dir_2 -I dir_3])
+        expect(argv).to  eq(%w[-I dir_1 -I dir_2 -I dir_3])
+      end
+    end
+
+    context "with --require" do
+      it "includes --require" do
+        expect(drb_argv_for(%w[--require a_path])).to eq(%w[--require a_path])
+      end
+
+      it "includes multiple paths" do
+        argv = drb_argv_for(%w[--require dir/ --require file.rb])
+        expect(argv).to  eq(%w[--require dir/ --require file.rb])
+      end
+    end
+
+    context "--drb specified in ARGV" do
+      it "renders all the original arguments except --drb" do
+        argv = drb_argv_for(%w[ --drb --color --format s --example pattern
+                                --profile --backtrace -I
+                                path/a -I path/b --require path/c --require
+                                path/d])
+        expect(argv).to eq(%w[ --color --profile --backtrace --example pattern --format s -I path/a -I path/b --require path/c --require path/d])
+      end
+    end
+
+    context "--drb specified in the options file" do
+      it "renders all the original arguments except --drb" do
+        File.open("./.rspec", "w") {|f| f << "--drb --color"}
+        drb_argv = drb_argv_for(%w[ --tty --format s --example pattern --profile --backtrace ])
+        expect(drb_argv).to eq(%w[ --color --profile --backtrace --tty --example pattern --format s])
+      end
+    end
+
+    context "--drb specified in ARGV and the options file" do
+      it "renders all the original arguments except --drb" do
+        File.open("./.rspec", "w") {|f| f << "--drb --color"}
+        argv = drb_argv_for(%w[ --drb --format s --example pattern --profile --backtrace])
+        expect(argv).to eq(%w[ --color --profile --backtrace --example pattern --format s])
+      end
+    end
+
+    context "--drb specified in ARGV and in as ARGV-specified --options file" do
+      it "renders all the original arguments except --drb and --options" do
+        File.open("./.rspec", "w") {|f| f << "--drb --color"}
+        argv = drb_argv_for(%w[ --drb --format s --example pattern --profile --backtrace])
+        expect(argv).to eq(%w[ --color --profile --backtrace --example pattern --format s ])
+      end
+    end
+
+    describe "--drb, -X" do
+      it "does not send --drb back to the parser after parsing options" do
+        expect(drb_argv_for(%w[--drb --color])).not_to include("--drb")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'rspec/support/spec/in_sub_process'
+
+main = self
+
+RSpec.describe "The RSpec DSL" do
+  include RSpec::Support::InSubProcess
+
+  shared_examples_for "dsl methods" do |*method_names|
+    context "when expose_dsl_globally is enabled" do
+      def enable
+        in_sub_process do
+          changing_expose_dsl_globally do
+            RSpec.configuration.expose_dsl_globally = true
+            expect(RSpec.configuration.expose_dsl_globally?).to eq true
+          end
+
+          yield
+        end
+      end
+
+      it 'makes them only available off of `RSpec`, `main` and modules' do
+        enable do
+          expect(::RSpec).to respond_to(*method_names)
+          expect(main).to respond_to(*method_names)
+          expect(Module.new).to respond_to(*method_names)
+
+          expect(Object.new).not_to respond_to(*method_names)
+        end
+      end
+    end
+
+    context "when expose_dsl_globally is disabled" do
+      def disable
+        in_sub_process do
+          changing_expose_dsl_globally do
+            RSpec.configuration.expose_dsl_globally = false
+            expect(RSpec.configuration.expose_dsl_globally?).to eq false
+          end
+
+          yield
+        end
+      end
+
+      it 'makes them only available off of `RSpec`' do
+        disable do
+          expect(::RSpec).to respond_to(*method_names)
+
+          expect(main).not_to respond_to(*method_names)
+          expect(Module.new).not_to respond_to(*method_names)
+          expect(Object.new).not_to respond_to(*method_names)
+        end
+      end
+    end
+  end
+
+  describe "built in DSL methods" do
+    include_examples "dsl methods", :describe, :context, :shared_examples, :shared_examples_for, :shared_context do
+      def changing_expose_dsl_globally
+        yield
+      end
+    end
+  end
+
+  describe "custom example group aliases" do
+    context "when adding aliases before exposing the DSL globally" do
+      include_examples "dsl methods", :detail do
+        def changing_expose_dsl_globally
+          RSpec.configuration.alias_example_group_to(:detail)
+          yield
+        end
+      end
+    end
+
+    context "when adding aliases after exposing the DSL globally" do
+      include_examples "dsl methods", :detail do
+        def changing_expose_dsl_globally
+          yield
+          RSpec.configuration.alias_example_group_to(:detail)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+module RSpec
+  module Core
+    class Example
+      RSpec.describe ExecutionResult do
+        it "supports ruby 2.1's `to_h` protocol" do
+          er = ExecutionResult.new
+          er.run_time = 17
+          er.pending_message = "just because"
+
+          expect(er.to_h).to include(
+            :run_time => 17,
+            :pending_message => "just because"
+          )
+        end
+
+        it 'includes all defined attributes in the `to_h` hash even if not set' do
+          expect(ExecutionResult.new.to_h).to include(
+            :status => nil,
+            :pending_message => nil
+          )
+        end
+
+        it 'provides a `pending_fixed?` predicate' do
+          er = ExecutionResult.new
+          expect { er.pending_fixed = true }.to change(er, :pending_fixed?).to(true)
+        end
+
+        describe "backwards compatibility" do
+          it 'supports indexed access like a hash' do
+            er = ExecutionResult.new
+            er.started_at = (started_at = ::Time.utc(2014, 3, 1, 12, 30))
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /execution_result/)
+            expect(er[:started_at]).to eq(started_at)
+          end
+
+          it 'supports indexed updates like a hash' do
+            er = ExecutionResult.new
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /execution_result/)
+            er[:started_at] = (started_at = ::Time.utc(2014, 3, 1, 12, 30))
+            expect(er.started_at).to eq(started_at)
+          end
+
+          it 'can get and set user defined attributes like with a hash' do
+            er = ExecutionResult.new
+            allow_deprecation
+            expect { er[:foo] = 3 }.to change { er[:foo] }.from(nil).to(3)
+            expect(er.to_h).to include(:foo => 3)
+          end
+
+          it 'supports `update` like a hash' do
+            er = ExecutionResult.new
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /execution_result/)
+            er.update(:pending_message => "some message", :exception => ArgumentError.new)
+            expect(er.pending_message).to eq("some message")
+            expect(er.exception).to be_a(ArgumentError)
+          end
+
+          it 'can set undefined attribute keys through any hash mutation method' do
+            allow_deprecation
+            er = ExecutionResult.new
+            er.update(:pending_message => "msg", :foo => 3)
+            expect(er.to_h).to include(:pending_message => "msg", :foo => 3)
+          end
+
+          it 'supports `merge` like a hash' do
+            er = ExecutionResult.new
+            er.exception = ArgumentError.new
+            er.pending_message = "just because"
+
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /execution_result/)
+            merged = er.merge(:exception => NotImplementedError.new, :foo => 3)
+
+            expect(merged).to include(
+              :exception => an_instance_of(NotImplementedError),
+              :pending_message => "just because",
+              :foo => 3
+            )
+
+            expect(er.exception).to be_an(ArgumentError)
+          end
+
+          it 'supports blocks for hash methods that support one' do
+            er = ExecutionResult.new
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /execution_result/)
+            expect(er.fetch(:foo) { 3 }).to eq(3)
+          end
+
+          # It's IndexError on 1.8.7, KeyError on 1.9+
+          fetch_not_found_error_class = defined?(::KeyError) ? ::KeyError : ::IndexError
+
+          specify '#fetch treats unset properties the same as a hash does' do
+            allow_deprecation
+            er = ExecutionResult.new
+            expect { er.fetch(:pending_message) }.to raise_error(fetch_not_found_error_class)
+            er.pending_message = "some msg"
+            expect(er.fetch(:pending_message)).to eq("some msg")
+          end
+
+          describe "status" do
+            it 'returns a string when accessed like a hash' do
+              er = ExecutionResult.new
+              expect(er[:status]).to eq(nil)
+              er.status = :failed
+              expect(er[:status]).to eq("failed")
+            end
+
+            it "sets the status to a symbol when assigned as a string via the hash interface" do
+              er = ExecutionResult.new
+              er[:status] = "failed"
+              expect(er.status).to eq(:failed)
+              er[:status] = nil
+              expect(er.status).to eq(nil)
+            end
+
+            it "is presented as a string when included in returned hashes" do
+              er = ExecutionResult.new
+              er.status = :failed
+              expect(er.merge(:foo => 3)).to include(:status => "failed", :foo => 3)
+
+              er.status = nil
+              expect(er.merge(:foo => 3)).to include(:status => nil, :foo => 3)
+            end
+
+            it "is updated to a symbol when updated as a string via `update`" do
+              er = ExecutionResult.new
+              er.update(:status => "passed")
+              expect(er.status).to eq(:passed)
+            end
+
+            it 'is presented as a symbol in `to_h`' do
+              er = ExecutionResult.new
+              er.status = :failed
+              expect(er.to_h).to include(:status => :failed)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe "::RSpec::Core::ExampleGroup" do
+  context "does not cause problems when users reference a top level constant of the same name" do
+    file_in_outer_group = File
+    example { expect(File).to eq ::File }
+    example { expect(file_in_outer_group).to be(::File) }
+
+    describe "File" do
+      file_in_inner_group = File
+      example { expect(File).to eq ::File }
+      example { expect(file_in_inner_group).to be(::File) }
+    end
+  end
+end