http_request.rb 1.0.7 → 1.1

data/Changelog

@@ -1,3 +1,9 @@
+v1.1
+   * added some testing with test/spec
+	 * fixed some bugs such as uploading files, combine parameters and query string etc.
+	 * supported the HTTP Digest Authentication
+	 * refactoring code...
+
 v1.0.7
    * bug fixing for the ':ajax' and ':xhr' directive
 

data/README.rdoc

@@ -220,13 +220,15 @@ download multiple files from a directory
           </items>'
    HttpRequest.post(:url => 'http://localhost/xml.php', :parameters = xml)
 
+== More examples please check the test directory
+
 == TODO
 
   bug fixing, testing and testing...
 
 == LATEST VERSION
-  1.0.6
+  1.1
 
 == Author
    
-   xianhua.zhou<xianhua.zhou at gmail.com>, homepage: http://my.cnzxh.net
+   xianhua.zhou<xianhua.zhou at gmail.com>

data/lib/http_request.rb

@@ -11,14 +11,13 @@
 #
 # == Version
 # 
-#   v1.0.6
+#   v1.1
 #
-#   Last Change: 7 July, 2009
+#   Last Change: 04 Oct, 2009
 #
 # == Author
 #
 #   xianhua.zhou<xianhua.zhou@gmail.com>
-#   homepage: http://my.cnzxh.net
 #
 #
 require 'cgi'
@@ -26,110 +25,85 @@ require 'net/http'
 require 'net/https'
 require 'net/ftp'
 require 'singleton'
-require 'md5'
+require 'digest/md5'
 require 'stringio'
 
 class HttpRequest
 	include Singleton
+	class << self
+		# version
+		VERSION = '1.1'.freeze
+		def version;VERSION;end
+
+		# avaiabled http methods
+		def http_methods
+			%w{get head post put proppatch lock unlock options propfind delete move copy mkcol trace}
+		end
 
-	# version
-	VERSION = '1.0.7'.freeze
-	def self.version;VERSION;end
+		# return data with or without block
+		def data(response, &block)
+			response.url = @@__url if defined? @@__url
+			block_given? ? block.call(response) : response
+		end
 
-	# avaiabled http methods
-	def self.http_methods
-		%w{get head post put proppatch lock unlock options propfind delete move copy mkcol trace}
-	end
+		# update cookies
+		def update_cookies(response)
+			return unless response.header['set-cookie']
+			response.header['set-cookie'].each {|k|
+				k, v = k.split(';')[0].split('=')
+				@@__cookies[k] = v
+			}
+		end
+
+		# return cookies
+		def cookies
+			@@__cookies
+		end
 
-	# return data with or without block
-	def self.data(response, &block)
-		response.url = @@__url if defined? @@__url
-		block_given? ? block.call(response) : response
+		# check the http resource whether or not available
+		def available?(url, timeout = 5)
+			timeout(timeout) {
+				u = URI(url)
+				s = TCPSocket.new(u.host, u.port)
+				s.close
+			}
+			return true
+		rescue Exception => e
+			return false
+		end
 	end
 
-	# check the http resource whether or not available
-	def self.available?(url, timeout = 5)
-		timeout(timeout) {
-			u = URI(url)
-			s = TCPSocket.new(u.host, u.port)
-			s.close
-		}
-		return true
-	rescue Exception => e
-		return false
+	def data(response, &block)
+		self.class.data(response, &block)
 	end
 
 	# send request by some given parameters
 	def request(method, opt, &block)
-		init_args(method, opt)
-		@options[:method] = method
-
-		# for upload files
-		if @options[:files].is_a?(Array) && 'post'.eql?(method)
-			build_multipart
-		else
-			if @options[:parameters].is_a? Hash
-				@options[:parameters] = @options[:parameters].collect{|k, v| 
-					"#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"
-				}.join('&')
-			end
-		end
 
-		# for proxy
-		http = if @options[:proxy_addr]
-						 if @options[:proxy_user] && @options[:proxy_pass]
-							 Net::HTTP::Proxy(@options[:proxy_addr], @options[:proxy_port], @options[:proxy_user], @options[:proxy_pass]).new(@u.host, @u.port)
-						 else
-							 Net::HTTP::Proxy(@options[:proxy_addr], @options[:proxy_port]).new(@uri.host, @uri.port)
-						 end
-					 else
-						 Net::HTTP.new(@uri.host, @uri.port)
-					 end
+		# parse the @options
+		parse_options(method, opt)
 
