opal-rspec 0.6.2 → 0.7.0.rc.1

data/rspec-mocks/spec/rspec/mocks/verifying_doubles/method_visibility_spec.rb

@@ -1,129 +0,0 @@
-require 'support/doubled_classes'
-
-module RSpec
-  module Mocks
-    RSpec.describe "Method visibility for verified doubles" do
-      include_context "with isolated configuration"
-
-      before do
-        RSpec::Mocks.configuration.verify_doubled_constant_names = true
-      end
-
-      context "for an instance double (when the class is loaded)" do
-        shared_examples "preserves method visibility" do |visibility|
-          method_name = :"defined_#{visibility}_method"
-
-          it "can allow a #{visibility} instance method" do
-            o = instance_double('LoadedClass')
-            allow(o).to receive(method_name).and_return(3)
-            expect(o.send method_name).to eq(3)
-          end
-
-          it "can expect a #{visibility} instance method" do
-            o = instance_double('LoadedClass')
-            expect(o).to receive(method_name)
-            o.send method_name
-          end
-
-          it "preserves #{visibility} visibility when allowing a #{visibility} method" do
-            preserves_visibility(method_name, visibility) do
-              instance_double('LoadedClass').tap do |o|
-                allow(o).to receive(method_name)
-              end
-            end
-          end
-
-          it "preserves #{visibility} visibility when expecting a #{visibility} method" do
-            preserves_visibility(method_name, visibility) do
-              instance_double('LoadedClass').tap do |o|
-                expect(o).to receive(method_name).at_least(:once)
-                o.send(method_name) # to satisfy the expectation
-              end
-            end
-          end
-
-          it "preserves #{visibility} visibility on a null object" do
-            preserves_visibility(method_name, visibility) do
-              instance_double('LoadedClass').as_null_object
-            end
-          end
-        end
-
-        include_examples "preserves method visibility", :private
-        include_examples "preserves method visibility", :protected
-      end
-
-      context "for a class double (when the class is loaded)" do
-        shared_examples "preserves method visibility" do |visibility|
-          method_name = :"defined_#{visibility}_class_method"
-
-          it "can allow a #{visibility} instance method" do
-            o = class_double('LoadedClass')
-            allow(o).to receive(method_name).and_return(3)
-            expect(o.send method_name).to eq(3)
-          end
-
-          it "can expect a #{visibility} instance method" do
-            o = class_double('LoadedClass')
-            expect(o).to receive(method_name)
-            o.send method_name
-          end
-
-          it "preserves #{visibility} visibility when allowing a #{visibility} method" do
-            preserves_visibility(method_name, visibility) do
-              class_double('LoadedClass').tap do |o|
-                allow(o).to receive(method_name)
-              end
-            end
-          end
-
-          it "preserves #{visibility} visibility when expecting a #{visibility} method" do
-            preserves_visibility(method_name, visibility) do
-              class_double('LoadedClass').tap do |o|
-                expect(o).to receive(method_name).at_least(:once)
-                o.send(method_name) # to satisfy the expectation
-              end
-            end
-          end
-
-          it "preserves #{visibility} visibility on a null object" do
-            preserves_visibility(method_name, visibility) do
-              class_double('LoadedClass').as_null_object
-            end
-          end
-        end
-
-        include_examples "preserves method visibility", :private
-        include_examples "preserves method visibility", :protected
-      end
-
-      def preserves_visibility(method_name, visibility)
-        double = yield
-
-        expect {
-          # send bypasses visbility, so we use eval instead.
-          eval("double.#{method_name}")
-        }.to raise_error(NoMethodError, a_message_indicating_visibility_violation(method_name, visibility))
-
-        expect { double.send(method_name) }.not_to raise_error
-        expect { double.__send__(method_name) }.not_to raise_error
-
-        unless double.null_object?
-          # Null object doubles use `method_missing` and so the singleton class
-          # doesn't know what methods are defined.
-          singleton_class = class << double; self; end
-          expect(singleton_class.send("#{visibility}_method_defined?", method_name)).to be true
-        end
-      end
-
-      RSpec::Matchers.define :a_message_indicating_visibility_violation do |method_name, visibility|
-        match do |msg|
-          # This should NOT Be just `msg.match(visibility)` because the method being called
-          # has the visibility name in it. We want to ensure it's a message that ruby is
-          # stating is of the given visibility.
-          msg.match("#{visibility} ") && msg.match(method_name.to_s)
-        end
-      end
-    end
-  end
-end

