opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+RSpec.describe RSpec::SharedContext do
+  it "is accessible as RSpec::Core::SharedContext" do
+    RSpec::Core::SharedContext
+  end
+
+  it "is accessible as RSpec::SharedContext" do
+    RSpec::SharedContext
+  end
+
+  it "supports before and after hooks" do
+    before_all_hook = false
+    before_each_hook = false
+    after_each_hook = false
+    after_all_hook = false
+    shared = Module.new do
+      extend RSpec::SharedContext
+      before(:all) { before_all_hook = true }
+      before(:each) { before_each_hook = true }
+      after(:each)  { after_each_hook = true }
+      after(:all)  { after_all_hook = true }
+    end
+    group = RSpec::Core::ExampleGroup.describe do
+      include shared
+      example { }
+    end
+
+    group.run
+
+    expect(before_all_hook).to be_truthy
+    expect(before_each_hook).to be_truthy
+    expect(after_each_hook).to be_truthy
+    expect(after_all_hook).to be_truthy
+  end
+
+  include RSpec::Core::SharedExampleGroup::TopLevelDSL
+
+  it "runs the before each hooks in configuration before those of the shared context" do
+    ordered_hooks = []
+    RSpec.configure do |c|
+      c.before(:each) { ordered_hooks << "config" }
+    end
+
+    RSpec.shared_context("before each stuff", :example => :before_each_hook_order) do
+      before(:each) { ordered_hooks << "shared_context"}
+    end
+
+    group = RSpec.describe "description", :example => :before_each_hook_order do
+      before(:each) { ordered_hooks << "example_group" }
+      example {}
+    end
+
+    group.run
+
+    expect(ordered_hooks).to be == ["config", "shared_context", "example_group"]
+  end
+
+  it "supports let" do
+    shared = Module.new do
+      extend RSpec::SharedContext
+      let(:foo) { 'foo' }
+    end
+    group = RSpec.describe do
+      include shared
+    end
+
+    expect(group.new.foo).to eq('foo')
+  end
+
+  it 'supports explicit subjects' do
+    shared = Module.new do
+      extend RSpec::SharedContext
+      subject { 17 }
+    end
+
+    group = RSpec::Core::ExampleGroup.describe do
+      include shared
+    end
+
+    expect(group.new.subject).to eq(17)
+  end
+
+  %w[describe context].each do |method_name|
+    it "supports nested example groups using #{method_name}" do
+      shared = Module.new do
+        extend RSpec::SharedContext
+        send(method_name, "nested using describe") do
+          example {}
+        end
+      end
+      group = RSpec::Core::ExampleGroup.describe do
+        include shared
+      end
+
+      group.run
+
+      expect(group.children.length).to eq(1)
+      expect(group.children.first.examples.length).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,268 @@
+require 'spec_helper'
+require 'rspec/support/spec/in_sub_process'
+
+module RandomTopLevelModule
+  def self.setup!
+    RSpec.shared_examples_for("top level in module") {}
+  end
+end
+
+module RSpec
+  module Core
+    RSpec.describe SharedExampleGroup do
+      include RSpec::Support::InSubProcess
+      let(:registry) { RSpec.world.shared_example_group_registry }
+
+      ExampleModule = Module.new
+      ExampleClass  = Class.new
+
+      it 'does not add a bunch of private methods to Module' do
+        seg_methods = RSpec::Core::SharedExampleGroup.private_instance_methods
+        expect(Module.private_methods & seg_methods).to eq([])
+      end
+
+      before do
+        # this is a work around as SharedExampleGroup is not world safe
+        RandomTopLevelModule.setup!
+      end
+
+      RSpec::Matchers.define :have_example_descriptions do |*descriptions|
+        match do |group|
+          group.examples.map(&:description) == descriptions
+        end
+
+        failure_message do |group|
+          actual = group.examples.map(&:description)
+          "expected #{group.name} to have descriptions: #{descriptions.inspect} but had #{actual.inspect}"
+        end
+      end
+
+      %w[shared_examples shared_examples_for shared_context].each do |shared_method_name|
+        describe shared_method_name do
+          let(:group) { ExampleGroup.describe('example group') }
+
+          define_method :define_shared_group do |*args, &block|
+            group.send(shared_method_name, *args, &block)
+          end
+
+          it "is exposed to the global namespace when expose_dsl_globally is enabled" do
+            in_sub_process do
+              RSpec.configuration.expose_dsl_globally = true
+              expect(Kernel).to respond_to(shared_method_name)
+            end
+          end
+
+          it "is not exposed to the global namespace when monkey patching is disabled" do
+            expect(Kernel).to_not respond_to(shared_method_name)
+          end
+
+          it "displays a warning when adding a second shared example group with the same name" do
+            group.send(shared_method_name, 'some shared group') {}
+            original_declaration = [__FILE__, __LINE__ - 1].join(':')
+
+            warning = nil
+            allow(::Kernel).to receive(:warn) { |msg| warning = msg }
+
+            group.send(shared_method_name, 'some shared group') {}
+            second_declaration = [__FILE__, __LINE__ - 1].join(':')
+            expect(warning).to include('some shared group', original_declaration, second_declaration)
+            expect(warning).to_not include 'Called from'
+          end
+
+          it 'works with top level defined examples in modules' do
+            expect(RSpec::configuration.reporter).to_not receive(:deprecation)
+            ExampleGroup.describe('example group') { include_context 'top level in module' }
+          end
+
+          ["name", :name, ExampleModule, ExampleClass].each do |object|
+            type = object.class.name.downcase
+            context "given a #{type}" do
+              it "captures the given #{type} and block in the collection of shared example groups" do
+                implementation = lambda { }
+                define_shared_group(object, &implementation)
+                expect(registry.find([group], object)).to eq implementation
+              end
+            end
+          end
+
+          context "given a hash" do
+            it "delegates include on configuration" do
+              implementation = Proc.new { def bar; 'bar'; end }
+              define_shared_group(:foo => :bar, &implementation)
+              a = RSpec.configuration.include_or_extend_modules.first
+              expect(a[0]).to eq(:include)
+              expect(Class.new.send(:include, a[1]).new.bar).to eq('bar')
+              expect(a[2]).to eq(:foo => :bar)
+            end
+          end
+
+          context "given a string and a hash" do
+            it "captures the given string and block in the World's collection of shared example groups" do
+              implementation = lambda { }
+              define_shared_group("name", :foo => :bar, &implementation)
+              expect(registry.find([group], "name")).to eq implementation
+            end
+
+            it "delegates include on configuration" do
+              implementation = Proc.new { def bar; 'bar'; end }
+              define_shared_group("name", :foo => :bar, &implementation)
+              a = RSpec.configuration.include_or_extend_modules.first
+              expect(a[0]).to eq(:include)
+              expect(Class.new.send(:include, a[1]).new.bar).to eq('bar')
+              expect(a[2]).to eq(:foo => :bar)
+            end
+          end
+
+          context "when called at the top level" do
+            before do
+              RSpec.__send__(shared_method_name, "shared context") do
+                example "shared spec"
+              end
+            end
+
+            it 'is available for inclusion from a top level group' do
+              group = RSpec.describe "group" do
+                include_examples "shared context"
+              end
+
+              expect(group).to have_example_descriptions("shared spec")
+            end
+
+            it 'is available for inclusion from a nested example group' do
+              group = nil
+
+              RSpec.describe "parent" do
+                context "child" do
+                  group = context("grand child") { include_examples "shared context" }
+                end
+              end
+
+              expect(group).to have_example_descriptions("shared spec")
+            end
+
+            it 'is trumped by a shared group with the same name that is defined in the including context' do
+              group = RSpec.describe "parent" do
+                __send__ shared_method_name, "shared context" do
+                  example "a different spec"
+                end
+
+                include_examples "shared context"
+              end
+
+              expect(group).to have_example_descriptions("a different spec")
+            end
+
+            it 'is trumped by a shared group with the same name that is defined in a parent group' do
+              group = nil
+
+              RSpec.describe "parent" do
+                __send__ shared_method_name, "shared context" do
+                  example "a different spec"
+                end
+
+                group = context("nested") { include_examples "shared context" }
+              end
+
+              expect(group).to have_example_descriptions("a different spec")
+            end
+          end
+
+          context "when called from within an example group" do
+            define_method :in_group_with_shared_group_def do |&block|
+              RSpec.describe "an example group" do
+                __send__ shared_method_name, "shared context" do
+                  example "shared spec"
+                end
+
+                module_exec(&block)
+              end
+            end
+
+            it 'is available for inclusion within that group' do
+              group = in_group_with_shared_group_def do
+                include_examples "shared context"
+              end
+
+              expect(group).to have_example_descriptions("shared spec")
+            end
+
+            it 'is available for inclusion in a child group' do
+              group = nil
+
+              in_group_with_shared_group_def do
+                group = context("nested") { include_examples "shared context" }
+              end
+
+              expect(group).to have_example_descriptions("shared spec")
+            end
+
+            it 'is not available for inclusion in a different top level group' do
+              in_group_with_shared_group_def { }
+
+              expect {
+                RSpec.describe "another top level group" do
+                  include_examples "shared context"
+                end
+              }.to raise_error(/Could not find/)
+            end
+
+            it 'is not available for inclusion in a nested group of a different top level group' do
+              in_group_with_shared_group_def { }
+
+              expect {
+                RSpec.describe "another top level group" do
+                  context("nested") { include_examples "shared context" }
+                end
+              }.to raise_error(/Could not find/)
+            end
+
+            it 'trumps a shared group with the same name defined at the top level' do
+              RSpec.__send__(shared_method_name, "shared context") do
+                example "a different spec"
+              end
+
+              group = in_group_with_shared_group_def do
+                include_examples "shared context"
+              end
+
+              expect(group).to have_example_descriptions("shared spec")
+            end
+
+            it 'is trumped by a shared group with the same name that is defined in the including context' do
+              group = nil
+
+              in_group_with_shared_group_def do
+                group = context "child" do
+                  __send__ shared_method_name, "shared context" do
+                    example "a different spec"
+                  end
+
+                  include_examples "shared context"
+                end
+              end
+
+              expect(group).to have_example_descriptions("a different spec")
+            end
+
+            it 'is trumped by a shared group with the same name that is defined in nearer parent group' do
+              group = nil
+
+              in_group_with_shared_group_def do
+                context "child" do
+                  __send__ shared_method_name, "shared context" do
+                    example "a different spec"
+                  end
+
+                  group = context("grandchild") { include_examples "shared context" }
+                end
+              end
+
+              expect(group).to have_example_descriptions("a different spec")
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,72 @@
+require "spec_helper"
+
+RSpec.describe "rspec warnings and deprecations" do
+
+  describe "#deprecate" do
+    it "passes the hash to the reporter" do
+      expect(RSpec.configuration.reporter).to receive(:deprecation).with(hash_including :deprecated => "deprecated_method", :replacement => "replacement")
+      RSpec.deprecate("deprecated_method", :replacement => "replacement")
+    end
+
+    it "adds the call site" do
+      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
+      RSpec.deprecate("deprecated_method")
+    end
+
+    it "doesn't override a passed call site" do
+      expect_deprecation_with_call_site("some_file.rb", 17)
+      RSpec.deprecate("deprecated_method", :call_site => "/some_file.rb:17")
+    end
+  end
+
+  describe "#warn_deprecation" do
+    it "puts message in a hash" do
+      expect(RSpec.configuration.reporter).to receive(:deprecation).with(hash_including :message => "this is the message")
+      RSpec.warn_deprecation("this is the message")
+    end
+
+    it "passes along additional options" do
+      expect(RSpec.configuration.reporter).to receive(:deprecation).with(hash_including :type => :tag)
+      RSpec.warn_deprecation("this is the message", :type => :tag)
+    end
+  end
+
+  describe "#warn_with" do
+    context "when :use_spec_location_as_call_site => true is passed" do
+      let(:options) do
+        {
+          :use_spec_location_as_call_site => true,
+          :call_site                      => nil,
+        }
+      end
+
+      it "adds the source location of spec" do
+        line = __LINE__ - 1
+        file_path = RSpec::Core::Metadata.relative_path(__FILE__)
+        expect(Kernel).to receive(:warn).with(/The warning. Warning generated from spec at `#{file_path}:#{line}`./)
+
+        RSpec.warn_with("The warning.", options)
+      end
+
+      it "appends a period to the supplied message if one is not present" do
+        line = __LINE__ - 1
+        file_path = RSpec::Core::Metadata.relative_path(__FILE__)
+        expect(Kernel).to receive(:warn).with(/The warning. Warning generated from spec at `#{file_path}:#{line}`./)
+
+        RSpec.warn_with("The warning", options)
+      end
+
+      context "when there is no current example" do
+        before do
+          allow(RSpec).to receive(:current_example).and_return(nil)
+        end
+
+        it "adds no message about the spec location" do
+          expect(Kernel).to receive(:warn).with(/The warning\.$/)
+
+          RSpec.warn_with("The warning.", options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+class Bar; end
+class Foo; end
+
+module RSpec::Core
+
+  RSpec.describe RSpec::Core::World do
+    let(:configuration) { RSpec::Core::Configuration.new }
+    let(:world) { RSpec::Core::World.new(configuration) }
+
+    describe '#reset' do
+      it 'clears #example_groups' do
+        world.example_groups << :example_group
+        world.reset
+        expect(world.example_groups).to be_empty
+      end
+    end
+
+    describe "#example_groups" do
+      it "contains all registered example groups" do
+        group = RSpec::Core::ExampleGroup.describe("group"){}
+        world.register(group)
+        expect(world.example_groups).to include(group)
+      end
+    end
+
+    describe "#preceding_declaration_line (again)" do
+      let(:group) do
+        RSpec::Core::ExampleGroup.describe("group") do
+
+          example("example") {}
+
+        end
+      end
+
+      let(:second_group) do
+        RSpec::Core::ExampleGroup.describe("second_group") do
+
+          example("second_example") {}
+
+        end
+      end
+
+      let(:group_declaration_line) { group.metadata[:line_number] }
+      let(:example_declaration_line) { group_declaration_line + 2 }
+
+      context "with one example" do
+        before { world.register(group) }
+
+        it "returns nil if no example or group precedes the line" do
+          expect(world.preceding_declaration_line(group_declaration_line - 1)).to be_nil
+        end
+
+        it "returns the argument line number if a group starts on that line" do
+          expect(world.preceding_declaration_line(group_declaration_line)).to eq(group_declaration_line)
+        end
+
+        it "returns the argument line number if an example starts on that line" do
+          expect(world.preceding_declaration_line(example_declaration_line)).to eq(example_declaration_line)
+        end
+
+        it "returns line number of a group that immediately precedes the argument line" do
+          expect(world.preceding_declaration_line(group_declaration_line + 1)).to eq(group_declaration_line)
+        end
+
+        it "returns line number of an example that immediately precedes the argument line" do
+          expect(world.preceding_declaration_line(example_declaration_line + 1)).to eq(example_declaration_line)
+        end
+      end
+
+      context "with two exaples and the second example is registre first" do
+        let(:second_group_declaration_line) { second_group.metadata[:line_number] }
+
+        before do
+          world.register(second_group)
+          world.register(group)
+        end
+
+        it 'return line number of group if a group start on that line' do
+          expect(world.preceding_declaration_line(second_group_declaration_line)).to eq(second_group_declaration_line)
+        end
+      end
+    end
+
+    describe "#announce_filters" do
+      let(:reporter) { double('reporter').as_null_object }
+      before { allow(world).to receive(:reporter) { reporter } }
+
+      context "with no examples" do
+        before { allow(world).to receive(:example_count) { 0 } }
+
+        context "with no filters" do
+          it "announces" do
+            expect(reporter).to receive(:message).
+              with("No examples found.")
+            world.announce_filters
+          end
+        end
+
+        context "with an inclusion filter" do
+          it "announces" do
+            configuration.filter_run_including :foo => 'bar'
+            expect(reporter).to receive(:message).
+              with(/All examples were filtered out/)
+            world.announce_filters
+          end
+        end
+
+        context "with an inclusion filter and run_all_when_everything_filtered" do
+          it "announces" do
+            allow(configuration).to receive(:run_all_when_everything_filtered?) { true }
+            configuration.filter_run_including :foo => 'bar'
+            expect(reporter).to receive(:message).
+              with(/All examples were filtered out/)
+            world.announce_filters
+          end
+        end
+
+        context "with an exclusion filter" do
+          it "announces" do
+            configuration.filter_run_excluding :foo => 'bar'
+            expect(reporter).to receive(:message).
+              with(/All examples were filtered out/)
+            world.announce_filters
+          end
+        end
+      end
+
+      context "with examples" do
+        before { allow(world).to receive(:example_count) { 1 } }
+
+        context "with no filters" do
+          it "does not announce" do
+            expect(reporter).not_to receive(:message)
+            world.announce_filters
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'rspec/support/spec/prevent_load_time_warnings'
+
+RSpec.describe RSpec do
+  fake_minitest = File.expand_path('../../support/fake_minitest', __FILE__)
+  it_behaves_like 'a library that issues no warnings when loaded', 'rspec-core',
+    # Loading minitest issues warnings, so we put our fake minitest on the load
+    # path to prevent the real minitest from being loaded.
+    "$LOAD_PATH.unshift '#{fake_minitest}'", 'require "rspec/core"', 'RSpec::Core::Runner.disable_autorun!' do
+    if RUBY_VERSION == '1.9.2' || (RUBY_PLATFORM == 'java' && RUBY_VERSION == '2.0.0')
+      before { pending "Not working on #{RUBY_DESCRIPTION}" }
+    end
+  end
+
+  describe "::configuration" do
+    it "returns the same object every time" do
+      expect(RSpec.configuration).to equal(RSpec.configuration)
+    end
+  end
+
+  describe "::configuration=" do
+    it "sets the configuration object" do
+      configuration = RSpec::Core::Configuration.new
+
+      RSpec.configuration = configuration
+
+      expect(RSpec.configuration).to equal(configuration)
+    end
+  end
+
+  describe "::configure" do
+    it "yields the current configuration" do
+      RSpec.configure do |config|
+        expect(config).to equal(RSpec::configuration)
+      end
+    end
+  end
+
+  describe "::world" do
+    it "returns the same object every time" do
+      expect(RSpec.world).to equal(RSpec.world)
+    end
+  end
+
+  describe "::world=" do
+    it "sets the world object" do
+      world = RSpec::Core::World.new
+
+      RSpec.world = world
+
+      expect(RSpec.world).to equal(world)
+    end
+  end
+
+  describe ".current_example" do
+    it "sets the example being executed" do
+      group = RSpec::Core::ExampleGroup.describe("an example group")
+      example = group.example("an example")
+
+      RSpec.current_example = example
+      expect(RSpec.current_example).to be(example)
+    end
+  end
+
+  describe "::reset" do
+    it "resets the configuration and world objects" do
+      config_before_reset = RSpec.configuration
+      world_before_reset  = RSpec.world
+
+      RSpec.reset
+
+      expect(RSpec.configuration).not_to equal(config_before_reset)
+      expect(RSpec.world).not_to equal(world_before_reset)
+    end
+  end
+
+  describe "::Core.path_to_executable" do
+    it 'returns the absolute location of the exe/rspec file' do
+      expect(File.exist? RSpec::Core.path_to_executable).to be_truthy
+      expect(File.executable? RSpec::Core.path_to_executable).to be_truthy
+    end
+  end
+
+  include RSpec::Support::ShellOut
+
+  # This is hard to test :(. Best way I could come up with was starting
+  # fresh ruby process w/o this stuff already loaded.
+  it "loads mocks and expectations when the constants are referenced", :slow do
+    code = 'require "rspec"; puts RSpec::Mocks.name; puts RSpec::Expectations.name'
+    out, err, status = run_ruby_with_current_load_path(code)
+
+    expect(err).to eq("")
+    expect(out.split("\n")).to eq(%w[ RSpec::Mocks RSpec::Expectations ])
+    expect(status.exitstatus).to eq(0)
+  end
+
+  it 'correctly raises an error when an invalid const is referenced' do
+    expect {
+      RSpec::NotAConst
+    }.to raise_error(NameError, /RSpec::NotAConst/)
+  end
+end
+