ramaze 0.3.9.1 → 2023.01.06

data/spec/ramaze/log/syslog.rb

@@ -1,10 +1,95 @@
-require 'spec/helper'
+# -*- coding: utf-8 -*-
+#          Copyright (c) 2008 rob@rebeltechnologies.nl
+# All files in this distribution are subject to the terms of the MIT license.
+
+require File.expand_path('../../../../spec/helper', __FILE__)
+
+spec_precondition 'Process.fork should be supported' do
+  if RUBY_DESCRIPTION.include?('jruby')
+    should.flunk 'These tests use Process.fork which does not work on jruby'
+  end
+end
 
 require 'ramaze/log/syslog'
 
 describe 'Syslog' do
-  it 'should do something' do
-    syslog = Ramaze::Syslog.new
-    syslog.send(:ident).should =~ /#{Regexp.escape(__FILE__)}$/
+
+  # close the syslog, if it was open for some reason before we
+  # start a test.
+  before do
+    Syslog.close if Syslog.opened?
+  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
+
+  # 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)
+    label = case priority
+            # when 'debug', 'info', 'error'
+            #   priority
+            when :dev
+              'debug'
+            when :warn
+              'warning'
+            else
+              priority.to_s
+            end
+    logpipe[0].gets.slice(/ramaze.*/).should == "ramaze_syslog_test[#{child}] <#{label.capitalize}>: #{msg}"
+  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
+
+  it 'should escape % sequences' do
+    test_log_msg :direct, :info, "Hello Cruel |évil| 戈 REAL %s World"
   end
 end

data/spec/ramaze/params.rb

@@ -1,7 +1,7 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
 
-require 'spec/helper'
+require File.expand_path('../../../spec/helper', __FILE__)
 
 class TCParamsController < Ramaze::Controller
   map '/'
@@ -51,7 +51,7 @@ class TCParamsController2 < Ramaze::Controller
   end
 
   def keys
-    request.params.keys.to_s.dump
+    request.params.keys.inspect
   end
 end
 
@@ -64,11 +64,10 @@ class TCParamsController3 < Ramaze::Controller
 end
 
 describe "Simple Parameters" do
-  behaves_like 'http'
-  ramaze
+  behaves_like :rack_test
 
   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
@@ -106,8 +103,7 @@ describe "Simple Parameters" do
   end
 
   it "action that takes all params but needs at least one (not given here)" do
-    lambda{ handle('/at_least_one') }.
-      should.raise(ArgumentError)
+    lambda{ handle('/at_least_one') }.should.raise(ArgumentError)
   end
 
   it "one default" do
@@ -144,14 +140,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,173 +1,64 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
 
-require 'spec/helper'
+require File.expand_path('../../../spec/helper', __FILE__)
 
-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 {}
-ramaze options.merge(:public_root => 'spec/ramaze/public')
-
-describe "Request" do
-  behaves_like 'http'
-
-  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'
+describe 'Ramaze::Request' do
+  def request(env = {})
+    Ramaze::Request.new(env)
   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
+  @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
 
-  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
+  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
 
-  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
+  should 'provide #accept_charset' do
+    request(@env).accept_charset.should == 'UTF-8'
   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
+  should 'properly parse requested locale' do
+    header = { "HTTP_ACCEPT_LANGUAGE" => "sv-se,sv;q=0.8,en-us;q=0.5,en;q=0.3" }
+    request(@env.merge(header)).accept_language_with_weight.should == [
+      ['sv-se', 1.0], ['sv', 0.8], ['en-us', 0.5], ['en', 0.3]
+    ]
 
-      response = get(css_path)
-      response.status.should == 200
-      response.body.strip.should == static_css
-    end
+    header = { "HTTP_ACCEPT_LANGUAGE" => "nl-nl" }
+    request(@env.merge(header)).accept_language_with_weight.should == [
+      ['nl-nl', 1.0]
+    ]
   end
 end

data/spec/ramaze/rewrite/file.css

@@ -0,0 +1 @@
+this is css

data/spec/ramaze/session/lru.rb

@@ -0,0 +1,58 @@
+require File.expand_path('../../../../spec/helper', __FILE__)
+spec_require 'sequel'
+
+class SpecSession < Ramaze::Controller
+  map '/'
+  engine :None
+
+  def index
+    'No session here'
+  end
+
+  def init
+    session[:counter] = 0
+  end
+
+  def view
+    session[:counter]
+  end
+
+  def increment
+    session[:counter] += 1
+  end
+
+  def decrement
+    session[:counter] -= 1
+  end
+
+  def reset
+    session.clear
+  end
+end
+
+Ramaze::Cache.options.session = Ramaze::Cache::LRU
+
+describe 'Sessions with Ramaze::Cache::LRU' do
+  behaves_like :rack_test
+
+  should 'initiate session as needed' do
+    get '/'
+    last_response.body.should == 'No session here'
+    last_response['Set-Cookie'].should == nil
+
+    get('/init')
+    last_response.body.should == '0'
+
+    1.upto(10) do |n|
+      get('/increment').body.should == n.to_s
+    end
+
+    get('/reset')
+    get('/view').body.should == ''
+    get('/init').body.should == '0'
+
+    -1.downto(-10) do |n|
+      get('/decrement').body.should == n.to_s
+    end
+  end
+end

