opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,56 +0,0 @@
-RSpec.describe "expection set on previously stubbed method" do
-  it "fails if message is not received after expectation is set" do
-    double = double(:msg => nil)
-    double.msg
-    expect(double).to receive(:msg)
-    expect { verify double }.to raise_error(RSpec::Mocks::MockExpectationError)
-  end
-
-  it "outputs arguments of similar calls" do
-    double = double('double', :foo => true)
-    expect(double).to receive(:foo).with('first')
-    double.foo('second')
-    double.foo('third')
-    expect {
-      verify double
-    }.to raise_error(%Q|Double "double" received :foo with unexpected arguments\n  expected: ("first")\n       got: ("second"), ("third")|)
-    reset double
-  end
-
-  context "with argument constraint on stub" do
-    it "matches any args if no arg constraint set on expectation" do
-      double = double("mock")
-      allow(double).to receive(:foo).with(3).and_return("stub")
-      expect(double).to receive(:foo).at_least(:once).and_return("expectation")
-      double.foo
-      verify double
-    end
-
-    it "matches specific args set on expectation" do
-      double = double("mock")
-      allow(double).to receive(:foo).with(3).and_return("stub")
-      expect(double).to receive(:foo).at_least(:once).with(4).and_return("expectation")
-      double.foo(4)
-      verify double
-    end
-
-    it "fails if expectation's arg constraint is not met" do
-      double = double("mock")
-      allow(double).to receive(:foo).with(3).and_return("stub")
-      expect(double).to receive(:foo).at_least(:once).with(4).and_return("expectation")
-      double.foo(3)
-      expect { verify double }.to raise_error(/expected: \(4\)\s+got: \(3\)/)
-    end
-
-    it 'distinguishes between individual values and arrays properly' do
-      dbl = double
-      allow(dbl).to receive(:foo).with('a', ['b'])
-
-      expect {
-        dbl.foo(['a'], 'b')
-      }.to raise_error { |e|
-        expect(e.message).to include('expected: ("a", ["b"])', 'got: (["a"], "b")')
-      }
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-module RSpec
-  module Mocks
-
-    RSpec.describe ".allow_message" do
-      let(:subject) { Object.new }
-
-      it "sets up basic message allowance" do
-        expect {
-          ::RSpec::Mocks.allow_message(subject, :basic)
-        }.to change {
-          subject.respond_to?(:basic)
-        }.to(true)
-
-        expect(subject.basic).to eq(nil)
-      end
-
-      it "sets up message allowance with params and return value" do
-        expect {
-          ::RSpec::Mocks.allow_message(subject, :x).with(:in).and_return(:out)
-        }.to change {
-          subject.respond_to?(:x)
-        }.to(true)
-
-        expect(subject.x(:in)).to eq(:out)
-      end
-
-      it "supports block implementations" do
-        ::RSpec::Mocks.allow_message(subject, :message) { :value }
-        expect(subject.message).to eq(:value)
-      end
-
-      it "does not set an expectation that the message will be received" do
-        ::RSpec::Mocks.allow_message(subject, :message)
-        expect { verify subject }.not_to raise_error
-      end
-
-      it 'does not get confused when the string and symbol message form are both used' do
-        ::RSpec::Mocks.allow_message(subject, :foo).with(1) { :a }
-        ::RSpec::Mocks.allow_message(subject, "foo").with(2) { :b }
-
-        expect(subject.foo(1)).to eq(:a)
-        expect(subject.foo(2)).to eq(:b)
-
-        reset subject
-      end
-    end
-
-    RSpec.describe ".expect_message" do
-      let(:subject) { Object.new }
-
-      it "sets up basic message expectation, verifies as uncalled" do
-        expect {
-          ::RSpec::Mocks.expect_message(subject, :basic)
-        }.to change {
-          subject.respond_to?(:basic)
-        }.to(true)
-
-        expect { verify subject }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails if never is specified and the message is called" do
-        expect {
-          ::RSpec::Mocks.expect_message(subject, :foo).never
-          subject.foo
-        }.to raise_error(/expected.*0 times/)
-      end
-
-      it "sets up basic message expectation, verifies as called" do
-        ::RSpec::Mocks.expect_message(subject, :basic)
-        subject.basic
-        verify subject
-      end
-
-      it "sets up message expectation with params and return value" do
-        ::RSpec::Mocks.expect_message(subject, :msg).with(:in).and_return(:out)
-        expect(subject.msg(:in)).to eq(:out)
-        verify subject
-      end
-
-      it "accepts a block implementation for the expected message" do
-        ::RSpec::Mocks.expect_message(subject, :msg) { :value }
-        expect(subject.msg).to eq(:value)
-        verify subject
-      end
-
-      it 'does not get confused when the string and symbol message form are both used' do
-        ::RSpec::Mocks.expect_message(subject, :foo).with(1)
-        ::RSpec::Mocks.expect_message(subject, "foo").with(2)
-
-        subject.foo(1)
-        subject.foo(2)
-
-        verify subject
-      end
-
-    end
-
-  end
-end

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

