merb-core 0.9.2

data/spec/public/router/default_spec.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "The default routes" do
+  
+  before :each do
+    Merb::Router.prepare {|r| r.default_routes}
+  end
+    
+  it "should match /foo to the Foo controller and index action" do
+    route_to("/foo").should have_route(:controller => "foo", :action => "index", :id => nil)
+  end
+  
+  it "should match /foo/bar to the Foo controller and the bar action" do
+    route_to("/foo/bar").should have_route(:controller => "foo", :action => "bar", :id => nil)
+  end
+  
+  it "should match /foo/bar/12 to the Foo controller, the bar action, and id of 12" do
+    route_to("/foo/bar/12").should have_route(:controller => "foo", :action => "bar", :id => "12")
+  end
+  
+end

data/spec/public/router/deferred_spec.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Deferred routes" do
+
+  before :each do
+    Merb::Router.prepare do |r|      
+      r.match("/deferred/:zoo").defer_to do |request, params|
+        params.merge(:controller => "w00t") if params[:zoo]
+      end
+      r.default_routes
+    end    
+  end
+  
+  it "should match routes based on the incoming params" do
+    route_to("/deferred/baz", :boo => "12").should have_route(:controller => "w00t", :zoo => "baz")
+  end
+
+  it "should fall back to the default route if the deferred condition is not met" do
+    route_to("/deferred").should have_route(:controller => "deferred", :action => "index")    
+  end
+  
+end

data/spec/public/router/namespace_spec.rb

@@ -0,0 +1,113 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+describe "namespaced resource(s) routes" do
+
+  after :each do
+    Merb::Router.named_routes = {}
+    Merb::Router.routes = []
+  end
+
+  it "should match a get to /admin/blogposts without setting namespace" do
+    Merb::Router.prepare do |r|
+      r.match('/admin') do |admin|
+        admin.resources :blogposts
+      end
+    end
+    route_to('/admin/blogposts', :method => :get).should have_route(:controller => 'blogposts', :action => 'index', :id => nil, :namespace=>nil)
+  end
+
+  it "should match a get to /admin/blogposts setting namespace manually" do
+    Merb::Router.prepare do |r|
+      r.match('/admin').to(:namespace => "my_admin") do |admin|
+        admin.resources :blogposts
+      end
+    end
+    route_to('/admin/blogposts', :method => :get).should have_route(:controller => 'blogposts', :action => 'index', :id => nil, :namespace=>"my_admin")
+  end
+
+  it "should match a get to /admin/blogposts to the blogposts controller and index action" do
+    Merb::Router.prepare do |r|
+      r.namespace :admin do |admin|
+        admin.resources :blogposts
+      end
+    end
+    route_to('/admin/blogposts', :method => :get).should have_route(:controller => 'blogposts', :action => 'index', :id => nil, :namespace => 'admin')
+  end
+  
+  it "should match a get to /admin/foo to the foo controller and show action" do
+    Merb::Router.prepare do |r|
+      r.namespace :admin do |admin|
+        admin.resource :foo
+      end
+    end
+    route_to('/admin/foo', :method => :get).should have_route(:controller => 'foo', :action => 'show', :id => nil)
+  end
+
+  it "should match a get to /admin/foo/blogposts to the blogposts controller and index action" do
+    Merb::Router.prepare do |r|
+      r.namespace :admin do |admin|
+        admin.resource :foo do |foo|
+          foo.resources :blogposts
+        end
+      end
+    end
+    route_to('/admin/foo/blogposts', :method => :get).should have_route(:controller => 'blogposts', :action => 'index', :id => nil, :namespace => 'admin')
+  end
+
+  it "should match a get to /admin/blogposts/1/foo to the foo controller and the show action" do
+    Merb::Router.prepare do |r|
+      r.namespace :admin do |admin|
+        admin.resources :blogposts do |blogposts|
+          blogposts.resource :foo
+        end
+      end
+    end
+    route_to('/admin/blogposts/1/foo', :method => :get).should have_route(:controller => 'foo', :action => 'show', :blogpost_id => '1', :id => nil, :namespace => "admin")
+  end
+
+  it "should match a get to /blogposts to the blogposts controller when namespace is passed in to resources" do
+    Merb::Router.prepare do |r|
+      r.resources :blogposts, :namespace => "admin"
+    end
+    route_to("/blogposts", :method =>:get).should have_route(:controller => 'blogposts', :action => 'index', :id => nil, :namespace => "admin")
+  end
+
+  it "should match a get to /blogposts/1/foo to the foo controller when namespace is passed in to resources as an option" do
+    Merb::Router.prepare do |r|
+      r.resources :blogposts, :namespace => "admin" do |blogposts|
+        blogposts.resource :foo, :namespace => "admin"
+      end
+    end
+    route_to("/blogposts", :method =>:get).should have_route(:controller => 'blogposts', :action => 'index', :id => nil, :namespace => "admin")
+    route_to("/blogposts/1/foo", :method =>:get).should have_route(:controller => 'foo', :action => 'show', :blogpost_id => '1', :namespace => "admin")
+  end
+  
+  it "should match a get to /blogposts/1/foo to the foo controller without a namespace" do
+    Merb::Router.prepare do |r|
+      r.resources :blogposts, :namespace => "admin" do |blogposts|
+        blogposts.resource :foo
+      end
+    end
+    route_to("/blogposts/1/foo", :method =>:get).should have_route(:controller => 'foo', :action => 'show', :blogpost_id => '1', :namespace => nil)
+  end
+  
+  it "should match a get to /my_admin/blogposts to the blogposts controller with a custom patch setting" do
+    Merb::Router.prepare do |r|
+      r.namespace(:admin, :path=>"my_admin") do |admin|
+        admin.resources :blogposts
+      end
+    end
+    route_to('/my_admin/blogposts', :method => :get).should have_route(:controller => 'blogposts', :action => 'index', :id => nil, :namespace => 'admin')
+  end
+
+  it "should match a get to /admin/blogposts/1/foo to the foo controller and the show action with namespace admin" do
+    Merb::Router.prepare do |r|
+      r.namespace(:admin, :path=>"") do |admin|
+        admin.resources :blogposts do |blogposts|
+          blogposts.resource :foo
+        end
+      end
+    end
+    route_to('/blogposts/1/foo', :method => :get).should have_route(:controller => 'foo', :action => 'show', :blogpost_id => '1', :id => nil, :namespace => "admin")
+  end
+
+end

