rjspotter-ramaze 2009.06.29

data/spec/ramaze/helper/user.rb

@@ -0,0 +1,72 @@
+require 'spec/helper'
+
+class MockSequelUser
+  def profile
+    "Arthur Dent, fearful human in outer space!"
+  end
+
+  def self.authenticate(hash)
+    new if hash.values_at('name', 'password') == %w[arthur 42]
+  end
+end
+
+class SpecUserHelper < Ramaze::Controller
+  map '/'
+  helper :user
+  trait :user_model => MockSequelUser
+
+  def status
+    logged_in? ? 'yes' : 'no'
+  end
+
+  def login
+    user_login ? 'logged in' : 'failed login'
+  end
+
+  def logout
+    user_logout
+  end
+
+  def profile
+    user.profile
+  end
+end
+
+Arthur = {
+  :name => 'arthur',
+  :pass => '42',
+  :profile => 'Arthur Dent, fearful human in outer space!'
+}
+
+
+class SpecUserHelperCallback < SpecUserHelper
+  map '/callback'
+  helper :user
+  trait :user_callback => lambda{|hash|
+    Arthur if hash.values_at('name', 'password') == Arthur.values_at(:name, :pass)
+  }
+
+  def profile
+    user[:profile]
+  end
+end
+
+describe Ramaze::Helper::User do
+  behaves_like :rack_test
+
+  should 'login' do
+    get('/status').body.should == 'no'
+    get('/login?name=arthur&password=42').body.should == 'logged in'
+    get('/status').body.should == 'yes'
+    get('/profile').body.should == MockSequelUser.new.profile
+    get('/logout').status.should == 200
+  end
+
+  should 'login via the callback' do
+    get('/callback/status').body.should == 'no'
+    get('/callback/login?name=arthur&password=42').body.should == 'logged in'
+    get('/callback/status').body.should == 'yes'
+    get('/callback/profile').body.should == MockSequelUser.new.profile
+    get('/logout').status.should == 200
+  end
+end

data/spec/ramaze/helper/view/locals.xhtml

@@ -0,0 +1 @@
+#{say}, #{to}!

data/spec/ramaze/helper/view/loop.xhtml

@@ -0,0 +1,4 @@
+<?r (1..5).each do |n| ?>
+  <?r @n = n ?>
+  #{render_template 'num.xhtml'}
+<?r end ?>

data/spec/ramaze/helper/view/num.xhtml

@@ -0,0 +1 @@
+#{@n}

data/spec/ramaze/helper/view/partial.xhtml

@@ -0,0 +1 @@
+From Partial #@here

data/spec/ramaze/helper/view/recursive.xhtml

@@ -0,0 +1,8 @@
+{
+  #@n
+  <?r if @n < 4 ?>
+    <?r @n += 1 ?>
+    #{render_template('recursive.xhtml')}
+  <?r end ?>
+  #@n
+}

data/spec/ramaze/helper/view/recursive_local_ivars.xhtml

@@ -0,0 +1,7 @@
+{
+  #{@n}
+  <?r if @n < 4 ?>
+    #{render_template('recursive_local_ivars.xhtml', :n => @n+1)}
+  <?r end ?>
+  #{@n}
+}

data/spec/ramaze/helper/view/recursive_locals.xhtml

@@ -0,0 +1,7 @@
+{
+  #{n}
+  <?r if n < 4 ?>
+    #{render_template('recursive_locals.xhtml', :n => n+1)}
+  <?r end ?>
+  #{n}
+}

data/spec/ramaze/helper/view/test_template.xhtml

@@ -0,0 +1 @@
+I am a template.

data/spec/ramaze/helper/xhtml.rb

