manveru-ramaze 2009.01 → 2009.04

data/spec/ramaze/error.rb

@@ -1,94 +1,88 @@
-#          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'
-require 'open-uri'
+require 'rexml/document'
+require 'rexml/xpath'
 
-class TCErrorController < Ramaze::Controller
-  map :/
+class SpecError < Ramaze::Controller
+  map '/'
 
-  def index
-    self.class.name
+  def raises
+    blah
   end
 
-  def erroring
-    blah
+  def empty
+    response.status = 404
+    ''
   end
 end
 
-class TCErrorCustomController < Ramaze::Controller
-  map "/custom"
+class SpecErrorHandling < SpecError
+  map '/handle'
 
-  def error
-    "The error page of custom"
+  def self.action_missing(path)
+    try_resolve("/not_found")
   end
 
-  def erroring
-    bluh
+  def not_found
+    "Sorry, this document doesn't exist"
+  end
+
+  def name_error
+    "Sorry, this name doesn't exist"
   end
 end
 
-describe "Error" do
-  behaves_like 'http'
-  ramaze :error_page => true,
-         :view_root => 'spec/ramaze/public'
+describe 'Error handling' do
+  behaves_like :mock
 
-  @handle_error = Ramaze::Dispatcher::Error::HANDLE_ERROR
-  @orig_handle_error = @handle_error.dup
+  Ramaze.options.mode = :live
 
-  before do
-    Ramaze::Cache.resolved.clear
-    Ramaze::Cache.patterns.clear
-    @handle_error.clear
-    @handle_error.merge!(@orig_handle_error)
-  end
+  it 'uses Rack::ShowException to display errors' do
+    got = get('/raises')
+    [got.status, got['Content-Type']].should == [500, 'text/html']
 
-  it 'should resolve custom error pages per controller' do
-    response = get("/custom/does_not_exist")
-    response.status.should == 404
-    response.body.should == "The error page of custom"
+    # we use this xpath notation because otherwise rexml is really slow...
+    doc = REXML::Document.new(got.body)
+    REXML::XPath.first(doc, "/html/body/div[1]/h1").text.
+      should == "NameError at /raises"
+    REXML::XPath.first(doc, "/html/body/div[4]/p/code").text.
+      should == "Rack::ShowExceptions"
   end
 