data/spec/ramaze/session/memcache.rb

@@ -0,0 +1,66 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+
+require File.expand_path('../../../../spec/helper', __FILE__)
+require 'dalli'
+
+spec_precondition 'memcached is running' do
+  cache = Dalli::Client.new('localhost:11211')
+  cache.set('active', true)
+end
+
+class SpecSession < Ramaze::Controller
+  map '/'
+  engine :None
+
+  def index
+    'No session here'
+  end
+
+  def init
+    session[:counter] = 0
+  end
+
+  def view
+    session[:counter]
+  end
+
+  def increment
+    session[:counter] += 1
+  end
+
+  def decrement
+    session[:counter] -= 1
+  end
+
+  def reset
+    session.clear
+  end
+end
+
+Ramaze::Cache.options.session = Ramaze::Cache::MemCache
+
+describe 'Sessions with Ramaze::Cache::MemCache' do
+  behaves_like :rack_test
+
+  should 'initiate session as needed' do
+    get '/'
+    last_response.body.should == 'No session here'
+    last_response['Set-Cookie'].should == nil
+
+    get('/init')
+    last_response.body.should == '0'
+
+    1.upto(10) do |n|
+      get('/increment').body.should == n.to_s
+    end
+
+    get('/reset')
+    get('/view').body.should == ''
+    get('/init').body.should == '0'
+
+    -1.downto(-10) do |n|
+      get('/decrement').body.should == n.to_s
+    end
+  end
+end

data/spec/ramaze/session/redis.rb

@@ -0,0 +1,63 @@
+require File.expand_path('../../../../spec/helper', __FILE__)
+spec_require 'redis'
+
+spec_precondition 'Redis is running' do
+  cache = Redis.new
+  "OK" == cache.set('testkey', 'testval')
+end
+
+class SpecSession < Ramaze::Controller
+  map '/'
+  engine :None
+
+  def index
+    'No session here'
+  end
+
+  def init
+    session[:counter] = 0
+  end
+
+  def view
+    session[:counter]
+  end
+
+  def increment
+    session[:counter] += 1
+  end
+
+  def decrement
+    session[:counter] -= 1
+  end
+
+  def reset
+    session.clear
+  end
+end
+
+Ramaze::Cache.options.session = Ramaze::Cache::Redis
+
+describe 'Sessions with Ramaze::Cache::Redis' do
+  behaves_like :rack_test
+
+  should 'initiate session as needed' do
+    get '/'
+    last_response.body.should == 'No session here'
+    last_response['Set-Cookie'].should == nil
+
+    get('/init')
+    last_response.body.should == '0'
+
+    1.upto(10) do |n|
+      get('/increment').body.should == n.to_s
+    end
+
+    get('/reset')
+    get('/view').body.should == ''
+    get('/init').body.should == '0'
+
+    -1.downto(-10) do |n|
+      get('/decrement').body.should == n.to_s
+    end
+  end
+end

data/spec/ramaze/session/sequel.rb

@@ -0,0 +1,62 @@
+require File.expand_path('../../../../spec/helper', __FILE__)
+
+spec_require 'sqlite3'
+spec_require 'sequel'
+
+class SpecSession < Ramaze::Controller
+  map '/'
+  engine :None
+
+  def index
+    'No session here'
+  end
+
+  def init
+    session[:counter] = 0
+  end
+
+  def view
+    session[:counter]
+  end
+
+  def increment
+    session[:counter] += 1
+  end
+
+  def decrement
+    session[:counter] -= 1
+  end
+
+  def reset
+    session.clear
+  end
+end
+
+Ramaze::Cache.options.session = Ramaze::Cache::Sequel.using(
+  :connection => Sequel.sqlite(':memory:')
+)
+
+describe 'Sessions with Ramaze::Cache::Sequel' do
+  behaves_like :rack_test
+
+  should 'initiate session as needed' do
+    get '/'
+    last_response.body.should == 'No session here'
+    last_response['Set-Cookie'].should == nil
+
+    get('/init')
+    last_response.body.should == '0'
+
+    1.upto(10) do |n|
+      get('/increment').body.should == n.to_s
+    end
+
+    get('/reset')
+    get('/view').body.should == ''
+    get('/init').body.should == '0'
+
+    -1.downto(-10) do |n|
+      get('/decrement').body.should == n.to_s
+    end
+  end
+end

data/spec/ramaze/view/erector/external_view.erector

@@ -0,0 +1,5 @@
+class ExternalView < Erector::Widget
+  def content
+    p 'view body.'
+  end
+end

data/spec/ramaze/view/erector/index.erector

@@ -0,0 +1,5 @@
+class Index < Erector::Widget
+  def content
+    p 'paragraph text'
+  end
+end

data/spec/ramaze/view/erector/layout.erector

@@ -0,0 +1,13 @@
+class Layout < Erector::Widget
+  def content
+    html do
+      head do
+        title 'erector'
+      end
+      
+      body do
+        rawtext @content
+      end
+    end
+  end
+end