clivecrous-ramaze 0.3.9.5

data/lib/ramaze/spec/helper/bacon.rb

@@ -0,0 +1,7 @@
+libdir = File.expand_path(File.join(File.dirname(__FILE__), '../../../'))
+$LOAD_PATH.unshift libdir
+require 'vendor/bacon'
+require 'ramaze/spec/helper/pretty_output'
+Bacon.extend Bacon::PrettyOutput
+# Bacon.extend Bacon::TestUnitOutput
+Bacon.summary_on_exit

data/lib/ramaze/spec/helper/browser.rb

@@ -0,0 +1,88 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class Browser
+  attr_reader :cookie, :http
+
+  def initialize(base = '/', &block)
+    @base     = base
+    @history  = []
+    @uri      = URI("http://localhost:#{Ramaze::Global.port}")
+    @http     = SimpleHttp.new(@uri)
+
+    story(&block) if block_given?
+  end
+
+  def story(&block)
+    instance_eval(&block) if block_given?
+  end
+
+  def get path = '/', hash = {}
+    request(:get, path, hash)
+  end
+
+  def post path = '/', hash = {}
+    request(:post, path, hash)
+  end
+
+  def erequest method, path, hash = {}
+    response = request(method, path, hash)
+    eval(response)
+  rescue Object => ex
+    p :response => response
+    ex.message
+  end
+
+  def epost path = '/', hash = {}
+    erequest(:post, path, hash)
+  end
+
+  def eget path = '/', hash = {}
+    erequest(:get, path, hash)
+  end
+
+  def hget(*args)
+    @page = Hpricot(get(*args))
+  end
+
+  def hpost(*args)
+    @page = Hpricot(post(*args))
+  end
+
+  def find_link(text)
+    link = @page.at("a[text()='#{text}']")
+    link.should.not.be.nil if link.respond_to?(:should)
+    link[:href]
+  end
+
+  def follow_link(text)
+    hget find_link(text)
+  end
+
+  def follow_links(*texts)
+    texts.each do |text|
+      follow_link text
+    end
+  end
+
+  def request method, path, hash = {}
+    @http.uri = @uri + "/#{@base}/#{path}".squeeze('/')
+    @http.request_headers['referer'] = @history.last.path rescue '/'
+
+    if method == :get and not hash.empty?
+      @http.uri.query = hash.inject([]){|s,(k,v)| s << "#{k}=#{v}"}.join('&')
+      hash.clear
+    end
+
+    response = @http.send(method, hash).strip
+    @history << @http.uri
+    get_cookie
+
+    response
+  end
+
+  def get_cookie
+    @cookie = @http.response_headers['set-cookie']
+    @http.request_headers['cookie'] = @cookie
+  end
+end

data/lib/ramaze/spec/helper/mock_http.rb

@@ -0,0 +1,69 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze'
+require 'rack/mock'
+
+module Ramaze
+  module Adapter
+    class Fake < Base
+    end
+  end
+end
+
+module MockHTTP
+  DEFAULTS = {
+    'REMOTE_ADDR' => '127.0.0.1'
+  }
+
+  MOCK_URI = URI::HTTP.build(
+    :host => 'localhost',
+    :port => 80
+  )
+
+  FISHING = {
+    :input => :input,
+    :referrer => 'HTTP_REFERER',
+    :referer => 'HTTP_REFERER',
+    :cookie => 'HTTP_COOKIE',
+    :if_none_match=> 'HTTP_IF_NONE_MATCH',
+    :if_modified_since=> 'HTTP_IF_MODIFIED_SINCE',
+  }
+
+  MOCK_REQUEST = ::Rack::MockRequest.new(Ramaze::Adapter::Fake)
+
+  def get(*args)    mock_request(:get,    *args) end
+  def put(*args)    mock_request(:put,    *args) end
+  def post(*args)   mock_request(:post,   *args) end
+  def delete(*args) mock_request(:delete, *args) end
+
+  def mock_request(meth, path, query = {})
+    uri, options = process_request(path, query)
+    MOCK_REQUEST.send(meth, uri, DEFAULTS.merge(options))
+  end
+
+  def raw_mock_request(meth, uri, options = {})
+    MOCK_REQUEST.send(meth, uri, DEFAULTS.merge(options))
+  end
+
+  def process_request(path, query)
+    options = {}
+    FISHING.each{|key, value|
+      options[value] = query.delete(key)} if query.is_a?(Hash)
+    [create_url(path, query), options]
+  end
+
+  def create_url(path, query)
+    uri = MOCK_URI.dup
+    uri.path = path
+    uri.query = make_query(query)
+    uri.to_s
+  end
+
+	def make_query query
+		return query unless query and not query.is_a?(String)
+    query.map{|key, value|
+      "#{CGI::escape(key.to_s)}=#{CGI::escape(value.to_s)}"
+    }.join('&')
+	end
+end

data/lib/ramaze/spec/helper/pretty_output.rb

