Pistos-ramaze 2008.09

data/spec/ramaze/action/cache.rb

@@ -0,0 +1,87 @@
+require 'spec/helper'
+
+class TCActionCache < Ramaze::Controller
+  map '/'
+  helper :cache
+
+  def index
+    rand
+  end
+  cache :index
+end
+
+class TCOtherCache < Ramaze::Controller
+  map '/other'
+  helper :cache
+
+  def foo
+    rand
+  end
+  cache :foo
+
+  def query
+    @foo = request['foo']
+    '#{rand} #{@foo}'
+  end
+  cache :query, :key => lambda{ request['foo'] }
+
+  def set_flash
+    flash[:message] = "This is a random flash message: #{rand}"
+  end
+
+  def use_flash
+    '#{rand} - Flash message: #{flash[:message]}'
+  end
+  cache :use_flash
+end
+
+describe 'Action rendering' do
+  behaves_like 'http', 'browser'
+  ramaze :adapter => :webrick
+
+  def req(path)
+    r = get(path)
+    [ r.content_type, r.body ]
+  end
+
+  should 'cache /' do
+    lambda{ req('/') }.should.not.change{ req('/') }
+  end
+
+  should 'cache /other/foo' do
+    lambda{ req('/other/foo') }.should.not.change{ req('/other/foo') }
+  end
+
+  should 'respect custom cache key' do
+    get('/other/query', {:foo => 1}).body.should == get('/other/query', {:foo => 1}).body
+    get('/other/query', {:foo => 1}).body.should.not == get('/other/query', {:foo => 2}).body
+  end
+
+  should 'not cache when flash data exists and no_cache_flash is on' do
+    Ramaze::Global.no_cache_flash = true
+    b = Browser.new
+
+    # If there's no flash data, caching should operate.
+    b.get('/other/use_flash').should == b.get('/other/use_flash')
+
+    # When flash data exists, should ignore cache and generate fresh response.
+    prev = b.get('/other/use_flash')
+    b.get('/other/set_flash')
+    b.get('/other/use_flash').should.not == prev
+    # On next request, flash data should be gone, so get cached response.
+    b.get('/other/use_flash').should == prev
+  end
+
+  should 'always cache if no_cache_flash is off' do
+    Ramaze::Global.no_cache_flash = false
+    b = Browser.new
+
+    b.get('/other/use_flash').should == b.get('/other/use_flash')
+
+    # When flash data exists, should still cache.
+    prev = b.get('/other/use_flash')
+    b.get('/other/set_flash')
+    b.get('/other/use_flash').should == prev
+  end
+
+end

data/spec/ramaze/action/file_cache.rb

@@ -0,0 +1,70 @@
+require 'spec/helper'
+
+# Tests the file_cache facility that saves rendered content to files in
+# /public and hence serves up the static files for subsequent requests.
+class TCActionCache < Ramaze::Controller
+  map '/'
+  helper :cache
+
+  def index
+    rand
+  end
+  cache :index
+end
+
+class TCOtherCache < Ramaze::Controller
+  map '/other'
+  helper :cache
+
+  def index
+    rand
+  end
+  cache :index
+end
+
+class TCIndexCache < Ramaze::Controller
+  map '/withparams'
+  helper :cache
+
+  def index(somearg = nil)
+    rand + somearg.to_f
+  end
+  alias :nonindex :index
+
+  cache :index, :nonindex
+end
+
+describe 'Action rendering' do
+  behaves_like 'http'
+
+  FileUtils.mkdir_p(public_root = __DIR__/:public)
+
+  ramaze :file_cache => true, :public_root => public_root
+
+  def req(path)
+    r = get(path)
+    [ r.content_type, r.body ]
+  end
+
+  should 'cache to file' do
+    lambda{ req('/') }.should.not.change{ req('/') }
+    File.file?(public_root/'index').should == true
+  end
+
+  should 'create subdirs as needed' do
+    lambda{ req('/other') }.should.not.change{ req('/other') }
+    File.file?(public_root/'other/index').should == true
+  end
+
+  should 'cache action with params' do
+    lambda{ req('/withparams/nonindex/42') }.should.not.change{ req('/withparams/nonindex/42') }
+    File.file?(public_root/'withparams/nonindex/42').should == true
+  end
+
+  should 'cache index action with params' do
+    lambda{ req('/withparams/42') }.should.not.change{ req('/withparams/42') }
+    File.file?(public_root/'withparams/42').should == true
+  end
+
+  FileUtils.rm_rf public_root
+end

data/spec/ramaze/action/layout.rb

