simple-client 0.0.2

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/rack_response.rb

@@ -0,0 +1,63 @@
+module WebMock
+  class RackResponse < Response
+    def initialize(app)
+      @app = app
+    end
+
+    def evaluate(request)
+      env = build_rack_env(request)
+
+      status, headers, response = @app.call(env)
+
+      Response.new(
+        :body => body_from_rack_response(response),
+        :headers => headers,
+        :status => status
+      )
+    end
+
+    def body_from_rack_response(response)
+      body = ""
+      response.each { |line| body << line }
+      response.close if response.respond_to?(:close)
+      return body
+    end
+
+    def build_rack_env(request)
+      uri = request.uri
+      headers = request.headers || {}
+      body = request.body || ''
+
+      env = {
+        # CGI variables specified by Rack
+        'REQUEST_METHOD' => request.method.to_s.upcase,
+        'CONTENT_TYPE'   => headers.delete('Content-Type'),
+        'CONTENT_LENGTH' => body.size,
+        'PATH_INFO'      => uri.path,
+        'QUERY_STRING'   => uri.query || '',
+        'SERVER_NAME'    => uri.host,
+        'SERVER_PORT'    => uri.port,
+        'SCRIPT_NAME'    => ""
+      }
+
+      env['HTTP_AUTHORIZATION'] = 'Basic ' + [uri.userinfo].pack('m').delete("\r\n") if uri.userinfo
+
+      # Rack-specific variables
+      env['rack.input']      = StringIO.new(body)
+      env['rack.version']    = Rack::VERSION
+      env['rack.url_scheme'] = uri.scheme
+      env['rack.run_once']   = true
+      env['rack.session']    = session
+
+      headers.each do |k, v|
+        env["HTTP_#{k.tr('-','_').upcase}"] = v
+      end
+
+      env
+    end
+
+    def session
+      @session ||= {}
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/request_execution_verifier.rb