-		# ssl support
-		http.use_ssl = true if @uri.scheme =~ /^https$/i
+		# parse and merge for the options[:parameters]
+		parse_parameters
 
-		# sending request and get response 
-		response = send_request http
+		# send http request and get the response
+		response = send_request_and_get_response
 
-		return HttpRequest.data(response, &block) unless @options[:redirect]
+		return data(response, &block) unless @options[:redirect]
 
 		# redirect?
-		case response
-		when Net::HTTPRedirection
-			url = "#{@uri.scheme}://#{@uri.host}#{':' + @uri.port.to_s if @uri.port != 80}"
-			@options[:url] = case response['location']
-											 when /^https?:\/\//i
-												 response['location']
-											 when /^\// 
-												 url + response['location']
-											 when /^(\.\.\/|\.\/)/
-												 paths = (File.dirname(@uri.path) + '/' + response['location']).split('/')
-												 location = []
-												 paths.each {|path|
-													 next if path.empty? || path.eql?('.')
-													 path == '..' ? location.pop : location.push(path)
-												 }
-												 url + '/' + location.join('/')
-											 else
-												 url + File.dirname(@uri.path) + '/' + response['location']
-											 end
-			@redirect_times = @redirect_times.succ
-			raise 'too many redirects...' if @redirect_times > @options[:redirect_limits]
-			request('get', @options, &block)
-		else
-			return HttpRequest.data(response, &block)
-		end
+		process_redirection response, &block
 	end
 
-	# catch all of http requests
+	# catch all available http requests
 	def self.method_missing(method_name, args, &block)
+		@@__cookies = {}
 		method_name = method_name.to_s.downcase
 		raise NoHttpMethodException, "No such http method can be called: #{method_name}" unless self.http_methods.include?(method_name)
 		self.instance.request(method_name, args, &block)
 	end
 
-	# for ftp
+	# for ftp, no plan to add new features to this method except bug fixing
 	def self.ftp(method, options, &block)
 		options = {:url => options} if options.is_a? String
 		options = {:close => true}.merge(options)
@@ -137,12 +111,13 @@ class HttpRequest
 		uri = URI(options[:url])
 		guest_name, guest_pass = 'anonymous', "guest@#{uri.host}"
 		unless options[:username]
-			options[:username], options[:password] = uri.userinfo ? uri.userinfo.split(':') : [guest_name, guest_pass]
+			options[:username], options[:password] = 
+				uri.userinfo ? uri.userinfo.split(':') : [guest_name, guest_pass]
 		end
 		options[:username] = guest_name unless options[:username]
 		options[:password] = guest_pass if options[:password].nil?
 		ftp = Net::FTP.open(uri.host, options[:username], options[:password])
-		return self.data(ftp, &block) unless method
+		return data(ftp, &block) unless method
 		stat = case method.to_sym
 					 when :get_as_string
 						 require 'tempfile'
@@ -168,19 +143,91 @@ class HttpRequest
 					 else
 						 return ftp
 					 end
-		if options[:close] && !block_given?
+		if options[:close] and not block_given?
 			ftp.close
 			stat
 		else
 			ftp.response = stat unless ftp.response
-			self.data(ftp, &block)
+			data(ftp, &block)
 		end
 	end
 
 	private
 