@@ -0,0 +1,32 @@
+require 'spec/helper'
+require 'ramaze/helper/xhtml'
+
+describe Ramaze::Helper::XHTML do
+  extend Ramaze::Helper::XHTML
+
+  should 'answer with <link> on #css' do
+    css(:foo).
+      should == '<link href="/css/foo.css" media="screen" rel="stylesheet" type="text/css" />'
+    css(:foo, 'mobile').
+      should == '<link href="/css/foo.css" media="mobile" rel="stylesheet" type="text/css" />'
+    css(:foo, 'screen', :only => :ie).
+      should == '<!--[if IE]><link href="/css/foo.css" media="screen" rel="stylesheet" type="text/css" /><![endif]-->'
+  end
+
+  should 'answer with <script> on #js' do
+    js(:foo).
+      should == '<script src="/js/foo.js" type="text/javascript"></script>'
+    js('http://example.com/foo.js').
+      should == '<script src="http://example.com/foo.js" type="text/javascript"></script>'
+  end
+
+  should 'answer with multiple <link> on #css_for' do
+    css_for(:foo, :bar).
+      should == "<link href=\"/css/foo.css\" media=\"screen\" rel=\"stylesheet\" type=\"text/css\" />\n<link href=\"/css/bar.css\" media=\"screen\" rel=\"stylesheet\" type=\"text/css\" />"
+  end
+
+  should 'ansewr with multiple <script> on #js_for' do
+    js_for(:foo, :bar).
+      should == "<script src=\"/js/foo.js\" type=\"text/javascript\"></script>\n<script src=\"/js/bar.js\" type=\"text/javascript\"></script>"
+  end
+end

data/spec/ramaze/log/informer.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'
+require 'ramaze/log/informer'
+
+describe 'Informer' do
+  @out = []
+  def @out.puts(*args) push(*args) end
+  Ramaze::Logger::Informer.trait[:colorize] = false
+  @inform = Ramaze::Logger::Informer.new(@out)
+
+  def format(tag, string)
+    /\[\d{4}-\d\d-\d\d \d\d:\d\d:\d\d\] #{tag.to_s.upcase.ljust(5)}  #{Regexp.escape(string)}/
+  end
+
+  should 'log #info' do
+    @inform.info('Some Info')
+    @out.last.should =~ format(:info, 'Some Info')
+  end
+
+  should 'log #debug' do
+    arr = [:some, :stuff]
+    @inform.debug(arr)
+    @out.last.should =~ format(:debug, arr.inspect)
+  end
+
+  should 'log #warn' do
+    @inform.warn('More things')
+    @out.last.should =~ format(:warn, 'More things')
+  end
+
+  should 'log #error' do
+    begin
+      raise('Stuff')
+    rescue => ex
+    end
+
+    @inform.error(ex)
+    @out.any?{|o| o =~ format(:error, ex.inspect) }.should.be.true
+  end
+
+  should 'choose stdout on init(stdout,:stdout,STDOUT)' do
+    a = Ramaze::Logger::Informer.new(STDOUT)
+    b = Ramaze::Logger::Informer.new(:stdout)
+    c = Ramaze::Logger::Informer.new('stdout')
+    [a,b,c].each { |x| x.out.should == $stdout}
+  end
+
+  should 'choose stderr on init(stderr,:stderr,STDERR)' do
+    a = Ramaze::Logger::Informer.new(STDERR)
+    b = Ramaze::Logger::Informer.new(:stderr)
+    c = Ramaze::Logger::Informer.new('stderr')
+    [a,b,c].each { |x| x.out.should == $stderr}
+  end
+
+  should 'use IO when supplied' do
+    i = Ramaze::Logger::Informer.new(s = StringIO.new)
+    i.out.should == s
+  end
+
+  should 'open file otherwise' do
+    begin
+      i = Ramaze::Logger::Informer.new('tmp.dummy')
+      out = i.out
+      out.should.be.instance_of(File)
+      out.path.should == 'tmp.dummy'
+    ensure
+      out.close
+      File.delete('tmp.dummy')
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+#          Copyright (c) 2008 rob@rebeltechnologies.nl
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'spec/helper'
+
+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
+
+	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)
+
+		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