@@ -0,0 +1,56 @@
+module WebMock
+  class RequestExecutionVerifier
+
+    attr_accessor :request_pattern, :expected_times_executed, :times_executed
+
+    def initialize(request_pattern = nil, expected_times_executed = nil)
+      @request_pattern = request_pattern
+      @expected_times_executed = expected_times_executed
+    end
+
+    def matches?
+      @times_executed =
+      RequestRegistry.instance.times_executed(@request_pattern)
+      @times_executed == (@expected_times_executed || 1)
+    end
+
+    def does_not_match?
+      @times_executed =
+      RequestRegistry.instance.times_executed(@request_pattern)
+      if @expected_times_executed
+        @times_executed != @expected_times_executed
+      else
+        @times_executed == 0
+      end
+    end
+
+
+    def failure_message
+      expected_times_executed = @expected_times_executed || 1
+      text = %Q(The request #{request_pattern.to_s} was expected to execute #{times(expected_times_executed)} but it executed #{times(times_executed)})
+      text << self.class.executed_requests_message
+      text
+    end
+
+    def negative_failure_message
+      text = if @expected_times_executed
+        %Q(The request #{request_pattern.to_s} was not expected to execute #{times(expected_times_executed)} but it executed #{times(times_executed)})
+      else
+        %Q(The request #{request_pattern.to_s} was expected to execute 0 times but it executed #{times(times_executed)})
+      end
+      text << self.class.executed_requests_message
+      text
+    end
+
+    def self.executed_requests_message
+      "\n\nThe following requests were made:\n\n#{RequestRegistry.instance.to_s}\n" + "="*60
+    end
+
+    private
+
+    def times(times)
+      "#{times} time#{ (times == 1) ? '' : 's'}"
+    end
+
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/request_pattern.rb

@@ -0,0 +1,282 @@
+module WebMock
+
+  module RSpecMatcherDetector
+    def rSpecHashIncludingMatcher?(matcher)
+      matcher.class.name =~ /R?Spec::Mocks::ArgumentMatchers::HashIncludingMatcher/
+    end
+  end
+
+  class RequestPattern
+
+    attr_reader :method_pattern, :uri_pattern, :body_pattern, :headers_pattern
+
+    def initialize(method, uri, options = {})
+      @method_pattern  = MethodPattern.new(method)
+      @uri_pattern     = create_uri_pattern(uri)
+      @body_pattern    = nil
+      @headers_pattern = nil
+      @with_block      = nil
+      assign_options(options)
+    end
+
+    def with(options = {}, &block)
+      assign_options(options)
+      @with_block = block
+      self
+    end
+
+    def matches?(request_signature)
+      content_type = request_signature.headers['Content-Type'] if request_signature.headers
+      content_type = content_type.split(';').first if content_type
+      @method_pattern.matches?(request_signature.method) &&
+        @uri_pattern.matches?(request_signature.uri) &&
+        (@body_pattern.nil? || @body_pattern.matches?(request_signature.body, content_type || "")) &&
+        (@headers_pattern.nil? || @headers_pattern.matches?(request_signature.headers)) &&
+        (@with_block.nil? || @with_block.call(request_signature))
+    end
+
+    def to_s
+      string = "#{@method_pattern.to_s.upcase}"
+      string << " #{@uri_pattern.to_s}"
+      string << " with body #{@body_pattern.to_s}" if @body_pattern
+      string << " with headers #{@headers_pattern.to_s}" if @headers_pattern
+      string << " with given block" if @with_block
+      string
+    end
+
+    private
+
+
+    def assign_options(options)
+      @body_pattern = BodyPattern.new(options[:body]) if options.has_key?(:body)
+      @headers_pattern = HeadersPattern.new(options[:headers]) if options.has_key?(:headers)
+      @uri_pattern.add_query_params(options[:query]) if options.has_key?(:query)
+    end
+
+    def create_uri_pattern(uri)
+      if uri.is_a?(Regexp)
+        URIRegexpPattern.new(uri)
+      else
+        URIStringPattern.new(uri)
+      end
+    end
+
+  end
+
+
+  class MethodPattern
+    def initialize(pattern)
+      @pattern = pattern
+    end
+
+    def matches?(method)
+      @pattern == method || @pattern == :any
+    end
+
+    def to_s
+      @pattern.to_s
+    end
+  end
+
+
+  class URIPattern
+    include RSpecMatcherDetector
+
+    def initialize(pattern)
+      @pattern = pattern.is_a?(Addressable::URI) ? pattern : WebMock::Util::URI.normalize_uri(pattern)
+      @query_params = nil
+    end
+
+    def add_query_params(query_params)
+      @query_params = if query_params.is_a?(Hash)
+        query_params
+      elsif query_params.is_a?(WebMock::Matchers::HashIncludingMatcher)
+        query_params
+      elsif rSpecHashIncludingMatcher?(query_params)
+        WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(query_params)
+      else
+        Addressable::URI.parse('?' + query_params).query_values
+      end
+    end
+
+    def to_s
+      str = @pattern.inspect
+      str += " with query params #{@query_params.inspect}" if @query_params
+      str
+    end
+  end
+
+  class URIRegexpPattern  < URIPattern
+    def matches?(uri)
+      WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) } &&
+        (@query_params.nil? || @query_params == uri.query_values)
+    end
+
+    def to_s
+      str = @pattern.inspect
+      str += " with query params #{@query_params.inspect}" if @query_params
+      str
+    end
+  end
+
+  class URIStringPattern < URIPattern
+    def matches?(uri)
+      if @pattern.is_a?(Addressable::URI)
+        if @query_params
+          uri.omit(:query) === @pattern && (@query_params.nil? || @query_params == uri.query_values)
+        else
+          uri === @pattern
+        end
+      else
+        false
+      end
+    end
+
+    def add_query_params(query_params)
+      super
+      if @query_params.is_a?(Hash) || @query_params.is_a?(String)
+        @pattern.query_values = (@pattern.query_values || {}).merge(@query_params)
+        @query_params = nil
+      end
+    end
+
+    def to_s
+      str = WebMock::Util::URI.strip_default_port_from_uri_string(@pattern.to_s)
+      str += " with query params #{@query_params.inspect}" if @query_params
+      str
+    end
+  end
+
+
+  class BodyPattern
+    include RSpecMatcherDetector
+
+    BODY_FORMATS = {
+      'text/xml'               => :xml,
+      'application/xml'        => :xml,
+      'application/json'       => :json,
+      'text/json'              => :json,
+      'application/javascript' => :json,
+      'text/javascript'        => :json,
+      'text/html'              => :html,
+      'application/x-yaml'     => :yaml,
+      'text/yaml'              => :yaml,
+      'text/plain'             => :plain
+    }
+
+    def initialize(pattern)
+      @pattern = if pattern.is_a?(Hash)
+        normalize_hash(pattern)
+      elsif rSpecHashIncludingMatcher?(pattern)
+        WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(pattern)
+      else
+        pattern
+      end
+    end
+
+    def matches?(body, content_type = "")
+      if (@pattern).is_a?(Hash)
+        return true if @pattern.empty?
+        matching_hashes?(body_as_hash(body, content_type), @pattern)
+      elsif (@pattern).is_a?(WebMock::Matchers::HashIncludingMatcher)
+        @pattern == body_as_hash(body, content_type)
+      else
+        empty_string?(@pattern) && empty_string?(body) ||
+          @pattern == body ||
+          @pattern === body
+      end
+    end
+
+    def to_s
+      @pattern.inspect
+    end
+
+    private
+    def body_as_hash(body, content_type)
+      case BODY_FORMATS[content_type]
+      when :json then
+        WebMock::Util::JSON.parse(body)
+      when :xml then
+        Crack::XML.parse(body)
+      else
+        Addressable::URI.parse('?' + body).query_values
+      end
+    end
+
+    # Compare two hashes for equality
+    #
+    # For two hashes to match they must have the same length and all
+    # values must match when compared using `#===`.
+    #
+    # The following hashes are examples of matches:
+    #
+    #     {a: /\d+/} and {a: '123'}
+    #
+    #     {a: '123'} and {a: '123'}
+    #
+    #     {a: {b: /\d+/}} and {a: {b: '123'}}
+    #
+    #     {a: {b: 'wow'}} and {a: {b: 'wow'}}
+    #
+    # @param [Hash] query_parameters typically the result of parsing
+    #   JSON, XML or URL encoded parameters.
+    #
+    # @param [Hash] pattern which contains keys with a string, hash or
+    #   regular expression value to use for comparison.
+    #
+    # @return [Boolean] true if the paramaters match the comparison
+    #   hash, false if not.
+    def matching_hashes?(query_parameters, pattern)
+      return false unless query_parameters.is_a?(Hash)
+      return false unless query_parameters.keys.sort == pattern.keys.sort
+      query_parameters.each do |key, actual|
+        expected = pattern[key]
+
+        if actual.is_a?(Hash) && expected.is_a?(Hash)
+          return false unless matching_hashes?(actual, expected)
+        else
+          return false unless expected === actual
+        end
+      end
+      true
+    end
+
+    def empty_string?(string)
+      string.nil? || string == ""
+    end
+
+    def normalize_hash(hash)
+      Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(hash).sort]
+    end
+
+  end
+
+  class HeadersPattern
+    def initialize(pattern)
+      @pattern = WebMock::Util::Headers.normalize_headers(pattern) || {}
+    end
+
+    def matches?(headers)
+      if empty_headers?(@pattern)
+        empty_headers?(headers)
+      else
+        return false if empty_headers?(headers)
+        @pattern.each do |key, value|
+          return false unless headers.has_key?(key) && value === headers[key]
+        end
+        true
+      end
+    end
+
+    def to_s
+      WebMock::Util::Headers.sorted_headers_string(@pattern)
+    end
+
+    private
+
+    def empty_headers?(headers)
+      headers.nil? || headers == {}
+    end
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/request_registry.rb