@@ -1,7 +0,0 @@
-module RSpec
-  RSpec.describe Mocks do
-    it "does not inadvertently define BasicObject on 1.8", :if => RUBY_VERSION.to_f < 1.9 do
-      expect(defined?(::BasicObject)).to be nil
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-module RSpec
-  module Mocks
-    RSpec.describe TestDouble do
-      describe "#freeze" do
-        subject { double }
-
-        it "gives a warning" do
-          expect(RSpec).to receive(:warn_with).with(/freeze a test double/)
-          subject.freeze
-        end
-
-        it "gives the correct call site for the warning" do
-          expect_warning_with_call_site(__FILE__, __LINE__+1)
-          subject.freeze
-        end
-
-        it "doesn't freeze the object" do
-          allow(RSpec).to receive(:warn_with).with(/freeze a test double/)
-          double.freeze
-          allow(subject).to receive(:hi)
-
-          expect {
-            subject.hi
-          }.not_to raise_error
-        end
-      end
-
-      RSpec.shared_examples_for "a copy method" do |method|
-        it "copies the `as_null_object` state when #{method}'d" do
-          dbl = double.as_null_object
-          copy = dbl.__send__(method)
-          expect(copy.foo.bar).to be(copy)
-        end
-      end
-
-      include_examples "a copy method", :dup
-      include_examples "a copy method", :clone
-
-      [[:should, :expect], [:expect], [:should]].each do |syntax|
-        context "with syntax #{syntax.inspect}" do
-          include_context "with syntax", syntax
-
-          it 'stubs the methods passed in the stubs hash' do
-            dbl = double("MyDouble", :a => 5, :b => 10)
-
-            expect(dbl.a).to eq(5)
-            expect(dbl.b).to eq(10)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-module RSpec
-  module Mocks
-    RSpec.describe "#thrice" do
-      before(:each) do
-        @double = double("test double")
-      end
-
-      it "passes when called thrice" do
-        expect(@double).to receive(:do_something).thrice
-        3.times { @double.do_something }
-        verify @double
-      end
-
-      it "passes when called thrice with specified args" do
-        expect(@double).to receive(:do_something).thrice.with("1", 1)
-        3.times { @double.do_something("1", 1) }
-        verify @double
-      end
-
-      it "passes when called thrice with unspecified args" do
-        expect(@double).to receive(:do_something).thrice
-        @double.do_something("1")
-        @double.do_something(1)
-        @double.do_something(nil)
-        verify @double
-      end
-
-      it "fails fast when call count is higher than expected" do
-        expect(@double).to receive(:do_something).thrice
-        3.times { @double.do_something }
-        expect {
-          @double.do_something
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails when call count is lower than expected" do
-        expect(@double).to receive(:do_something).thrice
-        @double.do_something
-        expect {
-          verify @double
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails when called with wrong args on the first call" do
-        expect(@double).to receive(:do_something).thrice.with("1", 1)
-        expect {
-          @double.do_something(1, "1")
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-        reset @double
-      end
-
-      it "fails when called with wrong args on the second call" do
-        expect(@double).to receive(:do_something).thrice.with("1", 1)
-        @double.do_something("1", 1)
-        expect {
-          @double.do_something(1, "1")
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-        reset @double
-      end
-
-      it "fails when called with wrong args on the third call" do
-        expect(@double).to receive(:do_something).thrice.with("1", 1)
-        @double.do_something("1", 1)
-        @double.do_something("1", 1)
-        expect {
-          @double.do_something(1, "1")
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-        reset @double
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-RSpec.describe "a double receiving to_ary" do
-  shared_examples "to_ary" do
-    it "can be overridden with a stub" do
-      allow(obj).to receive(:to_ary) { :non_nil_value }
-      expect(obj.to_ary).to be(:non_nil_value)
-    end
-
-    it "responds when overriden" do
-      allow(obj).to receive(:to_ary) { :non_nil_value }
-      expect(obj).to respond_to(:to_ary)
-    end
-
-    it "supports Array#flatten" do
-      obj = double('foo')
-      expect([obj].flatten).to eq([obj])
-    end
-  end
-
-  context "double as_null_object" do
-    let(:obj) { double('obj').as_null_object }
-    include_examples "to_ary"
-
-    it "does respond to to_ary" do
-      expect(obj).to respond_to(:to_ary)
-    end
-
-    it "does respond to to_a" do
-      expect(obj).to respond_to(:to_a)
-    end
-
-    it "returns nil" do
-      expect(obj.to_ary).to eq nil
-    end
-  end
-
-  context "double without as_null_object" do
-    let(:obj) { double('obj') }
-    include_examples "to_ary"
-
-    it "doesn't respond to to_ary" do
-      expect(obj).not_to respond_to(:to_ary)
-    end
-
-    it "doesn't respond to to_a", :if => ( RUBY_VERSION.to_f > 1.8 ) do
-      expect(obj).not_to respond_to(:to_a)
-    end
-
-    it "raises " do
-      expect { obj.to_ary }.to raise_error(NoMethodError)
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-module RSpec
-  module Mocks
-    RSpec.describe "#twice" do
-      before(:each) do
-        @double = double("test double")
-      end
-
-      it "passes when called twice" do
-        expect(@double).to receive(:do_something).twice
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when called twice with specified args" do
-        expect(@double).to receive(:do_something).twice.with("1", 1)
-        @double.do_something("1", 1)
-        @double.do_something("1", 1)
-        verify @double
-      end
-
-      it "passes when called twice with unspecified args" do
-        expect(@double).to receive(:do_something).twice
-        @double.do_something("1")
-        @double.do_something(1)
-        verify @double
-      end
-
-      it "fails fast when call count is higher than expected" do
-        expect(@double).to receive(:do_something).twice
-        @double.do_something
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails when call count is lower than expected" do
-        expect(@double).to receive(:do_something).twice
-        @double.do_something
-        expect {
-          verify @double
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails when called with wrong args on the first call" do
-        expect(@double).to receive(:do_something).twice.with("1", 1)
-        expect {
-          @double.do_something(1, "1")
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-        reset @double
-      end
-
-      it "fails when called with wrong args on the second call" do
-        expect(@double).to receive(:do_something).twice.with("1", 1)
-        @double.do_something("1", 1)
-        expect {
-          @double.do_something(1, "1")
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-        reset @double
-      end
-    end
-  end
-end

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

@@ -1,118 +0,0 @@
-require 'support/doubled_classes'
-
-module RSpec
-  module Mocks
-    RSpec.describe 'A class double with the doubled class loaded' do
-      include_context "with isolated configuration"
-
-      before do
-        RSpec::Mocks.configuration.verify_doubled_constant_names = true
-      end
-
-      it 'includes the double name in errors for unexpected messages' do
-        o = class_double("LoadedClass")
-        expect {
-          o.defined_class_method
-        }.to fail_matching('Double "LoadedClass"')
-      end
-
-      it 'only allows class methods that exist to be stubbed' do
-        o = class_double('LoadedClass', :defined_class_method => 1)
-        expect(o.defined_class_method).to eq(1)
-
-        prevents { allow(o).to receive(:undefined_instance_method) }
-        prevents { allow(o).to receive(:defined_instance_method) }
-      end
-
-      it 'only allows class methods that exist to be expected' do
-        o = class_double('LoadedClass')
-        expect(o).to receive(:defined_class_method)
-        o.defined_class_method
-
-        prevents { expect(o).to receive(:undefined_instance_method) }
-        prevents { expect(o).to receive(:defined_instance_method) }
-        prevents { expect(o).to receive(:undefined_instance_method) }
-        prevents { expect(o).to receive(:defined_instance_method) }
-      end
-
-      it 'gives a descriptive error message for NoMethodError' do
-        o = class_double("LoadedClass")
-        expect {
-          o.defined_private_class_method
-        }.to raise_error(NoMethodError, /Double "LoadedClass"/)
-      end
-
-      it 'checks that stubbed methods are invoked with the correct arity' do
-        o = class_double('LoadedClass', :defined_class_method => 1)
-        expect {
-          o.defined_class_method(:a)
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'allows dynamically defined class method stubs with arguments' do
-        o = class_double('LoadedClass')
-        allow(o).to receive(:dynamic_class_method).with(:a) { 1 }
-
-        expect(o.dynamic_class_method(:a)).to eq(1)
-      end
-
-      it 'allows dynamically defined class method mocks with arguments' do
-        o = class_double('LoadedClass')
-        expect(o).to receive(:dynamic_class_method).with(:a)
-
-        o.dynamic_class_method(:a)
-      end
-
-      it 'allows dynamically defined class methods to be expected' do
-        o = class_double('LoadedClass', :dynamic_class_method => 1)
-        expect(o.dynamic_class_method).to eq(1)
-      end
-
-      it 'allows class to be specified by constant' do
-        o = class_double(LoadedClass, :defined_class_method => 1)
-        expect(o.defined_class_method).to eq(1)
-      end
-
-      it 'can replace existing constants for the duration of the test' do
-        original = LoadedClass
-        object = class_double('LoadedClass').as_stubbed_const
-        expect(object).to receive(:defined_class_method)
-
-        expect(LoadedClass).to eq(object)
-        ::RSpec::Mocks.teardown
-        ::RSpec::Mocks.setup
-        expect(LoadedClass).to eq(original)
-      end
-
-      it 'can transfer nested constants to the double' do
-        class_double("LoadedClass").
-          as_stubbed_const(:transfer_nested_constants => true)
-        expect(LoadedClass::M).to eq(:m)
-        expect(LoadedClass::N).to eq(:n)
-      end
-
-      it 'correctly verifies expectations when constant is removed' do
-        dbl1 = class_double(LoadedClass::Nested).as_stubbed_const
-        class_double(LoadedClass).as_stubbed_const
-
-        prevents {
-          expect(dbl1).to receive(:undefined_class_method)
-        }
-      end
-
-      it 'only allows defined methods for null objects' do
-        o = class_double('LoadedClass').as_null_object
-
-        expect(o.defined_class_method).to eq(o)
-        prevents { o.undefined_method }
-      end
-
-      it 'validates `with` args against the method signature when stubbing a method' do
-        dbl = class_double(LoadedClass)
-        prevents(/Wrong number of arguments. Expected 0, got 2./) {
-          allow(dbl).to receive(:defined_class_method).with(2, :args)
-        }
-      end
-    end
-  end
-end