http_vanilli 0.0.2

data/lib/angry_web/matcher.rb

@@ -0,0 +1,105 @@
+require 'addressable/uri'
+require 'rack'
+require 'pp'
+
+class Object
+  def tapp(tag=nil)
+    print "#{tag}=" if tag
+    pp self
+    self
+  end
+end
+
+class AngryWeb
+  class ValueMatcher
+    attr_reader :mismatch_reason
+    def initialize(value)
+      @mismatch_reason = "<no reason>"
+      @value = value
+    end
+  end
+
+  class HashSubsetMatcher < ValueMatcher
+    def match?(params)
+      @value.keys.all? do |k|
+        match = @value[k]
+        param = params[k.to_s]
+
+        case match
+        when Regexp
+          !! param[match]
+        else
+          match == param
+        end
+      end
+    end
+  end
+
+  class REMatcher < ValueMatcher
+    def match?(other)
+      other.to_s.match(@value)
+    end
+  end
+
+  class EqlMatcher < ValueMatcher
+    def match?(other)
+      @value == other
+    end
+  end
+
+  class Matcher
+    attr_reader :mismatches
+
+    def initialize(&blk)
+      @parts = {}
+      yield self
+    end
+
+    def match?(uri)
+      uri = Addressable::URI.heuristic_parse(uri)
+      uri_hash = uri.to_hash
+
+      @mismatches = []
+
+      @parts.each {|k,v|
+        unless v.match?(__transform_value_from_uri(uri_hash,k))
+          @mismatches << v.mismatch_reason
+        end
+      }
+
+      @mismatches.empty?
+    end
+
+    def hash_subset(spec)
+      HashSubsetMatcher.new(spec)
+    end
+
+    def method_missing(meth,*args,&block)
+      if args.size == 1
+        @parts[meth] = __convert_value(args.first)
+      else
+        super
+      end
+    end
+
+    def __convert_value(value)
+      case value
+      when ValueMatcher
+        value
+      when Regexp
+        REMatcher.new(value)
+      else
+        EqlMatcher.new(value)
+      end
+    end
+
+    def __transform_value_from_uri(uri,key)
+      case key
+      when :params
+        Rack::Utils.parse_query(uri[:query])
+      else
+        uri[key]
+      end
+    end
+  end
+end

data/lib/http_vanilli/abstract_responder.rb

@@ -0,0 +1,13 @@
+module HttpVanilli
+  module AbstractResponder
+    include HttpVanilli::NetHttp::YieldResponse
+
+    def response_for_request(request)
+      code,headers,body = rack_response(request)
+
+      response = HttpVanilli::NetHttp::Response.new(code,headers,body)
+
+      nh_yield_response(response,request)
+    end
+  end
+end

data/lib/http_vanilli/basic_mapper.rb

@@ -0,0 +1,60 @@
+require 'addressable/uri'
+
+module HttpVanilli
+  class BasicMapper
+    attr_accessor :responder
+
+    def initialize(extra_responders = {})
+      responder_classes.update(extra_responders)
+    end
+
+    def responder_classes
+      @responder_classes ||= {
+        :block => HttpVanilli::Responders::Block,
+        :rack  => HttpVanilli::Responders::Rack
+      }
+    end
+
+    def responders; @responders ||= [] end
+
+    def add_block_responder(*args,&block)
+      responders << responder_classes[:block].new(*args,&block)
+    end
+
+    def add_rack_responder(*args,&block)
+      responders << responder_classes[:rack].new(*args,&block)
+    end
+
+    def add_responder(kind,*args,&block)
+      responders << responder_classes[kind].new(*args,&block)
+    end
+
+    ## Mapping API
+
+    # Take the info from the innards of Net::HTTP and build a request.
+    def build_request(kind,http,request,&block)
+      HttpVanilli::Request.build(kind,http,request,&block)
+    end
+
+    # Should we map the request?
+    def map_request?(request)
+      !! find_responder(request)
+    end
+
+    # Map the request
+    def map_request(request)
+      find_responder(request).response_for_request(request)
+    end
+
+    # The request wasn't matched and normal net connection was disallowed.
+    def unmapped_request(request)
+      raise "unmatched_request #{request}"
+    end
+
+    protected
+
+    def find_responder(request)
+      responders.find {|responder| responder.match?(request)}
+    end
+  end
+end

data/lib/http_vanilli/basic_mapping.rb

