rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/features/message_expectations/block_local_expectations.feature.pending

@@ -1,55 +0,0 @@
-Feature: block local expectations
-
-  Background:
-    Given a file named "lib/account.rb" with:
-      """
-      class Account
-        def self.create
-          yield new
-        end
-
-        def opening_balance(amount, currency)
-        end
-      end
-      """
-
-  Scenario: passing example
-    Given a file named "spec/account_spec.rb" with:
-      """
-      require 'account'
-
-      describe "account DSL" do
-        it "it succeeds when the block local receives the given call" do
-          account = double("Account")
-          Account.should_receive(:create).and_yield(account) do |account|
-            account.should_receive(:opening_balance).with(100, :USD)
-          end
-          Account.create do |account|
-            account.opening_balance 100, :USD
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: failing example
-
-    Given a file named "spec/account_spec.rb" with:
-      """
-      require 'account'
-
-      describe "account DSL" do
-        it "fails when the block local does not receive the expected call" do
-          Account.should_receive(:create).and_yield do |account|
-            account.should_receive(:opening_balance).with(100, :USD)
-          end
-          Account.create do |account|
-            # opening_balance is not called here
-          end
-        end
-      end
-      """
-
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 1 failure"

data/features/message_expectations/call_original.feature

@@ -1,23 +0,0 @@
-Feature: Calling the original method
-
-  You can use `and_call_original` on the fluent interface
-  to "pass through" the received message to the original method.
-
-  Scenario: expect a message
-    Given a file named "call_original_spec.rb" with:
-      """ruby
-      class Addition
-        def self.two_plus_two
-          4
-        end
-      end
-
-      describe "and_call_original" do
-        it "delegates the message to the original implementation" do
-          expect(Addition).to receive(:two_plus_two).and_call_original
-          expect(Addition.two_plus_two).to eq(4)
-        end
-      end
-      """
-    When I run `rspec call_original_spec.rb`
-    Then the examples should all pass

data/features/message_expectations/expect_message_using_expect.feature

@@ -1,107 +0,0 @@
-Feature: expect message using `expect`
-
-  Use `expect(object).to receive(:message)` to set an expectation that
-  `object` should receive the message `:message` before the example is
-  completed.
-
-  Note: You can use `expect_any_instance_of` when you don't have a reference
-  to the object that receives a message in your test. For more information,
-  see the message_expectations/expect_any_instance_of feature.
-
-  Scenario: expect a message
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      require "account"
-
-      describe Account do
-        context "when closed" do
-          it "logs an account closed message" do
-            logger = double("logger")
-            account = Account.new logger
-
-            expect(logger).to receive(:account_closed)
-
-            account.close
-          end
-        end
-      end
-      """
-    And a file named "lib/account.rb" with:
-      """ruby
-      Account = Struct.new(:logger) do
-        def close
-          logger.account_closed
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message with an argument
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      require "account"
-
-      describe Account do
-        context "when closed" do
-          it "logs an account closed message" do
-            logger = double("logger")
-            account = Account.new logger
-
-            expect(logger).to receive(:account_closed).with(account)
-
-            account.close
-          end
-        end
-      end
-      """
-    And a file named "lib/account.rb" with:
-      """ruby
-      Account = Struct.new(:logger) do
-        def close
-          logger.account_closed(self)
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: provide a return value
-    Given a file named "spec/message_expectation_spec.rb" with:
-      """ruby
-
-      describe "a message expectation with a return value" do
-        context "specified in a block" do
-          it "returns the specified value" do
-            object = double("object")
-            expect(object).to receive(:message) { :return_value }
-            expect(object.message).to eq(:return_value)
-          end
-        end
-
-        context "specified with and_return" do
-          it "returns the specified value" do
-            object = double("object")
-            expect(object).to receive(:message).and_return(:return_value)
-            expect(object.message).to eq(:return_value)
-          end
-        end
-      end
-      """
-    When I run `rspec spec/message_expectation_spec.rb`
-    Then the output should contain "2 examples, 0 failures"
-
-  Scenario: expect a specific number of calls
-    Given a file named "spec/message_count_spec.rb" with:
-      """ruby
-      describe "a message expectation with a count" do
-        it "passes if the expected number of calls happen" do
-          string = "hi"
-          expect(string).to receive(:length).exactly(3).times
-
-          3.times { string.length }
-        end
-      end
-      """
-    When I run `rspec spec/message_count_spec.rb`
-    Then the output should contain "1 example, 0 failures"

data/features/message_expectations/expect_message_using_should_receive.feature

@@ -1,118 +0,0 @@
-Feature: expect message using `should_receive`
-
-  Use `object.should_receive(:message)` to set an expectation that
-  `object` should receive the message `:message` before the example is
-  completed.
-
-  Background:
-    Given a file named "spec/spec_helper.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.mock_with :rspec do |mocks|
-          mocks.syntax = :should
-        end
-      end
-      """
-
-  Scenario: expect a message
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      require "account"
-      require "spec_helper"
-
-      describe Account do
-        context "when closed" do
-          it "logs an account closed message" do
-            logger = double("logger")
-            account = Account.new logger
-
-            logger.should_receive(:account_closed)
-
-            account.close
-          end
-        end
-      end
-      """
-    And a file named "lib/account.rb" with:
-      """ruby
-      Account = Struct.new(:logger) do
-        def close
-          logger.account_closed
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message with an argument
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      require "account"
-      require "spec_helper"
-
-      describe Account do
-        context "when closed" do
-          it "logs an account closed message" do
-            logger = double("logger")
-            account = Account.new logger
-
-            logger.should_receive(:account_closed).with(account)
-
-            account.close
-          end
-        end
-      end
-      """
-    And a file named "lib/account.rb" with:
-      """ruby
-      Account = Struct.new(:logger) do
-        def close
-          logger.account_closed(self)
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: provide a return value
-    Given a file named "spec/message_expectation_spec.rb" with:
-      """ruby
-      require "spec_helper"
-
-      describe "a message expectation with a return value" do
-        context "specified in a block" do
-          it "returns the specified value" do
-            object = double("object")
-            object.should_receive(:message) { :return_value }
-            expect(object.message).to eq(:return_value)
-          end
-        end
-
-        context "specified with and_return" do
-          it "returns the specified value" do
-            object = double("object")
-            object.should_receive(:message).and_return(:return_value)
-            expect(object.message).to eq(:return_value)
-          end
-        end
-      end
-      """
-    When I run `rspec spec/message_expectation_spec.rb`
-    Then the output should contain "2 examples, 0 failures"
-
-  Scenario: expect a specific number of calls
-    Given a file named "spec/message_count_spec.rb" with:
-      """ruby
-      require "spec_helper"
-
-      describe "a message expectation with a count" do
-        it "passes if the expected number of calls happen" do
-          string = "hi"
-          string.should_receive(:length).exactly(3).times
-
-          3.times { string.length }
-        end
-      end
-      """
-    When I run `rspec spec/message_count_spec.rb`
-    Then the output should contain "1 example, 0 failures"

