Pistos-ramaze 2009.02 → 2009.04.08

data/spec/ramaze/log/logging.rb

@@ -0,0 +1,63 @@
+require 'spec/helper'
+
+class SpecLogger
+  include Ramaze::Logging
+
+  attr_reader :history
+
+  def initialize
+    @history = []
+  end
+
+  def log(*args)
+    @history << args
+  end
+end
+
+describe Ramaze::Logging do
+  @log = SpecLogger.new
+
+  should 'provide #info - which calls #to_s' do
+    @log.info('info')
+    @log.history.last.should == [:info, 'info']
+
+    @log.info(1, 2)
+    @log.history.last(2).should == [[:info, '1'], [:info, '2']]
+  end
+
+  should 'provide #debug - which calls #inspect' do
+    @log.debug(:debug)
+    @log.history.last.should == [:debug, ':debug']
+  end
+
+  should 'provide #<< as alias for #debug' do
+    @log << :<<
+    @log.history.last.should == [:debug, ':<<']
+  end
+
+  should 'provide #dev - which calls #inspect' do
+    @log.dev(:dev)
+    @log.history.last.should == [:dev, ':dev']
+  end
+
+  should 'provide #error - which formats exceptions' do
+    @log.error(1)
+    @log.history.last.should == [:error, '1']
+
+    error = StandardError.new('for spec')
+    error.set_backtrace(['line 1', 'line 2'])
+    @log.error(error)
+    @log.history.last(3).should == [
+      [:error, "#<StandardError: for spec>"],
+      [:error, "line 1"],
+      [:error, "line 2"] ]
+  end
+
+  should 'not do anything on #shutdown' do
+    @log.shutdown.should == nil
+  end
+
+  should 'answer to #debug? for WEBrick' do
+    @log.debug?.should == false
+  end
+end

data/spec/ramaze/log/syslog.rb

@@ -7,70 +7,67 @@ require 'ramaze/log/syslog'
 
 describe 'Syslog' do
 
-  # close the syslog, if it was open for some reason before we
-  # start a test.
-  before do
-    if ( Syslog.opened? )
-      ::Syslog.close
-    end
-  end
+	# close the syslog, if it was open for some reason before we
+	# start a test. 
+	before do
+		if ( Syslog.opened? )
+			::Syslog.close
+		end
+	end
 
-  it 'should default initialize correctly' do
-    syslog = Ramaze::Logger::Syslog.new
-    ::Syslog.opened?.should == true
-    ::Syslog.ident.should   == $0
-    ::Syslog.options.should == ( ::Syslog::LOG_PID | ::Syslog::LOG_CONS )
-    ::Syslog.facility.should == ::Syslog::LOG_USER
-  end
+	it 'should default initialize correctly' do
+		syslog = Ramaze::Logger::Syslog.new
+		::Syslog.opened?.should == true
+		::Syslog.ident.should   == $0
+		::Syslog.options.should == ( ::Syslog::LOG_PID | ::Syslog::LOG_CONS )
+		::Syslog.facility.should == ::Syslog::LOG_USER
+	end
 
-  it 'should handle non default initialization' do
-    syslog = Ramaze::Logger::Syslog.new(
-      'ramaze_syslog_test', ::Syslog::LOG_NDELAY | ::Syslog::LOG_NOWAIT,
-      ::Syslog::LOG_DAEMON
-    )
-    ::Syslog.opened?.should == true
-    ::Syslog.ident.should   == 'ramaze_syslog_test'
-    ::Syslog.options.should == ( ::Syslog::LOG_NDELAY | ::Syslog::LOG_NOWAIT )
-    ::Syslog.facility.should == ::Syslog::LOG_DAEMON
-  end
+	it 'should handle non default initialization' do
+		syslog = Ramaze::Logger::Syslog.new( 'ramaze_syslog_test', 
+		                                               ::Syslog::LOG_NDELAY | ::Syslog::LOG_NOWAIT, 
+		                                               ::Syslog::LOG_DAEMON )
+		::Syslog.opened?.should == true
+		::Syslog.ident.should   == 'ramaze_syslog_test'
+		::Syslog.options.should == ( ::Syslog::LOG_NDELAY | ::Syslog::LOG_NOWAIT )
+		::Syslog.facility.should == ::Syslog::LOG_DAEMON
+	end
 