@@ -0,0 +1,22 @@
+require 'addressable/uri'
+
+module Unused 
+  class BasicMapping
+    include HttpVanilli::NetHttp::YieldResponse
+    
+    def initialize(method,url,&block)
+      @method = method
+      @url    = Addressable::URI.heuristic_parse(url)
+      @block  = block
+    end
+
+    def match?(request)
+      (request.host == @url.host)
+    end
+
+    def rack_response
+      @block[request]
+    end
+
+  end
+end

data/lib/http_vanilli/net_http/override.rb

@@ -0,0 +1,88 @@
+require 'http_vanilli/net_http/stubs'
+require 'http_vanilli/net_http/util'
+require 'http_vanilli/net_http/request'
+require 'http_vanilli/net_http/response'
+require 'net/http'
+require 'net/https'
+require 'stringio'
+
+module HttpVanilli
+  module NetHttp
+    def self.override!
+      record_loaded_net_http_replacement_libs
+      puts_warning_for_net_http_around_advice_libs_if_needed
+    end
+  end
+end
+
+module Net  #:nodoc: all
+  class BufferedIO
+    def initialize_with_http_vanilli(io, debug_output = nil)
+      @read_timeout = 60
+      @rbuf = ''
+      @debug_output = debug_output
+
+      @io = case io
+      when Socket, OpenSSL::SSL::SSLSocket, IO
+        io
+      when String
+        if !io.include?("\0") && File.exists?(io) && !File.directory?(io)
+          File.open(io, "r")
+        else
+          StringIO.new(io)
+        end
+      end
+      raise "Unable to create local socket" unless @io
+    end
+    alias_method :initialize_without_http_vanilli, :initialize
+    alias_method :initialize, :initialize_with_http_vanilli
+  end
+
+  class HTTP
+    class << self
+      def socket_type_with_http_vanilli
+        HttpVanilli::NetHttp::StubSocket
+      end
+      alias_method :socket_type_without_http_vanilli, :socket_type
+      alias_method :socket_type, :socket_type_with_http_vanilli
+    end
+
+    def request_with_http_vanilli(request, body = nil, &block)
+      mapper = HttpVanilli.request_mapper
+
+      request.set_body_internal body
+
+      # Wrap Net::HTTPRequest & associated info in a HttpVanilli::Request
+      vanilli_request = mapper.build_request(:net_http, self, request, &block)
+
+      # The mapper can map the request. Do it.
+      if mapper.map_request?(vanilli_request)
+        @socket = Net::HTTP.socket_type.new
+        mapper.map_request(vanilli_request)
+
+      # otherwise, either allow the request to happen as normal,
+      elsif HttpVanilli.allow_net_connect?
+        connect_without_http_vanilli
+        request_without_http_vanilli(request, body, &block)
+
+      # or note the request as unmapped.
+      else
+        mapper.unmapped_request(vanilli_request)
+      end
+    end
+    alias_method :request_without_http_vanilli, :request
+    alias_method :request, :request_with_http_vanilli
+
+
+    def connect_with_http_vanilli
+      unless @@alredy_checked_for_net_http_replacement_libs ||= false
+        HttpVanilli::NetHttp.puts_warning_for_net_http_replacement_libs_if_needed
+        @@alredy_checked_for_net_http_replacement_libs = true
+      end
+      nil
+    end
+    alias_method :connect_without_http_vanilli, :connect
+    alias_method :connect, :connect_with_http_vanilli
+  end
+
+end

data/lib/http_vanilli/net_http/request.rb

@@ -0,0 +1,33 @@
+require 'http_vanilli/request'
+
+module HttpVanilli
+  module NetHttp
+    class Request < HttpVanilli::Request
+      attr_reader :block, :uri, :method, :original_request
+
+      def initialize(http,request,&block)
+        @http             = http
+        @original_request = request
+        @block            = block
+
+        protocol = http.use_ssl? ? "https" : "http"
+
+        path = request.path
+        path = Addressable::URI.parse(request.path).request_uri if request.path =~ /^https?:/
+
+        @uri    = Addressable::URI.parse( "#{protocol}://#{http.address}:#{http.port}#{path}" )
+        @method = request.method.downcase.to_sym
+      end
+
+      def host; @uri.host end
+
+      def to_s
+        "#{@method} #{@uri.to_s}"
+      end
+
+      def body
+        @original_request.body
+      end
+    end
+  end
+end

data/lib/http_vanilli/net_http/response.rb

