messagebus_ruby_api 0.4.7 → 0.4.8

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

@@ -1,82 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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

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

@@ -1,196 +0,0 @@
-require 'rspec/mocks/framework'
-require 'rspec/mocks/version'
-require 'rspec/mocks/spec_methods'
-
-module RSpec
-  # == Test Doubles
-  #
-  # A Test Double is an object that stands in for a real object in a test.
-  # RSpec creates test doubles that support method stubs and message
-  # expectations.
-  #
-  #   book = double("book")
-  #
-  # == Method Stubs
-  #
-  # A method stub is an implementation that returns a pre-determined value.
-  #
-  #   book = double("book")
-  #   double.stub(:title) { "The RSpec Book" }
-  #   double.title => "The RSpec Book"
-  #
-  # When we declare a stub, we say we are "stubbing" a method.
-  #
-  # == Message Expectations
-  #
-  # A message expectation is an expectation that the test double will receive a
-  # message some time before the example ends. If the message is received, the
-  # expectation is satisfied. If not, the example fails.
-  #
-  #   validator = double("validator")
-  #   validator.should_receive(:validate).with("02134")
-  #   zipcode = Zipcode.new("02134", validator)
-  #   zipcode.valid?
-  #   
-  # When we declare a message expectation, we say we are "mocking" a method.
-  #
-  # == Mock Objects and Test Stubs
-  #
-  # The names Mock Object and Test Stub suggest specialized Test Doubles.  i.e.
-  # Test Stub evokes Test Double that only supports method stubs, and a Mock
-  # Object evokes a Test Double that only supports message expectations, or
-  # sometimes supports message expectations in addition to method stubs.
-  #
-  # There is a lot of overlapping nomenclature here, and there are many
-  # variations of these patterns (fakes, spies, etc). Keep in mind that most of
-  # the time we're talking about method-level concepts that are variations of
-  # method stubs and message expectations, and we're applying to them to _one_
-  # generic kind of object: a Test Double.
-  #
-  # == Test-Specific Extension
-  #
-  # a.k.a. Partial Stub/Mock, a Test-Specific Extension is an extension of a
-  # real object in a system that is instrumented with test-double like
-  # behaviour in the context of a test. This technique is very common in Ruby
-  # because we often see class objects acting as global namespaces for methods.
-  # For example, in Rails:
-  #
-  #   person = double("person")
-  #   Person.stub(:find) { person }
-  #
-  # In this case we're instrumenting Person to return the person object we've
-  # defined whenever it receives the +find+ message. We can do this with any
-  # object in a system because RSpec adds the +stub+ and +should_receive+
-  # methods to every object. When we use either, RSpec replaces the method
-  # we're stubbing or mocking with it's own test-double-like method. At the
-  # end of the example, RSpec verifies any message expectations, and then
-  # restores the original methods.
-  # 
-  # == Expecting Arguments
-  #
-  #   double.should_receive(:msg).with(*args)
-  #   double.should_not_receive(:msg).with(*args)
-  #
-  # == Argument Matchers
-  #
-  # Arguments that are passed to #with are compared with actual arguments received
-  # using == by default. In cases in which you want to specify things about the arguments
-  # rather than the arguments themselves, you can use any of RSpec's Expression Matchers.
-  # They don't all make syntactic sense (they were primarily designed for use with
-  # RSpec::Expectations), but you are free to create your own custom RSpec::Matchers.
-  #
-  # RSpec::Mocks does provide one additional Matcher method named #ducktype.
-  #
-  # In addition, RSpec::Mocks adds some keyword Symbols that you can use to
-  # specify certain kinds of arguments:
-  #
-  #   double.should_receive(:msg).with(no_args())
-  #   double.should_receive(:msg).with(any_args())
-  #   double.should_receive(:msg).with(1, kind_of(Numeric), "b") #2nd argument can any kind of Numeric
-  #   double.should_receive(:msg).with(1, boolean(), "b") #2nd argument can true or false
-  #   double.should_receive(:msg).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
-  #   double.should_receive(:msg).with(1, anything(), "b") #2nd argument can be anything at all
-  #   double.should_receive(:msg).with(1, ducktype(:abs, :div), "b")
-  #                            #2nd argument can be object that responds to #abs and #div
-  #                                                                       
-  # == Receive Counts
-  #
-  #   double.should_receive(:msg).once
-  #   double.should_receive(:msg).twice
-  #   double.should_receive(:msg).exactly(n).times
-  #   double.should_receive(:msg).at_least(:once)
-  #   double.should_receive(:msg).at_least(:twice)
-  #   double.should_receive(:msg).at_least(n).times
-  #   double.should_receive(:msg).at_most(:once)
-  #   double.should_receive(:msg).at_most(:twice)
-  #   double.should_receive(:msg).at_most(n).times
-  #   double.should_receive(:msg).any_number_of_times
-  #
-  # == Ordering
-  #
-  #   double.should_receive(:msg).ordered
-  #   double.should_receive(:other_msg).ordered
-  #     #This will fail if the messages are received out of order
-  #
-  # == Setting Reponses
-  #
-  # Whether you are setting a message expectation or a method stub, you can
-  # tell the object precisely how to respond. The most generic way is to pass
-  # a block to +stub+ or +should_receive+:
-  #
-  #   double.should_receive(:msg) { value }
-  #
-  # When the double receives the +msg+ message, it evaluates the block and returns
-  # the result.
-  #
-  #   double.should_receive(:msg).and_return(value)
-  #   double.should_receive(:msg).exactly(3).times.and_return(value1, value2, value3)
-  #     # returns value1 the first time, value2 the second, etc
-  #   double.should_receive(:msg).and_raise(error)
-  #     #error can be an instantiated object or a class
-  #     #if it is a class, it must be instantiable with no args
-  #   double.should_receive(:msg).and_throw(:msg)
-  #   double.should_receive(:msg).and_yield(values,to,yield)
-  #   double.should_receive(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
-  #     # for methods that yield to a block multiple times
-  #
-  # Any of these responses can be applied to a stub as well
-  #
-  #   double.stub(:msg).and_return(value)
-  #   double.stub(:msg).and_return(value1, value2, value3)
-  #   double.stub(:msg).and_raise(error)
-  #   double.stub(:msg).and_throw(:msg)
-  #   double.stub(:msg).and_yield(values,to,yield)
-  #   double.stub(:msg).and_yield(values,to,yield).and_yield(some,other,values,this,time)
-  #
-  # == Arbitrary Handling
-  #
-  # Once in a while you'll find that the available expectations don't solve the
-  # particular problem you are trying to solve. Imagine that you expect the message
-  # to come with an Array argument that has a specific length, but you don't care
-  # what is in it. You could do this:
-  #
-  #   double.should_receive(:msg) do |arg|
-  #     arg.should be_an_istance_of(Array)
-  #     arg.length.should == 7
-  #   end
-  #
-  # == Combining Expectation Details
-  #
-  # Combining the message name with specific arguments, receive counts and responses
-  # you can get quite a bit of detail in your expectations:
-  #
-  #   double.should_receive(:<<).with("illegal value").once.and_raise(ArgumentError)
-  #
-  # == Further Reading
-  # 
-  # There are many different viewpoints about the meaning of mocks and stubs. If you are interested
-  # in learning more, here is some recommended reading:
-  # 
-  # * Mock Objects: http://www.mockobjects.com/
-  # * Endo-Testing: http://www.mockobjects.com/files/endotesting.pdf
-  # * Mock Roles, Not Objects: http://www.mockobjects.com/files/mockrolesnotobjects.pdf
-  # * Test Double Patterns: http://xunitpatterns.com/Test%20Double%20Patterns.html
-  # * Mocks aren't stubs: http://www.martinfowler.com/articles/mocksArentStubs.html
-  module Mocks
-    class << self
-      attr_accessor :space
-
-      def setup(includer)
-        Object.class_eval { include RSpec::Mocks::Methods } unless Object < RSpec::Mocks::Methods
-        (class << includer; self; end).class_eval do
-          include RSpec::Mocks::ExampleMethods
-        end
-        self.space ||= RSpec::Mocks::Space.new
-      end
-
-      def verify
-        space.verify_all
-      end
-
-      def teardown
-        space.reset_all
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-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

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

