opal-rspec 0.7.0.rc.1 → 0.7.0.rc.2

data/rspec-mocks/upstream/features/verifying_doubles/object_doubles.feature

@@ -0,0 +1,62 @@
+Feature: Using an object double
+
+  `object_double` can be used to create a double from an existing "template" object, from
+  which it verifies that any stubbed methods on the double also exist on the template. This is
+  useful for objects that are readily constructable, but may have far-reaching side-effects
+  such as talking to a database or external API. In this case, using a double rather than the
+  real thing allows you to focus on the communication patterns of the object's interface
+  without having to worry about accidentally causing side-effects. Object doubles can also be
+  used to verify methods defined on an object using `method_missing`, which is not possible
+  with [`instance_double`](./using-an-instance-double).
+
+  In addition, `object_double` can be used with specific constant values, as shown below. This
+  is for niche situations, such as when dealing with singleton objects.
+
+  Scenario: doubling an existing object
+    Given a file named "spec/user_spec.rb" with:
+      """ruby
+      class User
+        # Don't want to accidentally trigger this!
+        def save; sleep 100; end
+      end
+
+      def save_user(user)
+        "saved!" if user.save
+      end
+
+      RSpec.describe '#save_user' do
+        it 'renders message on success' do
+          user = object_double(User.new, :save => true)
+          expect(save_user(user)).to eq("saved!")
+        end
+      end
+      """
+    When I run `rspec spec/user_spec.rb`
+    Then the examples should all pass
+
+  Scenario: doubling a constant object
+    Given a file named "spec/email_spec.rb" with:
+      """ruby
+      require 'logger'
+
+      module MyApp
+        LOGGER = Logger.new("myapp")
+      end
+
+      class Email
+        def self.send_to(recipient)
+          MyApp::LOGGER.info("Sent to #{recipient}")
+          # other emailing logic
+        end
+      end
+
+      RSpec.describe Email do
+        it 'logs a message when sending' do
+          logger = object_double("MyApp::LOGGER", :info => nil).as_stubbed_const
+          Email.send_to('hello@foo.com')
+          expect(logger).to have_received(:info).with("Sent to hello@foo.com")
+        end
+      end
+      """
+    When I run `rspec spec/email_spec.rb`
+    Then the examples should all pass

data/rspec-mocks/upstream/features/verifying_doubles/partial_doubles.feature

@@ -0,0 +1,34 @@
+Feature: Partial doubles
+
+  When the `verify_partial_doubles` configuration option is set, the same argument and
+  method existence checks that are performed for [`object_double`](./using-an-object-double) are also performed on
+  [partial doubles](../basics/partial-test-doubles). You should set this unless you have a good reason not to. It defaults to off
+  only for backwards compatibility.
+
+  Scenario: doubling an existing object
+    Given a file named "spec/user_spec.rb" with:
+      """ruby
+      class User
+        def save; false; end
+      end
+
+      def save_user(user)
+        "saved!" if user.save
+      end
+
+      RSpec.configure do |config|
+        config.mock_with :rspec do |mocks|
+          mocks.verify_partial_doubles = true
+        end
+      end
+
+      RSpec.describe '#save_user' do
+        it 'renders message on success' do
+          user = User.new
+          expect(user).to receive(:saave).and_return(true) # Typo in name
+          expect(save_user(user)).to eq("saved!")
+        end
+      end
+      """
+    When I run `rspec spec/user_spec.rb`
+    Then the output should contain "1 example, 1 failure"

data/rspec-mocks/upstream/features/working_with_legacy_code/README.md

@@ -0,0 +1,3 @@
+RSpec provides a few features that, while not generally recommended, can be useful when
+you are getting legacy code under test (or in similar situations). Usage of these features
+should be considered a code smell.

data/rspec-mocks/upstream/features/working_with_legacy_code/any_instance.feature

