ramaze 0.1.0 → 0.1.1

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
+  setup do
+    ramaze :adapter => :webrick, :record => lambda{|request|
+      request.remote_addr == '127.0.0.1'
+    }
+
+    @record = Ramaze::Record
+  end
+
+  it 'should record' do
+    get('/').body.should == 'The index'
+    get('/foo').body.should == 'The foo'
+    @record.should have(2).requests
+    @record.first.path_info.should == '/'
+    @record.last.path_info.should == '/foo'
+  end
+end

data/spec/ramaze/cache.rb

@@ -3,75 +3,62 @@
 
 require 'spec/helper'
 
-describe "MemoryCache" do
-  cache = Ramaze::MemoryCache.new
+caches = {:memory => 'Hash', :yaml => 'Ramaze::YAMLStoreCache'}
 
-  it "delete" do
-    cache.delete(:one)
-    cache.delete(:two)
-  end
-
-  it "set keys" do
-    (cache[:one] = 'eins').should == "eins"
-    (cache[:two] = 'zwei').should == "zwei"
-  end
-
-  it "read keys" do
-    cache[:one].should == 'eins'
-    cache[:two].should == 'zwei'
-  end
-
-  it "values_at" do
-    cache.values_at(:one, :two).should == %w[eins zwei]
-  end
+begin
+  require 'memcache'
+  caches[:memcached] = 'Ramaze::MemcachedCache'
+rescue LoadError
+  puts "skipping memcached"
 end
 
-describe "YAMLStoreCache" do
-  cache = Ramaze::YAMLStoreCache.new
-
-  it "delete" do
-    cache.delete(:one)
-    cache.delete(:two)
-  end
+caches.each do |cache, name|
+  describe "#{name} setup" do
+    it "should be assignable to Global" do
+      Ramaze::Global.cache = cache
+      Ramaze::Global.cache.to_s.should == name
+    end
 
-  it "set keys" do
-    (cache[:one] = 'eins').should == "eins"
-    (cache[:two] = 'zwei').should == "zwei"
+    it "should do .new" do
+      @cache = Ramaze::Global.cache.new
+      @cache.class.name.should == name
+    end
   end
 
-  it "read keys" do
-    cache[:one].should == 'eins'
-    cache[:two].should == 'zwei'
-  end
+  describe "#{name} modification" do
+    setup do
+      Ramaze::Global.cache = cache
+      @cache = Ramaze::Global.cache.new
+    end
 
-  it "values_at" do
-    cache.values_at(:one, :two).should == %w[eins zwei]
-  end
-end
+    after :each do
+      @cache.clear
+    end
 
-begin
-  describe "MemcachedCache" do
-    cache = Ramaze::MemcachedCache.new
+    after :all do
+      FileUtils.rm(@cache.file) if cache == :yaml
+    end
 
-    it "delete" do
-      cache.delete(:one)
-      cache.delete(:two)
+    it "should be assignable with #[]=" do
+      @cache[:foo] = :bar
+      @cache[:foo].should == :bar
     end
 
-    it "set keys" do
-      (cache[:one] = 'eins').should == "eins"
-      (cache[:two] = 'zwei').should == "zwei"
+    it "should be retrievable with #[]" do
+      @cache[:yoh] = :bar
+      @cache[:yoh].should == :bar
     end
 
-    it "read keys" do
-      cache[:one].should == 'eins'
-      cache[:two].should == 'zwei'
+    it "should delete keys" do
+      @cache[:bar] = :duh
+      @cache.delete(:bar)
+      @cache[:bar].should be_nil
     end
 
-    it "values_at" do
-      cache.values_at(:one, :two).should == %w[eins zwei]
+    it "should show values for multiple keys" do
+      @cache[:baz] = :foo
+      @cache[:beh] = :feh
+      @cache.values_at(:baz, :beh).should == [:foo, :feh]
     end
   end
-rescue LoadError
-  puts "cannot run test for memcached"
 end

data/spec/ramaze/controller.rb

@@ -5,7 +5,7 @@ require 'spec/helper'
 
 class TCControllerController < Ramaze::Controller
   map '/'
