opal-connect-rspec 0.5.0

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

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

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

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

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

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

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

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

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