@@ -0,0 +1,37 @@
+module HttpVanilli
+  module NetHttp
+    module YieldResponse
+      def nh_yield_response(response,request)
+        nh_rsp = response.to_net_http
+        request.block[nh_rsp] if request.block
+        nh_rsp
+      end
+    end
+
+    class Response < HttpVanilli::Response
+      attr_accessor :headers, :body
+      attr_reader :code, :message
+
+      def initialize(code,headers,body,message=StatusMessage[code.to_i])
+        @code,@body,@message = code.to_i,body,message
+        @headers = headers || {}
+      end
+
+      def body
+        @body.join("")
+      end
+
+      def to_net_http
+        response = Net::HTTPResponse.send(:response_class, code.to_s).new("1.0", code.to_s, message)
+
+        response.instance_variable_set(:@body, body) if body
+        headers.each { |name, value| response[name] = value }
+
+        response.instance_variable_set(:@read, true)
+        response.extend HttpVanilli::NetHttp::ResponseMixin
+
+        response
+      end
+    end
+  end
+end

data/lib/http_vanilli/net_http/stubs.rb

@@ -0,0 +1,25 @@
+module HttpVanilli
+  module NetHttp
+    class StubSocket #:nodoc:
+
+      def initialize(*args)
+      end
+
+      def closed?
+        @closed ||= true
+      end
+
+      def readuntil(*args)
+      end
+
+    end
+
+    module ResponseMixin #:nodoc:
+      def read_body(*args, &block)
+        yield @body if block_given?
+        @body
+      end
+
+    end
+  end
+end

data/lib/http_vanilli/net_http/util.rb

