opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,11 @@
+module RSpec
+  module Mocks
+    RSpec.describe ExampleMethods do
+      it 'does not define private helper methods since it gets included into a ' +
+         'namespace where users define methods and could inadvertently overwrite ' +
+         'them' do
+        expect(ExampleMethods.private_instance_methods).to eq([])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module RSpec
+  module Mocks
+    RSpec.describe "After a test double has been torn down" do
+      RSpec.shared_examples_for "expiration" do
+        before do
+          expect(dbl).to receive(:foo).at_least(:once)
+          allow(dbl).to receive(:bar)
+          dbl.foo
+
+          RSpec::Mocks.verify
+          RSpec::Mocks.teardown
+          RSpec::Mocks.setup
+        end
+
+        it 'disallows previously mocked methods' do
+          expect { dbl.foo }.to raise_error(ExpiredTestDoubleError)
+        end
+
+        it 'disallows previously stubbed methods' do
+          expect { dbl.bar }.to raise_error(ExpiredTestDoubleError)
+        end
+
+        it 'disallows stubbing new methods (with receive)' do
+          expect {
+            allow(dbl).to receive(:bazz)
+          }.to raise_error(ExpiredTestDoubleError)
+        end
+
+        it 'disallows stubbing new methods (with receive_messages)' do
+          expect {
+            allow(dbl).to receive_messages(:bazz => 3)
+          }.to raise_error(ExpiredTestDoubleError)
+        end
+
+        it 'disallows stubbing new message chains' do
+          expect {
+            allow(dbl).to receive_message_chain(:bazz, :bam, :goo)
+          }.to raise_error(ExpiredTestDoubleError)
+        end
+
+        it 'disallows mocking new methods' do
+          expect {
+            expect(dbl).to receive(:bazz)
+          }.to raise_error(ExpiredTestDoubleError)
+        end
+
+        it 'disallows being turned into a null object' do
+          expect { dbl.as_null_object }.to raise_error(ExpiredTestDoubleError)
+        end
+
+        it 'disallows being checked for nullness' do
+          expect { dbl.null_object? }.to raise_error(ExpiredTestDoubleError)
+        end
+
+      end
+
+      context "for a plain double" do
+        let(:dbl) { double }
+        include_examples "expiration"
+      end
+
+      class ExpiredInstanceInterface
+        def foo;  end
+        def bar;  end
+        def bazz; end
+      end
+
+      class ExpiredClassInterface
+        def self.foo;  end
+        def self.bar;  end
+        def self.bazz; end
+      end
+
+      context "for an instance_double" do
+        let(:dbl) { instance_double(ExpiredInstanceInterface) }
+        include_examples "expiration"
+      end
+
+      context "for a class_double" do
+        let(:dbl) { class_double(ExpiredClassInterface) }
+        include_examples "expiration"
+      end
+
+      context "for an object_double" do
+        let(:dbl) { object_double(ExpiredInstanceInterface.new) }
+        include_examples "expiration"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      RSpec.describe HashExcludingMatcher do
+
+        it "describes itself properly" do
+          expect(HashExcludingMatcher.new(:a => 5).description).to eq "hash_not_including(:a=>5)"
+        end
+
+        describe "passing" do
+          it "matches a hash without the specified key" do
+            expect(hash_not_including(:c)).to be === {:a => 1, :b => 2}
+          end
+
+          it "matches a hash with the specified key, but different value" do
+            expect(hash_not_including(:b => 3)).to be === {:a => 1, :b => 2}
+          end
+
+          it "matches a hash without the specified key, given as anything()" do
+            expect(hash_not_including(:c => anything)).to be === {:a => 1, :b => 2}
+          end
+
+          it "matches an empty hash" do
+            expect(hash_not_including(:a)).to be === {}
+          end
+
+          it "matches a hash without any of the specified keys" do
+            expect(hash_not_including(:a, :b, :c)).to be === { :d => 7 }
+          end
+
+        end
+
+        describe "failing" do
+          it "does not match a non-hash" do
+            expect(hash_not_including(:a => 1)).not_to be === 1
+          end
+
+          it "does not match a hash with a specified key" do
+            expect(hash_not_including(:b)).not_to be === { :b => 2 }
+          end
+
+          it "does not match a hash with the specified key/value pair" do
+            expect(hash_not_including(:b => 2)).not_to be === { :a => 1, :b => 2 }
+          end
+
+          it "does not match a hash with the specified key" do
+            expect(hash_not_including(:a, :b => 3)).not_to be === { :a => 1, :b => 2 }
+          end
+
+          it "does not match a hash with one of the specified keys" do
+            expect(hash_not_including(:a, :b)).not_to be === { :b => 2 }
+          end
+
+          it "does not match a hash with some of the specified keys" do
+            expect(hash_not_including(:a, :b, :c)).not_to be === { :a => 1, :b => 2 }
+          end
+
+          it "does not match a hash with one key/value pair included" do
+            expect(hash_not_including(:a, :b, :c, :d => 7)).not_to be === { :d => 7 }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      RSpec.describe HashIncludingMatcher do
+
+        it "describes itself properly" do
+          expect(HashIncludingMatcher.new(:a => 1).description).to eq "hash_including(:a=>1)"
+        end
+
+        describe "passing" do
+          it "matches the same hash" do
+            expect(hash_including(:a => 1)).to be === {:a => 1}
+          end
+
+          it "matches a hash with extra stuff" do
+            expect(hash_including(:a => 1)).to be === {:a => 1, :b => 2}
+          end
+
+          describe "when matching against other matchers" do
+            it "matches an int against anything()" do
+              expect(hash_including(:a => anything, :b => 2)).to be === {:a => 1, :b => 2}
+            end
+
+            it "matches a string against anything()" do
+              expect(hash_including(:a => anything, :b => 2)).to be === {:a => "1", :b => 2}
+            end
+
+            it 'can match against arbitrary objects that implement #===' do
+              expect(hash_including(:a => /foo/)).to be === { :a => "foobar" }
+            end
+          end
+
+          describe "when passed only keys or keys mixed with key/value pairs" do
+            it "matches if the key is present" do
+              expect(hash_including(:a)).to be === {:a => 1, :b => 2}
+            end
+
+            it "matches if more keys are present" do
+              expect(hash_including(:a, :b)).to be === {:a => 1, :b => 2, :c => 3}
+            end
+
+            it "matches a string against a given key" do
+              expect(hash_including(:a)).to be === {:a => "1", :b => 2}
+            end
+
+            it "matches if passed one key and one key/value pair" do
+              expect(hash_including(:a, :b => 2)).to be === {:a => 1, :b => 2}
+            end
+
+            it "matches if passed many keys and one key/value pair" do
+              expect(hash_including(:a, :b, :c => 3)).to be === {:a => 1, :b => 2, :c => 3, :d => 4}
+            end
+
+            it "matches if passed many keys and many key/value pairs" do
+              expect(hash_including(:a, :b, :c => 3, :e => 5)).to be === {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
+            end
+          end
+        end
+
+        describe "failing" do
+          it "does not match a non-hash" do
+            expect(hash_including(:a => 1)).not_to be === 1
+          end
+
+          it "does not match a hash with a missing key" do
+            expect(hash_including(:a => 1)).not_to be === { :b => 2 }
+          end
+
+          it "does not match a hash with a missing key" do
+            expect(hash_including(:a)).not_to be === { :b => 2 }
+          end
+
+          it "does not match an empty hash with a given key" do
+            expect(hash_including(:a)).not_to be === {}
+          end
+
+          it "does not match a hash with a missing key when one pair is matching" do
+            expect(hash_including(:a, :b => 2)).not_to be === { :b => 2 }
+          end
+
+          it "does not match a hash with an incorrect value" do
+            expect(hash_including(:a => 1, :b => 2)).not_to be === { :a => 1, :b => 3 }
+          end
+
+          it "does not match when values are nil but keys are different" do
+            expect(hash_including(:a => nil)).not_to be === { :b => nil }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module RSpec
+  module Mocks
+    RSpec.describe InstanceMethodStasher do
+      class ExampleClass
+        def hello
+          :hello_defined_on_class
+        end
+      end
+
+      def singleton_class_for(obj)
+        class << obj; self; end
+      end
+
+      def stasher_for(obj, method_name)
+        InstanceMethodStasher.new(obj, method_name)
+      end
+
+      it "stashes the current implementation of an instance method so it can be temporarily replaced" do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+
+        stashed_method = stasher_for(obj, :hello)
+        stashed_method.stash
+
+        with_isolated_stderr { def obj.hello; :overridden_hello; end }
+        expect(obj.hello).to eql :overridden_hello
+
+        stashed_method.restore
+        expect(obj.hello).to eql :hello_defined_on_singleton_class
+      end
+
+      it "stashes private instance methods" do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+        singleton_class_for(obj).__send__(:private, :hello)
+
+        stashed_method = stasher_for(obj, :hello)
+        stashed_method.stash
+
+        with_isolated_stderr { def obj.hello; :overridden_hello; end }
+        stashed_method.restore
+        expect(obj.send(:hello)).to eql :hello_defined_on_singleton_class
+      end
+
+      it "only stashes methods directly defined on the given class, not its ancestors" do
+        obj = ExampleClass.new
+
+        stashed_method = stasher_for(obj, :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end;
+        expect(obj.hello).to eql :overridden_hello
+
+        stashed_method.restore
+        expect(obj.hello).to eql :overridden_hello
+      end
+
+      it "does not unnecessarily create obfuscated aliased methods", :if => (RUBY_VERSION.to_f > 1.8) do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+
+        stashed_method = stasher_for(obj, :hello)
+
+        expect {
+          stashed_method.stash
+        }.not_to change { obj.methods.count }
+
+        expect(obj.methods.grep(/rspec/)).to eq([])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+RSpec.describe Marshal, 'extensions' do
+  # An object that raises when code attempts to dup it.
+  #
+  # Because we manipulate the internals of RSpec::Mocks.space below, we need
+  # an object that simply blows up when #dup is called without using any
+  # partial mocking or stubbing from rspec-mocks itself.
+  class UndupableObject
+    def dup
+      raise NotImplementedError
+    end
+  end
+
+  describe '#dump' do
+    context 'when rspec-mocks has been fully initialized' do
+      include_context "with monkey-patched marshal"
+
+      it 'duplicates objects with stubbed or mocked implementations before serialization' do
+        obj = double(:foo => "bar")
+
+        serialized = Marshal.dump(obj)
+        expect(Marshal.load(serialized)).to be_an(obj.class)
+      end
+
+      it 'does not duplicate other objects before serialization' do
+        obj = UndupableObject.new
+
+        serialized = Marshal.dump(obj)
+        expect(Marshal.load(serialized)).to be_an(UndupableObject)
+      end
+
+      it 'does not duplicate nil before serialization' do
+        serialized = Marshal.dump(nil)
+        expect(Marshal.load(serialized)).to be_nil
+      end
+
+      specify 'applying and unapplying patch is idempotent' do
+        obj = double(:foo => "bar")
+        config = RSpec::Mocks.configuration
+
+        config.patch_marshal_to_support_partial_doubles = true
+        config.patch_marshal_to_support_partial_doubles = true
+        serialized = Marshal.dump(obj)
+        expect(Marshal.load(serialized)).to be_an(obj.class)
+        config.patch_marshal_to_support_partial_doubles = false
+        config.patch_marshal_to_support_partial_doubles = false
+        expect { Marshal.dump(obj) }.to raise_error(TypeError)
+      end
+    end
+
+    context 'outside the per-test lifecycle' do
+      def outside_per_test_lifecycle
+        RSpec::Mocks.teardown
+        yield
+      ensure
+        RSpec::Mocks.setup
+      end
+
+      it 'does not duplicate the object before serialization' do
+        obj = UndupableObject.new
+        outside_per_test_lifecycle do
+          serialized = Marshal.dump(obj)
+          expect(Marshal.load(serialized)).to be_an(UndupableObject)
+        end
+      end
+    end
+  end
+end