messagebus_ruby_api 0.4.0 → 0.4.4

data/spec/ruby/1.9.1/gems/rspec-mocks-2.5.0/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/ruby/1.9.1/gems/rspec-mocks-2.5.0/features/message_expectations/expect_message.feature

@@ -0,0 +1,94 @@
+Feature: expect a message
+
+  Use should_receive() to set an expectation that a receiver should receive a
+  message before the example is completed.
+
+  Scenario: expect a message
+    Given a file named "spec/account_spec.rb" with:
+      """
+      require "account"
+
+      describe Account do
+        context "when closed" do
+          it "logs an account closed message" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_closed)
+
+            account.close
+          end
+        end
+      end
+      """
+    And a file named "lib/account.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        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:
+      """
+      require "account"
+
+      describe Account do
+        context "when closed" do
+          it "logs an account closed message" do
+            logger = double("logger")
+            account = Account.new
+            account.logger = logger
+
+            logger.should_receive(:account_closed).with(account)
+
+            account.close
+          end
+        end
+      end
+      """
+    And a file named "lib/account.rb" with:
+      """
+      class Account
+        attr_accessor :logger
+
+        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 "message_expectation_spec.rb" with:
+      """
+      describe "a message expectation" do
+        context "with a return value" do
+          context "specified in a block" do
+            it "returns the specified value" do
+              receiver = double("receiver")
+              receiver.should_receive(:message) { :return_value }
+              receiver.message.should eq(:return_value)
+            end
+          end
+
+          context "specified with and_return" do
+            it "returns the specified value" do
+              receiver = double("receiver")
+              receiver.should_receive(:message).and_return(:return_value)
+              receiver.message.should eq(:return_value)
+            end
+          end
+        end
+      end
+      """
+    When I run "rspec message_expectation_spec.rb"
+    Then the output should contain "2 examples, 0 failures"

data/spec/ruby/1.9.1/gems/rspec-mocks-2.5.0/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:
+      """
+      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:
+      """
+      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:
+      """
+      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"

data/spec/ruby/1.9.1/gems/rspec-mocks-2.5.0/features/method_stubs/README.md

@@ -0,0 +1,39 @@
+### Basics
+
+    # create a double
+    obj = double()
+
+    # stub a method
+    obj.stub(:message) # returns obj
+
+    # specify a return value
+    obj.stub(:message) { 'this is the value to return' }
+
+### Argument constraints
+   
+#### Explicit arguments
+
+    obj.stub(:message).with('an argument')
+    obj.stub(:message).with('more_than', 'one_argument')
+
+#### Argument matchers
+
+    obj.stub(:message).with(anything())
+    obj.stub(:message).with(an_instance_of(Money))
+    obj.stub(:message).with(hash_including(:a => 'b'))
+
+#### Regular expressions
+
+    obj.stub(:message).with(/abc/)
+
+### Raising/Throwing
+
+    obj.stub(:message) { raise "this error" }
+    obj.stub(:message) { throw :this_symbol }
+
+### Arbitrary handling
+
+    obj.stub(:message) do |arg1, arg2|
+      # set expectations about the args in this block
+      # and set a return value
+    end

data/spec/ruby/1.9.1/gems/rspec-mocks-2.5.0/features/method_stubs/simple_return_value.feature

@@ -0,0 +1,55 @@
+Feature: stub with a simple return value
+
+  Use the `stub` method on a test double or a real object to tell the object to
+  return a value (or values) in response to a given message. If the message is
+  never received, nothing happens.
+
+  Scenario: simple stub with no return value
+    Given a file named "example_spec.rb" with:
+      """
+      describe "a simple stub with no return value specified" do
+        let(:receiver) { double("receiver") }
+
+        it "returns nil" do
+          receiver.stub(:message)
+          receiver.message.should be(nil)
+        end
+
+        it "quietly carries on when not called" do
+          receiver.stub(:message)
+        end
+      end
+      """
+    When I run "rspec example_spec.rb"
+    Then the output should contain "0 failures"
+
+  Scenario: single return value
+    Given a file named "example_spec.rb" with:
+      """
+      describe "a simple stub with a return value" do
+        context "specified in a block" do
+          it "returns the specified value" do
+            receiver = double("receiver")
+            receiver.stub(:message) { :return_value }
+            receiver.message.should eq(:return_value)
+          end
+        end
+
+        context "specified in the double declaration" do
+          it "returns the specified value" do
+            receiver = double("receiver", :message => :return_value)
+            receiver.message.should eq(:return_value)
+          end
+        end
+
+        context "specified with and_return" do
+          it "returns the specified value" do
+            receiver = double("receiver")
+            receiver.stub(:message).and_return(:return_value)
+            receiver.message.should eq(:return_value)
+          end
+        end
+      end
+      """
+    When I run "rspec example_spec.rb"
+    Then the output should contain "0 failures"