+	def md5(string)
+		Digest::MD5.hexdigest string
+	end
+
+	# get params for the Digest auth
+	# see: http://www.rooftopsolutions.nl/article/223
+	def get_params_for_digest
+		return '' unless @options[:auth_username] and @options[:auth_password]
+		user, passwd = @options[:auth_username], @options[:auth_password]
+		hr = self.class.send @options[:method], 
+			@uri.userinfo ? 
+			@@__url.sub(/:\/\/(.+?)@/, '://') : 
+			@@__url
+		
+		params = HttpRequestParams.parse hr['WWW-Authenticate'].split(' ', 2).last
+		method = @options[:method].upcase
+		cnonce = md5(rand.to_s + Time.new.to_s)
+		nc = "00000001"
+
+		data = []
+		data << md5("#{user}:#{params['realm']}:#{passwd}") \
+		<< params['nonce'] \
+			<< ('%08x' % nc) \
+			<< cnonce \
+			<< params['qop'] \
+			<< md5("#{method}:#{@uri.path}")
+
+		params = params.update({
+			:username => user,
+			:nc => nc,
+			:cnonce => cnonce,
+			:uri => @uri.path,
+			:method => method,
+			:response => md5(data.join(":"))
+		})
+
+		headers = []
+		params.each {|k, v| headers << "#{k}=\"#{v}\"" }
+		headers.join(", ")
+	rescue
+		''
+	end
+
+	# for the Http Auth if need
+	def parse_http_auth
+		if @options[:auth] or
+			@uri.userinfo or
+			(@options[:auth_username] and @options[:auth_password])
+
+			if @options[:auth].is_a? Hash
+				@options[:auth_username] = @options[:auth][:username]
+				@options[:auth_password] = @options[:auth][:password]
+				@options[:auth] = @options[:auth][:type]
+			elsif @uri.userinfo and (!@options[:auth_username] or !@options[:auth_password])
+				@options[:auth_username], @options[:auth_password] = @uri.userinfo.split(/:/, 2)
+			end
+
+			if @options[:auth_username] and @options[:auth_password]
+				# Digest Auth
+				if @options[:auth].to_s == 'digest'
+					digest = get_params_for_digest
+					@headers['Authorization'] = "Digest " + digest unless digest.empty?
+				else
+					# Basic Auth
+					@headers['Authorization'] = "Basic " + 
+						["#{@options[:auth_username]}:#{@options[:auth_password]}"].pack('m').delete!("\r\n")
+				end
+			end
+
+		end
+	end
+
 	# initialize for the http request
-	def init_args(method, options)
+	def parse_options(method, options)
 		options = {:url => options.to_s} if [String, Array].include? options.class
 		@options = {
 			:ssl_port        => 443,
@@ -188,7 +235,8 @@ class HttpRequest
 			:redirect        => true,
 			:url             => nil,
 			:ajax            => false,
-			:xhr             => false
+			:xhr             => false,
+			:method          => method
 		}
 		@options.merge!(options)
 		@@__url = @options[:url]
@@ -197,7 +245,7 @@ class HttpRequest
 		@headers = {
 			'Host'            => @uri.host,
 			'Referer'         => @options[:url],
-			'User-Agent'      => 'HttpRequest.rb ' + VERSION
+			'User-Agent'      => 'HttpRequest.rb ' + self.class.version
 		}
 
 		# support gzip
@@ -207,8 +255,8 @@ class HttpRequest
 		# ajax calls?
 		@headers['X_REQUESTED_WITH'] = 'XMLHttpRequest' if @options[:ajax] or @options[:xhr]
 
-		# Basic Authenication
-		@headers['Authorization'] = "Basic " + [@uri.userinfo].pack('m').delete!("\r\n") if @uri.userinfo
+		# Http Authenication
+		parse_http_auth
 
 		# headers
 		@options[:headers].each {|k, v| @headers[k] = v} if @options[:headers].is_a? Hash
@@ -230,9 +278,25 @@ class HttpRequest
 		@redirect_times = 0 if @options[:redirect]
 	end
 
-	# for upload files by post method
+	# parse parameters for the options[:parameters] and @uri.query
+	def parse_parameters
+		if @options[:parameters].is_a? Hash
+			@options[:parameters] = @options[:parameters].collect{|k, v| 
+					"#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"
+			}.join('&')
+		end
+		@options[:parameters] = '' if @options[:parameters].nil?
+		if not @uri.query.to_s.empty? 
+			@options[:parameters] << (@options[:parameters].empty? ? @uri.query : "&#{@uri.query}")
+		end
+
+		# for uploading files
+		build_multipart	if @options[:files].is_a?(Array) and 'post'.eql?(@options[:method])
+	end
+
+	# for uploading files
 	def build_multipart
-		boundary = MD5.md5(rand.to_s).to_s[0..5]
+		boundary = md5(rand.to_s).to_s[0..5]
 		@headers['Content-type'] = "multipart/form-data, boundary=#{boundary}"
 		multipart = []
 		if @options[:parameters]
@@ -262,35 +326,90 @@ class HttpRequest
 		@options[:parameters] = multipart
 	end
 
+	# send request and get the response by some options
+	def send_request_and_get_response
+		# for proxy
+		http = if @options[:proxy_addr]
+						 if @options[:proxy_user] and @options[:proxy_pass]
+							 Net::HTTP::Proxy(
+								 @options[:proxy_addr], 
+								 @options[:proxy_port], 
+								 @options[:proxy_user], 
+								 @options[:proxy_pass]
+							 ).new(@u.host, @u.port)
+						 else
+							 Net::HTTP::Proxy(
+								 @options[:proxy_addr], 
+								 @options[:proxy_port]
+							 ).new(@uri.host, @uri.port)
+						 end
+					 else
+						 Net::HTTP.new(@uri.host, @uri.port)
+					 end
+
+		# ssl support
+		http.use_ssl = true if @uri.scheme =~ /^https$/i
+
+		# sending request and get response 
+		send_request http
+	end
+
 	# send http request
 	def send_request(http)