-  trait :template_root => 'spec/ramaze/template/ezamar'
+  template_root 'spec/ramaze/template/ezamar'
 
   def index
     @text = "World"
@@ -28,157 +28,141 @@ class TCControllerController < Ramaze::Controller
 end
 
 describe "Controller" do
-  ramaze :error_page => false
-
-  describe 'dry specs' do
-    describe 'pattern_for' do
-      hash = {
-        '/' => [
-          ["/", 'index', []]
-        ],
-
-        '/foo' => [
-          ["/foo", 'index',[]],
-          ['/',    'foo',  []],
-          ["/",    'index', ["foo"]],
-        ],
-
-        '/foo/bar' => [
-          ["/foo__bar", "index",    []],
-          ["/foo/bar",  "index",    []],
-
-          ["/foo",      "bar",      []],
-          ["/foo",      "index",    ["bar"]],
-
-          ["/",         "foo__bar", []],
-          ["/",         "foo",      ["bar"]],
-          ["/",         "index",    ["foo", "bar"]],
-        ],
-
-        '/foo/bar/baz' => [
-
-          ['/foo__bar__baz', 'index',         []],
-          ['/foo/bar/baz',   'index',         []],
-
-          ['/foo__bar',      'baz',           []],
-          ['/foo__bar',      'index',         ['baz']],
-
-          ['/foo/bar',       'baz',           []],
-          ['/foo/bar',       'index',         ['baz']],
-
-          ['/foo',           'bar__baz',      []],
-          ['/foo',           'bar',           ['baz']],
-          ['/foo',           'index',         ['bar', 'baz']],
-
-          ['/',              'foo__bar__baz', []],
-          ['/',              'foo__bar',      ['baz']],
-          ['/',              'foo',           ['bar', 'baz']],
-          ['/',              'index',         ['foo', 'bar', 'baz']],
-        ],
-
-        '/foo/bar/baz/oof' => [
-          ['/foo__bar__baz__oof', 'index',               []],
-
-          ['/foo/bar/baz/oof',    'index',               []],
-
-          ['/foo__bar__baz',      'oof',                 []],
-          ['/foo__bar__baz',      'index',               ['oof']],
-
-          ['/foo/bar/baz',        'oof',                 []],
-          ['/foo/bar/baz',        'index',               ['oof']],
-
-          ['/foo__bar',           'baz__oof',            []],
-          ['/foo__bar',           'baz',                 ['oof']],
-          ['/foo__bar',           'index',               ['baz', 'oof']],
-
-          ['/foo/bar',            'baz__oof',            []],
-          ['/foo/bar',            'baz',                 ['oof']],
-          ['/foo/bar',            'index',               ['baz', 'oof']],
-
-          ['/foo',                'bar__baz__oof',       []],
-          ['/foo',                'bar__baz',            ['oof']],
-          ['/foo',                'bar',                 ['baz', 'oof']],
-          ['/foo',                'index',               ['bar', 'baz', 'oof']],
-
-          ['/',                   'foo__bar__baz__oof',  []],
-          ['/',                   'foo__bar__baz',       ['oof']],
-          ['/',                   'foo__bar',            ['baz', 'oof']],
-          ['/',                   'foo',                 ['bar', 'baz', 'oof']],
-          ['/',                   'index',               ['foo', 'bar', 'baz', 'oof']],
-        ]
-      }
-
-      hash.each do |path, correct|
-        describe path do
-          patterns = Ramaze::Controller.pattern_for(path)
-
-          describe path do
-=begin
-            puts
-            patterns.zip(correct).each do |pa, co|
-              p :pa => pa
-              p :co => co
-              puts
-            end
-            puts
-=end
-            it(path){ patterns.should == correct }
-            correct.zip(patterns).each do |(cc,cm,cp),(pc,pm,pp)|
-              {cc,pc,cm,pm,cp,pp}.each{|a,b| a.should == b}
-            end
-          end
-        end
-      end
-    end
+  def handle(*args)
+    Ramaze::Controller.handle(*args)
   end
 
