simplehttp 0.1.0

data/AUTHORS

@@ -0,0 +1 @@
+Tim Becker (tim@kuriositaet.de)

data/LICENSE

@@ -0,0 +1,58 @@
+This package is copyrighted free software by Tim Becker <tim@kuriositaet.de>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING.txt file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/README

@@ -0,0 +1,74 @@
+SimpleHttp - a simplified wrapper around Net::Http
+
+SimpleHttp aims to reduce the complexity of Net::Http while providing
+the most commonly used (by me) http functionality. 
+
+FEATURES / USAGE
+
+* No fuss one line GET and POST requests:
+	
+	str = SimpleHttp.get "http://www.example.com"
+	str = SimpleHttp.get "www.example.com"
+
+* Can use URI or String url interchangibly
+
+	str = SimpleHttp.get URI.parse "http://www.example.com/"
+
+* Transparent Proxy Handling. Uses the 'http_proxy' environment
+  variable if set, also provides a +set_proxy+ method.
+
+	http = SimpleHttp.new "http://www.example.com"
+	http.set_proxy "http://proxy.example.com:8000"
+	http.post "query" => "example_query"
+
+* POST sends ruby Hashes as 'application/x-www-form/urlencoded' per
+  default, but can send any data.
+
+	http = SimpleHttp.new "http://www.example.com/image_upload"
+	http.post imageData, "img/png"
+
+* Automatically handles SSL
+	
+	str = SimpleHttp.get "https://secure.example.com"
+
+* Easy HTTP Basic Authentication
+	str = SimpleHttp.get URI.parse("http://usr:pwd@www.example.com") 
+	#or
+	http = SimpleHttp.new "http://www.example.com"
+	http.basic_authentication "user", "password"
+	http.post "query" => "example_query" 
+
+* Access headers of the request or response
+	http = SimpleHttp.new "www.example.com"
+	http.request_header["X-Custom-Header"]="useful header"	
+	
+* Automatically follows Http Redirects.
+	
+
+The +get+ and +post+ methods return a +String+ containing the
+body of the request if the request was successful (HTTP 200). In case of
+a redirect, the redirect is followed and the ultimate response is
+returned. Per Default, up to three redirects are followed, this
+behaviour can be modified by setting +follow_num_redirects+. 
+
+In case of any other type of response, an exception is raised.
+
+The default behaviour can be modified by registering handlers
+using the +register_response_handler+ method. E.g. if you'd like to
+retrieve the +Date+ header instead of the body for successful
+transactions:
+
+	http = SimpleHttp.new ...
+	http.register_response_handler(Net::HTTPSuccess) {|req,res,http|
+		res['date']
+	}
+
+Or you'd like to print the +Location+ and then raise an exception in
+case of a redirect:
+
+	
+	http = SimpleHttp.new ...
+	http.register_response_handler(Net::HTTPRedirect) {|req,res,http|
+		puts res['location']
+		raise "REDIRECT not allowed!"
+	}

data/Rakefile