data/rspec-mocks/spec/rspec/mocks/verifying_doubles/object_double_spec.rb

@@ -1,68 +0,0 @@
-require 'support/doubled_classes'
-
-module RSpec
-  module Mocks
-    RSpec.describe 'An object double' do
-      it 'can replace an unloaded constant' do
-        o = object_double("LoadedClass::NOINSTANCE").as_stubbed_const
-
-        expect(LoadedClass::NOINSTANCE).to eq(o)
-
-        expect(o).to receive(:undefined_instance_method)
-        o.undefined_instance_method
-      end
-
-      it 'can replace a constant by name and verify instance methods' do
-        o = object_double("LoadedClass::INSTANCE").as_stubbed_const
-
-        expect(LoadedClass::INSTANCE).to eq(o)
-
-        prevents { expect(o).to receive(:undefined_instance_method) }
-        prevents { expect(o).to receive(:defined_class_method) }
-        prevents { o.defined_instance_method }
-
-        expect(o).to receive(:defined_instance_method)
-        o.defined_instance_method
-        expect(o).to receive(:defined_private_method)
-        o.send :defined_private_method
-      end
-
-      it 'can create a double that matches the interface of any arbitrary object' do
-        o = object_double(LoadedClass.new)
-
-        prevents { expect(o).to receive(:undefined_instance_method) }
-        prevents { expect(o).to receive(:defined_class_method) }
-        prevents { o.defined_instance_method }
-
-        expect(o).to receive(:defined_instance_method)
-        o.defined_instance_method
-        expect(o).to receive(:defined_private_method)
-        o.send :defined_private_method
-      end
-
-      it 'does not allow transferring constants to an object' do
-        expect {
-          object_double("LoadedClass::INSTANCE").
-            as_stubbed_const(:transfer_nested_constants => true)
-        }.to raise_error(/Cannot transfer nested constants/)
-      end
-
-      it 'does not allow as_stubbed_constant for real objects' do
-        expect {
-          object_double(LoadedClass.new).as_stubbed_const
-        }.to raise_error(/Can not perform constant replacement with an object/)
-      end
-
-      it 'is not a module' do
-        expect(object_double("LoadedClass::INSTANCE")).to_not be_a(Module)
-      end
-
-      it 'validates `with` args against the method signature when stubbing a method' do
-        dbl = object_double(LoadedClass.new)
-        prevents(/Wrong number of arguments. Expected 2, got 3./) {
-          allow(dbl).to receive(:instance_method_with_two_args).with(3, :foo, :args)
-        }
-      end
-    end
-  end
-end

data/rspec-mocks/spec/rspec/mocks_spec.rb