data/spec/public/router/nested_resources_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+Merb::Router.prepare do |r|
+  r.resources :blogposts do |b|
+    b.resources :comments do |c|
+      c.resources :versions
+    end
+  end
+  r.resources :users do |u|
+    u.resources :comments
+  end
+  r.resource :foo do |f|
+    f.resources :comments
+  end
+end
+
+describe "nested resources routes" do
+  
+  it "should match a get to /blogposts/1/comments to the comments controller and index action with blogpost_id" do
+    route_to('/blogposts/1/comments', :method => :get).should have_route(:controller => 'comments', :action => 'index', :id => nil, :blogpost_id => '1')
+  end
+  
+  it "should match a get to /blogposts/1/comments/2/versions to the versions controller and index action with blogpost_id and comment_id" do
+    route_to('/blogposts/1/comments/2/versions', :method => :get).should have_route(:controller => 'versions', :action => 'index', :id => nil, :blogpost_id => '1', :comment_id => '2')
+  end
+  
+  it "should match a get to /users/1/comments to the comments controller and index action with user_id" do
+    route_to('/users/1/comments', :method => :get).should have_route(:controller => 'comments', :action => 'index', :id => nil, :user_id => '1')
+  end
+
+  it "should match a get to /foo/comments to the comments controller and index action" do
+    route_to('/foo/comments', :method => :get).should have_route(:controller => 'comments', :action => 'index', :id => nil)
+  end
+end

data/spec/public/router/resource_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "resources routes" do
+  before :each do
+    Merb::Router.prepare do |r|
+      r.resource :foo
+    end
+  end
+  
+  it "should match a get to /foo to the blogposts controller and show action" do
+    route_to('/foo', :method => :get).should have_route(:controller => 'foo', :action => 'show', :id => nil)
+  end
+  
+  it "should match a post to /foo to the blogposts controller and create action" do
+    route_to('/foo', :method => :post).should have_route(:controller => 'foo', :action => 'create', :id => nil)
+  end
+  
+  it "should match a put to /foo to the blogposts controller and update action" do
+    route_to('/foo', :method => :put).should have_route(:controller => 'foo', :action => 'update', :id => nil)
+  end
+  
+  it "should match a delete to /foo to the blogposts controller and show action" do
+    route_to('/foo', :method => :delete).should have_route(:controller => 'foo', :action => 'destroy', :id => nil)
+  end
+  
+  it "should match a get to /foo/new to the blogposts controller and new action" do
+    route_to('/foo/new', :method => :get).should have_route(:controller => 'foo', :action => 'new', :id => nil)
+  end
+  
+  it "should match a get to /foo/edit to the blogposts controller and edit action" do
+    route_to('/foo/edit', :method => :get).should have_route(:controller => 'foo', :action => 'edit', :id => nil)
+  end
+  
+  it "should match a get to /foo;edit to the blogposts controller and edit action" do
+    route_to('/foo;edit', :method => :get).should have_route(:controller => 'foo', :action => 'edit', :id => nil)
+  end
+  
+  it "should match a get to /foo/delete to the blogposts controller and delete action" do
+    route_to('/foo/delete', :method => :get).should have_route(:controller => 'foo', :action => 'delete', :id => nil)
+  end
+  
+  it "should match a get to /foo;delete to the blogposts controller and delete action" do
+    route_to('/foo;delete', :method => :get).should have_route(:controller => 'foo', :action => 'delete', :id => nil)
+  end
+end