data/spec/ruby/1.9.1/gems/rspec-mocks-2.5.0/features/method_stubs/stub_chain.feature

@@ -0,0 +1,44 @@
+Feature: stub a chain of methods
+
+  The `stub_chain` method lets you to stub a chain of methods in one statement.
+  Method chains are considered a design smell, but it's not really the method
+  chain that is the problem - it's the dependency chain represented by a chain
+  of messages to different objects:
+
+      foo.get_bar.get_baz
+
+  This is a Law of Demeter violation if `get_bar` returns an object other than
+  `foo`, and `get_baz` returns yet another object.
+
+  Fluent interfaces look similar from a caller's perspective, but don't
+  represent a dependency chain (the caller depends only on the object it is
+  calling). Consider this common example from Ruby on Rails:
+
+      Article.recent.by(current_user)
+
+  The `recent` and `by` methods return the same object, so this is not a Law of
+  Demeter violation.
+
+  Scenario: stub a chain of methods
+    Given a file named "stub_chain_spec.rb" with:
+      """
+      describe "stubbing a chain of methods" do
+        subject { Object.new }
+
+        context "given symbols representing methods" do
+          it "returns the correct value" do
+            subject.stub_chain(:one, :two, :three).and_return(:four)
+            subject.one.two.three.should eq(:four)
+          end
+        end
+
+        context "given a string of methods separated by dots" do
+          it "returns the correct value" do
+            subject.stub_chain("one.two.three").and_return(:four)
+            subject.one.two.three.should eq(:four)
+          end
+        end
+      end
+      """
+    When I run "rspec stub_chain_spec.rb"
+    Then the output should contain "2 examples, 0 failures"

data/spec/ruby/1.9.1/gems/rspec-mocks-2.5.0/features/method_stubs/stub_implementation.feature

@@ -0,0 +1,26 @@
+Feature: stub with substitute implementation
+
+  You can stub an implementation of a method (a.k.a. fake) by passing a block
+  to the stub() method.
+  
+  Scenario: stub implementation
+    Given a file named "stub_implementation_spec.rb" with:
+      """
+      describe "a stubbed implementation" do
+        it "works" do
+          object = Object.new
+          object.stub(:foo) do |arg|
+            if arg == :this
+              "got this"
+            elsif arg == :that
+              "got that"
+            end
+          end
+          
+          object.foo(:this).should eq("got this")
+          object.foo(:that).should eq("got that")
+        end
+      end
+      """
+    When I run "rspec ./stub_implementation_spec.rb"
+    Then the output should contain "1 example, 0 failures"

data/spec/ruby/1.9.1/gems/rspec-mocks-2.5.0/features/outside_rspec/configuration.feature

@@ -0,0 +1,82 @@
+Feature: configure any test framework to use rspec-mocks
+
+  Test frameworks that want to use rspec-mocks can use
+  RSpec::Mocks::setup(self) to hook into rspec-mocks. Doing so adds the
+  following:
+
+    To the object passed to setup:
+
+      double # creates a test double
+      mock   # creates a test double
+      stub   # creates a test double
+
+    To every object in the system:
+
+      should_receive
+      should_not_receive
+      stub
+      
+  In order to give control to the consuming framework, none of these facilities
+  are added until RSpec::Mocks::setup(self) is called. Simply requiring
+  'rspec/mocks' is not sufficient. 
+
+  NOTICE: the stub() method that is added to the object passed to setup is not
+  the same stub() method that is added to every other object.
+
+  Scenario: RSpec::Mocks::setup(object) adds double, mock, and stub methods to the submitted object
+    Given a file named "foo.rb" with:
+      """
+      require 'rspec/mocks'
+
+      class CodeExample
+        def init
+          RSpec::Mocks::setup(self)
+        end
+      end
+
+      example = CodeExample.new
+      example.init
+
+      puts example.respond_to?(:double)
+      puts example.respond_to?(:mock)
+      puts example.respond_to?(:stub)
+      """
+
+    When I run "ruby foo.rb"
+    Then the output should contain "true"
+    But  the output should not contain "false"
+
+  Scenario: RSpec::Mocks::setup(anything) adds methods to Object
+    Given a file named "foo.rb" with:
+      """
+      require 'rspec/mocks'
+
+      RSpec::Mocks::setup(Object.new)
+
+      obj = Object.new
+
+      puts obj.respond_to?(:should_receive)
+      puts obj.respond_to?(:should_not_receive)
+      puts obj.respond_to?(:stub)
+      """
+
+    When I run "ruby foo.rb"
+    Then the output should contain "true"
+    But  the output should not contain "false"
+
+  Scenario: require "rspec/mocks" does not add methods to Object
+    Given a file named "foo.rb" with:
+      """
+      require 'rspec/mocks'
+
+      obj = Object.new
+
+      puts obj.respond_to?(:should_receive)
+      puts obj.respond_to?(:should_not_receive)
+      puts obj.respond_to?(:stub)
+      """
+
+    When I run "ruby foo.rb"
+    Then the output should contain "false"
+    But  the output should not contain "true"
+