-  # We test the actual logging using a trick found in te test code of the
-  # syslog module.  We create a pipe, fork a child, reroute the childs
-  # stderr to the pipe. Then we open the logging using LOG_PERROR, so all
-  # log messages are written to stderror.  In the parent we read the messages
-  # from the pipe and compare them to what we expected.
-  def test_log_msg( type, priority, msg )
-    logpipe = IO::pipe
-    child = fork {
-      logpipe[0].close
-      STDERR.reopen(logpipe[1])
-      syslog = Ramaze::Logger::Syslog.new(
-        'ramaze_syslog_test',
-        ::Syslog::LOG_PID | ::Syslog::LOG_NDELAY | ::Syslog::LOG_PERROR,
-        ::Syslog::LOG_USER
-      )
-      syslog.send priority, msg
-      Process.exit!( 0 )
-    }
-    logpipe[1].close
-    Process.waitpid(child)
+    # We test the actual logging using a trick found in te test code of the
+    # syslog module.  We create a pipe, fork a child, reroute the childs
+    # stderr to the pipe. Then we open the logging using LOG_PERROR, so all
+    # log messages are written to stderror.  In the parent we read the messages
+    # from the pipe and compare them to what we expected.
+	def test_log_msg( type, priority, msg )
+		logpipe = IO::pipe
+		child = fork {
+			logpipe[0].close
+			STDERR.reopen(logpipe[1])
+			syslog = Ramaze::Logger::Syslog.new( 'ramaze_syslog_test', 
+			                                              ::Syslog::LOG_PID | ::Syslog::LOG_NDELAY | ::Syslog::LOG_PERROR,
+														  ::Syslog::LOG_USER )
+			syslog.send priority, msg
+			Process.exit!( 0 )
+		}
+		logpipe[1].close
+		Process.waitpid(child)
 
-    logpipe[0].gets.should == "ramaze_syslog_test[#{child}]: #{msg}\n"
-  end
-
-  it 'should handle debug' do
-    test_log_msg :direct, :debug, "Hello Debug World"
-  end
-  it 'should handle dev' do
-    test_log_msg :direct, :dev, "Hello Dev World"
-  end
-  it 'should handle info' do
-    test_log_msg :direct, :info, 'Hello Info World!'
-  end
-  it 'should handle warn' do
-    test_log_msg :direct, :warn, 'Hello Warn World!'
-  end
-  it 'should handle error' do
-    test_log_msg :direct, :error, 'Hello Error World!'
-  end
+		logpipe[0].gets.should == "ramaze_syslog_test[#{child}]: #{msg}\n"
+	end
+	
+	it 'should handle debug' do
+		test_log_msg :direct, :debug, "Hello Debug World"
+	end
+	it 'should handle dev' do
+		test_log_msg :direct, :dev, "Hello Dev World"
+	end
+	it 'should handle info' do
+		test_log_msg :direct, :info, 'Hello Info World!'
+	end
+	it 'should handle warn' do
+		test_log_msg :direct, :warn, 'Hello Warn World!'
+	end
+	it 'should handle error' do
+		test_log_msg :direct, :error, 'Hello Error World!'
+	end
 end

data/spec/ramaze/params.rb

@@ -1,4 +1,4 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'spec/helper'
@@ -64,11 +64,10 @@ class TCParamsController3 < Ramaze::Controller
 end
 
 describe "Simple Parameters" do
-  behaves_like 'http'
-  ramaze
+  behaves_like :mock
 
   def handle(*url)
-    Ramaze::Controller.handle(*url)
+    Ramaze::Mock.get(*url).body
   end
 
   it "Should respond to no parameters given" do
@@ -80,8 +79,7 @@ describe "Simple Parameters" do
   end
 
   it "call /bar though index doesn't take params" do
-    lambda{ handle('/bar') }.
-      should.raise(Ramaze::Error::NoAction)
+    handle('/bar').should == 'No action found at: "/bar"'
   end
 
   it "action that takes a single param" do
@@ -93,8 +91,7 @@ describe "Simple Parameters" do
   end
 
   it "action that takes two params but we give only one" do