@@ -0,0 +1,190 @@
+require 'spec/helper'
+
+class TCActionLayout < Ramaze::Controller
+  map '/'
+  layout '/wrapper'
+
+  def wrapper
+    "<pre>#@content</pre>"
+  end
+
+  def index
+    'Hello, World!'
+  end
+
+  def foo
+    "bar"
+  end
+end
+
+class TCActionOtherLayout < Ramaze::Controller
+  map '/other'
+  layout '/other_wrapper'
+  view_root __DIR__/:view
+
+  def index
+    "Others Hello"
+  end
+end
+
+class TCActionSingleLayout < Ramaze::Controller
+  map '/single'
+  layout '/single_wrapper' => :index
+
+  def index
+    "Single Hello"
+  end
+
+  def without
+    "Without wrapper"
+  end
+end
+
+class TCActionDenyLayout < Ramaze::Controller
+  map '/deny'
+  layout '/single_wrapper'
+  deny_layout :without
+
+  def index
+    "Single Hello"
+  end
+
+  def without
+    "Without wrapper"
+  end
+end
+
+class TCActionMultiLayout < Ramaze::Controller
+  map '/multi'
+  layout '/single_wrapper' => [:index, :second]
+
+  def index
+    "Single Hello"
+  end
+
+  def second
+    "Second with layout"
+  end
+
+  def without
+    "Without wrapper"
+  end
+end
+
+class TCActionSubLayout < Ramaze::Controller
+  map '/sub'
+  layout :sub_wrapper
+
+  def index
+    "Sub Hello"
+  end
+end
+
+class TCReUseActionLayout < Ramaze::Controller
+  map '/reuse'
+  layout '/wrapper'
+
+  def index
+    'hi'
+  end
+
+  def other_layout
+    "#@title: #@content"
+  end
+end
+
+class TCLayoutInstance < Ramaze::Controller
+  map '/reuse_instance'
+  layout '/reuse/other_layout'
+
+  def index
+    @title = 'hello'
+    'world'
+  end
+end
+
+class TCLayoutInstanceVars < Ramaze::Controller
+  map '/instancevars'
+  layout :layout
+
+  def layout
+    @title = "layout"
+  end
+
+  def test
+    'test'
+  end
+end
+
+class TCActionTwoLevelLayout < Ramaze::Controller
+  map '/twolevel'
+  layout :wrapper
+  layout :wrapper2 => [:foo]
+
+  def wrapper
+    "<pre>#@content</pre>"
+  end
+
+  def wrapper2
+    "<code>#@content</code>"
+  end
+
+  def index
+    'Hello, World!'
+  end
+
+  def foo
+    "bar"
+  end
+end
+
+describe 'Action rendering' do
+  behaves_like 'http'
+  ramaze :view_root => __DIR__/:view
+
+  it 'should work with layouts' do
+    get('/').body.should == "<pre>Hello, World!</pre>"
+    get('/foo').body.should == "<pre>bar</pre>"
+    get('/bar').body.should == "<pre>Hello from bar</pre>"
+  end
+
+  it 'should work with layout from file' do
+    get('/other').body.should == "<p>Others Hello</p>"
+    get('/other/bar').body.should == "<p>Hello from bar</p>"
+  end
+
+  it 'should apply single layout' do
+    get('/single').body.should == "<b>Single Hello</b>"
+    get('/single/without').body.should == "Without wrapper"
+  end
+
+  it 'should deny a single action' do
+    get('/deny').body.should == "<b>Single Hello</b>"
+    get('/deny/without').body.should == "Without wrapper"
+  end
+
+  it 'should apply layout to a list of actions' do
+    get('/multi').body.should == "<b>Single Hello</b>"
+    get('/multi/second').body.should == "<b>Second with layout</b>"
+    get('/multi/without').body.should == "Without wrapper"
+  end
+
+  it 'should apply relative layouts' do
+    get('/sub').body.should == "<h1>SubWrapper</h1>"
+  end
+
+  it 'should use instance vars defined in the layout action in external templates' do
+    get('/instancevars/test').body.should == 'layout: test'
+  end
+
+  it 'should allow re-using layouts from other controllers' do
+    get('/reuse').body.should == "<pre>hi</pre>"
+    get('/reuse_instance').body.should == "hello: world"
+  end
+
+  it 'should be able to override :all' do
+    get('/twolevel/index').body.should == '<pre>Hello, World!</pre>'
+    get('/twolevel/foo').body.should == '<code>bar</code>'
+  end
+
+end

data/spec/ramaze/action/render.rb