@@ -0,0 +1,115 @@
+Feature: Any Instance
+
+  rspec-mocks provides two methods, `allow_any_instance_of` and
+  `expect_any_instance_of`, that will allow you to stub or mock any instance of a class. They
+  are used in place of [`allow`](../basics/allowing-messages) or [`expect`](../basics/expecting-messages):
+
+  ```ruby
+  allow_any_instance_of(Widget).to receive(:name).and_return("Wibble")
+  expect_any_instance_of(Widget).to receive(:name).and_return("Wobble")
+  ```
+
+  These methods add the appropriate stub or expectation to all instances of `Widget`.
+
+  This feature is sometimes useful when working with legacy code, though in general we
+  discourage its use for a number of reasons: 
+
+  * The `rspec-mocks` API is designed for individual object instances, but this feature
+    operates on entire classes of objects. As a result there are some sematically confusing
+    edge cases. For example, in `expect_any_instance_of(Widget).to
+    receive(:name).twice` it isn't clear whether each specific instance is expected to
+    receive `name` twice, or if two receives total are expected. (It's the former.)
+  * Using this feature is often a design smell. It may be that your test is trying to do too
+    much or that the object under test is too complex.
+  * It is the most complicated feature of `rspec-mocks`, and has historically received the
+    most bug reports. (None of the core team actively use it, which doesn't help.)
+
+  Scenario: Use `allow_any_instance_of` to stub a method
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.describe "allow_any_instance_of" do
+        it "returns the specified value on any instance of the class" do
+          allow_any_instance_of(Object).to receive(:foo).and_return(:return_value)
+
+          o = Object.new
+          expect(o.foo).to eq(:return_value)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Use `allow_any_instance_of` to stub multiple methods
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.describe "allow_any_instance_of" do
+        context "with receive_messages" do
+          it "stubs multiple methods" do
+            allow_any_instance_of(Object).to receive_messages(:foo => 'foo', :bar => 'bar')
+
+            o = Object.new
+            expect(o.foo).to eq('foo')
+            expect(o.bar).to eq('bar')
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Stubbing any instance of a class with specific arguments
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.describe "allow_any_instance_of" do
+        context "with arguments" do
+          it "returns the stubbed value when arguments match" do
+            allow_any_instance_of(Object).to receive(:foo).with(:param_one, :param_two).and_return(:result_one)
+            allow_any_instance_of(Object).to receive(:foo).with(:param_three, :param_four).and_return(:result_two)
+
+            o = Object.new
+            expect(o.foo(:param_one, :param_two)).to eq(:result_one)
+            expect(o.foo(:param_three, :param_four)).to eq(:result_two)
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Block implementation is passed the receiver as first arg
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.describe "allow_any_instance_of" do
+        it 'yields the receiver to the block implementation' do
+          allow_any_instance_of(Array).to receive(:shuffle) do |array|
+            array.unshift(array.pop)
+          end
+
+          expect([1, 2, 3].shuffle).to eq([3, 1, 2])
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Use `expect_any_instance_of` to set a message expectation on any instance
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.describe "expect_any_instance_of" do
+        before do
+          expect_any_instance_of(Object).to receive(:foo)
+        end
+
+        it "passes when an instance receives the message" do
+          Object.new.foo
+        end
+
+        it "fails when no instance receives the message" do
+          Object.new.to_s
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then it should fail with the following output:
+      | 2 examples, 1 failure |
+      | Exactly one instance should have received the following message(s) but didn't: foo |

data/rspec-mocks/upstream/features/working_with_legacy_code/message_chains.feature

@@ -0,0 +1,79 @@
+Feature: Message Chains
+
+  You can use `receive_message_chain` in place of `receive` to stub a chain of messages:
+
+  ```ruby
+  allow(double).to receive_message_chain("foo.bar") { :baz }
+  allow(double).to receive_message_chain(:foo, :bar => :baz)
+  allow(double).to receive_message_chain(:foo, :bar) { :baz }
+  ````
+
+  Given any of these three forms:
+
+  ```ruby
+  double.foo.bar # => :baz
+  ```
+
+  Common use in Rails/ActiveRecord:
+
+  ```ruby
+  allow(Article).to receive_message_chain("recent.published") { [Article.new] }
+  ```
+
+  Warning:
+  ========
+
+  Chains can be arbitrarily long, which makes it quite painless to violate the Law of Demeter
+  in violent ways, so you should consider any use of `receive_message_chain` a code smell.
+  Even though not all code smells indicate real problems (think fluent interfaces),
+  `receive_message_chain` still results in brittle examples. For example, if you write
+  `allow(foo).to receive_message_chain(:bar, :baz => 37)` in a spec and then the
+  implementation calls `foo.baz.bar`, the stub will not work.
+
+  Scenario: Use `receive_message_chain` on a double
+    Given a file named "receive_message_chain_spec.rb" with:
+      """ruby
+      RSpec.describe "Using receive_message_chain on a double" do
+        let(:dbl) { double }
+
+        example "using a string and a block" do
+          allow(dbl).to receive_message_chain("foo.bar") { :baz }
+          expect(dbl.foo.bar).to eq(:baz)
+        end
+
+        example "using symbols and a hash" do
+          allow(dbl).to receive_message_chain(:foo, :bar => :baz)
+          expect(dbl.foo.bar).to eq(:baz)
+        end
+
+        example "using symbols and a block" do
+          allow(dbl).to receive_message_chain(:foo, :bar) { :baz }
+          expect(dbl.foo.bar).to eq(:baz)
+        end
+      end
+      """
+    When I run `rspec receive_message_chain_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Use `receive_message_chain` on any instance of a class
+    Given a file named "receive_message_chain_spec.rb" with:
+      """ruby
+      RSpec.describe "Using receive_message_chain on any instance of a class" do
+        example "using a string and a block" do
+          allow_any_instance_of(Object).to receive_message_chain("foo.bar") { :baz }
+          expect(Object.new.foo.bar).to eq(:baz)
+        end
+
+        example "using symbols and a hash" do
+          allow_any_instance_of(Object).to receive_message_chain(:foo, :bar => :baz)
+          expect(Object.new.foo.bar).to eq(:baz)
+        end
+
+        example "using symbols and a block" do
+          allow_any_instance_of(Object).to receive_message_chain(:foo, :bar) { :baz }
+          expect(Object.new.foo.bar).to eq(:baz)
+        end
+      end
+      """
+    When I run `rspec receive_message_chain_spec.rb`
+    Then the examples should all pass

data/rspec-mocks/upstream/lib/rspec/mocks.rb

@@ -0,0 +1,126 @@
+require 'rspec/support'
+RSpec::Support.require_rspec_support 'caller_filter'
+RSpec::Support.require_rspec_support 'warnings'
+RSpec::Support.require_rspec_support 'ruby_features'
+
+RSpec::Support.define_optimized_require_for_rspec(:mocks) { |f| require_relative f }
+
+%w[
+  instance_method_stasher
+  method_double
+  argument_matchers
+  example_methods
+  proxy
+  test_double
+  argument_list_matcher
+  message_expectation
+  order_group
+  error_generator
+  space
+  mutate_const
+  targets
+  syntax
+  configuration
+  verifying_double
+  version
+].each { |name| RSpec::Support.require_rspec_mocks name }
+
+# Share the top-level RSpec namespace, because we are a core supported
+# extension.
+module RSpec
+  # Contains top-level utility methods. While this contains a few
+  # public methods, these are not generally meant to be called from
+  # a test or example. They exist primarily for integration with
+  # test frameworks (such as rspec-core).
+  module Mocks
+    # Performs per-test/example setup. This should be called before
+    # an test or example begins.
+    def self.setup
+      @space_stack << (@space = space.new_scope)
+    end
+
+    # Verifies any message expectations that were set during the
+    # test or example. This should be called at the end of an example.
+    def self.verify
+      space.verify_all
+    end
+
+    # Cleans up all test double state (including any methods that were
+    # redefined on partial doubles). This _must_ be called after
+    # each example, even if an error was raised during the example.
+    def self.teardown
+      space.reset_all
+      @space_stack.pop
+      @space = @space_stack.last || @root_space
+    end
+
+    # Adds an allowance (stub) on `subject`
+    #
+    # @param subject the subject to which the message will be added
+    # @param message a symbol, representing the message that will be
+    #                added.
+    # @param opts a hash of options, :expected_from is used to set the
+    #             original call site
+    # @yield an optional implementation for the allowance
+    #
+    # @example Defines the implementation of `foo` on `bar`, using the passed block
+    #   x = 0
+    #   RSpec::Mocks.allow_message(bar, :foo) { x += 1 }
+    def self.allow_message(subject, message, opts={}, &block)
+      space.proxy_for(subject).add_stub(message, opts, &block)
+    end
+
+    # Sets a message expectation on `subject`.
+    # @param subject the subject on which the message will be expected
+    # @param message a symbol, representing the message that will be
+    #                expected.
+    # @param opts a hash of options, :expected_from is used to set the
+    #             original call site
+    # @yield an optional implementation for the expectation
+    #
+    # @example Expect the message `foo` to receive `bar`, then call it
+    #   RSpec::Mocks.expect_message(bar, :foo)
+    #   bar.foo
+    def self.expect_message(subject, message, opts={}, &block)
+      space.proxy_for(subject).add_message_expectation(message, opts, &block)
+    end
+
+    # Call the passed block and verify mocks after it has executed. This allows
+    # mock usage in arbitrary places, such as a `before(:all)` hook.
+    def self.with_temporary_scope
+      setup
+
+      begin
+        yield
+        verify
+      ensure
+        teardown
+      end
+    end
+
+    class << self
+      # @private
+      attr_reader :space
+    end
+    @space_stack = []
+    @root_space  = @space = RSpec::Mocks::RootSpace.new
+
+    # @private
+    IGNORED_BACKTRACE_LINE = 'this backtrace line is ignored'
+
+    # To speed up boot time a bit, delay loading optional or rarely
+    # used features until their first use.
+    autoload :AnyInstance,      "rspec/mocks/any_instance"
+    autoload :ExpectChain,      "rspec/mocks/message_chain"
+    autoload :StubChain,        "rspec/mocks/message_chain"
+    autoload :MarshalExtension, "rspec/mocks/marshal_extension"
+
+    # Namespace for mock-related matchers.
+    module Matchers
+      autoload :HaveReceived,        "rspec/mocks/matchers/have_received"
+      autoload :Receive,             "rspec/mocks/matchers/receive"
+      autoload :ReceiveMessageChain, "rspec/mocks/matchers/receive_message_chain"
+      autoload :ReceiveMessages,     "rspec/mocks/matchers/receive_messages"
+    end
+  end
+end

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance.rb

@@ -0,0 +1,10 @@
+%w[
+  any_instance/chain
+  any_instance/stub_chain
+  any_instance/stub_chain_chain
+  any_instance/expect_chain_chain
+  any_instance/expectation_chain
+  any_instance/message_chains
+  any_instance/recorder
+  any_instance/proxy
+].each { |f| RSpec::Support.require_rspec_mocks(f) }

data/rspec-mocks/upstream/lib/rspec/mocks/any_instance/chain.rb

@@ -0,0 +1,109 @@
+module RSpec
+  module Mocks
+    # @private
+    module AnyInstance
+      # @private
+      class Chain
+        def initialize(recorder, *args, &block)
+          @recorder          = recorder
+          @expectation_args  = args
+          @expectation_block = block
+          @argument_list_matcher = ArgumentListMatcher::MATCH_ALL
+        end
+
+        # @private
+        #
+        # Provides convenience methods for recording customizations on message
+        # expectations.
+        module Customizations
+          # @macro [attach] record
+          #   @method $1(*args, &block)
+          #   Records the `$1` message for playback against an instance that
+          #   invokes a method stubbed or mocked using `any_instance`.
+          #
+          #   @see RSpec::Mocks::MessageExpectation#$1
+          #
+          def self.record(method_name)
+            define_method(method_name) do |*args, &block|
+              record(method_name, *args, &block)
+            end
+          end
+
+          record :and_return
+          record :and_raise
+          record :and_throw
+          record :and_yield
+          record :and_call_original
+          record :with
+          record :once
+          record :twice
+          record :thrice
+          record :exactly
+          record :times
+          record :never
+          record :at_least
+          record :at_most
+        end
+
+        include Customizations
+
+        # @private
+        def playback!(instance)
+          message_expectation = create_message_expectation_on(instance)
+          messages.inject(message_expectation) do |object, message|
+            object.__send__(*message.first, &message.last)
+          end
+        end
+
+        # @private
+        def constrained_to_any_of?(*constraints)
+          constraints.any? do |constraint|
+            messages.any? do |message|
+              message.first.first == constraint
+            end
+          end
+        end
+
+        # @private
+        def matches_args?(*args)
+          @argument_list_matcher.args_match?(*args)
+        end
+
+        # @private
+        def expectation_fulfilled!
+          @expectation_fulfilled = true
+        end
+
+        def never
+          ErrorGenerator.raise_double_negation_error("expect_any_instance_of(MyClass)") if negated?
+          super
+        end
+
+        def with(*args, &block)
+          @argument_list_matcher = ArgumentListMatcher.new(*args)
+          super
+        end
+
+      private
+
+        def negated?
+          messages.any? { |(message, *_), _| message == :never }
+        end
+
+        def messages
+          @messages ||= []
+        end
+
+        def last_message
+          messages.last.first.first unless messages.empty?
+        end
+
+        def record(rspec_method_name, *args, &block)
+          verify_invocation_order(rspec_method_name, *args, &block)
+          messages << [args.unshift(rspec_method_name), block]
+          self
+        end
+      end
+    end
+  end
+end