@@ -1,199 +0,0 @@
-require 'rspec/support/spec/prevent_load_time_warnings'
-
-RSpec.describe RSpec::Mocks do
-  it_behaves_like 'a library that issues no warnings when loaded',
-    'rspec-mocks', 'require "rspec/mocks"',
-    # Must be required before other files due to how our autoloads are setup.
-    # (Users won't hit this problem because they won't require all the files
-    # individually in whatever order the file system returns)
-    'require "rspec/mocks/any_instance"'
-
-  describe ".verify" do
-    it "delegates to the space" do
-      foo = double
-      expect(foo).to receive(:bar)
-      expect do
-        RSpec::Mocks.verify
-      end.to raise_error(RSpec::Mocks::MockExpectationError)
-
-      RSpec::Mocks.teardown # so the mocks aren't re-verified after this example
-    end
-  end
-
-  describe ".teardown" do
-    it "resets method stubs" do
-      string = "foo"
-      allow(string).to receive(:bar)
-      RSpec::Mocks.teardown
-      expect { string.bar }.to raise_error(NoMethodError)
-    end
-
-    it "does not put rspec-mocks into an inconsistent state when called extra times" do
-      RSpec::Mocks.teardown
-      RSpec::Mocks.teardown
-      RSpec::Mocks.teardown
-
-      string = "foo"
-      expect { allow(string).to receive(:bar) }.to raise_error(RSpec::Mocks::OutsideOfExampleError)
-
-      RSpec::Mocks.setup
-      allow(string).to receive(:bar).and_return(:baz)
-      expect(string.bar).to eq(:baz)
-    end
-  end
-
-  describe ".setup" do
-    it 'starts a new space scope that is later removed by .teardown' do
-      old_space = RSpec::Mocks.space
-      RSpec::Mocks.setup
-
-      new_space = RSpec::Mocks.space
-      expect(new_space).not_to equal(old_space)
-
-      RSpec::Mocks.teardown
-      expect(RSpec::Mocks.space).to equal(old_space)
-    end
-  end
-
-  describe ".configuration" do
-    it 'returns a memoized configuration instance' do
-      expect(RSpec::Mocks.configuration).to be_a(RSpec::Mocks::Configuration)
-      expect(RSpec::Mocks.configuration).to be(RSpec::Mocks.configuration)
-    end
-  end
-
-  describe ".with_temporary_scope" do
-    context "in a before(:all) with a stubbed double" do
-      before(:all) do
-        RSpec::Mocks.with_temporary_scope do
-          @calculator = double
-          allow(@calculator).to receive(:add) { |a, b| a + b }
-          @sum = @calculator.add(3, 4)
-        end
-
-        capture_error { @calculator.add(1, 10) }
-      end
-
-      it 'allows the stubbed double to be used' do
-        expect(@sum).to eq(7)
-      end
-
-      it 'does not allow the double to be used in the examples' do
-        expect {
-          @calculator.add(1, 2)
-        }.to raise_error(RSpec::Mocks::ExpiredTestDoubleError)
-      end
-
-      it 'does not allow the double to be used after the scope in before(:all)' do
-        expect(@error).to be_a(RSpec::Mocks::OutsideOfExampleError)
-      end
-    end
-
-    context "in a before(:all) with a stubbed const" do
-      before(:all) do
-        RSpec::Mocks.with_temporary_scope do
-          stub_const("ValueX", 3)
-          stub_const("ValueY", 4)
-          @sum = ValueX + ValueY
-        end
-
-        capture_error { ValueX + ValueY }
-      end
-
-      it 'allows the stubbed constants to be used' do
-        expect(@sum).to eq(7)
-      end
-
-      it 'does not allow the stubbed constants to be used in the examples' do
-        expect(defined?(ValueX)).to be_falsey
-        expect(defined?(ValueY)).to be_falsey
-      end
-
-      it 'does not allow the stubbed constants to be used after the scope in before(:all)' do
-        expect(@error).to be_a(NameError)
-        expect(@error.message).to include("ValueX")
-      end
-    end
-
-    context "in a before(:all) with a unmet mock expectation" do
-      before(:all) do
-        capture_error do
-          RSpec::Mocks.with_temporary_scope do
-            calculator = double
-            expect(calculator).to receive(:add)
-          end
-        end
-      end
-
-      it 'fails with a mock expectation error' do
-        expect(@error).to be_a(RSpec::Mocks::MockExpectationError)
-      end
-    end
-
-    context "in a before(:all) with an any_instance stub" do
-      before(:all) do
-        RSpec::Mocks.with_temporary_scope do
-          allow_any_instance_of(String).to receive(:sum_with) { |val, x| val + x }
-          @sum = "foo".sum_with("bar")
-        end
-
-        capture_error { "you".sum_with("me") }
-      end
-
-      it 'allows the stub to be used' do
-        expect(@sum).to eq("foobar")
-      end
-
-      it 'does not allow the double to be used in the examples' do
-        expect {
-          "foo".sum_with("baz")
-        }.to raise_error(NameError, /sum_with/)
-      end
-
-      it 'does not allow the double to be used after the scope in before(:all)' do
-        expect(@error).to be_a(NameError)
-        expect(@error.message).to include("sum_with")
-      end
-    end
-
-    it 'tears down even if an error occurs' do
-      foo = Object.new
-
-      expect {
-        RSpec::Mocks.with_temporary_scope do
-          allow(foo).to receive(:bar)
-          raise "boom"
-        end
-      }.to raise_error("boom")
-
-      expect(foo).not_to respond_to(:bar)
-    end
-
-    it 'does not verify if an error occurs before the block completes' do
-      expect {
-        RSpec::Mocks.with_temporary_scope do
-          foo   = Object.new
-          expect(foo).to receive(:bar)
-          raise "boom"
-        end
-      }.to raise_error("boom") # rather than MockExpectationError
-    end
-
-    def capture_error
-      yield
-    rescue Exception => @error
-    end
-  end
-
-  context "when there is a `let` declaration that overrides an argument matcher" do
-    let(:boolean) { :from_let }
-
-    before do
-      expect(RSpec::Mocks::ArgumentMatchers.method_defined?(:boolean)).to be true
-    end
-
-    it 'allows the `let` definition to win' do
-      expect(boolean).to eq(:from_let)
-    end
-  end
-end