@@ -0,0 +1,31 @@
+require 'spec/helper'
+
+class TCActionOne < Ramaze::Controller
+  map '/'
+
+  def index
+    'Hello, World!'
+  end
+
+  def foo
+    Ramaze::Action(:controller => self.class, :method => :bar).render
+  end
+
+  def bar
+    "yo from bar"
+  end
+end
+
+describe 'Action rendering' do
+  behaves_like "http"
+  ramaze
+
+  it 'should render' do
+    action = Ramaze::Action(:method => :index, :controller => TCActionOne)
+    action.render.should == 'Hello, World!'
+  end
+
+  it 'should render inside the controller' do
+    get('/foo').body.should == 'yo from bar'
+  end
+end

data/spec/ramaze/action/view/bar.xhtml

@@ -0,0 +1 @@
+Hello from bar

data/spec/ramaze/action/view/instancevars/layout.xhtml

@@ -0,0 +1 @@
+#@title: #@content

data/spec/ramaze/action/view/other_wrapper.xhtml

@@ -0,0 +1 @@
+<p>#@content</p>

data/spec/ramaze/action/view/single_wrapper.xhtml

@@ -0,0 +1 @@
+<b>#@content</b>

data/spec/ramaze/action/view/sub/sub_wrapper.xhtml

@@ -0,0 +1 @@
+<h1>SubWrapper</h1>

data/spec/ramaze/adapter/ebb.rb

@@ -0,0 +1,12 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'spec/helper'
+
+spec_require 'ebb'
+
+def ramaze_options
+  { :adapter => :ebb }
+end
+
+require 'spec/ramaze/adapter'

data/spec/ramaze/adapter/mongrel.rb

@@ -0,0 +1,12 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'spec/helper'
+
+spec_require 'mongrel'
+
+def ramaze_options
+  { :adapter => :mongrel }
+end
+
+require 'spec/ramaze/adapter'

data/spec/ramaze/adapter/record.rb

@@ -0,0 +1,31 @@
+require 'spec/helper'
+
+class TCRecordController < Ramaze::Controller
+  map '/'
+
+  def index
+    'The index'
+  end
+
+  def foo
+    'The foo'
+  end
+end
+
+describe 'Adapter recording' do
+  behaves_like 'http'
+
+  ramaze :adapter => :webrick, :record => lambda{|request|
+    request.remote_addr == '127.0.0.1'
+  }
+
+  @record = Ramaze::Record
+
+  it 'should record' do
+    get('/').body.should == 'The index'
+    get('/foo').body.should == 'The foo'
+    @record.size.should == 2
+    @record.first.path_info.should == '/'
+    @record.last.path_info.should == '/foo'
+  end
+end

data/spec/ramaze/adapter/webrick.rb

@@ -0,0 +1,12 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'spec/helper'
+
+spec_require 'webrick'
+
+def ramaze_options
+  { :adapter => :webrick }
+end
+
+require 'spec/ramaze/adapter'

data/spec/ramaze/adapter.rb

@@ -0,0 +1,49 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'spec/helper'
+
+class TCAdapterController < Ramaze::Controller
+  map '/'
+
+  def index
+    "The index"
+  end
+end
+
+$output = StringIO.new
+Ramaze::Log.loggers << Ramaze::Logger::Informer.new($output)
+
+describe "Adapter" do
+  ramaze ramaze_options ||= {}
+  behaves_like "http"
+
+  it 'should do a simple request' do
+    get('/').body.should == 'The index'
+  end
+
+  it 'should measure request processing time' do
+    Ramaze::Global.benchmarking = true
+    $output.string = ""
+    get('/')
+    $output.string.should =~ /request took/
+    Ramaze::Global.benchmarking = false
+  end
+
+  it 'should not measure request processing time' do
+    Ramaze::Global.benchmarking = false
+    $output.string = ""
+    get('/')
+    $output.string.should.not =~ /request took/
+  end
+
+  it 'should allow using an Adapter.before block' do
+    Ramaze::Adapter.before do |env|
+      [ 200, {'Content-Type'=>'text/plain'}, 'i am before' ]
+    end
+
+    ret = get('/')
+    ret.status.should == 200
+    ret.body.should == 'i am before'
+  end
+end

data/spec/ramaze/cache.rb