-  describe 'resolve' do
-    def resolve(path)
-      TCControllerController.resolve(path)
-    end
+  def resolve(*args)
+    Ramaze::Controller.resolve(*args)
+  end
 
-    it '/' do
-      resolve('/').last.should ==
-        Ramaze::Action.new('index', [],'spec/ramaze/template/ezamar/index.zmr')
-    end
+  def values(*url)
+    resolve(*url).last.values_at(:method, :params, :template)
+  end
 
-    it '/sum/1/2' do
-      resolve('/sum/1/2').last.should ==
-        Ramaze::Action.new('sum', ['1', '2'],'spec/ramaze/template/ezamar/sum.zmr')
-    end
+  before :all do
+    ramaze :error_page => false
+    @hash = {
+      '/' => [
+        ["/", 'index', []]
+      ],
 
-    it '/another/long/action' do
-      resolve('/another/long/action').last.should ==
-        Ramaze::Action.new('another__long__action', [], 'spec/ramaze/template/ezamar/another/long/action.zmr')
-    end
-    it '/some/long/action' do
-      resolve('/some/long/action').last.should ==
-        Ramaze::Action.new('some__long__action', [], 'spec/ramaze/template/ezamar/some__long__action.zmr')
+      '/foo' => [
+        ["/foo", 'index',[]],
+        ['/',    'foo',  []],
+        ["/",    'index', ["foo"]],
+      ],
+
+      '/foo/bar' => [
+        ["/foo__bar", "index",    []],
+        ["/foo/bar",  "index",    []],
+
+        ["/foo",      "bar",      []],
+        ["/foo",      "index",    ["bar"]],
+
+        ["/",         "foo__bar", []],
+        ["/",         "foo",      ["bar"]],
+        ["/",         "index",    ["foo", "bar"]],
+      ],
+
+      '/foo/bar/baz' => [
+
+        ['/foo__bar__baz', 'index',         []],
+        ['/foo/bar/baz',   'index',         []],
+
+        ['/foo__bar',      'baz',           []],
+        ['/foo__bar',      'index',         ['baz']],
+
+        ['/foo/bar',       'baz',           []],
+        ['/foo/bar',       'index',         ['baz']],
+
+        ['/foo',           'bar__baz',      []],
+        ['/foo',           'bar',           ['baz']],
+        ['/foo',           'index',         ['bar', 'baz']],
+
+        ['/',              'foo__bar__baz', []],
+        ['/',              'foo__bar',      ['baz']],
+        ['/',              'foo',           ['bar', 'baz']],
+        ['/',              'index',         ['foo', 'bar', 'baz']],
+      ],
+
+      '/foo/bar/baz/oof' => [
+        ['/foo__bar__baz__oof', 'index',               []],
+
+        ['/foo/bar/baz/oof',    'index',               []],
+
+        ['/foo__bar__baz',      'oof',                 []],
+        ['/foo__bar__baz',      'index',               ['oof']],
+
+        ['/foo/bar/baz',        'oof',                 []],
+        ['/foo/bar/baz',        'index',               ['oof']],
+
+        ['/foo__bar',           'baz__oof',            []],
+        ['/foo__bar',           'baz',                 ['oof']],
+        ['/foo__bar',           'index',               ['baz', 'oof']],
+
+        ['/foo/bar',            'baz__oof',            []],
+        ['/foo/bar',            'baz',                 ['oof']],
+        ['/foo/bar',            'index',               ['baz', 'oof']],
+
+        ['/foo',                'bar__baz__oof',       []],
+        ['/foo',                'bar__baz',            ['oof']],
+        ['/foo',                'bar',                 ['baz', 'oof']],
+        ['/foo',                'index',               ['bar', 'baz', 'oof']],
+
+        ['/',                   'foo__bar__baz__oof',  []],
+        ['/',                   'foo__bar__baz',       ['oof']],
+        ['/',                   'foo__bar',            ['baz', 'oof']],
+        ['/',                   'foo',                 ['bar', 'baz', 'oof']],
+        ['/',                   'index',               ['foo', 'bar', 'baz', 'oof']],
+      ]
+    }
+  end
+
+  it "dry pattern_for" do
+    @hash.each do |path, correct|
+      patterns = Ramaze::Controller.pattern_for(path)
+      patterns.should == correct
     end
   end
 
