manveru-ramaze 2009.01 → 2009.04

data/spec/ramaze/helper/paginate.rb

@@ -0,0 +1,68 @@
+require 'spec/helper'
+spec_require 'hpricot'
+
+class SpecHelperPaginateArray < Ramaze::Controller
+  map '/array'
+  helper :paginate
+
+  ALPHA = %w[ alpha beta gamma delta epsilon zeta eta theta iota kappa lambda
+              mu nu xi omicron pi rho sigma tau ypsilon phi chi psi omega ]
+
+  def navigation
+    pager = paginate(ALPHA)
+    pager.navigation
+  end
+
+  def iteration
+    pager = paginate(ALPHA)
+    out = []
+    pager.each{|item| out << item }
+    out.inspect
+  end
+end
+
+describe Ramaze::Helper::Paginate do
+  describe 'Array' do
+    behaves_like :mock
+
+    it 'shows navigation for page 1' do
+      doc = Hpricot(get("/array/navigation").body)
+      (doc/:a).map{|a| [a.inner_text, a[:href]] }.
+        should == [
+          ['1', '/array/navigation?pager=1'],
+          ['2', '/array/navigation?pager=2'],
+          ['3', '/array/navigation?pager=3'],
+          ['>', '/array/navigation?pager=2'],
+          ['>>', '/array/navigation?pager=3']]
+    end
+
+    it 'shows navigation for page 2' do
+      doc = Hpricot(get("/array/navigation?pager=2").body)
+      (doc/:a).map{|a| [a.inner_text, a[:href]] }.
+        should == [
+          ['<<', '/array/navigation?pager=1'],
+          ['<', '/array/navigation?pager=1'],
+          ['1', '/array/navigation?pager=1'],
+          ['2', '/array/navigation?pager=2'],
+          ['3', '/array/navigation?pager=3'],
+          ['>', '/array/navigation?pager=3'],
+          ['>>', '/array/navigation?pager=3']]
+    end
+
+    it 'shows navigation for page 3' do
+      doc = Hpricot(get("/array/navigation?pager=3").body)
+      (doc/:a).map{|a| [a.inner_text, a[:href]] }.
+        should == [
+          ['<<', '/array/navigation?pager=1'],
+          ['<', '/array/navigation?pager=2'],
+          ['1', '/array/navigation?pager=1'],
+          ['2', '/array/navigation?pager=2'],
+          ['3', '/array/navigation?pager=3']]
+    end
+
+    it 'iterates over the items in the pager' do
+      got = get('/array/iteration')
+      got.body.scan(/\w+/).should == SpecHelperPaginateArray::ALPHA.first(10)
+    end
+  end
+end

data/spec/ramaze/helper/request_accessor.rb

@@ -0,0 +1,19 @@
+require 'spec/helper'
+
+class SpecHelperRequestAccessor < Ramaze::Controller
+  map '/'
+  helper :request_accessor
+
+  def index
+    get? ? 'GET' : request_method
+  end
+end
+
+describe 'Ramaze::Helper::RequestAccessor' do
+  behaves_like :mock
+
+  it 'gives direct access to methods in Request' do
+    get('/').body.should == 'GET'
+    put('/').body.should == 'PUT'
+  end
+end

data/spec/ramaze/helper/sequel_form.rb

