ramaze 0.3.9.1 → 2023.01.06

data/spec/ramaze/helper/cache.rb

@@ -1,37 +1,31 @@
-#          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'
-
-class TCCacheHelperController < Ramaze::Controller
-  map :/
+require File.expand_path('../../../../spec/helper', __FILE__)
 
+class SpecHelperCache < Ramaze::Controller
+  map '/'
   helper :cache
-  cache :cached_action
 
-  def index
-    self.class.name
-  end
+  cache_action(:method => :cached_action)
+  cache_action(:method => :with_params)
+  cache_action(:method => :with_type)
 
   def cached_value
-    value_cache[:time] ||= random
+    cache_value[:time] ||= random
   end
 
-  def alt_cached_value
-    cache[:rand] ||= random
-  end
-
-  def uncache_values
-    value_cache.delete :time
-    cache.delete :rand
+  def cached_action
+    random.to_s
   end
 
-  def cached_action
-    random
+  def with_params(foo, bar)
+    "foo: #{foo}, bar: #{bar}, random: #{random}"
   end
 
-  def uncache_actions
-    action_cache.clear
+  def with_type
+    response['Content-Type'] = 'text/plain'
+    random.to_s
   end
 
   private
@@ -41,103 +35,90 @@ class TCCacheHelperController < Ramaze::Controller
   end
 end
 
-class TCCacheHelperTTLController < Ramaze::Controller
+class SpecHelperCacheTTL < Ramaze::Controller
   map '/ttl'
-
   helper :cache
-  cache :index, :ttl => 1
-
-  def cached_list
-    actions_cached.inspect
-  end
+  cache_action(:method => :index, :ttl => 1)
 
   def index
-    rand
+    rand.to_s
   end
 end
 
-class TCCacheHelperKeyController < Ramaze::Controller
+class SpecHelperCacheKey < Ramaze::Controller
   map '/key'
-
   helper :cache
-  cache :name, :key => lambda{ request['name'] }
-
-  def cached_list
-    actions_cached.inspect
-  end
+  cache_action(:method => :index){ request[:name] }
 
-  def name
+  def index
     "hi #{request['name']} #{rand}"
   end
 end
 
-class TCCacheHelperOldController < Ramaze::Controller
-  map '/old'
+describe Ramaze::Helper::Cache do
+  behaves_like :rack_test
 
-  helper :cache
-  trait :actions_cached => [:index, :action]
+  it 'caches actions' do
+    got = get('/cached_action')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.should.not.be.empty
 
-  def index
-    rand
-  end
+    cached_body = got.body
 
-  def action with, param
-    with + param + rand.to_s
+    got = get('/cached_action')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.should == cached_body
   end
-end
 
-describe "CacheHelper" do
-  behaves_like 'http'
-  ramaze
+  it 'caches values' do
+    got = get('/cached_value')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.should.not.be.empty
 
-  def req(path='/', *args) get(path, *args).body end
+    cached_body = got.body
 
-  it "testrun" do
-    req.should == 'TCCacheHelperController'
+    got = get('/cached_value')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.should == cached_body
   end
 
-  it "cached value" do
-    3.times do
-      lambda{ req('/cached_value') }.should.not.change{ req('/cached_value') }
-    end
-
-    3.times do
-      lambda{ req('/uncache_values') }.should.change{ req('/cached_value') }
+  it 'caches actions with params' do
+    2.times do
+      lambda{ get('/with_params/foo/bar').body }.should.not.change{ get('/with_params/foo/bar').body }
     end
 
-    lambda{ req('/uncache_values') }.should.change{ req('/alt_cached_value') }
+    get('/with_params/foo/bar').body.should.not == get('/with_params/baz/quux').body
   end
 
-  it "cached action" do
-    3.times do
-      lambda{ req('/cached_action') }.should.not.change{ req('/cached_action') }
+  it 'preserves the Content-Type' do
+    2.times do
+      lambda{ get('/with_type').body }.should.not.change{ get('/with_type').body }
     end
 
-    3.times do
-      lambda{ req('/uncache_actions') }.should.change{ req('/cached_action') }
-    end
+    get('/with_type')['Content-Type'].should == 'text/plain'
   end
 