@@ -0,0 +1,120 @@
+require "rake/rdoctask"
+require "rake/gempackagetask"
+require "rake/testtask"
+require "rake/clean"
+require "rubygems"
+
+require "lib/simple_http"
+
+# Specifies the default task to execute. This is often the "test" task
+# and we'll change things around as soon as we have some tests.
+
+task  :default => [:rdoc]
+
+# The directory to generate +rdoc+ in.
+RDOC_DIR="doc/html"
+
+# This global variable contains files that will be erased by the `clean` task.
+# The `clean` task itself is automatically generated by requiring `rake/clean`.
+
+CLEAN << RDOC_DIR 
+
+
+# This is the task that generates the +rdoc+ documentation from the
+# source files. Instantiating Rake::RDocTask automatically generates a
+# task called `rdoc`.
+
+Rake::RDocTask.new do |rd|
+	# Options for documenation generation are specified inside of
+	# this block. For example the following line specifies that the
+	# content of the README file should be the main page of the
+	# documenation.
+	rd.main = "README" 
+	
+	# The following line specifies all the files to extract
+	# documenation from.
+	rd.rdoc_files.include(	"README", "AUTHORS", "LICENSE", "TODO",
+				"CHANGELOG", "bin/**/*", "lib/**/*.rb", 
+				"examples/**/*rb","test/**/*.rb", "doc/*.rdoc")
+	# This one specifies the output directory ...
+	rd.rdoc_dir 	= "doc/html"
+
+	# Or the HTML title of the generated documentation set.
+	rd.title 	= "simple_http: Simple Http client lib."
+
+	# These are options specifiying how source code inlined in the
+	# documentation should be formatted.
+	
+	rd.options 	= ["--line-numbers", "--inline-source"]
+
+	# Check:
+	# `rdoc --help` for more rdoc options
+	# the {rdoc documenation home}[http://www.ruby-doc.org/stdlib/libdoc/rdoc/rdoc/index.html]
+	# or the documentation for the +Rake::RDocTask+ task[http://rake.rubyforge.org/classes/Rake/RDocTask.html]
+end
+
+# The GemPackageTask facilitates getting all your files collected
+# together into gem archives. You can also use it to generate tarball
+# and zip archives.
+
+# First you'll need to assemble a gemspec
+
+PROJECT_NAME 	= "simplehttp"
+PKG_VERSION 	= SimpleHttp::VERSION 
+PKG_FILES 	= FileList['lib/**/*.rb', 'bin/**/*', 'examples/**/*', '[A-Z]*', 'test/**/*'].to_a
+
+spec = Gem::Specification.new do |s|
+	s.platform = Gem::Platform::RUBY
+	s.summary = "simple_http: Simple Http client lib."
+	s.name = PROJECT_NAME
+	s.version = PKG_VERSION
+	s.files = PKG_FILES
+	s.requirements << "none"
+	s.require_path = 'lib'
+	s.description = <<END_DESC
+Wrapper around net/http to provide quick and dirty http access.
+END_DESC
+end
+
+# Adding a new GemPackageTask adds a task named `package`, which generates
+# packages as gems, tarball and zip archives.
+Rake::GemPackageTask.new(spec) do |pkg|
+	pkg.need_zip = true
+	pkg.need_tar_gz = true
+end
+
+
+# This task is used to demonstrate how to upload files to Rubyforge.
+# Calling `upload_page` creates a current version of the +rdoc+
+# documentation and uploads it to the Rubyforge homepage of the project,
+# assuming it's hosted there and naming conventions haven't changed.
+#
+# This task uses `sh` to call the `scp` binary, which is plattform
+# dependant and may not be installed on your computer if you're using
+# Windows. I'm currently not aware of any pure ruby way to do scp
+# transfers.
+
+RubyForgeUser="a2800276"
+RubyForgeProject=PROJECT_NAME
+
+desc "Upload the web pages to the web."
+task :upload_pages => ["rdoc", "clean"] do
+  if RubyForgeProject then
+    path = "/var/www/gforge-projects/#{RubyForgeProject}"
+    sh "scp -r doc/html/* #{RubyForgeUser}@rubyforge.org:#{path}"
+    sh "scp doc/images/*.png #{RubyForgeUser}@rubyforge.org:#{path}/images"
+  end
+end
+
+
+# This task will run the unit tests provided in files called
+# `test/test*.rb`. The task itself can be run with a call to `rake test`
+
+Rake::TestTask.new do |t| 
+	t.libs << "test" 
+	t.libs << "lib" 
+	t.test_files = FileList['test/*.rb'] 
+	t.verbose = true 
+end
+
+

data/TODO