@@ -0,0 +1,140 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'spec/helper'
+
+caches = {:memory => 'Hash', :yaml => 'Ramaze::YAMLStoreCache'}
+
+begin
+  require 'memcache'
+  caches[:memcached] = 'Ramaze::MemcachedCache'
+rescue LoadError
+  puts "skipping memcached"
+end
+
+caches.each do |cache, name|
+  describe "#{name} setup" do
+    should 'be assignable to Global' do
+      Ramaze::Global.cache = cache
+      Ramaze::Global.cache.to_s.should == name
+    end
+
+    should 'do .new' do
+      @cache = Ramaze::Global.cache.new
+      @cache.class.name.should == name
+    end
+  end
+
+  describe "#{name} modification" do
+    before do
+      Ramaze::Global.cache = cache
+      @cache = Ramaze::Global.cache.new
+    end
+
+    after do
+      @cache.clear
+    end
+
+    should 'be assignable with #[]=' do
+      @cache[:foo] = :bar
+      @cache[:foo].should == :bar
+    end
+
+    should 'be retrievable with #[]' do
+      @cache[:yoh] = :bar
+      @cache[:yoh].should == :bar
+    end
+
+    should 'delete keys' do
+      @cache[:bar] = :duh
+      @cache.delete(:bar)
+      @cache[:bar].should == nil
+    end
+
+    should 'show values for multiple keys' do
+      @cache[:baz] = :foo
+      @cache[:beh] = :feh
+      @cache.values_at(:baz, :beh).should == [:foo, :feh]
+    end
+
+    FileUtils.rm(@cache.file) if cache == :yaml
+  end
+end
+
+describe "Cache wrapper" do
+  before do
+    @cache = Ramaze::Cache.new(Hash)
+  end
+
+  after do
+    @cache.clear
+  end
+
+  should 'be assignable with #[]= and retrievable with #[]' do
+    @cache[:foo] = :bar
+    @cache[:foo].should == :bar
+  end
+
+  should 'return nil if key not found' do
+    @cache[:baz].should == nil
+  end
+
+  should 'be assignable with #store and retrievable with #fetch' do
+    @cache.store(:foo, :bar)
+    @cache.fetch(:foo).should == :bar
+  end
+
+  should 'return default value if key not found' do
+    @cache.fetch(:monkeys, :default).should == :default
+  end
+
+  should 'be assignable with #set and retrievable with #get' do
+    @cache.set(:ninjas, :totally_sweet)
+    @cache.get(:ninjas).should == :totally_sweet
+  end
+
+  should 'expire key after ttl' do
+    @cache[:cow].should == nil
+    @cache.store(:cow, :moo, :ttl => 1)
+    @cache[:cow].should == :moo
+    sleep(1.1)
+    @cache[:cow].should == nil
+  end
+
+  should 'accept an int as the ttl parameter for #store' do
+    @cache[:cow].should == nil
+    @cache.store(:cow, :moo, 1)
+    @cache[:cow].should == :moo
+  end
+
+  should 'delete keys' do
+    @cache[:abc] = :cba
+    @cache[:def] = :fed
+    @cache.delete(:abc, :def)
+    @cache[:abc].should == nil
+    @cache[:def].should == nil
+  end
+
+  should 'show values for multiple keys' do
+    @cache[:baz] = :foo
+    @cache[:beh] = :feh
+    @cache.values_at(:baz, :beh).should == [:foo, :feh]
+  end
+
+  should 'clear' do
+    @cache[:moo] = :cow
+    @cache.clear
+    @cache[:moo].should == nil
+  end
+
+  should 'not allow different cache namespaces to overlap' do
+    Ramaze::Cache.add :foo
+    Ramaze::Cache.add :bar
+
+    key = "foobar"
+    Ramaze::Cache.foo[key] = 'foo'
+    Ramaze::Cache.bar[key] = 'bar'
+
+    Ramaze::Cache.foo[key].should.not == Ramaze::Cache.bar[key]
+  end
+end

data/spec/ramaze/controller/actionless_templates.rb

@@ -0,0 +1,32 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'spec/helper'
+
+class MainController < Ramaze::Controller
+  template :non_existant_method, :list
+end
+
+class TCActionOtherLayout < Ramaze::Controller
+  map '/other'
+  layout '/other_wrapper'
+
+  def index
+    "Others Hello"
+  end
+end
+
+describe "Testing Actionless Templates" do
+  behaves_like 'http'
+  ramaze :actionless_templates => false,
+         :view_root => __DIR__/:view, :error_page => true
+
+  it "should not find template file for non existant method" do
+    get('/non_existant_method').status.should == 404
+    get('/non_existant_method2').status.should == 404
+  end
+
+  it "should render layout(without method) for normal action" do
+    get('/other/index').body.should == '<p>Others Hello</p>'
+  end
+end