-
 		# xml data?
 		if @options[:parameters].to_s[0..4].eql?('<?xml') and @options[:method].eql? 'post'
 			@headers['Content-Type'] = 'application/xml'
 			@headers['Content-Length'] = @options[:parameters].size.to_s
-			@headers['Content-MD5'] = MD5.md5(@options[:parameters]).to_s
-		else
-			# merge parameters
-			parameters = @options[:parameters].to_s
-			@options[:parameters] = "#{@uri.query}" if @uri.query
-			if parameters
-				if @options[:parameters]
-					@options[:parameters] << "&#{parameters}"
-				else
-					@options[:parameters] = "#{parameters}"
-				end
-			end
+			@headers['Content-MD5'] = md5(@options[:parameters]).to_s
 		end
 
 		# GO !!
 		if @options[:method] =~ /^(get|head|options|delete|move|copy|trace|)$/
 			@options[:parameters] = "?#{@options[:parameters]}" if @options[:parameters]
-			http.method(@options[:method]).call("#{@uri.path}#{@options[:parameters] unless @options[:parameters].eql?('?')}", @headers)
+			h = http.method(@options[:method]).call(
+					 "#{@uri.path}#{@options[:parameters] unless @options[:parameters].eql?('?')}", 
+					 @headers
+			)
 		else
-			http.method(@options[:method]).call(@uri.path, @options[:parameters], @headers)
+			h = http.method(@options[:method]).call(@uri.path, @options[:parameters], @headers)
 		end
 
+		self.class.update_cookies h
+		h
+	end
+
+	# process the redirectation if need
+	def process_redirection(response, &block)
+		case response
+		when Net::HTTPRedirection
+			url = "#{@uri.scheme}://#{@uri.host}#{':' + @uri.port.to_s if @uri.port != 80}"
+			@options[:url] = case response['location']
+											 when /^https?:\/\//i
+												 response['location']
+											 when /^\// 
+												 url + response['location']
+											 when /^(\.\.\/|\.\/)/
+												 paths = (File.dirname(@uri.path) + '/' + response['location']).split('/')
+												 location = []
+												 paths.each {|path|
+													 next if path.empty? || path.eql?('.')
+													 path == '..' ? location.pop : location.push(path)
+												 }
+												 url + '/' + location.join('/')
+											 else
+												 url + File.dirname(@uri.path) + '/' + response['location']
+											 end
+			@redirect_times = @redirect_times.succ
+			raise 'too many redirects...' if @redirect_times > @options[:redirect_limits]
+			if @options[:cookies].nil?
+				@options[:cookies] = self.class.cookies
+			else
+				@options[:cookies] = @options[:cookies].update self.class.cookies
+			end
+			request('get', @options, &block)
+		else
+			data(response, &block)
+		end
 	end
 
 end
@@ -302,13 +421,7 @@ module Net
 
 		# get cookies as a hash
 		def cookies
-			cookies = {}
-			return cookies unless @header['set-cookie']
-			@header['set-cookie'].each {|k|
-				k, v = k.split(';')[0].split('=')
-				cookies[k] = v
-			}
-			cookies
+			HttpRequest.cookies
 		end
 
 		# for gzipped body
@@ -342,10 +455,10 @@ module Net
 		# code_100? code_101? code_200? code_201? ... code_505?
 		def method_missing(method_name)
 			case method_name.to_s
-			when /^code_([0-9])xx\?$/
-				is_a? CODE_CLASS_TO_OBJ[$1]
-			when /^code_([0-9]+)\?$/
-				is_a? CODE_TO_OBJ[$1]
+			when /^(code|status)_([0-9])xx\?$/
+				not CODE_CLASS_TO_OBJ[$2].nil? and is_a? CODE_CLASS_TO_OBJ[$2]
+			when /^(code|status)_([0-9]+)\?$/
+				not CODE_TO_OBJ[$2].nil? and is_a? CODE_TO_OBJ[$2]
 			else
 				raise NoHttpMethodException, 'Unknown method of response code!'
 			end