@@ -0,0 +1,89 @@
+require 'spec/helper'
+
+spec_requires 'hpricot', 'sequel'
+
+DB = Sequel.sqlite
+
+class User < Sequel::Model(:user)
+  set_schema do
+    primary_key :id
+
+    boolean :online
+    varchar :name
+    integer :level
+    text :description
+    date :birthday
+    time :created
+  end
+
+  create_table unless table_exists?
+end
+
+class FormController < Ramaze::Controller
+  map '/'
+  helper :sequel_form
+
+  def new
+    sequel_form(User).to_s
+  end
+
+  def new_with_options
+    sequel_form(User, :method => :post, :action => r(:create)).to_s
+  end
+
+  def edit(id)
+    sequel_form(User[id]).to_s
+  end
+
+  def edit_with_options(id)
+    sequel_form(User[id], :method => :post, :action => r(:create)).to_s
+  end
+end
+
+describe Ramaze::Helper::SequelForm do
+  behaves_like :mock
+
+  def hget(uri)
+    got = get(uri)
+    got.status.should == 200
+    Hpricot(got.body)
+  end
+
+  it 'provides forms for model class' do
+    form = hget('/new').at(:form)
+    (form/:input).size.should == 5
+    (form/:input).map{|i| i[:name] }.compact.sort.should == %w[level name online]
+    form.at(:textarea)[:name].should == 'description'
+  end
+
+  it 'provides form for model class with options' do
+    form = hget('/new_with_options').at(:form)
+    form.raw_attributes.should == {'action' => '/create', 'method' => 'post'}
+  end
+
+  data = {
+    :name        => 'manveru',
+    :description => 'Ramaze dev',
+    :online      => true,
+    :level       => 2,
+    :birthday    => Time.now,
+    :created     => Time.now,
+  }
+  User.create(data)
+
+  it 'provides form for instance of model' do
+    form = hget('/edit/1').at(:form)
+    form.at('input[@name=name]').raw_attributes.should ==
+      { 'name' => 'name', 'type' => 'text', 'value' => data[:name] }
+    form.at('input[@name=online]').raw_attributes.should ==
+      { "name" => "online", "type" => "checkbox", "checked" => "checked",
+        "value" => data[:online].to_s }
+    form.at('input[@name=level]').raw_attributes.should ==
+      { "name" => "level", "type" => "text", "value" => data[:level].to_s }
+  end
+
+  it 'provides form with options for instance of model' do
+    hget('/edit_with_options/1').at(:form).raw_attributes.should ==
+      {"action" => "/create", "method" => "post"}
+  end
+end

data/spec/ramaze/helper/simple_captcha.rb

@@ -1,22 +1,45 @@
+#          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/helper/simple_captcha'
 
-describe Ramaze::Helper::SimpleCaptcha do
-  extend Ramaze::Helper::SimpleCaptcha
+class SpecSimpleCaptcha < Ramaze::Controller
+  helper :simple_captcha
+  map '/'
+
+  def ask_question
+    question = simple_captcha
+  end
+
+  def answer_question(with)
+    check_captcha(with) ? 'correct' : 'wrong'
+  end
+end
 
-  # mock session
-  SESSION = {}
-  def session; SESSION; end
+class SpecCustomCaptcha < SpecSimpleCaptcha
+  map '/fish'
 
-  should 'generate question and answer' do
-    simple_captcha
-    question = SESSION[:CAPTCHA][:question]
+  trait :captcha => lambda{
+    ["the answer to everything", 42]
+  }
+end
+
+describe Ramaze::Helper::SimpleCaptcha do
+  behaves_like :mock
+
+  should 'ask question' do
+    get('/ask_question')
+    question = last_response.body
     question.should =~ /^\d+ [+-] \d+$/
+
     lh, m, rh = question.split
+    answer = lh.to_i.send(m, rh.to_i)
 
-    answer = SESSION[:CAPTCHA][:answer]
-    answer.should =~ /^\d+$/
+    get("/answer_question/#{answer}").body.should == 'correct'
+  end
 
-    lh.to_i.send(m, rh.to_i).should == answer.to_i
+  should 'ask custom question' do
+    get('/fish/ask_question').body.should == 'the answer to everything'
+    get('/fish/answer_question/42').body.should == 'correct'
   end
 end

data/spec/ramaze/helper/stack.rb

@@ -1,23 +1,20 @@
-#          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'
 
-class TCStackHelperController < Ramaze::Controller
-  map :/
-  helper :stack, :aspect
+class SpecStackHelper < Ramaze::Controller
+  map '/'
+  helper :stack
+  engine :None
 
-  def index
-    session.inspect
+  def logged_in_page
+    call(r(:login)) unless logged_in?
+    "the logged in page"
   end
 
-  def foo
-    call Rs(:login) unless logged_in?
-    "logged in"
-  end
-
-  def bar
-    call Rs(:login) unless logged_in?
+  def logged_in_params
+    call(r(:login)) unless logged_in?
     request.params.inspect
   end
 
@@ -27,11 +24,11 @@ class TCStackHelperController < Ramaze::Controller
 
   def login
     session[:logged_in] = true
-    answer
+    answer(r(:secure))
   end
 
   def logout
-    session.clear
+    session.delete(:logged_in)
   end
 
   private
@@ -41,33 +38,49 @@ class TCStackHelperController < Ramaze::Controller
   end
 end
 