data/spec/public/router/resources_spec.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "resources routes" do
+  before :each do
+    Merb::Router.prepare do |r|
+      r.resources :blogposts
+    end
+  end
+  
+  it "should match a get to /blogposts to the blogposts controller and index action" do
+    route_to('/blogposts', :method => :get).should have_route(:controller => 'blogposts', :action => 'index', :id => nil)
+  end
+  
+  it "should match a post to /blogposts to the blogposts controller and create action" do
+    route_to('/blogposts', :method => :post).should have_route(:controller => 'blogposts', :action => 'create', :id => nil)
+  end
+  
+  it "should match a get to /blogposts/new to the blogposts controller and the new action" do
+    route_to('/blogposts/new', :method => :get).should have_route(:controller => 'blogposts', :action => 'new', :id => nil)
+  end
+  
+  it "should match a get to /blogposts/1 ot the  blogposts controller and the show action with id 1" do
+    route_to('/blogposts/1', :method => :get).should have_route(:controller => 'blogposts', :action => 'show', :id => "1")
+  end
+  
+  it "should match a put to /blogposts/1 ot the  blogposts controller and the update action with id 1" do
+    route_to('/blogposts/1', :method => :put).should have_route(:controller => 'blogposts', :action => 'update', :id => "1")
+  end
+  
+  it "should match a delete to /blogposts/1 ot the  blogposts controller and the destroy action with id 1" do
+    route_to('/blogposts/1', :method => :delete).should have_route(:controller => 'blogposts', :action => 'destroy', :id => "1")
+  end
+
+  it "should match a get to /blogposts/1/edit to the blogposts controller and the edit action with id 1" do
+    route_to('/blogposts/1/edit', :method => :get).should have_route(:controller => 'blogposts', :action => 'edit', :id => "1")
+  end
+  
+  it "should match a get to /blogposts/1;edit to the blogposts controller and the edit action with id 1" do
+    route_to('/blogposts/1;edit', :method => :get).should have_route(:controller => 'blogposts', :action => 'edit', :id => "1")
+  end
+  
+  it "should not match a put to /blogposts/1/edit" do
+    # not sure which of these is the best way to specify what I mean - so they're both in...
+    route_to('/blogposts/1/edit', :method => :put).should have_nil_route
+    route_to('/blogposts/1/edit', :method => :put).should_not have_route(:controller => 'blogposts', :action => 'edit', :id => "1")
+  end
+  
+  it "should not match a put to /blogposts/1;edit" do
+    # not sure which of these is the best way to specify what I mean - so they're both in...
+    route_to('/blogposts/1;edit', :method => :put).should have_nil_route
+    route_to('/blogposts/1;edit', :method => :put).should_not have_route(:controller => 'blogposts', :action => 'edit', :id => "1")
+  end
+  
+  it "should match a get to /blogposts/1/delete to the blogposts controller and the delete action with id 1" do
+    route_to('/blogposts/1/delete', :method => :get).should have_route(:controller => 'blogposts', :action => 'delete', :id => "1")
+  end
+end

data/spec/public/router/spec_helper.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
+require 'ostruct'
+class SimpleRequest < OpenStruct
+  
+  def method
+    @table[:method]
+  end
+  
+  def params
+    @table
+  end
+end
+
+def prepare_route(from, to)
+  Merb::Router.prepare {|r| r.match(from).to(to)}  
+end
+
+def route_to(path, args = {}, protocol = "http://")
+  Merb::Router.match(SimpleRequest.new({:protocol => protocol, :path => path}.merge(args)))[1]
+end
+
+def generate(*args)
+  Merb::Router.generate *args
+end
+
+module Merb
+  
+  module Test
+    
+    module RspecMatchers
+
+      class HaveRoute
+        
+        def self.build(expected)
+          this = new
+          this.instance_variable_set("@expected", expected)
+          this
+        end
+
+        def matches?(target)
+          @target = target
+          @errors = []
+          @expected.all? { |param, value| @target[param] == value }
+        end
+
+        def failure_message
+          @target.each do |param, value|
+            @errors << "Expected :#{param} to be #{@expected[param].inspect}, but was #{value.inspect}" unless
+              @expected[param] == value
+          end
+          @errors << "Got #{@target.inspect}"
+          @errors.join("\n")
+        end
+
+        def negative_failure_message
+          "Expected #{@expected.inspect} not to be #{@target.inspect}, but it was."
+        end
+
+        def description() "have_route #{@target.inspect}" end
+      end
+
+      def have_route(expected)
+        HaveRoute.build(expected)
+      end
+      
+      def have_nil_route
+        have_route({})
+      end
+  
+    end
+  end
+end