@@ -0,0 +1,153 @@
+#          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'
+
+class TCParamsController < Ramaze::Controller
+  map '/'
+
+  def index
+    "index"
+  end
+
+  def no_params
+    "no params"
+  end
+
+  def single_param param
+    "single param (#{param})"
+  end
+
+  def double_param param1, param2
+    "double param (#{param1}, #{param2})"
+  end
+
+  def all_params *params
+    "all params (#{params.join(', ')})"
+  end
+
+  def at_least_one param, *params
+    "at least one (#{param}, #{params.join(', ')})"
+  end
+
+  def one_default param = 'default'
+    "one_default (#{param})"
+  end
+
+  def cat1__cat11
+    'cat1: cat11'
+  end
+
+  def cat1__cat11__cat111
+    'cat1: cat11: cat111'
+  end
+end
+
+class TCParamsController2 < Ramaze::Controller
+  map '/jo'
+
+  def add(one, two = nil, three = nil)
+    "#{one}:#{two}:#{three}"
+  end
+
+  def keys
+    request.params.keys.inspect
+  end
+end
+
+class TCParamsController3 < Ramaze::Controller
+  map '/ma'
+
+  def index(*args)
+    request.params['foo'].to_s.dump
+  end
+end
+
+describe "Simple Parameters" do
+  behaves_like :rack_test
+
+  def handle(*url)
+    Ramaze::Mock.get(*url).body
+  end
+
+  it "Should respond to no parameters given" do
+    handle('/no_params').should == "no params"
+  end
+
+  it "Should respond to only / with the index" do
+    handle('/').should == "index"
+  end
+
+  it "call /bar though index doesn't take params" do
+    handle('/bar').should == 'No action found at: "/bar"'
+  end
+
+  it "action that takes a single param" do
+    handle('/single_param/foo').should == "single param (foo)"
+  end
+
+  it "action that takes two params" do
+    handle('/double_param/foo/bar').should == "double param (foo, bar)"
+  end
+
+  it "action that takes two params but we give only one" do
+    handle('/double_param/foo').should == 'No action found at: "/double_param/foo"'
+  end
+
+  it "action that takes all params" do
+    handle('/all_params/foo/bar/foobar').should == "all params (foo, bar, foobar)"
+  end
+
+  it "action that takes all params but needs at least one" do
+    handle('/at_least_one/foo/bar/foobar').should == "at least one (foo, bar, foobar)"
+  end
+
+  it "action that takes all params but needs at least one (not given here)" do
+    lambda{ handle('/at_least_one') }.should.raise(ArgumentError)
+  end
+
+  it "one default" do
+    handle('/one_default').should == "one_default (default)"
+  end
+
+  it "one default" do
+    handle('/one_default/my_default').should == "one_default (my_default)"
+  end
+
+  it "double underscore lookup" do
+    handle('/cat1/cat11').should == 'cat1: cat11'
+  end
+
+  it "double double underscore lookup" do
+    handle('/cat1/cat11/cat111').should == 'cat1: cat11: cat111'
+  end
+
+
+  it "jo/add should raise with 0 parameters" do
+    lambda{ handle('/jo/add') }.
+      should.raise(ArgumentError)
+  end
+
+  it "add should raise with 4 parameters" do
+    lambda{ handle('/jo/add/1/2/3/4') }.
+      should.raise(ArgumentError)
+  end
+
+  it "add should not raise with 1-3 parameters" do
+    handle('/jo/add/1').should == '1::'
+    handle('/jo/add/1/2').should == '1:2:'
+    handle('/jo/add/1/2/3').should == '1:2:3'
+  end
+
+  it 'params should have no content without params' do
+    handle('/ma').should == '""'
+  end
+
+  it 'should have a parameter via QUERY_PARAMS' do
+    handle('/ma?foo=bar').should == '"bar"'
+  end
+
+  it 'should handle valueless params' do
+    handle('/jo/keys?foo').should == '["foo"]'
+  end
+end