+  it '/' do
+    values('/').should ==
+      ['index', [], 'spec/ramaze/template/ezamar/index.zmr']
+  end
+
+  it '/sum/1/2' do
+    values('/sum/1/2').should ==
+      ['sum', ['1', '2'],'spec/ramaze/template/ezamar/sum.zmr']
+  end
+
+  it '/another/long/action' do
+    values('/another/long/action').should ==
+      ['another__long__action', [], 'spec/ramaze/template/ezamar/another/long/action.zmr']
+  end
+  it '/some/long/action' do
+    values('/some/long/action').should ==
+      ['some__long__action', [], 'spec/ramaze/template/ezamar/some__long__action.zmr']
+  end
+
   it "simple request to index" do
-    get('/').body.should == 'Hello, World!'
+    handle('/').should == 'Hello, World!'
   end
 
   it "summing two values" do
-    get('/sum/1/2').body.should == '3'
+    handle('/sum/1/2').should == '3'
   end
 
   it "double underscore in templates" do
-    get('/some/long/action').body.should == 'some long action'
-    get('/another/long/action').body.should == 'another long action'
-  end
-
-  describe "should not respond to private methods" do
-    TCControllerController.private_methods.sort.each do |action|
-      next if action =~ /\?$/ or action == '`'
-      it action do
-        path = "/#{action}"
-        response = get(path)
-        response.body.should =~ %r(No Action found for `#{path}' on TCControllerControlle)
-        response.status.should == 404
-      end
+    handle('/some/long/action').should == 'some long action'
+    handle('/another/long/action').should == 'another long action'
+  end
+
+  TCControllerController.private_methods.sort.each do |action|
+    it action do
+      path = "/#{action}"
+      message = "No Action found for `#{path}' on TCControllerController"
+      lambda{ resolve(path) }.should raise_error(Ramaze::Error::NoAction, message)
     end
   end
 end

data/spec/ramaze/controller/template/list.xhtml

@@ -0,0 +1 @@
+<html>#{@obj}</html>

data/spec/ramaze/controller/template/other/greet/other.xhtml

@@ -0,0 +1 @@
+<html>Other: #{@greet}</html>

data/spec/ramaze/controller/template_resolving.rb

@@ -4,21 +4,32 @@
 require 'spec/helper'
 
 class MainController < Ramaze::Controller
-  trait :template_root => "#{File.expand_path(File.dirname(__FILE__))}/template"
+  template_root "#{File.expand_path(File.dirname(__FILE__))}/template"
 
   def greet(type, message = "Message")
     @greet = "#{type} : #{message}"
   end
+
+  def list
+    @obj = @action.method
+  end
+  alias_method :index, :list
+  template :index, 'list'
+
 end
 
 class OtherController < MainController
-  trait :template_root => "#{File.expand_path(File.dirname(__FILE__))}/template/other"
+  template_root "#{File.expand_path(File.dirname(__FILE__))}/template/other"
 
   def greet__mom(message = "Moms are cool!")
     greet('Mom', message)
   end
+  template :greet__mom, MainController, :greet
 
-  trait :greet__mom_template => '/greet'
+  def greet__other(one, two)
+    @greet = "Other"
+  end
+  template :greet__other, 'greet/other'
 
   def partial_stuff
     render_partial('/greet/the/world', :foo => :bar)
@@ -44,6 +55,19 @@ describe "Testing Template overriding" do
   it "referencing template from MainController" do
     get('/other/greet/mom').body.should == '<html>Mom : Moms are cool!</html>'
   end
+
+  it "should accept template overrides with same name as controller" do
+    get('/other/greet/other/one/two').body.should == '<html>Other: Other</html>'
+  end
+
+  it "setting template for non-existant :index action should not arbitrary parameters" do
+    get('/list').body.should == '<html>list</html>'
+
+    response = get('/non_existant_method')
+    response.status.should == 404
+    response.body.should =~ %r(No Action found for `/non_existant_method' on MainController)
+  end
+
 end
 
 describe "render_partial" do