data/features/message_expectations/message_chains_using_expect.feature

@@ -1,49 +0,0 @@
-Feature: Message chains in the expect syntax
-
-  You can use `receive_message_chain` to stub nested calls
-  on both partial and pure mock objects.
-
-  Scenario: allow a chained message
-    Given a file named "spec/chained_messages.rb" with:
-      """ruby
-      describe "a chained message expectation" do
-        it "passes if the expected number of calls happen" do
-          d = double
-          allow(d).to receive_message_chain(:to_a, :length)
-
-          d.to_a.length
-        end
-      end
-      """
-    When I run `rspec spec/chained_messages.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: allow a chained message with a return value
-    Given a file named "spec/chained_messages.rb" with:
-      """ruby
-      describe "a chained message expectation" do
-        it "passes if the expected number of calls happen" do
-          d = double
-          allow(d).to receive_message_chain(:to_a, :length).and_return(3)
-
-          expect(d.to_a.length).to eq(3)
-        end
-      end
-      """
-    When I run `rspec spec/chained_messages.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a chained message with a return value
-    Given a file named "spec/chained_messages.rb" with:
-      """ruby
-      describe "a chained message expectation" do
-        it "passes if the expected number of calls happen" do
-          d = double
-          expect(d).to receive_message_chain(:to_a, :length).and_return(3)
-
-          expect(d.to_a.length).to eq(3)
-        end
-      end
-      """
-    When I run `rspec spec/chained_messages.rb`
-    Then the output should contain "1 example, 0 failures"

data/features/message_expectations/receive_counts.feature

@@ -1,209 +0,0 @@
-Feature: receive counts
-
-  Scenario: expect a message once
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            expect(logger).to receive(:account_opened).once
-
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message twice
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            expect(logger).to receive(:account_opened).twice
-
-            account.open
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message 3 times
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            expect(logger).to receive(:account_opened).exactly(3).times
-
-            account.open
-            account.open
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message at least (:once)
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            expect(logger).to receive(:account_opened).at_least(:once)
-
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-
-  Scenario: expect a message at least (n) times
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            expect(logger).to receive(:account_opened).at_least(3).times
-
-            # Note that I am calling method under test 4 times
-            # and I specified it to be called at least 3 times
-            account.open
-            account.open
-            account.open
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message at most (:once)
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            expect(logger).to receive(:account_opened).at_most(:once)
-
-            account.open
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "expected: at most 1 time"
-     And the output should contain "received: 2 times"
-
-  Scenario: expect a message at most (n) times
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      class Account
-        attr_accessor :logger
-
-        def open
-          logger.account_opened
-        end
-      end
-
-      describe Account do
-        context "when opened" do
-          it "logger#account_opened was called once" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            expect(logger).to receive(:account_opened).at_most(2).times
-
-            account.open
-            account.open
-          end
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"