dxruby_rp5 0.0.1

data/spec/vendor/rspec-mocks-2.14.4/features/message_expectations/allow_any_instance_of.feature

@@ -0,0 +1,26 @@
+Feature: allow a message on any instance of a class
+
+  Use `allow_any_instance_of(Class).to receive` when you want to configure how
+  instances of the given class respond to a message without setting an
+  expectation that the message will be received.
+
+  Scenario: allowing a message on any instance of a class
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "any_instance.should_receive" do
+        before do
+          allow_any_instance_of(Object).to receive(:foo).and_return(:return_value)
+        end
+
+        it "allows any instance of the class to receive the message" do
+          o = Object.new
+          expect(o.foo).to eq(:return_value)
+        end
+
+        it "passes even if no instances receive that message" do
+          o = Object.new
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass

data/spec/vendor/rspec-mocks-2.14.4/features/message_expectations/any_instance.feature

@@ -0,0 +1,21 @@
+Feature: expect a message on any instance of a class
+
+  Use `any_instance.should_receive` to set an expectation that one (and only
+  one) instance of a class receives a message before the example is completed.
+
+  The spec will fail if no instance receives a message.
+
+  Scenario: expect a message on any instance of a class
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "any_instance.should_receive" do
+        it "verifies that one instance of the class receives the message" do
+          Object.any_instance.should_receive(:foo).and_return(:return_value)
+
+          o = Object.new
+          o.foo.should eq(:return_value)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass

data/spec/vendor/rspec-mocks-2.14.4/features/message_expectations/block_local_expectations.feature.pending

@@ -0,0 +1,55 @@
+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/spec/vendor/rspec-mocks-2.14.4/features/message_expectations/call_original.feature

@@ -0,0 +1,24 @@
+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
+          Addition.should_receive(:two_plus_two).and_call_original
+          Addition.two_plus_two.should eq(4)
+        end
+      end
+      """
+    When I run `rspec call_original_spec.rb`
+    Then the examples should all pass
+

data/spec/vendor/rspec-mocks-2.14.4/features/message_expectations/expect_any_instance_of.feature

@@ -0,0 +1,27 @@
+Feature: expect a message on any instance of a class
+
+  Use `expect_any_instance_of(Class).to receive` to set an expectation that one
+  (and only one) instance of a class receives a message before the example is
+  completed. The spec will fail if no instance receives a message.
+
+  Scenario: expect a message on any instance of a class
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "expect_any_instance_of" do
+        before do
+          expect_any_instance_of(Object).to receive(:foo).and_return(:return_value)
+        end
+
+        it "verifies that one instance of the class receives the message" do
+          o = Object.new
+          expect(o.foo).to eq(:return_value)
+        end
+
+        it "fails unless an instance receives that message" do
+          o = Object.new
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "2 examples, 1 failure"
+    And the output should contain "1) expect_any_instance_of fails unless an instance receives that message"

data/spec/vendor/rspec-mocks-2.14.4/features/message_expectations/expect_message_using_expect.feature

@@ -0,0 +1,107 @@
+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 }
+            object.message.should 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)
+            object.message.should 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/spec/vendor/rspec-mocks-2.14.4/features/message_expectations/expect_message_using_should_receive.feature

@@ -0,0 +1,118 @@
+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 }
+            object.message.should 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)
+            object.message.should 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/spec/vendor/rspec-mocks-2.14.4/features/message_expectations/receive_counts.feature

@@ -0,0 +1,209 @@
+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
+
+            logger.should_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
+
+            logger.should_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
+
+            logger.should_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
+
+            logger.should_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
+
+            logger.should_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
+
+            logger.should_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
+
+            logger.should_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"

data/spec/vendor/rspec-mocks-2.14.4/features/message_expectations/warn_when_expectation_is_set_on_nil.feature

@@ -0,0 +1,50 @@
+Feature: warn when expectation is set on nil
+
+  Scenario: nil instance variable
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.configure {|c| c.mock_with :rspec}
+      describe "something" do
+        it "does something" do
+          @i_do_not_exist.should_receive(:foo)
+          @i_do_not_exist.foo
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "An expectation of :foo was set on nil"
+
+  Scenario: allow
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.configure {|c| c.mock_with :rspec}
+      describe "something" do
+        it "does something" do
+          allow_message_expectations_on_nil
+          nil.should_receive(:foo)
+          nil.foo
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should not contain "An expectation"
+
+  Scenario: allow in one example, but not on another
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.configure {|c| c.mock_with :rspec}
+      describe "something" do
+        it "does something (foo)" do
+          allow_message_expectations_on_nil
+          nil.should_receive(:foo)
+          nil.foo
+        end
+        it "does something (bar)" do
+          nil.should_receive(:bar)
+          nil.bar
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "An expectation of :bar"
+    And  the output should not contain "An expectation of :foo"