-    lambda{ handle('/double_param/foo') }.
-      should.raise(Ramaze::Error::NoAction)
+    handle('/double_param/foo').should == 'No action found at: "/double_param/foo"'
   end
 
   it "action that takes all params" do
@@ -144,14 +141,14 @@ describe "Simple Parameters" do
   end
 
   it 'params should have no content without params' do
-    get('/ma').body.should == '""'
+    handle('/ma').should == '""'
   end
 
   it 'should have a parameter via QUERY_PARAMS' do
-    get('/ma', 'foo' => 'bar').body.should == '"bar"'
+    handle('/ma?foo=bar').should == '"bar"'
   end
 
   it 'should handle valueless params' do
-    raw_mock_request(:get, '/jo/keys?foo').body.should == '"foo"'
+    handle('/jo/keys?foo').should == '"foo"'
   end
 end

data/spec/ramaze/request.rb

@@ -1,185 +1,49 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
 require 'spec/helper'
 
-class TCRequestController < Ramaze::Controller
-  map '/'
-  engine :None
-
-  def is_post()   request.post?.to_s end
-  def is_get()    request.get?.to_s end
-  def is_put()    request.put?.to_s end
-  def is_delete() request.delete?.to_s end
-
-  def request_inspect
-    request.params.inspect
-  end
-
-  def post_inspect
-    request.params.inspect
-  end
-
-  def put_inspect(file)
-    # referencing request.rack_params breaks this test
-    # request.params is hacked to return {} on PUT requests
-    request.params
-    request.body.read
-  end
-
-  def get_inspect
-    request.params.inspect
-  end
-
-  def test_get
-    request['foo']
-  end
-
-  def test_post
-    request.params.inspect
-  end
-
-  def test_headers
-  end
-
-  def my_ip
-    request.remote_addr
-  end
-
-  def to_ivs
-    request.to_ivs :foo, :bar
-    instance_variables.sort.map{|iv|
-      [ iv.to_s, instance_variable_get(iv) ].join(' => ')
-    }.join(', ')
-  end
-end
-
-options = ramaze_options rescue {}
-
-describe "Request" do
-  behaves_like 'http'
-  ramaze options.merge(:public_root => 'spec/ramaze/public')
-
-  Request = Ramaze::Request
-
-  it 'to_ivs' do
-    got = get('/to_ivs', 'foo' => 'a')
-    got.body.should == '@foo => a'
-    got = get('/to_ivs', 'bar' => 'b', 'foo' => 'c')
-    got.body.should == '@bar => b, @foo => c'
-  end
-
-  should 'show locales' do
-    r = Request.new('HTTP_ACCEPT_LANGUAGE' => 'en-ca,en-us;q=1,en;q=0.6')
-    r.locales.should == %w[en-ca en-us en]
-  end
-
-  describe "POST" do
-    behaves_like 'http'
-
-    it "give me the result of request.post?" do
-      post("/is_post").body.should == 'true'
-    end
-
-    it "give me the result of request.get?" do
-      post("/is_get").body.should == 'false'
-    end
-
-    # this here has shown some odd errors... keep an eye on it.
-    it "give me back what i gave" do
-      post("/post_inspect", 'this' => 'post').body.should == {"this" => "post"}.inspect
-    end
-
-    should "handle key[nested_key]" do
-      get('/test_get', 'foo' => 'bar').body.should == 'bar'
-      params = {'foo' => 'null', 'bar[1]' => 'eins', 'bar[7]' => 'sieben'}
-
-      eval(post('/test_post', params).body).should ==
-        {'foo' => 'null', 'bar' => {'1' => 'eins', '7' => 'sieben'}}
-    end
-
-    should 'handle key[nested_key][nested_nested_key]' do
-      eval(post('/test_post', 'foo[1][2]' => 'eins zwei').body).should ==
-        {'foo' => {'1' => {'2' => 'eins zwei'}}}
-    end
-
-    should 'handle key&key[nested]' do
-      eval(post('/test_post', 'a' => 'b', 'a[c]' => 'd').body).should ==
-        {'a' => {'c' => 'd'}}
-    end
-  end
-
-  describe "PUT" do
-    behaves_like 'http'
-
-    it "put a resource" do
-      image = 'favicon.ico'
-      image_path = File.join('spec', 'ramaze', 'public', image)
-      address = "/put_inspect/#{image}"
-
-      if RUBY_VERSION >= '1.9.0'
-        file = File.open(image_path, 'r:ASCII'){|f| f.read}
-      else
-        file = File.read(image_path)
-      end
-
-      response = put(address, :input => file)
-      response.body.dump.should == file.dump
-    end
-  end
-
-  describe "DELETE" do
-    behaves_like 'http'
-
-    it "delete a resource" do
-      delete('/is_delete').body.should == 'true'
-    end
-  end
-
-  describe "GET" do
-    behaves_like 'http'
-
-    it "give me the result of request.post?" do
-      get("/is_post").body.should == 'false'
-    end
-
-    it "give me the result of request.get?" do
-      get("/is_get").body.should == 'true'
-    end
-
-    it "give me back what i gave" do
-      params = {'one' => 'two', 'three' => 'four'}
-      get("/get_inspect", params).body.should == params.inspect
-    end
-
-    it "my ip" do
-      get("/my_ip").body.should == '127.0.0.1'
-    end
-  end
-
-  describe "get files" do
-    behaves_like 'http'
-
-    it "binary" do
-      image_path = '/favicon.ico'
-      if RUBY_VERSION >= '1.9.0'
-        static_image = File.open("spec/ramaze/public#{image_path}", 'r:ASCII'){|f| f.read}
-      else
-        static_image = File.read("spec/ramaze/public#{image_path}")
-      end
-
-      response = get(image_path)
-      response.status.should == 200
-      response.body.should == static_image
-    end
-
-    it 'plain test' do
-      css_path = '/test_download.css'
-      static_css = File.read("spec/ramaze/public#{css_path}").strip
-
-      response = get(css_path)
-      response.status.should == 200
-      response.body.strip.should == static_css
-    end
+describe 'Ramaze::Request' do
+  def request(env = {})
+    Ramaze::Request.new(env)
+  end
+
+  @env = {
+    "GATEWAY_INTERFACE"    => "CGI/1.1",
+    "HTTP_ACCEPT"          => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "HTTP_ACCEPT_CHARSET"  => "UTF-8,*",
+    "HTTP_ACCEPT_ENCODING" => "gzip,deflate",
+    "HTTP_ACCEPT_LANGUAGE" => "en-us,en;q=0.8,de-at;q=0.5,de;q=0.3",
+    "HTTP_CACHE_CONTROL"   => "max-age=0",
+    "HTTP_CONNECTION"      => "keep-alive",
+    "HTTP_HOST"            => "localhost:7000",
+    "HTTP_KEEP_ALIVE"      => "300",
+    "HTTP_USER_AGENT"      => "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.5) Gecko/2008123017 Firefox/3.0.4 Ubiquity/0.1.4",
+    "HTTP_VERSION"         => "HTTP/1.1",
+    "PATH_INFO"            => "/",
+    "QUERY_STRING"         => "a=b",
+    "REMOTE_ADDR"          => "127.0.0.1",
+    "REMOTE_HOST"          => "delta.local",
+    "REQUEST_METHOD"       => "GET",
+    "REQUEST_PATH"         => "/",
+    "REQUEST_URI"          => "http://localhost:7000/",
+    "SCRIPT_NAME"          => "",
+    "SERVER_NAME"          => "localhost",
+    "SERVER_PORT"          => "7000",
+    "SERVER_PROTOCOL"      => "HTTP/1.1",
+  }
+
+  should 'provide #accept_language' do
+    request(@env).accept_language.should == %w[en-us en de-at de]
+  end
+
+  should 'provide #http_variables' do
+    keys = %w[ HTTP_CACHE_CONTROL HTTP_HOST HTTP_KEEP_ALIVE HTTP_USER_AGENT
+               HTTP_VERSION PATH_INFO QUERY_STRING REMOTE_ADDR REMOTE_HOST
+               REQUEST_METHOD REQUEST_PATH REQUEST_URI ]
+    vars = request(@env).http_variables
+    vars.keys.sort.should == keys
+    vars.values_at(*keys).should == @env.values_at(*keys)
+  end
+
+  should 'provide #accept_charset' do
+    request(@env).accept_charset.should == 'UTF-8'
   end
 end