data/rspec-mocks/spec/spec_helper.rb

@@ -1,131 +0,0 @@
-require 'rspec/support/spec'
-require 'rspec/support/ruby_features'
-
-RSpec::Support::Spec.setup_simplecov do
-  minimum_coverage 95
-end
-
-require 'yaml'
-begin
-  require 'psych'
-rescue LoadError
-end
-
-RSpec::Matchers.define :include_method do |expected|
-  match do |actual|
-    actual.map { |m| m.to_s }.include?(expected.to_s)
-  end
-end
-require 'support/matchers'
-
-module VerifyAndResetHelpers
-  def verify(object)
-    proxy = RSpec::Mocks.space.proxy_for(object)
-    proxy.verify
-  ensure
-    proxy.reset # so it doesn't fail the verify after the example completes
-  end
-
-  def reset(object)
-    RSpec::Mocks.space.proxy_for(object).reset
-  end
-
-  def verify_all
-    RSpec::Mocks.space.verify_all
-  ensure
-    reset_all
-  end
-
-  def reset_all
-    RSpec::Mocks.space.reset_all
-  end
-end
-
-module VerificationHelpers
-  def prevents(msg = //, &block)
-    expect(&block).to \
-      raise_error(RSpec::Mocks::MockExpectationError, msg)
-  end
-end
-
-require 'rspec/support/spec'
-
-RSpec.configure do |config|
-  config.expose_dsl_globally = false
-  config.mock_with :rspec
-  config.color = true
-  config.order = :random
-
-  config.expect_with :rspec do |expectations|
-    expectations.syntax = :expect
-  end
-
-  config.mock_with :rspec do |mocks|
-    $default_rspec_mocks_syntax = mocks.syntax
-    mocks.syntax = :expect
-  end
-
-  old_verbose = nil
-  config.before(:each, :silence_warnings) do
-    old_verbose = $VERBOSE
-    $VERBOSE = nil
-  end
-
-  config.after(:each, :silence_warnings) do
-    $VERBOSE = old_verbose
-  end
-
-  config.include VerifyAndResetHelpers
-  config.include VerificationHelpers
-  config.extend RSpec::Support::RubyFeatures
-  config.include RSpec::Support::RubyFeatures
-end
-
-RSpec.shared_context "with syntax" do |syntax|
-  orig_syntax = nil
-
-  before(:all) do
-    orig_syntax = RSpec::Mocks.configuration.syntax
-    RSpec::Mocks.configuration.syntax = syntax
-  end
-
-  after(:all) do
-    RSpec::Mocks.configuration.syntax = orig_syntax
-  end
-end
-
-
-RSpec.shared_context "with isolated configuration" do
-  orig_configuration = nil
-  before do
-    orig_configuration = RSpec::Mocks.configuration
-    RSpec::Mocks.instance_variable_set(:@configuration, RSpec::Mocks::Configuration.new)
-  end
-
-  after do
-    RSpec::Mocks.instance_variable_set(:@configuration, orig_configuration)
-  end
-end
-
-RSpec.shared_context "with monkey-patched marshal" do
-  before do
-    RSpec::Mocks.configuration.patch_marshal_to_support_partial_doubles = true
-  end
-
-  after do
-    RSpec::Mocks.configuration.patch_marshal_to_support_partial_doubles = false
-  end
-end
-
-RSpec.shared_context "with the default mocks syntax" do
-  orig_syntax = nil
-
-  before(:all) do
-    orig_syntax = RSpec::Mocks.configuration.syntax
-    RSpec::Mocks.configuration.reset_syntaxes_to_default
-  end
-
-  after(:all) do
-    RSpec::Mocks.configuration.syntax = orig_syntax
-  end
-end