-  it 'should throw errors from rendering' do
-    response = get('/erroring')
-    response.status.should == 500
-    regex = %r(undefined local variable or method `blah' for .*?TCErrorController)
-    response.body.should =~ regex
-  end
+  it 'uses original action_missing when no action was found' do
+    got = get('/missing')
+    [got.status, got['Content-Type']].should == [404, 'text/plain']
 
-  it 'should throw errors from rendering' do
-    response = get('/custom/erroring')
-    response.status.should == 500
-    response.body.should == "The error page of custom"
+    got.body.should == 'No action found at: "/missing"'
   end
 
-  it 'should give 404 when no action is found' do
-    response = get('/foobar')
-    response.status.should == 404
-    response.body.should =~ %r(No Action found for `/foobar' on TCErrorController)
+  it 'uses custom action_missing when no action was found' do
+    got = get('/handle/mssing')
+    [got.status, got['Content-Type']].should == [200, 'text/html']
+
+    got.body.should == "Sorry, this document doesn't exist"
   end
 
-  it "should give custom status when no action is found" do
-    @handle_error[Ramaze::Error::NoAction] = [707, '/error']
+  it 'uses Rack::RouteExceptions when a route is set' do
+    Rack::RouteExceptions[NameError] = '/handle/name_error'
 
-    response = get('/illegal1')
-    response.status.should == 707
-    response.body.should =~ %r(No Action found for `/illegal1' on TCErrorController)
-  end
+    got = get('/raises')
+    [got.status, got['Content-Type']].should == [200, 'text/html']
 
-  it "should give 404 when no controller is found" do
-    old_mapping = Ramaze::Global.mapping.dup
-    Ramaze::Global.mapping.clear
-    response = get('/illegal2')
-    response.status.should == 404
-    response.body.should =~ %r(No Controller found for `/error')
-    Ramaze::Global.mapping = old_mapping
+    got.body.should == "Sorry, this name doesn't exist"
   end
 
-  it "should return custom error page" do
-    @handle_error[Ramaze::Error::NoAction] = [404, '/error404']
-    response = get('/illegal3')
-    response.status.should == 404
-    response.body.should == '404 - not found'
+  it 'uses Rack::ShowStatus for empty responses > 400' do
+    got = get('/empty')
+    [got.status, got['Content-Type']].should == [404, 'text/html']
+
+    # we use this xpath notation because otherwise rexml is really slow...
+    doc = REXML::Document.new(got.body)
+    REXML::XPath.first(doc, "/html/body/div[1]/h1").text.strip.
+      should == "Not Found"
+    REXML::XPath.first(doc, "/html/body/div[3]/p/code").text.
+      should == "Rack::ShowStatus"
   end
 end

data/spec/ramaze/files/public_1/plain.txt

@@ -0,0 +1 @@
+Just some text in a file

data/spec/ramaze/files/public_2/rich.txt

@@ -0,0 +1 @@
+Some rich text in here

data/spec/ramaze/files.rb

@@ -0,0 +1,29 @@
+require 'spec/helper'
+
+class SpecFilesCore < Ramaze::Controller
+  map '/', :core
+end
+
+class SpecFilesOther < Ramaze::Controller
+  map '/', :other
+end
+
+Ramaze::App[:core].location = '/'
+Ramaze::App[:core].options.publics = 'files/public_1'
+
+Ramaze::App[:other].location = '/other'
+Ramaze::App[:other].options.publics = 'files/public_2'
+
+Ramaze.middleware!(:spec){|m| m.run(Ramaze::AppMap) }
+
+describe Ramaze::Files do
+  behaves_like :mock
+
+  it 'serves files for core app from public_1' do
+    get('/plain.txt').body.should == "Just some text in a file\n"
+  end
+
+  it 'serves files for other app from public_2' do
+    get('/other/rich.txt').body.should == "Some rich text in here\n"
+  end
+end

data/spec/ramaze/gestalt.rb

@@ -1,9 +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.
+# * Encoding: UTF-8
 
 require 'spec/helper'
-
-spec_require 'ramaze/gestalt'
+require 'ramaze/gestalt'
 
 describe "Gestalt" do
   # This is useful for any controller using Gestalt,

data/spec/ramaze/helper/auth.rb

@@ -1,9 +1,11 @@
-#          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 TCAuthHelperController < Ramaze::Controller
+$password = Digest::SHA1.hexdigest('pass')
+
+class SpecHelperAuth < Ramaze::Controller
   map '/'
   helper :auth
 
@@ -21,45 +23,60 @@ class TCAuthHelperController < Ramaze::Controller
   before(:secured){ login_required }
 end
 
-class TCAuthHashHelperController < TCAuthHelperController
+class SpecHelperAuthHash < SpecHelperAuth
   map '/hash'
   trait :auth_table => {
-      'manveru' => '5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8'
+      'manveru' => $password
     }
 end
 
-class TCAuthMethodHelperController < TCAuthHelperController
+class SpecHelperAuthMethod < SpecHelperAuth
   map '/method'
   trait :auth_table => :auth_table
 
+  private
+
   def auth_table
-    { 'manveru' => '5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8' }
+    { 'manveru' => $password }
   end
 end
 
-class TCAuthLambdaHelperController < TCAuthHelperController
+class SpecHelperAuthLambda < SpecHelperAuth
   map '/lambda'
   trait :auth_table => lambda{
-      { 'manveru' => '5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8' }
+      { 'manveru' => $password }
     }
 end
 
-describe "StackHelper" do
-  behaves_like 'browser'
-
-  ramaze :adapter => :webrick
-  [ TCAuthHashHelperController,
-    TCAuthMethodHelperController,
-    TCAuthLambdaHelperController
-  ].each do |controller|
-
-    it controller.to_s do
-      Browser.new(Ramaze::Global.mapping.invert[controller]) do
-        get('/secured').should == ''
-        post('/login', 'username' => 'manveru', 'password' => 'password')
-        get('/secured').should == 'Secret content'
-        get('/logout')
-        get('/secured').should == ''
+describe Ramaze::Helper::Auth do
+  %w[ hash lambda method ].each do |prefix|
+    describe "login" do
+      behaves_like :mock
+
+      it "uses a #{prefix}" do
+        get "/#{prefix}/secured"
+        follow_redirect!
+        last_response.status.should == 200
+        last_response.body.should =~ (/<form/)
+
+        post("/#{prefix}/login", 'username' => 'manveru', 'password' => 'pass')
+        follow_redirect!
+        last_response.status.should == 200
+        last_response.body.should == 'Secret content'
+
+        get "/#{prefix}/secured"
+        last_response.status.should == 200
+        last_response.body.should == 'Secret content'
+
+        get "/#{prefix}/logout"
+        follow_redirect!
+        last_response.status.should == 200
+        last_response.body.should == 'SpecHelperAuth'
+
+        get "/#{prefix}/secured"
+        follow_redirect!
+        last_response.status.should == 200
+        last_response.body.should =~ (/<form/)
       end
     end
   end

data/spec/ramaze/helper/bench.rb

@@ -0,0 +1,17 @@
+require 'spec/helper'
+require 'ramaze/helper/bench'
+
+describe Ramaze::Helper::Bench do
+  extend Ramaze::Helper::Bench
+
+  log = []
+  def log.info(arg); push(arg); end
+  Ramaze::Log.loggers = [log]
+
+  it 'logs running time' do
+    result = bench{ sleep 0.1; 'result' }
+    result.should == 'result'
+    log.size.should == 1
+    log.pop.should =~ %r!Bench #{__FILE__}:#{__LINE__ - 3}: \d\.\d+!
+  end
+end

data/spec/ramaze/helper/cache.rb

@@ -1,37 +1,31 @@
-#          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 TCCacheHelperController < Ramaze::Controller
-  map :/
-
+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
-  end
-
-  def alt_cached_value
-    cache[:rand] ||= random
+    cache_value[:time] ||= 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,120 +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 :mock
 
-  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
-
-
 
-# TODO:
-#   * specs fail horribly with the yaml store.
-caches = {:memory => 'Hash'}
+  it 'caches values' do
+    got = get('/cached_value')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.should.not.be.empty
 
-begin
-  require 'memcache'
-  caches[:memcached] = 'Ramaze::MemcachedCache'
-rescue LoadError
-  puts "skipping memcached"
-end
-
-caches.each do |cache, name|
-  Ramaze::Global.cache = cache
+    cached_body = got.body
 
-  describe "CacheHelper on #{name}" do
-    behaves_like 'http'
-    ramaze
-
-    def req(path='/', *args) get(path, *args).body end
+    got = get('/cached_value')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.should == cached_body
+  end
 
-    it "testrun" do
-      req.should == 'TCCacheHelperController'
+  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
 
-    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') }
-      end
+    get('/with_params/foo/bar').body.should.not == get('/with_params/baz/quux').body
+  end
 
-      lambda{ req('/uncache_values') }.should.change{ req('/alt_cached_value') }
+  it 'preserves the Content-Type' do
+    2.times do
+      lambda{ get('/with_type').body }.should.not.change{ get('/with_type').body }
     end
 
-    it "cached action" do
-      3.times do
-        lambda{ req('/cached_action') }.should.not.change{ req('/cached_action') }
-      end
+    get('/with_type')['Content-Type'].should == 'text/plain'
+  end
 
-      3.times do
-        lambda{ req('/uncache_actions') }.should.change{ req('/cached_action') }
-      end
+  it 'caches actions with ttl' do
+    2.times do
+      lambda{ get('/ttl').body }.should.not.change{ get('/ttl').body }
     end
 
-    it "should support options" do
-      req('/ttl/cached_list').should == {:index=>{:ttl=>1}}.inspect
-      req('/key/cached_list').should =~ /^\{:name=>\{:key=>/
-    end
+    lambda{ sleep 1; get('/ttl').body }.should.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
+  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
 
-    it "should cache using key lambda if provided" do
-      req('/key/name', :name=>'Aman').should == req('/key/name', :name=>'Aman')
-      req('/key/name', :name=>'Bob').should =~ /^hi Bob/
-    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/
-    end
+  it 'caches actions on a per-controller basis' do
+    get('/ttl').body.should.not == get('/key').body
   end
 end