@@ -0,0 +1,35 @@
+module WebMock
+
+  class RequestRegistry
+    include Singleton
+
+    attr_accessor :requested_signatures
+
+    def initialize
+      reset!
+    end
+
+    def reset!
+      self.requested_signatures = Util::HashCounter.new
+    end
+
+    def times_executed(request_pattern)
+      self.requested_signatures.hash.select { |request_signature, times_executed|
+        request_pattern.matches?(request_signature)
+      }.inject(0) {|sum, (_, times_executed)| sum + times_executed }
+    end
+
+    def to_s
+      if requested_signatures.hash.empty?
+        "No requests were made."
+      else
+        text = ""
+        self.requested_signatures.each do |request_signature, times_executed|
+          text << "#{request_signature} was made #{times_executed} time#{times_executed == 1 ? '' : 's' }\n"
+        end
+        text
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/request_signature.rb

@@ -0,0 +1,50 @@
+module WebMock
+
+  class RequestSignature
+
+    attr_accessor :method, :uri, :body
+    attr_reader :headers
+
+    def initialize(method, uri, options = {})
+      self.method = method
+      self.uri = uri.is_a?(Addressable::URI) ? uri : WebMock::Util::URI.normalize_uri(uri)
+      assign_options(options)
+    end
+
+    def to_s
+      string = "#{self.method.to_s.upcase}"
+      string << " #{WebMock::Util::URI.strip_default_port_from_uri_string(self.uri.to_s)}"
+      string << " with body '#{body.to_s}'" if body && body.to_s != ''
+      if headers && !headers.empty?
+        string << " with headers #{WebMock::Util::Headers.sorted_headers_string(headers)}"
+      end
+      string
+    end
+
+    def headers=(headers)
+      @headers = WebMock::Util::Headers.normalize_headers(headers)
+    end
+
+    def hash
+      self.to_s.hash
+    end
+
+    def eql?(other)
+      self.to_s == other.to_s
+    end
+    alias == eql?
+
+    def url_encoded?
+      headers && headers['Content-Type'] == 'application/x-www-form-urlencoded'
+    end
+
+    private
+
+    def assign_options(options)
+      self.body = options[:body] if options.has_key?(:body)
+      self.headers = options[:headers] if options.has_key?(:headers)
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/webmock-1.8.8/lib/webmock/request_stub.rb