@@ -0,0 +1,36 @@
+module HttpVanilli
+  module NetHttp
+    def self.puts_warning_for_net_http_around_advice_libs_if_needed
+      libs = {"Samuel" => defined?(Samuel)}
+      warnings = libs.select { |_, loaded| loaded }.map do |name, _|
+        <<-TEXT.gsub(/ {10}/, '')
+          \e[1mWarning: HttpVanilli was loaded after #{name}\e[0m
+          * #{name}'s code is being ignored when a request is handled by HttpVanilli::NetHttp,
+            because both libraries work by patching Net::HTTP.
+          * To fix this, just reorder your requires so that HttpVanilli is before #{name}.
+        TEXT
+      end
+      $stderr.puts "\n" + warnings.join("\n") + "\n" if warnings.any?
+    end
+
+    def self.record_loaded_net_http_replacement_libs
+      libs = {"RightHttpConnection" => defined?(RightHttpConnection)}
+      @loaded_net_http_replacement_libs = libs.map { |name, loaded| name if loaded }.compact
+    end
+
+    def self.puts_warning_for_net_http_replacement_libs_if_needed
+      libs = {"RightHttpConnection" => defined?(RightHttpConnection)}
+      warnings = libs.select { |_, loaded| loaded }.
+                    reject { |name, _| @loaded_net_http_replacement_libs.include?(name) }.
+                    map do |name, _|
+        <<-TEXT.gsub(/ {10}/, '')
+          \e[1mWarning: #{name} was loaded after HttpVanilli::NetHttp\e[0m
+          * HttpVanilli's code is being ignored, because #{name} replaces parts of
+            Net::HTTP without deferring to other libraries. This will break Net::HTTP requests.
+          * To fix this, just reorder your requires so that #{name} is before HttpVanilli.
+        TEXT
+      end
+      $stderr.puts "\n" + warnings.join("\n") + "\n" if warnings.any?
+    end
+  end
+end

data/lib/http_vanilli/other_mapper.rb

@@ -0,0 +1,54 @@
+require 'ostruct'
+require 'pp'
+
+module HttpVanilli
+  class OtherMapper
+    def customise_request(&block)
+      @customise_request = block
+    end
+
+    # Take the info from the innards of Net::HTTP and build a request.
+    def build_request(kind,http,request,body,&block)
+      req = OpenStruct.new
+      req.block = block
+
+      pp http
+      pp request.to_hash
+
+      protocol = http.use_ssl? ? "https" : "http"
+
+      path = request.path
+      path = Addressable::URI.parse(request.path).request_uri if request.path =~ /^http/
+
+      req.uri = Addressable::URI.parse( "#{protocol}://#{http.address}:#{http.port}#{path}" )
+      req.method = request.method.downcase.to_sym
+
+      if @customise_request
+        @customise_request[req]
+      end
+
+      req
+    end
+
+    # Should we map the request?
+    def map_request?(request)
+      true
+    end
+
+    # Map the request
+    def map_request(request)
+      response = HttpVanilli::NetHttp::Response.new(200,'cool')
+      response.body = "boddy"
+
+      nhrsp = response.to_net_http
+      request.block[nhrsp] if request.block
+
+      nhrsp
+    end
+
+    # The request wasn't matched and normal net connection was disallowed.
+    def unmapped_request(request)
+      raise "unmatched_request :("
+    end
+  end
+end

data/lib/http_vanilli/request.rb

@@ -0,0 +1,12 @@
+module HttpVanilli
+  class Request
+    def self.build(kind,*args,&block)
+      case kind
+      when :net_http
+        HttpVanilli::NetHttp::Request.new(*args,&block)
+      else
+        raise "Unknown request kind #{kind}"
+      end
+    end
+  end
+end

data/lib/http_vanilli/responders/block.rb

@@ -0,0 +1,19 @@
+module HttpVanilli
+  module Responders
+    class Block
+      include HttpVanilli::AbstractResponder
+
+      def initialize(&block)
+        @block = block
+      end
+
+      def match?(request)
+        !! @block[request]
+      end
+
+      def rack_response(request)
+        @block[request]
+      end
+    end
+  end
+end

data/lib/http_vanilli/responders/rack.rb

@@ -0,0 +1,61 @@
+module HttpVanilli
+  module Responders
+    class Rack
+      include HttpVanilli::AbstractResponder
+
+      def initialize(app_class,*args,&block)
+        @app_class = app_class
+        @args = args
+        @block = block
+      end
+
+      BadStatus = 999
+      def match?(request)
+        rsp = rack_response(request)
+        Array === rsp && rsp.first != BadStatus
+      end
+
+      def rack_response(request)
+        uri = request.uri
+
+        env = {
+          'REQUEST_METHOD' => request.original_request.method,
+          
+          # this'll to for now
+          'SCRIPT_NAME'    => "",
+          'PATH_INFO'      => uri.path,
+
+          'QUERY_STRING'   => uri.query,
+          'SERVER_NAME'    => uri.host,
+          'SERVER_PORT'    => uri.port
+        }
+
+        request.original_request.each_header {|k,v|
+          env["HTTP_#{k.upcase}"] = v
+        }
+
+        rack_input = StringIO.new((request.body || '').to_s)
+        rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
+
+        env.update({"rack.version" => [1,1],
+                     "rack.input"  => rack_input,
+                     "rack.errors" => $stderr,
+
+                     "rack.multithread"  => true,
+                     "rack.multiprocess" => false,
+                     "rack.run_once"     => false,
+
+                     "rack.url_scheme" => request.uri.scheme
+                   })
+
+        app.call(env)
+      end
+
+      def app
+        inner_app = lambda {|l| [BadStatus,{'Content-Type' => 'text/plain'},['']]}
+        @app_class.new(inner_app,*@args,&@block)
+      end
+    end
+  end
+end
+

data/lib/http_vanilli/responders.rb

@@ -0,0 +1,6 @@
+module HttpVanilli
+  module Responders
+    autoload :Block, 'http_vanilli/responders/block'
+    autoload :Rack , 'http_vanilli/responders/rack'
+  end
+end

data/lib/http_vanilli/response.rb

@@ -0,0 +1,46 @@
+module HttpVanilli
+  class Response
+    StatusMessage = {
+      100, 'Continue',
+      101, 'Switching Protocols',
+      200, 'OK',
+      201, 'Created',
+      202, 'Accepted',
+      203, 'Non-Authoritative Information',
+      204, 'No Content',
+      205, 'Reset Content',
+      206, 'Partial Content',
+      300, 'Multiple Choices',
+      301, 'Moved Permanently',
+      302, 'Found',
+      303, 'See Other',
+      304, 'Not Modified',
+      305, 'Use Proxy',
+      307, 'Temporary Redirect',
+      400, 'Bad Request',
+      401, 'Unauthorized',
+      402, 'Payment Required',
+      403, 'Forbidden',
+      404, 'Not Found',
+      405, 'Method Not Allowed',
+      406, 'Not Acceptable',
+      407, 'Proxy Authentication Required',
+      408, 'Request Timeout',
+      409, 'Conflict',
+      410, 'Gone',
+      411, 'Length Required',
+      412, 'Precondition Failed',
+      413, 'Request Entity Too Large',
+      414, 'Request-URI Too Large',
+      415, 'Unsupported Media Type',
+      416, 'Request Range Not Satisfiable',
+      417, 'Expectation Failed',
+      500, 'Internal Server Error',
+      501, 'Not Implemented',
+      502, 'Bad Gateway',
+      503, 'Service Unavailable',
+      504, 'Gateway Timeout',
+      505, 'HTTP Version Not Supported'
+    }
+  end
+end

data/lib/http_vanilli/test_adapters/rspec.rb

@@ -0,0 +1,9 @@
+require 'http_vanilli'
+
+module HttpVanilli
+  module RSpec
+    def stub_web(method, url, &block)
+      HttpVanilli.mapper.add_mapping(method,url,&block)
+    end
+  end
+end

data/lib/http_vanilli/util.rb

@@ -0,0 +1,32 @@
+require 'uri'
+
+module HttpVanilli
+  class Util
+    def self.decode_userinfo_from_header(header)
+      header.sub(/^Basic /, "").unpack("m").first
+    end
+
+    def self.encode_unsafe_chars_in_userinfo(userinfo)
+      unsafe_in_userinfo = /[^#{URI::REGEXP::PATTERN::UNRESERVED};&=+$,]|^(#{URI::REGEXP::PATTERN::ESCAPED})/
+      userinfo.split(":").map { |part| uri_escape(part, unsafe_in_userinfo) }.join(":")
+    end
+
+    def self.strip_default_port_from_uri(uri)
+      case uri
+      when %r{^http://}  then uri.sub(%r{:80(/|$)}, '\1')
+      when %r{^https://} then uri.sub(%r{:443(/|$)}, '\1')
+      else uri
+      end
+    end
+
+    # Wrapper for URI escaping that switches between URI::Parser#escape and
+    # URI.escape for 1.9-compatibility
+    def self.uri_escape(*args)
+      if URI.const_defined?(:Parser)
+        URI::Parser.new.escape(*args)
+      else
+        URI.escape(*args)
+      end
+    end
+  end
+end

data/lib/http_vanilli/version.rb

@@ -0,0 +1,3 @@
+module HttpVanilli
+  Version = '0.0.2'
+end

data/lib/http_vanilli.rb

@@ -0,0 +1,62 @@
+require 'pathname'
+require 'pp'
+
+class Object
+  def tapp(tag=nil)
+    print "#{tag}=" if tag
+    pp self
+    self
+  end
+end
+
+module HttpVanilli
+  autoload :Util   , 'http_vanilli/util'
+
+  autoload :BasicMapper , 'http_vanilli/basic_mapper'
+
+  autoload :AbstractResponder, 'http_vanilli/abstract_responder'
+  autoload :Responders       , 'http_vanilli/responders'
+
+  autoload :Request , 'http_vanilli/request'
+  autoload :Response, 'http_vanilli/response'
+
+  class << self
+    def here
+      @here ||= Pathname(__FILE__).dirname
+    end
+
+    def override_net_http!
+      require here+'http_vanilli/net_http/override'
+      HttpVanilli::NetHttp.override!
+    end
+
+    def allow_net_connect!
+      @allow_net_connect = true
+    end
+
+    def disallow_net_connect!
+      @allow_net_connect = false
+    end
+
+    def allow_net_connect?
+      !(FalseClass === @allow_net_connect)
+    end
+
+    def use_basic_mapper!(extra_responder_classes={})
+      self.request_mapper = BasicMapper.new(extra_responder_classes)
+    end
+
+    def request_mapper=(request_mapper)
+      @request_mapper = request_mapper
+    end
+
+    def request_mapper
+      unless @request_mapper
+        raise "HttpVanilli requires a request mapper.\n" +
+              "Use the basic mapper with HttpVanilli.basic_mapper! ,\n" +
+              "or plug one in with HttpVanilli.request_mapper=Yourmapper.new"
+      end
+      @request_mapper
+    end
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: http_vanilli
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Lachie Cox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-01 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: exemplor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: HttpVanilli gives you lip-synced http connections with pluggable band members for testing.
+email: 
+- lachiec@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/angry_web/matcher.rb
+- lib/http_vanilli/abstract_responder.rb
+- lib/http_vanilli/basic_mapper.rb
+- lib/http_vanilli/basic_mapping.rb
+- lib/http_vanilli/net_http/override.rb
+- lib/http_vanilli/net_http/request.rb
+- lib/http_vanilli/net_http/response.rb
+- lib/http_vanilli/net_http/stubs.rb
+- lib/http_vanilli/net_http/util.rb
+- lib/http_vanilli/other_mapper.rb
+- lib/http_vanilli/request.rb
+- lib/http_vanilli/responders/block.rb
+- lib/http_vanilli/responders/rack.rb
+- lib/http_vanilli/responders.rb
+- lib/http_vanilli/response.rb
+- lib/http_vanilli/test_adapters/rspec.rb
+- lib/http_vanilli/util.rb
+- lib/http_vanilli/version.rb
+- lib/http_vanilli.rb
+has_rdoc: true
+homepage: http://github.com/lachie/http_vanilli
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: http_vanilli
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Flexible web connection mocking lib.
+test_files: []
+