@@ -0,0 +1,82 @@
+module Bacon
+  module PrettyOutput
+    NAME = ''
+
+    # store name and run
+    def handle_specification(name)
+      NAME.replace name
+			puts NAME
+      yield
+			puts
+    end
+
+    # Core, yields the requirement and outputs problems
+    def handle_requirement(description)
+	    print "- #{description}\n"
+      error = yield
+
+      unless error.empty?
+        if defined?(Ramaze::Logging)
+          puts '', " #{NAME} -- #{description} [FAILED]".center(70, '-'), ''
+          colors = Ramaze::Informer::COLORS
+
+          until RamazeLogger.history.empty?
+            tag, line = RamazeLogger.history.shift
+            out = "%6s | %s" % [tag.to_s, line]
+            puts out.send(colors[tag])
+          end
+        end
+
+        general_error
+      end
+    end
+
+    # Show nicer output on error
+    def general_error
+      puts "", ErrorLog
+      ErrorLog.scan(/^\s*(.*?):(\d+): #{NAME} - (.*?)$/) do
+        puts "#{ENV['EDITOR'] || 'vim'} #$1 +#$2 # #$3"
+      end
+      ErrorLog.replace ''
+    end
+
+    # output summary
+    def handle_summary
+	    puts
+      puts "%d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+end
+
+if defined?(Ramaze::Logging)
+  module Ramaze
+    # Special Logger, stores everything in its history
+    class SpecLogger
+      include Ramaze::Logging
+      include Enumerable
+
+      attr_accessor :history
+
+      # Create new history
+      def initialize
+        @history = []
+      end
+
+      # Yield the history
+      def each
+        @history.each{|e| yield(e) }
+      end
+
+      # general log
+      def log(tag, str)
+        @history << [tag, str]
+      end
+    end
+  end
+
+  module Bacon::PrettyOutput
+    RamazeLogger = Ramaze::SpecLogger.new
+    Ramaze::Log.loggers = [RamazeLogger]
+  end
+end

data/lib/ramaze/spec/helper/requester.rb

@@ -0,0 +1,63 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Requester
+  def get url = '/', hash = {}
+    request(:get, url, hash)
+  end
+
+  def post url = '/', hash = {}
+    request(:post, url, hash)
+  end
+
+  def request method, url, hash = {}
+    http = SimpleHttp.new(url2uri(url))
+    if method == :get and not hash.empty?
+      http.uri.query = hash.map{|k,v| "#{k}=#{v}"}.join('&')
+      hash = {}
+    end
+
+    puts "#{method.to_s.upcase} => #{http.uri}"
+    http.send(method, hash).strip
+  end
+
+  def epost url = '/', hash = {}
+    erequest(:post, url, hash)
+  end
+
+  def eget url = '/', hash = {}
+    erequest(:get, url, hash)
+  end
+
+  def erequest method, url, hash = {}
+    response = request(method, url, hash)
+    eval(response)
+  rescue Object => ex
+    p :response => response
+    ex.message
+  end
+
+  def hget(url = '/', hash = {})
+    @response = get(url, hash)
+    @body = @response.body
+    @status = @response.status
+    Hpricot(@body)
+  end
+
+  def hpost(url = '/', hash = {})
+    @response = post(url, hash)
+    @body = @response.body
+    @status = @response.status
+    Hpricot(@body)
+  end
+
+  def url2uri url
+    uri = URI.parse(url)
+    #p uri.methods.sort.grep(/=/)
+    uri.scheme = 'http'
+    uri.host = 'localhost'
+    uri.port = Ramaze::Global.port
+    uri.path = "/#{url}".squeeze('/')
+    uri
+  end
+end

data/lib/ramaze/spec/helper/simple_http.rb

@@ -0,0 +1,434 @@
+=begin
+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.
+=end
+
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'cgi'
+
+
+# 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.1'
+
+	attr_accessor :proxy_host, :proxy_port, :proxy_user, :proxy_pwd, :uri, :request_headers, :response_headers, :response_handlers, :follow_num_redirects
+
+	RESPONSE_HANDLERS = {
+		Net::HTTPResponse => lambda { |request, response, http|
+			response.each_header {|key, value|
+				http.response_headers[key]=value
+			}
+			raise response.to_s
+		},
+		Net::HTTPSuccess => lambda { |request, response, http|
+			response.each_header {|key, value|
+				http.response_headers[key]=value
+			}
+			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
+
+			# copy the request headers
+			sh.request_headers  = http.request_headers
+			sh.response_headers = http.response_headers
+
+      # copy host and port
+      sh.uri.host = http.uri.host
+      sh.uri.port = http.uri.port
+
+			# 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.)
+
+      case request
+      when Net::HTTP::Get
+        sh.get
+      when Net::HTTP::Post
+        sh.post
+			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_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 = ["#{usr}:#{pwd}"].pack("*m")
+		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
+    query.inject([]) do |s, (key, value)|
+			s + [CGI::escape(key) + "=" + CGI::escape(value)]
+    end.join('&')
+	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
+