data/spec/ramaze/view/erubis/external.rhtml

@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <title>Erubis Test</title>
+  </head>
+  <body>
+    <h1>Erubis Template</h1>
+  </body>
+</html>

data/spec/ramaze/view/erubis/sum.rhtml

@@ -0,0 +1 @@
+<div><%= @num1 + @num2 %></div>

data/spec/ramaze/view/erubis.rb

@@ -0,0 +1,73 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'spec/helper'
+spec_require 'erubis'
+
+Ramaze::App.options.views = 'erubis'
+
+class SpecErubis < Ramaze::Controller
+  map '/'
+  engine :Erubis
+
+  def index
+    '<h1>Erubis Index</h1>'
+  end
+
+  def links
+    '<ul>
+      <li><%= a("Index page", :index) %></li>
+      <li><%= a("Internal template", :internal) %></li>
+      <li><%= a("External template", :external) %></li>
+    </ul>'.ui
+  end
+
+  def sum(num1, num2)
+    @num1, @num2 = num1.to_i, num2.to_i
+  end
+end
+
+describe "Ramaze::View::Erubis" do
+  behaves_like :mock
+
+  should 'render' do
+    got = get('/')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.strip.should == "<h1>Erubis Index</h1>"
+  end
+
+  should 'use other helper methods' do
+    got = get('/links')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.strip.should ==
+'<ul>
+  <li><a href="/index">Index page</a></li>
+  <li><a href="/internal">Internal template</a></li>
+  <li><a href="/external">External template</a></li>
+</ul>'
+  end
+
+  should 'render external template' do
+    got = get('/external')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.strip.should ==
+"<html>
+  <head>
+    <title>Erubis Test</title>
+  </head>
+  <body>
+    <h1>Erubis Template</h1>
+  </body>
+</html>"
+  end
+
+  should 'render external template with instance variables' do
+    got = get('/sum/1/2')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.strip.should == "<div>3</div>"
+  end
+end