@@ -1,233 +0,0 @@
-module RSpec
-  module Mocks
-
-    # ArgumentMatchers are messages that you can include in message
-    # expectations to match arguments against a broader check than simple
-    # equality.
-    #
-    # With the exception of any_args() and no_args(), the matchers
-    # are all positional - they match against the arg in the given position.
-    module ArgumentMatchers
-
-      class AnyArgsMatcher
-        def description
-          "any args"
-        end
-      end
-
-      class AnyArgMatcher
-        def initialize(ignore)
-        end
-
-        def ==(other)
-          true
-        end
-      end
-
-      class NoArgsMatcher
-        def description
-          "no args"
-        end
-      end
-
-      class RegexpMatcher
-        def initialize(regexp)
-          @regexp = regexp
-        end
-
-        def ==(value)
-          return value =~ @regexp unless value.is_a?(Regexp)
-          value == @regexp
-        end
-      end
-
-      class BooleanMatcher
-        def initialize(ignore)
-        end
-
-        def ==(value)
-          TrueClass === value || FalseClass === value
-        end
-      end
-
-      class HashIncludingMatcher
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def ==(actual)
-          @expected.each do | key, value |
-            return false unless actual.has_key?(key) && value == actual[key]
-          end
-          true
-        rescue NoMethodError => ex
-          return false
-        end
-
-        def description
-          "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
-        end
-      end
-      
-      class HashNotIncludingMatcher
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def ==(actual)
-          @expected.each do | key, value |
-            return false if actual.has_key?(key) && value == actual[key]
-          end
-          true
-        rescue NoMethodError => ex
-          return false
-        end
-
-        def description
-          "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
-        end
-      end
-      
-      class DuckTypeMatcher
-        def initialize(*methods_to_respond_to)
-          @methods_to_respond_to = methods_to_respond_to
-        end
-
-        def ==(value)
-          @methods_to_respond_to.all? { |sym| value.respond_to?(sym) }
-        end
-      end
-
-      class MatcherMatcher
-        def initialize(matcher)
-          @matcher = matcher
-        end
-
-        def ==(value)
-          @matcher.matches?(value)
-        end
-      end
-
-      class EqualityProxy
-        def initialize(given)
-          @given = given
-        end
-
-        def ==(expected)
-          @given == expected
-        end
-      end
-      
-      class InstanceOf
-        def initialize(klass)
-          @klass = klass
-        end
-        
-        def ==(actual)
-          actual.instance_of?(@klass)
-        end
-      end
-      
-      class KindOf
-        def initialize(klass)
-          @klass = klass
-        end
-        
-        def ==(actual)
-          actual.kind_of?(@klass)
-        end
-      end
-
-      # :call-seq:
-      #   object.should_receive(:message).with(any_args())
-      #
-      # Passes if object receives :message with any args at all. This is
-      # really a more explicit variation of object.should_receive(:message)
-      def any_args
-        AnyArgsMatcher.new
-      end
-      
-      # :call-seq:
-      #   object.should_receive(:message).with(anything())
-      #
-      # Passes as long as there is an argument.
-      def anything
-        AnyArgMatcher.new(nil)
-      end
-      
-      # :call-seq:
-      #   object.should_receive(:message).with(no_args)
-      #
-      # Passes if no arguments are passed along with the message
-      def no_args
-        NoArgsMatcher.new
-      end
-      
-      # :call-seq:
-      #   object.should_receive(:message).with(duck_type(:hello))
-      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
-      #
-      # Passes if the argument responds to the specified messages.
-      #
-      # == Examples
-      #
-      #   array = []
-      #   display = double('display')
-      #   display.should_receive(:present_names).with(duck_type(:length, :each))
-      #   => passes
-      def duck_type(*args)
-        DuckTypeMatcher.new(*args)
-      end
-
-      # :call-seq:
-      #   object.should_receive(:message).with(boolean())
-      #
-      # Passes if the argument is boolean.
-      def boolean
-        BooleanMatcher.new(nil)
-      end
-      
-      # :call-seq:
-      #   object.should_receive(:message).with(hash_including(:key => val))
-      #   object.should_receive(:message).with(hash_including(:key))
-      #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
-      # Passes if the argument is a hash that includes the specified key(s) or key/value
-      # pairs. If the hash includes other keys, it will still pass.
-      def hash_including(*args)
-        HashIncludingMatcher.new(anythingize_lonely_keys(*args))
-      end
-      
-      # :call-seq:
-      #   object.should_receive(:message).with(hash_not_including(:key => val))
-      #   object.should_receive(:message).with(hash_not_including(:key))
-      #   object.should_receive(:message).with(hash_not_including(:key, :key2 => :val2))
-      #
-      # Passes if the argument is a hash that doesn't include the specified key(s) or key/value
-      def hash_not_including(*args)
-        HashNotIncludingMatcher.new(anythingize_lonely_keys(*args))
-      end
-      
-      # Passes if arg.instance_of?(klass)
-      def instance_of(klass)
-        InstanceOf.new(klass)
-      end
-      
-      alias_method :an_instance_of, :instance_of
-      
-      # Passes if arg.kind_of?(klass)
-      def kind_of(klass)
-        KindOf.new(klass)
-      end
-      
-      alias_method :a_kind_of, :kind_of
-      
-      private
-      
-      def anythingize_lonely_keys(*args)
-        hash = args.last.class == Hash ? args.delete_at(-1) : {}
-        args.each { | arg | hash[arg] = anything }
-        hash
-      end
-    end
-  end
-end