-  it "should support options" do
-    req('/ttl/cached_list').should == {:index=>{:ttl=>1}}.inspect
-    req('/key/cached_list').should =~ /^\{:name=>\{:key=>/
-  end
+  it 'caches actions with ttl' do
+    2.times do
+      lambda{ get('/ttl').body }.should.not.change{ get('/ttl').body }
+    end
 
-  it "should expire cache after time-to-live" do
-    orig_value = req('/ttl')
-    req('/ttl').should == orig_value
-    sleep 1
-    req('/ttl').should.not == orig_value
+    lambda{ sleep 1.5; get('/ttl').body }.should.change{ get('/ttl').body }
   end
 
-  it "should cache using key lambda if provided" do
-    lambda{ req('/key/name', :name=>'Aman') }.should.not.change{ req('/key/name', :name=>'Aman') }
-    req('/key/name', :name=>'Bob').should =~ /^hi Bob/
+  it 'caches actions with block keys' do
+    2.times do
+      lambda{ get('/key?name=foo').body }.should.not.change{ get('/key?name=foo').body }
+    end
+
+    get('/key?name=foo').body.should.not == get('/key?name=bar').body
   end
 
-  it "should remain backwards compatible" do
-    lambda{ req('/old') }.should.not.change{ req('/old') }
-    lambda{ req('/old/action/two/three') }.should.not.change{ req('/old/action/one/two') }
-    req('/old/action/two/three').should =~ /^twothree/
+  it 'caches actions on a per-controller basis' do
+    get('/ttl').body.should.not == get('/key').body
   end
 end

data/spec/ramaze/helper/csrf.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../../../spec/helper', __FILE__)
+require 'ramaze/helper/csrf'
+
+class SpecHelperCSRF < Ramaze::Controller
+
+  engine :none
+  helper :csrf
+
+  before_all do
+    csrf_protection :check_post, :protect_me do
+      respond("The specified CSRF token is incorrect.", 401)
+    end
+  end
+
+  def index
+    generate_csrf_token
+  end
+
+  def get
+    return get_csrf_token
+  end
+
+  def check_post
+    "POST allowed."
+  end
+
+  def get_token
+    get_csrf_token
+  end
+end
+
+describe Ramaze::Helper::CSRF do
+  behaves_like :rack_test
+
+  it 'generate a new csrf token' do
+    got = get '/'
+
+    got.status.should.equal 200
+    got.body.should.equal ''
+  end
+
+  it 'retrieve the current CSRF token' do
+    got = get '/get'
+
+    got.status.should.equal 200
+    got.body.length.should.equal 128
+  end
+
+  it 'validate all HTTP requests' do
+    methods = [:get, :post, :put, :delete]
+
+    methods.each do |method|
+      token       = get('/get_token').body
+      got_invalid = self.send(method, '/check_post', :name => "Yorick Peterse")
+      got_valid   = self.send(method, '/check_post', :csrf_token => token)
+
+      got_invalid.status.should.equal 401
+      got_invalid.body.should.equal "The specified CSRF token is incorrect."
+
+      got_valid.status.should.equal 200
+      got_valid.body.should.equal "POST allowed."
+    end
+  end
+end

data/spec/ramaze/helper/email.rb

@@ -0,0 +1,69 @@
+require File.expand_path('../../../../spec/helper', __FILE__)
+require 'ramaze/helper/email'
+
+include Ramaze::Helper::Email
+
+# Modify Net::SMTP so it doesn't actually send the Emails
+class Net::SMTP
+  MockData = {
+    :email     => nil,
+    :sender    => nil,
+    :receivers => [],
+    :helo      => nil,
+    :user      => nil,
+    :secret    => nil,
+    :auth_type => nil
+  }
+
+  def start(helo = 'localhost', user = nil, secret = nil, auth_type = nil)
+    MockData[:helo], MockData[:user], MockData[:secret], MockData[:auth_type] = helo, \
+      user, secret, auth_type
+
+    if block_given?
+      return yield(self)
+    else
+      return self
+    end
+  end
+
+  # Rather than sending the Email we'll store them in a variable
+  def send_message(email, sender, *to_addrs)
+    MockData[:email], MockData[:sender], MockData[:receivers] = email, sender, to_addrs
+  end
+end # Net::SMTP
+
+describe Ramaze::Helper::Email do
+
+  it('The options should be available') do
+    Ramaze::Helper::Email.options.host.should.equal ''
+    Ramaze::Helper::Email.options.auth_type.should.equal :login
+  end
+
+  it('The options should be editable') do
+    Ramaze::Helper::Email.options.host = 'smtp.awesome.tld'
+    Ramaze::Helper::Email.options.host.should.equal 'smtp.awesome.tld'
+  end
+
+  it('Send an Email') do
+    Ramaze::Helper::Email.options.host     = 'smtp_host'
+    Ramaze::Helper::Email.options.username = 'smtp_user'
+    Ramaze::Helper::Email.options.password = 'smtp_pass'
+    Ramaze::Helper::Email.options.sender   = 'email@domain.tld'
+
+    send_email('email@domain.tld', 'simple', 'This is a simple email')
+
+    Net::SMTP::MockData[:helo].should.empty
+    Net::SMTP::MockData[:sender].should.equal    'email@domain.tld'
+    Net::SMTP::MockData[:user].should.equal      'smtp_user'
+    Net::SMTP::MockData[:secret].should.equal    'smtp_pass'
+    Net::SMTP::MockData[:auth_type].should.equal :login
+
+    # Right, time to validate the actual Email itself
+    [
+      /From: email@domain\.tld/,  /To: <email@domain\.tld>/, /Subject: simple/, /\r\n/
+    ].each do |regex|
+      Net::SMTP::MockData[:email].should.match regex
+    end
+  end
+
+end

data/spec/ramaze/helper/flash.rb

@@ -1,120 +1,41 @@
-#          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 TCFlashHelperFirstController < Ramaze::Controller
-  map :/
+class SpecHelperFlash < Ramaze::Controller
+  map '/'
   helper :flash
-
-  def index
-    self.class.name
-  end
-
-  def first_here
-    flash[:first] = 'hey'
-  end
-
-  def then_here
-    flash[:first].to_s
-  end
-
-  def set(*hash)
-    Hash[*hash].each do |key, value|
-      flash[key] = value
-    end
-    hash.inspect
-  end
+  trait :flashbox => "%key : %value"
 
   def box
     flashbox
   end
-end
-
-class TCFlashHelperSecondController < Ramaze::Controller
-  map '/second'
-  helper :flash
-
-  def index
-    self.class.name
-  end
 
-  def first_here
-    flash[:first] = 'hey'
+  def populate_one
+    flash[:one] = 'for starters'
   end
 
-  def then_here
-    flash[:first].to_s
-  end
-end
-
-class TCFlashHelperThirdController < Ramaze::Controller
-  map '/third'
-  helper :flash
-
-  def index
-  end
-
-  def noop
-    'noop'
-  end
-
-  def set par
-    flash[:e] = par
-  end
-
-  def retrieve
-    flash[:e]
+  def populate_two
+    flash[:one] = 'this one'
+    flash[:two] = 'and this'
   end
 end
 
 describe Ramaze::Helper::Flash do
-  behaves_like 'browser'
-  ramaze :adapter => :webrick
+  behaves_like :rack_test
 
-  should "set and forget flash twice" do
-    Browser.new do
-      get('/first_here')
-      get('/then_here').should == 'hey'
-      2.times{ get('/then_here').should.be.empty }
-      get('/first_here')
-      get('/then_here').should == 'hey'
-      get('/then_here').should.be.empty
-    end
+  it 'displays a flashbox with one item' do
+    get('/populate_one')
+    get('/box')
+    last_response.status.should == 200
+    last_response.body.should == 'one : for starters'
   end
 
-  should "work over multiple controllers" do
-    Browser.new do
-      get('/first_here')
-      get('/second/then_here').should == 'hey'
-      get('/then_here').should.be.empty
-      get('/second/then_here').should.be.empty
-      get('/second/first_here')
-      get('/then_here').should == 'hey'
-      get('/second/then_here').should.be.empty
-    end
-  end
-
-  should "set and retrieve custom value" do
-    Browser.new do
-      get('/third/set/foo').should == 'foo'
-      get('/third/retrieve').should == 'foo'
-      2.times{ get('/third/retrieve').should.be.empty }
-    end
-  end
-
-  should "show a flashbox" do
-    Browser.new do
-      error_div = "<div class='flash' id='flash_error'>stuff failed</div>"
-      success_div = "<div class='flash' id='flash_success'>other things worked</div>"
-
-      get('/set/error/stuff%20failed')
-      get('/box').should == error_div
-
-      get('/set/error/stuff%20failed/success/other%20things%20worked')
-      get('/box').should == [error_div, success_div].join("\n")
-
-      get('/box').should.be.empty
-    end
+  it 'displays a flashbox with two items' do
+    get('/populate_two')
+    get('/box')
+    last_response.status.should == 200
+    last_response.body.split("\n").sort.should == ['one : this one', 'two : and this']
   end
 end

data/spec/ramaze/helper/formatting.rb

@@ -1,10 +1,43 @@
-require 'spec/helper'
+#          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 'ramaze/helper/formatting'
 
 describe 'Helper::Formatting' do
   extend Ramaze::Helper::Formatting
 
-  it 'should format numbers' do
+  describe '#number_counter' do
+    extend Ramaze::Helper::Formatting
+
+    it 'gives a correct plural counter' do
+      number_counter(0, 'comment').should == 'no comments'
+      number_counter(1, 'comment').should == 'one comment'
+      number_counter(2, 'comment').should == 'two comments'
+      number_counter(3, 'comment').should == 'three comments'
+      number_counter(4, 'comment').should == 'four comments'
+      number_counter(5, 'comment').should == 'five comments'
+      number_counter(6, 'comment').should == 'six comments'
+      number_counter(7, 'comment').should == 'seven comments'
+      number_counter(8, 'comment').should == 'eight comments'
+      number_counter(9, 'comment').should == 'nine comments'
+      number_counter(10, 'comment').should == 'ten comments'
+      number_counter(11, 'comment').should == '11 comments'
+      number_counter(12, 'comment').should == '12 comments'
+    end
+
+    it 'uses +items+ as plural version' do
+      number_counter(0, 'pants', 'pants').should == 'no pants'
+    end
+
+    it 'tries using the pluralize method on +item+ if no +items+ given' do
+      item = 'person'
+      def item.pluralize; 'people'; end
+      number_counter(0, item).should == 'no people'
+    end
+  end
+
+  it 'formats numbers' do
     number_format(2_123_456).should == '2,123,456'
     number_format(1234.567).should == '1,234.567'
     number_format(123456.789, '.').should == '123.456,789'
@@ -12,9 +45,70 @@ describe 'Helper::Formatting' do
     number_format(132123456.789123, '.').should == '132.123.456,789123'
   end
 
-  it 'should return difference in time as a string' do
-    time_diff(Time.now-29).should == 'less than a minute'
-    time_diff(Time.now-60).should == '1 minute'
-    time_diff(Time.now, Time.now+29, true).should == 'half a minute'
+  it 'returns difference in time as a string' do
+    check = lambda{|diff, string| time_diff(Time.now - diff).should == string }
+
+    check[1, 'less than a minute']
+    check[60, '1 minute']
+    check[60 * 50, 'about 1 hour']
+    check[60 * 120, 'about 2 hours']
+    check[60 * 60 * 24, '1 day']
+    check[60 * 60 * 48, '2 days']
+    check[60 * 60 * 24 * 30, 'about 1 month']
+    check[60 * 60 * 24 * 60, '2 months']
+    check[60 * 60 * 24 * 30 * 20, 'about 1 year']
+    check[60 * 60 * 24 * 30 * 42, 'over 3 years']
+
+    time_diff(Time.now, Time.now + 4, true).should == 'less than 5 seconds'
+    time_diff(Time.now, Time.now + 6, true).should == 'less than 10 seconds'
+    time_diff(Time.now, Time.now + 29, true).should == 'half a minute'
+    time_diff(Time.now, Time.now + 50, true).should == 'less than a minute'
+    time_diff(Time.now, Time.now + 66, true).should == '1 minute'
+  end
+
+  it 'linkifies urls' do
+    auto_link("http://ramaze.net is the coolest framework, but <a href='http://merbivore.com'>merb</a> is good too").should ==
+      "<a href=\"http://ramaze.net\">http://ramaze.net</a> is the coolest framework, but <a href='http://merbivore.com'>merb</a> is good too"
+
+    auto_link("http://ramaze.net", :target => '_blank').should ==
+      "<a href=\"http://ramaze.net\" target='_blank'>http://ramaze.net</a>"
+  end
+
+  it 'auto_links urls, setting the result of the given block as the link text' do
+    auto_link('http://ramaze.net rocks, so does http://rubyonrails.org.') { |url| url.sub!(%r{http://}, '') }.should ==
+      '<a href="http://ramaze.net">ramaze.net</a> rocks, so does <a href="http://rubyonrails.org">rubyonrails.org</a>.'
+  end
+
+  it 'ordinalizes numbers' do
+    ordinal(1).should == '1st'
+    ordinal(2).should == '2nd'
+    ordinal(3).should == '3rd'
+    ordinal(4).should == '4th'
+    ordinal(10).should == '10th'
+    ordinal(12).should == '12th'
+    ordinal(21).should == '21st'
+    ordinal(23).should == '23rd'
+    ordinal(100).should == '100th'
+    ordinal(133).should == '133rd'
+  end
+
+  it 'generates tagclouds' do
+    tags = %w[ruby ruby code ramaze]
+    tagcloud(tags).should ==
+      {"code"=>0.75, "ramaze"=>0.75, "ruby"=>1.0}
+    tagcloud(tags, 0.5, 2.0).should ==
+      {"code"=>0.875, "ramaze"=>0.875, "ruby"=>1.25}
+  end
+
+  it 'converts newlines to br tags' do
+    nl2br("foo\nbar\nfoobar").should == 'foo<br />bar<br />foobar'
+    nl2br("foo\nbar\nfoobar", false).should == 'foo<br>bar<br>foobar'
+  end
+
+  it 'obfuscates email addresses' do
+    obfuscate_email('foo@example.com').
+      should == "<a href=\"mailto:&#102&#111&#111&#064&#101&#120&#097&#109&#112&#108&#101&#046&#099&#111&#109\">&#102&#111&#111&#064&#101&#120&#097&#109&#112&#108&#101&#046&#099&#111&#109</a>"
+    obfuscate_email('foo@example.com', 'mail foo').
+      should == "<a href=\"mailto:&#102&#111&#111&#064&#101&#120&#097&#109&#112&#108&#101&#046&#099&#111&#109\">mail foo</a>"
   end
 end

data/spec/ramaze/helper/gestalt.rb

@@ -0,0 +1,18 @@
+#          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 'ramaze/helper/gestalt'
+
+describe Ramaze::Helper::Gestalt do
+  extend Ramaze::Helper::Gestalt
+
+  it 'has a shortcut for Ramaze::Gestalt::new' do
+    gestalt{ h1('title') }.to_s.should ==
+      Ramaze::Gestalt.new{ h1('title') }.to_s
+  end
+
+  it 'has a shortcut for Ramaze::Gestalt::build' do
+    build{ h1('title') }.should == '<h1>title</h1>'
+  end
+end

data/spec/ramaze/helper/gravatar.rb

@@ -0,0 +1,43 @@
+#          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 'ramaze/helper/gravatar'
+
+describe Ramaze::Helper::Gravatar do
+  extend Ramaze::Helper::Gravatar
+
+  @email = 'ramaze-spec-gravatar@manveru.oib.com'
+  @digest = Digest::MD5.hexdigest(@email)
+
+  def uri(*tail)
+    URI("http://www.gravatar.com/avatar/#{@digest}#{tail.join}")
+  end
+
+  it 'takes an email and turns it into a hashed part of the uri' do
+    gravatar(@email).should == uri
+  end
+
+  it 'takes :size option' do
+    gravatar(@email, :size => 100).should == uri('?size=100')
+  end
+
+  it 'takes :rating option' do
+    gravatar(@email, :rating => 'g').should == uri('?rating=g')
+    gravatar(@email, :rating => 'pg').should == uri('?rating=pg')
+    gravatar(@email, :rating => 'r').should == uri('?rating=r')
+    gravatar(@email, :rating => 'x').should == uri('?rating=x')
+  end
+
+  it 'takes :default option' do
+    gravatar(@email, :default => :identicon).should == uri('?default=identicon')
+    gravatar(@email, :default => :monsterid).should == uri('?default=monsterid')
+    gravatar(@email, :default => :wavatar).should == uri('?default=wavatar')
+    gravatar(@email, :default => 'http://example.com/me.jpg').should == uri('?default=http%3A%2F%2Fexample.com%2Fme.jpg')
+  end
+
+  it 'takes :force option' do
+    gravatar(@email, :force => true).should == uri('?force=1')
+    gravatar(@email, :force => false).should == uri('')
+  end
+end

data/spec/ramaze/helper/layout/alternative.xhtml

@@ -0,0 +1,5 @@
+<em>alternative</em>
+
+<div id="content">
+#@content
+</div>