data/spec/ruby/1.9.1/gems/rspec-mocks-2.5.0/features/outside_rspec/standalone.feature

@@ -0,0 +1,32 @@
+Feature: standalone
+
+  require "rspec/mocks/standalone" to expose the mock framework
+  outside the RSpec environment. This is especially useful for
+  exploring rspec-mocks in irb.
+
+  Scenario: method stub outside rspec
+    Given a file named "example.rb" with:
+      """
+      require "rspec/mocks/standalone"
+
+      greeter = double("greeter")
+      greeter.stub(:say_hi) { "Hello!" }
+      puts greeter.say_hi
+      """
+    When I run "ruby example.rb"
+    Then the output should contain "Hello!"
+
+  Scenario: message expectation outside rspec
+    Given a file named "example.rb" with:
+      """
+      require "rspec/mocks/standalone"
+
+      greeter = double("greeter")
+      greeter.should_receive(:say_hi)
+
+      RSpec::Mocks.verify
+      """
+    When I run "ruby example.rb"
+    Then the output should contain "say_hi(any args) (RSpec::Mocks::MockExpectationError)"
+    Then the output should contain "expected: 1 time"
+    Then the output should contain "received: 0 times"

data/spec/ruby/1.9.1/gems/rspec-mocks-2.5.0/features/support/env.rb

@@ -0,0 +1,2 @@
+require 'aruba'
+require 'rspec/expectations'

data/spec/ruby/1.9.1/gems/rspec-mocks-2.5.0/lib/rspec/mocks/argument_expectation.rb

@@ -0,0 +1,53 @@
+module RSpec
+  module Mocks
+    class ArgumentExpectation
+      attr_reader :args
+      
+      def initialize(*args, &block)
+        @args = args
+        @matchers_block = args.empty? ? block : nil
+        @match_any_args = false
+        @matchers = nil
+        
+        case args.first
+        when ArgumentMatchers::AnyArgsMatcher
+          @match_any_args = true
+        when ArgumentMatchers::NoArgsMatcher
+          @matchers = []
+        else
+          @matchers = args.collect {|arg| matcher_for(arg)}
+        end
+      end
+      
+      def matcher_for(arg)
+        return ArgumentMatchers::MatcherMatcher.new(arg) if is_matcher?(arg)
+        return ArgumentMatchers::RegexpMatcher.new(arg)  if arg.is_a?(Regexp)
+        return ArgumentMatchers::EqualityProxy.new(arg)
+      end
+      
+      def is_matcher?(obj)
+        !is_stub_as_null_object?(obj) & obj.respond_to?(:matches?) & obj.respond_to?(:description)
+      end
+
+      def is_stub_as_null_object?(obj)
+        obj.respond_to?(:__rspec_double_acting_as_null_object?) && obj.__rspec_double_acting_as_null_object?
+      end
+      
+      def args_match?(*args)
+        match_any_args? || matchers_block_matches?(*args) || matchers_match?(*args)
+      end
+      
+      def matchers_block_matches?(*args)
+        @matchers_block ? @matchers_block.call(*args) : nil
+      end
+      
+      def matchers_match?(*args)
+        @matchers == args
+      end
+      
+      def match_any_args?
+        @match_any_args
+      end
+    end
+  end
+end