data/spec/ramaze/view/ezamar/external.zmr

@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <title>Ezamar Test</title>
+  </head>
+  <body>
+    <h1>Ezamar Template</h1>
+  </body>
+</html>

data/spec/ramaze/view/ezamar/sum.zmr

@@ -0,0 +1 @@
+<div>#{@num1 + @num2}</div>

data/spec/ramaze/view/ezamar.rb

@@ -0,0 +1,73 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'spec/helper'
+spec_require 'ezamar'
+
+Ramaze::App.options.views = 'ezamar'
+
+class SpecEzamar < Ramaze::Controller
+  map '/'
+  engine :Ezamar
+
+  def index
+    '<h1>Ezamar Index</h1>'
+  end
+
+  def links
+    '<ul>
+      <li>#{a "Index page", r(:index) }</li>
+      <li>#{a "Internal template", r(:internal) }</li>
+      <li>#{a "External template", r(:external) }</li>
+    </ul>'.ui
+  end
+
+  def sum(num1, num2)
+    @num1, @num2 = num1.to_i, num2.to_i
+  end
+end
+
+describe "Ramaze::View::Ezamar" do
+  behaves_like :mock
+
+  should 'render' do
+    got = get('/')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.strip.should == "<h1>Ezamar Index</h1>"
+  end
+
+  should 'use other helper methods' do
+    got = get('/links')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.strip.should ==
+'<ul>
+  <li><a href="/index">Index page</a></li>
+  <li><a href="/internal">Internal template</a></li>
+  <li><a href="/external">External template</a></li>
+</ul>'
+  end
+
+  should 'render external template' do
+    got = get('/external')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.strip.should ==
+"<html>
+  <head>
+    <title>Ezamar Test</title>
+  </head>
+  <body>
+    <h1>Ezamar Template</h1>
+  </body>
+</html>"
+  end
+
+  should 'render external template with instance variables' do
+    got = get('/sum/1/2')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.strip.should == "<div>3</div>"
+  end
+end

data/spec/ramaze/view/haml/external.haml

@@ -0,0 +1,5 @@
+%html
+  %head
+    %title Haml Test
+  %body
+    %h1 Haml Template

data/spec/ramaze/view/haml/sum.haml

@@ -0,0 +1,2 @@
+%div
+  = @num1 + @num2