opal-rspec 0.6.2 → 0.7.0.rc.1

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

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

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

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

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