data/spec/public/router/special_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Regex-based routes" do
+  
+  it "should process a simple regex" do
+    prepare_route(%r[^/foos?/(bar|baz)/:id], :controller => "foo", :action => "[1]", :id => ":id")      
+    route_to("/foo/bar/baz").should have_route(:controller => "foo", :action => "bar", :id => "baz")
+    route_to("/foos/baz/bam").should have_route(:controller => "foo", :action => "baz", :id => "bam")
+  end
+
+  it "should support inbound user agents" do
+    Merb::Router.prepare do |r|
+      r.match(%r[^/foo/(.+)], :user_agent => /(MSIE|Gecko)/).
+        to(:controller => "foo", :title => "[1]", :action => "show", :agent => ":user_agent[1]")    
+    end
+    route_to("/foo/bar", :user_agent => /MSIE/).should have_route(
+      :controller => "foo", :action => "show", :title => "bar", :agent => "MSIE"
+    )
+  end
+
+end
+
+describe "Routes that are restricted based on incoming params" do
+  
+  it "should allow you to restrict routes to POST requests" do
+    Merb::Router.prepare do |r|
+      r.match("/:controller/create/:id").
+        to(:action => "create")
+    end
+    route_to("/foo/create/12", :method => "post").should have_route(
+      :controller => "foo", :action => "create", :id => "12"
+    )
+  end
+  
+  it "should allow you to restrict routes based on protocol" do
+    Merb::Router.prepare do |r|
+      r.match(:protocol => "http://").to(:controller => "foo", :action => "bar")
+      r.default_routes
+    end
+    route_to("/foo/bar").should have_route(:controller => "foo", :action => "bar")
+    route_to("/boo/hoo", :protocol => "https://").should have_route(:controller => "boo", :action => "hoo")
+  end
+  
+end

data/spec/public/router/string_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "A plain route with no variables" do
+  
+  it "should return the parameters passed to #to" do
+    prepare_route("/info", :controller => "info", :action => "foo")
+    route_to("/info").should have_route(:controller => "info", :action => "foo", :id => nil)
+  end
+    
+end
+
+describe "A route with variables specified as :foo/:bar" do
+  
+  it "should work with :controller/:action/:id" do
+    prepare_route("/foo/:action/:id", :controller => "foobar")
+    route_to("/foo/bar/baz").should have_route(:controller => "foobar", :action => "bar", :id => "baz")
+  end
+  
+  it "should work with :foo/:bar/:baz to :controller => ':foo/:bar'" do
+    prepare_route("/:foo/:bar/:baz/:id", :controller => ":foo/:bar", :action => ":baz")
+    route_to("/one/two/three/4").should have_route(:controller => "one/two", :action => "three", :id => "4")
+  end
+  
+end
+
+describe "A route containing block matchers" do
+  
+  it "should support block matchers as a path namespace" do
+    Merb::Router.prepare do |r|
+      r.match("/foo") do |path|
+        path.match("/bar/:id").to(:controller => "foo/bar", :action => "bar")
+      end
+    end
+    route_to("/foo/bar/1").should have_route(:controller => "foo/bar", :action => "bar", :id => "1")
+  end
+  
+  it "should still support :variables in the to route from any level" do
+    Merb::Router.prepare do |r|
+      r.match("/foo/:bar") do |path|
+        path.match("/:baz/:id").to(:controller => "foo", :action => ":id", :id => ":bar/:baz")
+      end
+    end
+    route_to("/foo/hello/goodbye/zoo").should have_route(:controller => "foo", :action => "zoo", :id => "hello/goodbye")
+  end
+  
+end
+
+describe "A route containing block matchers for the 'to' section" do
+  
+  it "should point a bunch of 'from' segments to the same 'to'" do
+    Merb::Router.prepare do |r|
+      r.to(:controller => "foo") do |a|
+        a.match("/hello/:action/:id").to(:tag => ":id")
+      end
+    end
+    route_to("/hello/goodbye/tagging").should have_route(
+      :controller => "foo", :action => "goodbye", :id => "tagging", :tag => "tagging"
+    )
+  end
+  
+end