@@ -365,6 +478,55 @@ class Net::FTP
 	end
 end
 
+# from Rack, parsing parameters for the Digest auth
+class HttpRequestParams < Hash
+	def self.parse(str)
+		split_header_value(str).inject(new) do |header, param|
+			k, v = param.split('=', 2)
+			header[k] = dequote(v)
+			header
+		end
+	end
+
+	def self.dequote(str) # From WEBrick::HTTPUtils
+		ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
+		ret.gsub!(/\\(.)/, "\\1")
+		ret
+	end
+
+	def self.split_header_value(str)
+		str.scan( /(\w+\=(?:"[^\"]+"|[^,]+))/n ).collect{ |v| v[0] }
+	end
+
+	def initialize
+		super
+
+		yield self if block_given?
+	end
+
+	def [](k)
+		super k.to_s
+	end
+
+	def []=(k, v)
+		super k.to_s, v.to_s
+	end
+
+	UNQUOTED = ['qop', 'nc', 'stale']
+
+	def to_s
+		inject([]) do |parts, (k, v)|
+			parts << "#{k}=" + (UNQUOTED.include?(k) ? v.to_s : quote(v))
+		parts
+		end.join(', ')
+	end
+
+	def quote(str) # From WEBrick::HTTPUtils
+		'"' << str.gsub(/[\\\"]/o, "\\\1") << '"'
+	end
+end
+
+
 # exception
 class NoHttpMethodException < Exception; end
 

data/test/test_http_request.rb

@@ -0,0 +1,266 @@
+require 'test/spec'
+require File.join(File.dirname(__FILE__), '..', 'lib/http_request.rb')
+
+URL = 'http://localhost:9527'
+hr = HttpRequest
+
+context "some basic http requests" do
+
+	specify "get the first page" do
+		hr.get(URL) do |http|
+			http.body.should.equal 'It Works!'
+			http['content-type'].should.equal 'text/html'
+		end
+		hr.get(URL + '/').body.should.equal 'It Works!'
+	end
+
+	specify "post or get method" do
+		hr.get(URL + "/method/post").body.should.equal 'No'
+		hr.post(URL + "/method/post").body.should.equal 'Yes'
+
+		hr.get(URL + "/method/get").body.should.equal 'Yes'
+		hr.post(URL + "/method/get").body.should.equal 'No'
+	end
+
+	specify "xhr?" do
+		hr.get(:url => URL + "/ajax").body.should.equal 'N'
+		hr.get(:url => URL + "/ajax", :xhr => true).body.should.equal 'Y'
+		hr.get(:url => URL + "/ajax", :ajax => true).body.should.equal 'Y'
+	end
+
+	specify "available http methods" do
+		url = URL + '/get-method-name'
+		hr.get(url).body.should.equal 'GET'
+		hr.post(url).body.should.equal 'POST'
+		hr.put(url).body.should.equal 'PUT'
+		hr.delete(url).body.should.equal 'DELETE'
+		hr.trace(url).body.should.equal 'TRACE'
+		hr.lock(url).body.should.equal 'LOCK'
+		hr.unlock(url).body.should.equal 'UNLOCK'
+		hr.move(url).body.should.equal 'MOVE'
+		hr.copy(url).body.should.equal 'COPY'
+		hr.propfind(url).body.should.equal 'PROPFIND'
+		hr.proppatch(url).body.should.equal 'PROPPATCH'
+		hr.mkcol(url).body.should.equal 'MKCOL'
+
+		hr.options(url).body.should.equal nil 
+		hr.options(url)['content-length'].should.equal 'options'.size.to_s
+
+		hr.head(url).body.should.equal nil
+		hr.head(url)['content-length'].should.equal 'head'.size.to_s
+	end
+
+end
+
+context "some basic requests with parameter" do
+
+	specify "get method" do
+		hr.get(URL + '/get').body.should.equal({}.inspect)
+		hr.get(URL + '/get?&').body.should.equal({}.inspect)
+		hr.get(URL + '/get?&#').body.should.equal({}.inspect)
+		hr.get(URL + '/get?abc=').body.should.equal({'abc' => ''}.inspect)
+
+		hr.get(URL + '/get?lang=Ruby&version=1.9').body.should.equal({
+			'lang' => 'Ruby', 'version' => '1.9'
+		}.inspect)
+
+		hr.get(:url => URL + '/get', :parameters => 'lang=Ruby&version=1.9').body.should.equal({
+			'lang' => 'Ruby', 'version' => '1.9'
+		}.inspect)
+
+		hr.get(:url => URL + '/get', :parameters => {:lang => 'Ruby', :version => 1.9}).body.should.equal({
+			'lang' => 'Ruby', 'version' => '1.9'
+		}.inspect)
+
+		hr.get(:url => URL + '/get?lang=Ruby', :parameters => {:version => 1.9}).body.should.equal({
+			'lang' => 'Ruby', 'version' => '1.9'
+		}.inspect)
+
+		hr.get(:url => URL + '/get', :parameters => {'lang' => 'Ruby', 'version' => '1.9'}).body.should.equal({
+			'lang' => 'Ruby', 'version' => '1.9'
+		}.inspect)
+
+		hr.get(URL + '/get?ids[]=1&ids[]=2').body.should.equal({
+      'ids' => ['1', '2']
+		}.inspect)
+
+		hr.get(:url => URL + '/get', :parameters => 'ids[]=1&ids[]=2').body.should.equal({
+      'ids' => ['1', '2']
+		}.inspect)
+
+		hr.get(URL + '/get?ids[a]=1&ids[b]=2').body.should.equal({
+      'ids' => {'a' => '1', 'b' => '2'}
+		}.inspect)
+
+		hr.get(:url => URL + '/get', :parameters => 'ids[a]=1&ids[b]=2').body.should.equal({
+      'ids' => {'a' => '1', 'b' => '2'}
+		}.inspect)
+
+		hr.get(:url => URL + '/get', :parameters => {'ids[a]' => 1, 'ids[b]' => 2}).body.should.equal({
+      'ids' => {'a' => '1', 'b' => '2'}
+		}.inspect)
+	end
+
+	specify "post method" do
+		hr.post(URL + '/get').body.should.equal({}.inspect)
+		hr.post(URL + '/get?&').body.should.equal({}.inspect)
+		hr.post(URL + '/get?&#').body.should.equal({}.inspect)
+		hr.post(URL + '/get?abc=').body.should.equal({'abc' => ''}.inspect)
+
+		hr.post(URL + '/get?lang=Ruby&version=1.9').body.should.equal({
+			'lang' => 'Ruby', 'version' => '1.9'
+		}.inspect)
+
+		hr.post(:url => URL + '/get', :parameters => 'lang=Ruby&version=1.9').body.should.equal({
+			'lang' => 'Ruby', 'version' => '1.9'
+		}.inspect)
+
+		hr.post(:url => URL + '/get', :parameters => {:lang => 'Ruby', :version => 1.9}).body.should.equal({
+			'lang' => 'Ruby', 'version' => '1.9'
+		}.inspect)
+
+		hr.post(:url => URL + '/get', :parameters => {'lang' => 'Ruby', 'version' => '1.9'}).body.should.equal({
+			'lang' => 'Ruby', 'version' => '1.9'
+		}.inspect)
+
+		hr.post(URL + '/get?ids[]=1&ids[]=2').body.should.equal({
+      'ids' => ['1', '2']
+		}.inspect)
+
+		hr.post(:url => URL + '/get', :parameters => 'ids[]=1&ids[]=2').body.should.equal({
+      'ids' => ['1', '2']
+		}.inspect)
+
+		hr.post(URL + '/get?ids[a]=1&ids[b]=2').body.should.equal({
+      'ids' => {'a' => '1', 'b' => '2'}
+		}.inspect)
+
+		hr.post(:url => URL + '/get', :parameters => 'ids[a]=1&ids[b]=2').body.should.equal({
+      'ids' => {'a' => '1', 'b' => '2'}
+		}.inspect)
+
+		hr.post(:url => URL + '/get', :parameters => {'ids[a]' => 1, 'ids[b]' => 2}).body.should.equal({
+      'ids' => {'a' => '1', 'b' => '2'}
+		}.inspect)
+	end
+
+end
+
+context "http auth" do
+	specify "Basic Auth" do
+		hr.get("http://zhou:password@localhost:9527/auth/basic").body.should.equal "success!"
+		hr.get("http://localhost:9527/auth/basic").body.should.equal ""
+
+		hr.get(
+			:url  => "http://zhou:password@localhost:9527/auth/basic",
+			:auth => :basic
+		).body.should.equal "success!"
+
+		hr.get(
+			:url  => "http://localhost:9527/auth/basic",
+			:auth_username => 'zhou',
+			:auth_password => 'password',
+			:auth => :basic
+		).body.should.equal "success!"
+
+		hr.get(
+			:url  => "http://localhost:9527/auth/basic",
+			:auth => {
+				 :password => 'password',
+				 :username => 'zhou',
+			   :type => :basic
+		   }
+		).body.should.equal "success!"
+
+		hr.get(
+			:url  => "http://localhost:9527/auth/basic",
+			:auth => {
+				 :password => 'password',
+				 :username => 'zhou'
+		   }
+		).body.should.equal "success!"
+	end
+
+	specify "Digest Auth" do
+		hr.get(
+			:url  => "http://zhou:password@localhost:9527/auth/digest",
+			:auth => :digest
+		).body.should.equal "success!"
+
+		hr.get(
+			:url  => "http://localhost:9527/auth/digest",
+			:auth_username => 'zhou',
+			:auth_password => 'password',
+			:auth => :digest
+		).body.should.equal "success!"
+
+		hr.get(
+			:url  => "http://localhost:9527/auth/digest",
+			:auth => {
+				 :password => 'password',
+				 :username => 'zhou',
+			   :type => :digest
+		   }
+		).body.should.equal "success!"
+	end
+
+end
+
+context 'Session && Cookie' do
+	specify "Session" do
+		h = hr.get(URL + "/session")
+		h.body.should.equal "1"
+
+		h = hr.get(:url => URL + "/session", :cookies => h.cookies)
+		h.body.should.equal "2"
+
+		h = hr.get(:url => URL + "/session", :cookies => h.cookies)
+		h.body.should.equal "3"
+
+		h1 = hr.get(URL + "/session")
+		h1.body.should.equal "1"
+
+		h1 = hr.get(:url => URL + "/session", :cookies => h1.cookies)
+		h1.body.should.equal "2"
+
+		h = hr.get(URL + "/session/1")
+		h.body.should.equal "/session/1:/session/2"
+
+		h = hr.get(:url => URL + "/session/1", :redirect => false)
+		h.code_3xx?.should.equal true
+	end
+
+	specify "Cookie" do
+		h = hr.get(URL + "/cookie")
+		h.cookies['name'].should.equal 'zhou'
+	end
+end
+
+context 'upload file' do
+	specify 'upload file' do
+		files = [{:file_name => 'hi.txt', :field_name => 'file', :file_content => 'hi'}]
+		h = hr.post(:url => URL + '/upload_file', :files => files)
+		h.body.should.equal 'hi.txt - hi'
+	end
+
+	specify 'upload file with parameters' do
+		files = [{:file_name => 'hi.txt', :field_name => 'file', :file_content => 'hi'}]
+		h = hr.post(:url => URL + '/upload_file', :files => files, :parameters => {:name => 'Ruby'})
+		h.body.should.equal 'hi.txt - hi' + {'name' => 'Ruby'}.inspect
+	end
+
+	specify 'upload file with parameters and query string' do
+		files = [{:file_name => 'hi.txt', :field_name => 'file', :file_content => 'hi'}]
+		h = hr.post(:url => URL + '/upload_file?version=1.9', :files => files, :parameters => {:name => 'Ruby'})
+		h.body.should.equal 'hi.txt - hi' + {'name' => 'Ruby', 'version' => '1.9'}.inspect
+	end
+
+	specify 'upload 2 files' do
+		files = [
+			{:file_name => 'hi.txt', :field_name => 'file', :file_content => 'hi'},
+			{:file_name => 'ih.txt', :field_name => 'elif', :file_content => 'ih'}
+		]
+		h = hr.post(:url => URL + '/upload_file2', :files => files)
+		h.body.should.equal 'hi.txt - hi, ih.txt - ih' 
+	end
+end

data/test/web_server.rb

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rack'
+include Rack
+
+builder = Builder.new do
+
+	map '/' do
+		run lambda {|env| 
+			[200, {'Content-Type' => 'text/html'}, 'It Works!']
+		}
+	end
+
+	map '/get' do
+		run lambda {|env|
+			[200, {'Content-Type' => 'text/html'}, Request.new(env).params.inspect]
+		}
+	end
+
+	map '/post' do
+		run lambda {|env|
+			[200, {'Content-Type' => 'text/html'}, Request.new(env).params.inspect]
+		}
+	end
+
+	map '/ajax' do
+		run lambda {|env|
+			[200, {'Content-Type' => 'text/html'}, Request.new(env).xhr? ? 'Y' : 'N']
+		}
+	end
+
+	map '/method/post' do
+		run lambda {|env|
+			body = Request.new(env).post? ? 'Yes' : 'No'
+			[200, {'Content-Type' => 'text/html'}, body]
+		}
+	end
+
+	map '/method/get' do
+		run lambda {|env|
+			body = Request.new(env).get? ? 'Yes' : 'No'
+			[200, {'Content-Type' => 'text/html'}, body]
+		}
+	end
+
+	map '/get-method-name' do
+		run lambda {|env|
+			[200, {'Content-Type' => 'text/html'}, Request.new(env).request_method]
+		}
+	end
+
+	map '/auth/basic' do
+		auths = {:username => 'zhou', :password => 'password'}
+
+		app = lambda {|env|
+			headers = {
+         'Content-Type'       => 'text/html'
+			}
+			[200, headers, 'success!']
+		}
+
+		app = Auth::Basic.new(app) {|user, pass| 
+			auths[:username] == user and auths[:password] == pass
+		}
+		app.realm = 'HttpRequest'
+		run app
+	end
+
+	map '/auth/digest' do
+		auths = {:username => 'zhou', :password => 'password'}
+		realm = 'HttpRequest'
+
+		app = lambda {|env|
+			headers = {
+         'Content-Type'       => 'text/html'
+			}
+			[200, headers, 'success!']
+		}
+
+		app = Auth::Digest::MD5.new(app) {|user| 
+			user == auths[:username] ? 
+				Digest::MD5.hexdigest("#{auths[:username]}:#{realm}:#{auths[:password]}") : nil
+		}
+		app.realm = realm
+		app.opaque = 'have a nice day!'
+		app.passwords_hashed = true
+		run app
+	end
+
+	map '/session' do
+		app = lambda {|env|
+			env['rack.session']['counter'] ||= 0
+			env['rack.session']['counter'] += 1
+			[200, {'Content-Type' => 'text/html'}, "#{env['rack.session']['counter']}"]
+		}
+		run Rack::Session::Cookie.new(app)
+	end
+
+	map '/session/1' do
+		app = lambda {|env|
+			env['rack.session']['page1'] = '/session/1'
+			response = Response.new
+			response.redirect '/session/2', 301
+			response.finish
+		}
+		run Rack::Session::Cookie.new(app)
+	end
+
+	map '/session/2' do
+		app = lambda {|env|
+			env['rack.session']['page2'] = '/session/2'
+			[200, 
+				    {'Content-Type' => 'text/html'}, 
+            "#{env['rack.session']['page1']}:#{env['rack.session']['page2']}"
+			]
+		}
+		run Rack::Session::Cookie.new(app)
+	end
+
+	map '/cookie' do
+		run lambda {|env|
+			response = Response.new
+			response.set_cookie 'name', 'zhou'
+			response.finish
+		}
+	end
+
+	map '/upload_file' do
+		run lambda {|env|
+			request = Request.new env
+			data = ''
+			if request.params['file']
+				file = request.params['file']
+				data << file[:filename] + ' - ' + file[:tempfile].read
+			end
+			params = request.params
+			params.delete 'file'
+			data << params.inspect if params.size > 0
+			[200, {'Content-Type' => 'text/html'}, data]
+		}
+	end
+
+	map '/upload_file2' do
+		run lambda {|env|
+			request = Request.new env
+			data = ''
+			file = request.params['file']
+			data << file[:filename] + ' - ' + file[:tempfile].read
+			file = request.params['elif']
+			data << ", " + file[:filename] + ' - ' + file[:tempfile].read
+			[200, {'Content-Type' => 'text/html'}, data]
+		}
+	end
+
+end
+
+Handler::Mongrel.run builder, :Port => 9527

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: http_request.rb
 version: !ruby/object:Gem::Version 
-  version: 1.0.7
+  version: "1.1"
 platform: ruby
 authors: 
 - xianhua.zhou
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-24 00:00:00 +08:00
+date: 2009-10-04 00:00:00 +08:00
 default_executable: 
 dependencies: []
 
@@ -25,8 +25,12 @@ files:
 - Changelog
 - README.rdoc
 - lib/http_request.rb
+- test/test_http_request.rb
+- test/web_server.rb
 has_rdoc: true
 homepage: http://my.cnzxh.net
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -47,9 +51,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: http_request.rb
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: http_request.rb is a small, lightweight, powerful HttpRequest class based on the 'net/http' and 'net/ftp' libraries
 test_files: []