@@ -0,0 +1,26 @@
+* There seems to be a bug in webrick that it doesn't recognize the
+  Content-Length header if using basic authentication. The POST test
+  cases lead to a:
+  ERROR HTTPRequest#fixup: WEBrick::HTTPStatus::LengthRequired occured.
+  even though the Content-Length header is set correctly in the http
+  packet...
+
+* I've not figured out how to set_up and teardown webbrick properly.
+  Since webbrick blocks after calling `start`, it needs to started in a
+  seperate thread. I didn't handle communication with it properly
+  though.  Test::Unit calls set_up and teardown before
+  and after executing each test... method, and not as I expected, before
+  and after each test file. This leads to a new TestServer being
+  instantiated which complains "bind-adress already in use", because the
+  other instance wasn't properly shut down. I tried to dix this by setting 
+  up the server in the constructor, but that has the same effect.
+  It seems like a new instance of TestCase is instantiated to run every
+  single test... method.
+
+* There also seems to be something screwy about how rake calls the
+  tests. Some ruby files seem to be included twice. This leads to
+  "already initialized constant" error in the output of the unit tests. 
+
+* The two previous bugs aren't really problematic, because they only
+  make the output of the tests ugly. They should be easy to fix... (But
+  they're not high on my list of priorities.)

data/lib/simple_http.rb

@@ -0,0 +1,361 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'cgi'
+require 'base64'
+
+
+# Wrapper around ruby's standard net/http classes. Currently, only GET
+# and POST https methods are supported. `SimpleHttp` provides class
+# methods `get` and `post` to handle basic functionality. In case more
+# complicated requests need to be made or default settings need to be
+# overriden, it's possible to instantiate `SimpleHttp` and use instance
+# methods `get` and `put`.
+#  
+#
+# Features:
+# 
+# * Handles Redirects automatically
+# * Proxy used transparently if http_proxy environment variable is
+#   set.
+# * SSL handled automatically
+# * fault tolerant uri, e.g. all of these would work:
+# 	"www.example.com", "www.example.com/", "http://www.example.com"
+#
+# Some usage examples:
+#		# plain GET (using class methods)
+#		SimpleHttp.get "www.example.com"
+#
+#		# POST using the instance methods
+#		uri = URI.parse "https://www.example.com/index.html"
+#		sh = SimpleHttp uri
+#		sh.set_proxy "my.proxy", "8080"
+#		sh.post {"query" => "query_data"}
+#
+#		# POST using class methods.
+#		binaryData = getImage
+#		SimpleData.post binaryData, "image/png"
+#
+#		# GET requst with a custom request_header
+#		sh = SimpleHttp.new "http://www.example.com"
+#		sh.request_headers= {'X-Special-Http-Header'=>'my-value'}
+#		sh.get
+class SimpleHttp
+	
+	VERSION='0.1.0'
+
+	attr_accessor :proxy_host, :proxy_port, :proxy_user, :proxy_pwd, :uri, :request_headers, :response_handlers, :follow_num_redirects
+
+	RESPONSE_HANDLERS = {
+		Net::HTTPResponse => lambda { |request, response, http| 
+			raise response.to_s
+		},
+		Net::HTTPSuccess => lambda { |request, response, http|
+			return response.body
+		},
+		Net::HTTPRedirection => lambda { |request, response, http|
+			raise "too many redirects!" unless http.follow_num_redirects > 0	
+			
+			# create a new SimpleHttp for the location
+			# refered to decreasing the remaining redirects
+			# by one.
+			sh = SimpleHttp.new response['location']
+			sh.follow_num_redirects = http.follow_num_redirects-1
+
+			# copy the response handlers used in the current
+			# request in case they were non standard.
+			sh.response_handlers = http.response_handlers
+
+			# http doesn't permit redirects for methods
+			# other than GET of HEAD, so we complain in case
+			# we get them in response to a POST request. (Or
+			# anything other than GET, for that matter.) 
+			
+			if request.class == Net::HTTP::Get
+				return sh.get
+			else 
+				raise "Not a valid HTTP method for redirection: #{request.class}"
+				
+			end
+		}
+
+	}
+
+	# SimpleHttp can either be used directly through the +get+ and
+	# +post+ class methods or be instantiated, in case you need to
+	# to add custom behaviour to the requests.
+	#
+	# @param may be a URI or a String.
+	#
+	# Example:
+	# 	http = SimpleHttp.new(URI.parse("http://www.example.com"))
+	# 	http = SimpleHttp.new "www.example.com"
+	# 	http = SimpleHttp.new "http://usr:pwd@www.example.com:1234"
+	def initialize uri
+		set_proxy ENV['http_proxy'] if ENV['http_proxy']
+						
+		if uri.class == String
+
+			unless uri =~ /^https?:\/\//
+				uri = "http://#{uri}"
+			end
+
+			uri = URI.parse uri
+
+		end
+		@uri = uri
+		if !@uri.path || "" == @uri.path.strip
+			@uri.path="/"
+		end
+
+
+		@request_headers={}
+		@response_handlers=RESPONSE_HANDLERS.clone
+		@follow_num_redirects=3
+
+		if @uri.user
+			basic_authentication @uri.user, @uri.password
+		end
+
+	end
+
+	# 
+	# Provides facilities to perform http basic authentication. You
+	# don't need to provide +usr+ and +pwd+ if they are already included
+	# in the uri, i.e. http://user:password@www.example.com/
+	#
+	
+	def basic_authentication usr, pwd
+		str = Base64.encode64("#{usr}:#{pwd}")
+		str = "Basic #{str}"
+		@request_headers["Authorization"]=str
+	end
+	
+	#
+	# this method can be used to register response handlers for specific
+	# http responses in case you need to override the default behaviour.
+	# Defaults are: 
+	#
+	# 	HTTPSuccess : return the body of the response 
+	# 	HTTPRedirection : follow the redirection until success
+	# 	Others : raise an exception 
+	#
+	# `clazz` is the subclass of HTTPResponse (or HTTPResponse in case you
+	# want to define "default" behaviour) that you are registering the
+	# handler for.
+	#
+	# `block` is the handler itself, if a response of the appropriate class
+	# is received, `block` is called with three parameters: the the
+	# Net::HTTPRequest, the actual HTTPResponse object that was received
+	# and a reference to the instance of `SimpleHttp` that is executing the
+	# call.
+	#
+	# example: 
+	#
+	# 	# to override the default action of following a HTTP
+	# 	# redirect, you could register the folllowing handler:
+	#
+	# 	sh = SimpleHttp "www.example.com" 
+	# 	sh.register_response_handler Net::HTTPRedirection {|request, response, shttp| 
+	# 		response['location'] 
+	# 	}
+	#
+	
+	def register_response_handler clazz, &block
+		c = clazz
+	       	while c != Object
+			# completely unnecessary sanity check to make sure parameter
+			# `clazz` is in fact a HTTPResponse ...
+			if c == Net::HTTPResponse
+				@response_handlers[clazz]=block 
+				return
+			end
+			c = c.superclass
+		end
+
+		raise "Trying to register a response handler for non-response class: #{clazz}"	
+	end
+
+	#
+	#	Set the proxy to use for the http request.
+	# 	Note that you don't need to set the proxy in case the
+	# 	`http_proxy` environment variable is set. To override 
+	#	previous proxy settings and connect directly, call 
+	#	`set_proxy nil`
+	#
+	#	usage:
+	#		http = SimpleHttp.new "www.example.com"
+	#		
+	#		http.set_proxy "http://proxy:8000"
+	#	or:
+	#		http.set_proxy(URI.parse("http://proxy:8000"))
+	#	or:
+	#		http.set_proxy 'proxy', '8000', 'my_user', 'secret'
+	#	or:
+	#		http.set_proxy nil # to override previous proxy
+	#		settings and make the request directly.
+	#
+			
+	
+	def set_proxy proxy, port=nil, user=nil, pwd=nil
+		
+		
+		if !proxy	
+			@proxy_host=@proxy_port=@proxy_user=@proxy_pwd=nil 
+			return
+		end
+
+		if proxy.class == String 
+			if !port && !user && !pwd
+				proxy = URI.parse(proxy)
+			else 
+				@proxy_host= host
+				@proxy_port= port
+				@proxy_user= user
+				@proxy_pwd = pwd
+			end
+		end
+		
+		if proxy.class == URI::HTTP 
+			@proxy_host= proxy.host
+			@proxy_port= proxy.port
+			@proxy_user= proxy.user
+			@proxy_pwd = proxy.password
+		end
+	end
+
+	# interal 
+	# Takes a HTTPResponse (or subclass) and determines how to
+	# handle the response. Default behaviour is:
+	#
+	# 	HTTPSuccess : return the body of the response
+	# 	HTTPRedirection : follow the redirect until success.
+	# 	default : raise the HTTPResponse.
+	#
+	# the default behaviour can be overidden by registering a
+	# response handler using the `register_response_handler` method.
+	#
+	
+	def handle_response http_request, http_response
+		raise "Not a Net::HTTPResponse" unless http_response.is_a? Net::HTTPResponse
+		
+		c = http_response.class
+		while c!=Object
+			# the response_handlers hash contains a handler
+			# for the specific response class.
+			if @response_handlers[c]
+				return @response_handlers[c].call(http_request, http_response, self)
+			end
+
+			c=c.superclass
+		end	
+
+		# if we reached this place, no handler was registered
+		# for this response. default is to return the response.
+		
+		return http_response
+	end
+
+	# internal
+	def do_http request
+		response = nil
+
+		http = Net::HTTP.new(@uri.host, @uri.port, @proxy_host,
+			@proxy_port, @proxy_user, @proxy_pwd)
+		http.use_ssl = @uri.scheme == 'https'
+	
+		# add custom request headers.
+		
+		@request_headers.each {|key,value|
+			request[key]=value;
+		}
+
+		handle_response(request, http.request(request));
+	end
+
+	# internal
+	def make_query query
+		return query unless query && query.class == Hash
+		str = ""
+		query.collect { |key, value|
+			str += CGI::escape(key) + "=" + CGI::escape(value)
+		}
+		str
+	end
+	
+	# Make a simple GET request to the provided URI.
+	#
+	# Example:
+	# 	puts(SimpleHttp.get("www.example.com"))
+	def self.get uri, query=nil
+		http = SimpleHttp.new uri
+		http.get query	
+	end
+
+	# Make a POST request to the provided URI.
+	#
+	# Example:
+	# 	puts(SimpleHttp.post("www.example.com", "query"=>"my_query"))
+	#
+	# Alternatively, you can post any sort of data, but will have to
+	# set the appriate content_type:
+	#
+	# 	SimpleHttp.post("http://www.example.com/", binary_data, "img/png")
+	 
+	def self.post uri, query=nil, content_type='application/x-www-form-urlencoded'
+		http = SimpleHttp.new uri
+		http.post query, content_type
+	end
+	
+	# Call the +get+ method as an instance method if you need to
+	# modify the default behaviour of the library, or set special
+	# headers:
+	#
+	# 	http = SimpleHttp.new "www.example.com"
+	# 	http.request_headers["X-Special"]="whatever"
+	# 	str = http.get 
+	def get query = nil
+		if (query = make_query query)
+			@uri.query = @uri.query ? @uri.query+"&"+query : query
+		end
+		full_path = @uri.path + (@uri.query ? "?#{@uri.query}" : "")
+			
+		req = Net::HTTP::Get.new(full_path)
+		# puts Net::HTTP::Proxy(@proxy_host, @proxy_port, @proxy_user, @proxy_pwd).get(@uri)
+		do_http req
+	end
+
+	#
+	#	Post the query data to the url. 
+	#	The body of the request remains empty if query=nil.
+	#	In case `query` is a `Hash`, it's assumed that we are
+	#	sending a form.
+	#	In case `query` is a `String`, it's also assumed that a
+	#	form is being sent, UNLESS the `content_type` parameter
+	#	is set.
+	#
+	def post query=nil, content_type='application/x-www-form-urlencoded'
+		req = Net::HTTP::Post.new(@uri.path)
+
+		req.body= make_query query if query
+		req.content_type=content_type if query
+		req.content_length=query ? req.body.length : 0
+
+		do_http req
+	end
+	
+end
+
+#ht = SimpleHttp.new "http://www.google.com/aldfksjaldskjfalskjfdlk"
+##ht.register_response_handler(Net::HTTPRedirection) {|req, res, ht| puts res['location']}
+#puts ht.get.class
+##puts(ht.get("q"=>"bla"))
+#
+##puts (SimpleHttp.get "http://www.google.com")
+#
+#['http://www.google.com/', 'www.google.com', 'https://www.google.com'].each {|u|
+#	SimpleHttp.new u
+#}
+##puts ht.post
+
+

data/test/http_test.rb

@@ -0,0 +1,193 @@
+require 'simple_http.rb'
+require 'http_test_server.rb'
+
+require 'test/unit'
+require 'uri'
+require 'base64'
+
+# These tests communicate with a corresponding http server (TestServer), which is
+# implemented in `http_test_server.rb`
+
+class SimpleHttpTest < Test::Unit::TestCase
+	def initialize *args
+		super *args
+		# create webbrick server in a separate thread
+		Thread.new {
+			TestServer.new.start
+		}
+	end
+
+	def teardown
+		#@t.shutdown # webrick blocks in a weird way, can't
+		#commnicate with it in a different thread. this, of
+		#course, is really ugly.
+	end
+
+	# Tests of SimpleHttp class method behaviour.
+	
+	def test_get_class_method
+		# string url
+		ret = SimpleHttp.get "http://127.0.0.1:12345/test1"
+		assert_equal(ret, TestServer::SUCCESS_TEXT_0, "basic GET 1 test failed.");
+		
+		# string url, with query	
+		ret = SimpleHttp.get "http://127.0.0.1:12345/test1?query=true"
+		assert_equal(ret, TestServer::SUCCESS_TEXT_0, "basic GET 2 test failed.");
+		
+		# uri
+		uri = URI.parse "http://127.0.0.1:12345/test1?query=true"
+		ret = SimpleHttp.get uri 
+		assert_equal(ret, TestServer::SUCCESS_TEXT_0, "basic GET 3 test failed.");
+
+		#string with query as hash	
+		ret = SimpleHttp.get "http://127.0.0.1:12345/test2", "query" => "query_test"
+		assert_equal("query_test", ret, "basic GET (query) 4 test failed.");
+		
+		#uri with existing query + query as hash.
+		uri = URI.parse "http://127.0.0.1:12345/test2?query2=true"
+		ret = SimpleHttp.get uri, "query" => "query_test"
+		assert_equal("query_test", ret, "basic GET (query) 4.1 test failed.");
+
+	end
+
+	# Tests for http GET calls implemented using instantiated SimpleHttp objects.
+	
+	def test_get_class_instance_method
+		http = SimpleHttp.new "http://127.0.0.1:12345/test1"
+		ret = http.get 
+		assert_equal(ret, TestServer::SUCCESS_TEXT_0, "instance GET 1 test failed.");
+
+		http = SimpleHttp.new "http://127.0.0.1:12345/test2?query=query_test"
+		ret = http.get
+		assert_equal("query_test", ret, "instance GET 2 test (query)");
+
+		http = SimpleHttp.new "http://127.0.0.1:12345/query_test2?query=query_test"
+		ret = http.get "query2"=>"query2_test"
+		assert_equal("query2_test", ret, "instance GET 2.1 test (add to existing query")
+
+		http = SimpleHttp.new(URI.parse("http://127.0.0.1:12345/query_test2?bla=true"))
+		ret = http.get "query2" => "query_test"
+		assert_equal("query_test", ret, "basic GET (query) 3 test failed.")
+
+		# GET requst with a custom request_header
+		http = SimpleHttp.new "http://127.0.0.1:12345/header_test"
+		http.request_headers= {'x-special-http-header'=>'my-value'}
+		ret = http.get
+		assert_equal("my-value", ret, "GET header test 4")
+
+
+	end
+	
+	# http POST calls using class methods.
+	#
+	def test_post_class_method
+
+		# string url
+		ret = SimpleHttp.post "http://127.0.0.1:12345/test1"
+		assert_equal(ret, TestServer::SUCCESS_TEXT_0, "basic POST 1 test failed.");
+		
+
+		#string with query as hash	
+		ret = SimpleHttp.post "http://127.0.0.1:12345/test2", "query" => "query_test"
+		assert_equal("query_test", ret, "basic POST (query) 2 test failed.");
+		
+		#uri with existing query + query as hash.
+		uri = URI.parse "http://127.0.0.1:12345/test2"
+		ret = SimpleHttp.post uri, "query" => "query_test"
+		assert_equal("query_test", ret, "basic POST (query) 2.1 test failed.");
+		
+		# post something other than a form.
+		ret = SimpleHttp.post "http://127.0.0.1:12345/post_data_test", TestServer::POST_DATA, "misc/test-data"
+		assert_equal(TestServer::POST_DATA, ret, "class Post data test")
+
+
+	end
+
+	
+	def test_post_instance_method
+		http = SimpleHttp.new "http://127.0.0.1:12345/test1"
+		ret = http.post 
+		assert_equal(ret, TestServer::SUCCESS_TEXT_0, "instance POST 1 test failed.");
+
+		http = SimpleHttp.new "http://127.0.0.1:12345/test2"
+		ret = http.post "query" => "query_test"
+		assert_equal("query_test", ret, "instance POST 2 test (query)");
+
+		http = SimpleHttp.new "http://127.0.0.1:12345/query_test2?query=query_test"
+		ret = http.post "query2"=>"query2_test"
+		assert_equal("query2_test", ret, "instance POST 2.1 test (add to existing query")
+
+		http = SimpleHttp.new(URI.parse("http://127.0.0.1:12345/query_test2?bla=true"))
+		ret = http.post "query2" => "query_test"
+		assert_equal("query_test", ret, "basic POST (query) 3 test failed.")
+
+		# POST requst with a custom request_header
+		http = SimpleHttp.new "http://127.0.0.1:12345/header_test"
+		http.request_headers= {'x-special-http-header'=>'my-value'}
+		ret = http.post
+		assert_equal("my-value", ret, "POST header test 4")
+		
+		# POST request with a custom data type (not posting a form.)
+		http = SimpleHttp.new "http://127.0.0.1:12345/post_data_test"
+		ret = http.post TestServer::POST_DATA, "misc/test-data"
+		assert_equal(TestServer::POST_DATA, ret, "Post data test")
+
+
+	end
+	
+	def test_basic_auth
+
+		# string url
+		ret = SimpleHttp.get "http://test:pwd@127.0.0.1:12345/basic_auth"
+		assert_equal(TestServer::SUCCESS_TEXT_1, ret, "basic auth get class 1 test failed.");
+		
+		http = SimpleHttp.new "http://127.0.0.1:12345/basic_auth"
+		http.basic_authentication "test", "pwd"
+		ret = http.get 
+		assert_equal(ret, TestServer::SUCCESS_TEXT_1, "basic auth get instance 2 test failed.");
+		#string with query as hash	
+		ret = SimpleHttp.post "http://test:pwd@127.0.0.1:12345/basic_auth", "query" => "query_test"
+		assert_equal(TestServer::SUCCESS_TEXT_1, ret, "basic auth post class 3 test failed.");
+		
+		http = SimpleHttp.new "http://127.0.0.1:12345/basic_auth"
+		http.basic_authentication "test", "pwd"
+		ret = http.post TestServer::POST_DATA, "misc/test-data"
+		assert_equal(TestServer::SUCCESS_TEXT_1, ret, "Post data test")
+	end
+
+	def test_response_handler
+		assert_raise(RuntimeError) {	
+			ret = SimpleHttp.get "http://test:pwd@127.0.0.1:12345/non_existant"
+		}
+		
+		http = SimpleHttp.new "http://test:pwd@127.0.0.1:12345/non_existant"
+		http.register_response_handler(Net::HTTPNotFound) { |req, res, http|
+			res.code
+		}
+		ret = http.get
+		assert_equal("404", ret, "response handler test 2")
+		
+		http = SimpleHttp.new "http://test:pwd@127.0.0.1:12345/redirect1"
+		http.register_response_handler(Net::HTTPRedirection) { |req, res, http|
+			res['location']
+		}
+		ret = http.get
+		assert_equal("http://127.0.0.1:12345/redirect2", ret, "response handler test 3") 
+
+	end
+
+	def test_redirect 
+		assert_raise(RuntimeError) {	
+			http = SimpleHttp.new "http://test:pwd@127.0.0.1:12345/redirect1"
+			ret = http.get
+		}
+		
+		ret = SimpleHttp.get "http://test:pwd@127.0.0.1:12345/redirect"
+		assert_equal(ret, TestServer::SUCCESS_TEXT_0, "redirect test 2");
+		
+
+	end
+
+
+end
+

data/test/http_test_server.rb

@@ -0,0 +1,90 @@
+require 'webrick'
+
+include WEBrick
+class TestServer
+	SUCCESS_TEXT_0 = "success_0"
+	SUCCESS_TEXT_1 = "success_1"
+	SUCCESS_TEXT_2 = "success_2"
+	SUCCESS_TEXT_3 = "success_3"
+	SUCCESS_TEXT_4 = "success_4"
+	SUCCESS_TEXT_5 = "success_5"
+	SUCCESS_TEXT_6 = "success_6"
+	SUCCESS_TEXT_7 = "success_7"
+	SUCCESS_TEXT_8 = "success_8"
+	SUCCESS_TEXT_9 = "success_9"
+
+	POST_DATA = [0xbe, 0x00, 0x12, 0x23, 0x45, 0x67, 0x89, 0xAB].join
+
+	def initialize
+		@server = HTTPServer.new(
+			:Port => 12345
+		)
+
+		add_tests
+	end
+	
+	def start
+		@server.start
+	end
+
+	def shutdown
+		@server.shutdown
+	end
+	
+	def dbg str 
+		puts "!!!!!!!!! #{str}"
+	end
+	def add_tests
+		# return a text
+		@server.mount_proc("/test1"){|req, res|
+			res.body=SUCCESS_TEXT_0
+		}
+		#return value of query param named "query"
+		@server.mount_proc("/test2"){|req, res|
+			res.body=req.query["query"]
+		}
+		
+		# return value of query param named "query2"
+		@server.mount_proc("/query_test2"){|req, res|
+			res.body=req.query["query2"]
+		}
+		
+		# return value of request header named "X-Special-Http-Header"
+		@server.mount_proc("/header_test"){|req, res|
+			res.body=req.header["x-special-http-header"][0]
+		}
+		
+		# return value of request header named "X-Special-Http-Header"
+		@server.mount_proc("/post_data_test"){|req, res|
+			ctype = req.header['content-type'][0]
+			if "misc/test-data" == ctype 
+				res.body=req.body
+			else
+				res.body="failed, content-type: #{ctype}"
+			end	
+		}
+
+		@server.mount_proc("/basic_auth") {|req, res|
+			
+			auth = Base64.decode64(req.header['authorization'][0].split[1])
+			usr, pwd = auth.split(':')
+			if ('test'==usr && 'pwd'==pwd)
+				res.body=SUCCESS_TEXT_1	
+			else
+				res.status=403
+			end
+		}
+
+		1.upto(6) {|i|
+			@server.mount_proc("/redirect#{i}") { |req, res|
+				res.status=301
+				res.header['location']="http://127.0.0.1:12345/redirect#{i+1}"	
+			}
+		}
+		
+		@server.mount_proc("/redirect") { |req, res|
+			res.status=301
+			res.header['location']="http://127.0.0.1:12345/test1"	
+		}
+	end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: simplehttp
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-02-08 00:00:00 +01:00
+summary: "simple_http: Simple Http client lib."
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: Wrapper around net/http to provide quick and dirty http access.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: []
+
+files: 
+- lib/simple_http.rb
+- AUTHORS
+- CHANGELOG
+- LICENSE
+- Rakefile
+- README
+- TODO
+- test/http_test.rb
+- test/http_test_server.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: 
+- none
+dependencies: []
+