@@ -0,0 +1,97 @@
+module WebMock
+  class RequestStub
+
+    attr_accessor :request_pattern
+
+    def initialize(method, uri)
+      @request_pattern = RequestPattern.new(method, uri)
+      @responses_sequences = []
+      self
+    end
+
+    def with(params = {}, &block)
+      @request_pattern.with(params, &block)
+      self
+    end
+
+    def to_return(*response_hashes, &block)
+      if block
+        @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(block)])
+      else
+        @responses_sequences << ResponsesSequence.new([*response_hashes].flatten.map {|r| ResponseFactory.response_for(r)})
+      end
+      self
+    end
+
+    def to_rack(app, options={})
+      @responses_sequences << ResponsesSequence.new([RackResponse.new(app)])
+    end
+
+    def to_raise(*exceptions)
+      @responses_sequences << ResponsesSequence.new([*exceptions].flatten.map {|e|
+        ResponseFactory.response_for(:exception => e)
+      })
+      self
+    end
+
+    def to_timeout
+      @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(:should_timeout => true)])
+      self
+    end
+
+    def response
+      if @responses_sequences.empty?
+        WebMock::Response.new
+      elsif @responses_sequences.length > 1
+        @responses_sequences.shift if @responses_sequences.first.end?
+        @responses_sequences.first.next_response
+      else
+        @responses_sequences[0].next_response
+      end
+    end
+
+    def has_responses?
+      !@responses_sequences.empty?
+    end
+
+    def then
+      self
+    end
+
+    def times(number)
+      raise "times(N) accepts integers >= 1 only" if !number.is_a?(Fixnum) || number < 1
+      if @responses_sequences.empty?
+        raise "Invalid WebMock stub declaration." +
+          " times(N) can be declared only after response declaration."
+      end
+      @responses_sequences.last.times_to_repeat += number-1
+      self
+    end
+
+    def matches?(request_signature)
+      self.request_pattern.matches?(request_signature)
+    end
+
+    def to_s
+      self.request_pattern.to_s
+    end
+
+    def self.from_request_signature(signature)
+      stub = self.new(signature.method.to_sym, signature.uri.to_s)
+
+      if signature.body.to_s != ''
+        body = if signature.url_encoded?
+          Addressable::URI.parse('?' + signature.body).query_values
+        else
+          signature.body
+        end
+        stub.with(:body => body)
+      end
+
+      if (signature.headers && !signature.headers.empty?)
+        stub.with(:headers => signature.headers)
+      end
+      stub
+    end
+  end
+end