-describe "StackHelper" do
-  behaves_like 'browser'
-  ramaze(:adapter => :webrick)
-
-  it "conventional login" do
-    Browser.new do
-      get('/secure').should == 'please login'
-      get('/login')
-      get('/secure').should == 'secret content'
-      get('/logout')
-    end
+describe Ramaze::Helper::Stack do
+  behaves_like :mock
+  @uri = 'http://example.org'
+
+  should 'login directly' do
+    get('/secure').body.should == 'please login'
+
+    get('/login').status.should == 302
+    last_response['Location'].should == "#@uri/secure"
+
+    get('/secure').status.should == 200
+    last_response.body.should == 'secret content'
+
+    get('/secure').body.should == 'secret content'
+    get('/logout')
+    get('/secure').body.should == 'please login'
   end
 
-  it "indirect login" do
-    Browser.new do
-      get('/')
-      get('/foo').should == 'logged in'
-      get('/secure').should == 'secret content'
-      eget('/').should == {:logged_in => true}
-    end
+  should 'login via redirects' do
+    get('/logged_in_page').status.should == 302
+    last_response['Location'].should == 'http://example.org/login'
+
+    get('/login').status.should == 302
+    last_response['Location'].should == 'http://example.org/logged_in_page'
+
+    get('/logged_in_page').status.should == 200
+    last_response.body.should == 'the logged in page'
+
+    get('/logout')
+    get('/secure').body.should == 'please login'
   end
 
-  it "indirect login with params" do
-    Browser.new do
-      get('/')
-      eget('/bar', 'x' => 'y').should == {'x' => 'y'}
-      eget('/').should == {:logged_in => true}
-    end
+  should 'login with params via redirects' do
+    get('/logged_in_params?x=y').status.should == 302
+    last_response['Location'].should == 'http://example.org/login'
+
+    get('/login').status.should == 302
+    last_response['Location'].should == 'http://example.org/logged_in_params?x=y'
+
+    get('/logged_in_params?x=y').status.should == 200
+    last_response.body.should == {'x' => 'y'}.inspect
+
+    get('/logout')
+    get('/secure').body.should == 'please login'
   end
 end

data/spec/ramaze/helper/user.rb

@@ -16,11 +16,15 @@ class SpecUserHelper < Ramaze::Controller
   trait :user_model => MockSequelUser
 
   def status
-    logged_in?
+    logged_in? ? 'yes' : 'no'
   end
 
   def login
-    user_login
+    user_login ? 'logged in' : 'failed login'
+  end
+
+  def logout
+    user_logout
   end
 
   def profile
@@ -28,16 +32,41 @@ class SpecUserHelper < Ramaze::Controller
   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 'browser'
-  ramaze :adapter => :webrick
+  behaves_like :mock
 
   should 'login' do
-    Browser.new do
-      get('/status').should == 'false'
-      get('/login', 'name' => 'arthur', 'password' => '42')
-      get('/status').should == 'true'
-      get('/profile').should == MockSequelUser.new.profile
-    end
+    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/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

@@ -1,63 +1,65 @@
+#          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
-  before do
-    @out = []
-    def @out.puts(*args) push(*args) end
-    Ramaze::Logger::Informer.trait[:colorize] = false
-    @inform = Ramaze::Logger::Informer.new(@out)
-  end
+  @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
 
-  it 'info' do
+  should 'log #info' do
     @inform.info('Some Info')
-    @out.first.should =~ format(:info, 'Some Info')
+    @out.last.should =~ format(:info, 'Some Info')
   end
 
-  it 'debug' do
+  should 'log #debug' do
     arr = [:some, :stuff]
     @inform.debug(arr)
-    @out.first.should =~ format(:debug, arr.inspect)
+    @out.last.should =~ format(:debug, arr.inspect)
   end
 
-  it 'warn' do
+  should 'log #warn' do
     @inform.warn('More things')
-    @out.first.should =~ format(:warn, 'More things')
+    @out.last.should =~ format(:warn, 'More things')
   end
 
-  it 'error' do
+  should 'log #error' do
     begin
       raise('Stuff')
     rescue => ex
     end
 
     @inform.error(ex)
-    @out.first.should =~ format(:error, ex.inspect)
+    @out.any?{|o| o =~ format(:error, ex.inspect) }.should.be.true
   end
 
-  it 'should choose stdout on init(stdout,:stdout,STDOUT)' do
+  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
 
-  it 'should choose stderr on init(stderr,:stderr,STDERR)' do
+  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
 
-  it 'should use IO when supplied' do
+  should 'use IO when supplied' do
     i = Ramaze::Logger::Informer.new(s = StringIO.new)
     i.out.should == s
   end
 
-  it 'should open file otherwise' do
+  should 'open file otherwise' do
     begin
       i = Ramaze::Logger::Informer.new('tmp.dummy')
       out = i.out
@@ -68,5 +70,4 @@ describe 'Informer' do
       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/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