joshbuddy-usher 0.5.4 → 0.5.6

data/spec/private/generate_spec.rb

@@ -2,37 +2,37 @@ require 'lib/usher'
 require 'rack'
 
 describe "Usher URL generation" do
-  
+
   before(:each) do
     @route_set = Usher.new(:generator => Usher::Util::Generators::URL.new)
     @route_set.reset!
   end
-  
+
   it "should generate a simple URL" do
     @route_set.add_named_route(:sample, '/sample', :controller => 'sample', :action => 'action')
     @route_set.generator.generate(:sample, {}).should == '/sample'
   end
-  
+
   it "should generate a simple URL with a single variable" do
     @route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample')
     @route_set.generator.generate(:sample, {:action => 'action'}).should == '/sample/action'
   end
-  
+
   it "should generate a simple URL with a single variable (and escape)" do
     @route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample')
     @route_set.generator.generate(:sample, {:action => 'action time'}).should == '/sample/action%20time'
   end
-  
+
   it "should generate a simple URL with a single variable (thats not a string)" do
     @route_set.add_named_route(:sample, '/sample/:action/:id', :controller => 'sample')
     @route_set.generator.generate(:sample, {:action => 'action', :id => 123}).should == '/sample/action/123'
   end
-  
+
   it "should generate a simple URL with a glob variable" do
     @route_set.add_named_route(:sample, '/sample/*action', :controller => 'sample')
     @route_set.generator.generate(:sample, {:action => ['foo', 'baz']}).should == '/sample/foo/baz'
   end
-  
+
   it "should generate a mutliple vairable URL from a hash" do
     @route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
     @route_set.generator.generate(:sample, {:first => 'zoo', :second => 'maz'}).should == '/sample/zoo/maz'
@@ -125,7 +125,7 @@ describe "Usher URL generation" do
     @route_set.add_named_route(:name, '/:one/:two/:three', {:default_values => {:one => 'one', :two => 'two', :three => 'three'}})
     @route_set.generator.generate(:name).should == '/one/two/three'
   end
-  
+
   it "should generate a route using defaults and optionals using the last parameter" do
     @route_set.add_named_route(:opts_with_defaults, '/:one(/:two(/:three))', {:default_values => {:one => '1', :two => '2', :three => '3'}})
     @route_set.generator.generate(:opts_with_defaults, {:three => 'three'}).should == '/1/2/three'
@@ -135,61 +135,114 @@ describe "Usher URL generation" do
     @route_set.add_named_route(:optionals, '/:controller(/:action(/:id))(.:format)')
     @route_set.generator.generate(:optionals, {:controller => "foo", :action => "bar"}).should == '/foo/bar'
   end
-  
+
   describe "nested generation" do
     before do
       @route_set2 = Usher.new(:generator => Usher::Util::Generators::URL.new)
       @route_set3 = Usher.new(:generator => Usher::Util::Generators::URL.new)
       @route_set4 = Usher.new(:generator => Usher::Util::Generators::URL.new)
-      
+
       @route_set.add_named_route(:simple,   "/mount_point").match_partially!.to(@route_set2)
       @route_set.add_route("/third/:foo", :default_values => {:foo => "foo"}).match_partially!.to(@route_set3)
       @route_set.add_route("/fourth/:bar").match_partially!.to(@route_set4)
-      
+
       @route_set2.add_named_route(:nested_simple,   "/nested/simple",     :controller => "nested",  :action => "simple")
       @route_set2.add_named_route(:nested_complex,  "/another_nested(/:complex)", :controller => "nested",  :action => "complex")
-      
+
       @route_set3.add_named_route(:nested_simple, "/nested/simple", :controller => "nested", :action => "simple")
       @route_set3.add_named_route(:nested_complex,  "/another_nested(/:complex)", :controller => "nested",  :action => "complex")
-      
+
       @route_set4.add_named_route(:nested_simple, "/nested/simple", :controller => "nested", :action => "simple")
     end
-    
+
     it "should generate a route for the simple nested route" do
       @route_set2.generator.generate(:nested_simple).should == "/mount_point/nested/simple"
     end
-    
+
     it "should generate a simple route without optional segments" do
       @route_set2.generator.generate(:nested_complex).should == "/mount_point/another_nested"
     end
-    
+
     it "should generate a route with optional segements" do
       @route_set2.generator.generate(:nested_complex, :complex => "foo").should == "/mount_point/another_nested/foo"
     end
-    
+
     it "should genearte a route with the specified value for the parent route" do
       @route_set3.generator.generate(:nested_simple, :foo => "bar").should == "/third/bar/nested/simple"
     end
-    
+
     it "should generate a route with the default value from the parent route" do
       @route_set3.generator.generate(:nested_simple).should == "/third/foo/nested/simple"
     end
-    
+
     it "should generate a route with an optional segement in the parent and child" do
       @route_set3.generator.generate(:nested_complex, :complex => "complex").should == "/third/foo/another_nested/complex"
     end
-    
+
     it "should generate a route without the optional value from the child" do
       @route_set3.generator.generate(:nested_complex).should == "/third/foo/another_nested"
     end
-    
+
     it "should raise an exception when trying to generate a route where the parent variable is not defined and does not have a default value" do
       lambda do
         @route_set4.generator.generate(:nested_simple)
       end.should raise_error(Usher::MissingParameterException)
     end
-    
-    
-    
   end
-end
+
+  describe "dupped generation" do
+    before(:each) do
+      @r1 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+      @r2 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+      @r3 = Usher.new(:generator => Usher::Util::Generators::URL.new)
+
+      @r1.add_route("/r1", :router => "r1").name(:route)
+      @r2.add_route("/r2", :router => "r2").name(:route)
+      @r3.add_route("/r3", :router => "r3").name(:route)
+    end
+
+    it "should generate dupped routes" do
+      @r1.generator.generate(:route).should == "/r1"
+      r1 = @r1.dup
+      r1.generator.generate(:route).should == "/r1"
+    end
+
+    it "should not generate new routes added to a dup on the original" do
+      r1 = @r1.dup
+      r1.add_route("/new_r1", :router => "r4").name(:new_route)
+      lambda do
+        @r1.generator.generate(:new_route).should be_nil
+      end
+    end
+
+    it "should generate new routes added to a dup" do
+      r1 = @r1.dup
+      r1.add_route("/new_r1", :router => "r4").name(:new_route)
+      r1.generator.generate(:new_route).should == "/new_r1"
+    end
+
+    it "should generate a route for a nested usher" do
+      @r1.add_route("/mounted").match_partially!.to(@r2)
+      @r2.generator.generate(:route).should == "/mounted/r2"
+    end
+
+    it "should generate a route for a dupped nested usher" do
+      r3 = @r3.dup
+      @r1.add_route("/mounted").match_partially!.to(r3)
+      r3.generator.generate(:route).should == "/mounted/r3"
+    end
+
+    it "should generate a route for 2 differently mounted dupped ushers" do
+      r21 = @r2.dup
+      r22 = @r2.dup
+
+      @r1.add_route("/mounted").match_partially!.to(r21)
+      @r1.add_route("/other_mount").match_partially!.to(r22)
+
+      r21.generator.generate(:route).should == "/mounted/r2"
+      r22.generator.generate(:route).should == "/other_mount/r2"
+      @r2.generator.generate(:route).should == "/r2"
+    end
+  end
+
+end

data/spec/private/rack/dispatch_spec.rb

@@ -55,90 +55,96 @@ describe "Usher (for rack) route dispatching" do
     response = route_set.call_with_mock_request("/not-existing-url")
     response.status.should eql(404)
   end
-  
+
   describe "mounted rack instances" do
     before do
       @bad_app = mock("bad_app")
-      
+
       @usher2 = Usher::Interface.for(:rack)
       @usher2.add("/good" ).to(@app)
       @usher2.add("/bad"  ).match_partially!.to(@bad_app)
       @usher2.add("/some(/:foo)").to(@app)
-      
+
       route_set.add("/foo/:bar", :default_values => {:foo => "foo"}).match_partially!.to(@usher2)
       route_set.add("/foo", :default_values => {:controller => :foo}).to(@app)
     end
-    
+
     it "should match the route without nesting" do
       @app.should_receive(:call).once.with{ |e| e['usher.params'].should == {:controller => :foo}}
       route_set.call(Rack::MockRequest.env_for("/foo"))
     end
-    
+
     it "should route through the first route, and the second to the app" do
       @app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "bar", :foo => "foo"}}
       result = route_set.call(Rack::MockRequest.env_for("/foo/bar/good"))
     end
-    
+
     it "should go through to the bad app" do
       @bad_app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "some_bar", :foo => "foo"}}
       result = route_set.call(Rack::MockRequest.env_for("/foo/some_bar/bad"))
     end
-    
+
     it "should match optional routes paramters" do
       @app.should_receive(:call).once.with{|e| e['usher.params'].should == {:bar => "bar", :foo => "a_different_foo"}}
       route_set.call(Rack::MockRequest.env_for("/foo/bar/some/a_different_foo"))
     end
-    
+
     describe "SCRIPT_NAME & PATH_INFO" do
-      it "should update the script name for a fully consumed route" do
+      it "shouldn't update the script name for a fully consumed route" do
         @app.should_receive(:call).once.with do |e|
-          e['SCRIPT_NAME'].should == "/foo"
-          e['PATH_INFO'].should   == ""
+          e['SCRIPT_NAME'].should == ""
+          e['PATH_INFO'].should   == "/foo"
         end
         route_set.call(Rack::MockRequest.env_for("/foo"))
       end
-      
+
       it "should update the script name and path info for a partially consumed route" do
         @app.should_receive(:call).once.with do |e|
           e['SCRIPT_NAME'].should == "/partial"
           e['PATH_INFO'].should   == "/bar/baz"
         end
-        
+
         route_set.add("/partial").match_partially!.to(@app)
         route_set.call(Rack::MockRequest.env_for("/partial/bar/baz"))
       end
-      
+
       it "should consume the path through a mounted usher" do
         @bad_app.should_receive(:call).once.with do |e|
           e['SCRIPT_NAME'].should == "/foo/bar/bad"
           e['PATH_INFO'].should   == "/leftovers"
         end
-        
+
         route_set.call(Rack::MockRequest.env_for("/foo/bar/bad/leftovers"))
       end
-      
+
+      it "should not modify SCRIPT_NAME in place since thin freezes it" do
+        @app.should_receive(:call).once
+        env = Rack::MockRequest.env_for("/foo/bar/good")
+        env["SCRIPT_NAME"] = "".freeze
+        route_set.call(env)
+      end
     end
-    
+
     describe "dupping" do
-      before do 
+      before do
         @app  = mock("app")
         @u1   = Usher::Interface.for(:rack)
         @u2   = Usher::Interface.for(:rack)
-        
+
         @u1.add("/one", :default_values => {:one => :one}).to(@app)
         @u1.add("/mount").match_partially!.to(@u2)
-        
+
         @u2.add("/app", :default_values => {:foo => :bar}).to(@app)
-        
+
       end
-      
+
       it "should allow me to dup the router" do
         @app.should_receive(:call).twice.with{|e| e['usher.params'].should == {:one => :one}}
         @u1.call(Rack::MockRequest.env_for("/one"))
         u1_dash = @u1.dup
         u1_dash.call(Rack::MockRequest.env_for("/one"))
       end
-      
+
       it "should allow me to dup the router and add a new route without polluting the original" do
         @app.should_receive(:call).with{|e| e['usher.params'].should == {:foo => :bar}}
         u1_dash = @u1.dup
@@ -147,27 +153,53 @@ describe "Usher (for rack) route dispatching" do
         @app.should_not_receive(:call)
         @u1.call(Rack::MockRequest.env_for("/foo"))
       end
-      
+
       it "should allow me to dup the router and nested routers should remain intact" do
         @app.should_receive(:call).with{|e| e['usher.params'].should == {:foo => :bar}}
         u1_dash = @u1.dup
         u1_dash.call(Rack::MockRequest.env_for("/mount/app"))
       end
-      
+
       it "should allow me to dup the router and add more routes" do
         @app.should_receive(:call).with{|e| e['usher.params'].should == {:another => :bar}}
-        
+
         u3 = Usher::Interface.for(:rack)
         u1_dash = @u1.dup
-        
+
         u3.add("/another_bar", :default_values => {:another => :bar}).to(@app)
         u1_dash.add("/some/mount").match_partially!.to(u3)
-        
+
         u1_dash.call(Rack::MockRequest.env_for("/some/mount/another_bar"))
-        
+
         @app.should_not_receive(:call)
         @u1.call(Rack::MockRequest.env_for("/some/mount/another_bar"))
       end
     end
   end
+  
+  describe "use as middlware" do
+    it "should allow me to set a default application to use" do
+      @app.should_receive(:call).with{|e| e['usher.params'].should == {:middle => :ware}}
+
+      u = Usher::Interface::RackInterface.new(@app)
+      u.add("/foo", :default_values => {:middle => :ware}).name(:foo)
+
+      u.call(Rack::MockRequest.env_for("/foo"))
+    end
+
+    it "should use the default application when no routes match" do
+      env = Rack::MockRequest.env_for("/not_a_route")
+      @app.should_receive(:call).with(env)
+      u = Usher::Interface::RackInterface.new(@app)
+      u.call(env)
+    end
+
+    it "should allow me to set the application after initialization" do
+      @app.should_receive(:call).with{|e| e['usher.params'].should == {:after => :stuff}}
+      u = Usher::Interface.for(:rack)
+      u.app = @app
+      u.add("/foo", :default_values => {:after => :stuff})
+      u.call(Rack::MockRequest.env_for("/foo"))
+    end
+  end
 end

data/spec/private/rack/generate_spec.rb

@@ -0,0 +1,41 @@
+require 'lib/usher'
+require 'rack'
+
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
+route_set = Usher::Interface.for(:rack)
+route_set.extend(CallWithMockRequestMixin)
+
+describe "Usher (for rack) route generation" do
+  before(:each) do
+    route_set.reset!
+    @app = MockApp.new("Hello World!")
+    route_set.add("/fixed").name(:fixed)
+    route_set.add("/simple/:simple_var")
+    route_set.add("/named/simple/:named_simple_var").name(:simple)
+    route_set.add("/optional(/:optional_var)")
+    route_set.add("/named/optional(/:named_optional_var)").name(:optional)
+  end
+  
+  describe "named routes" do
+    it "should generate a fixed path" do
+      route_set.generate(:fixed).should == "/fixed"
+    end
+    
+    it "should generate a basic path route" do
+      route_set.generate(nil, :simple_var => "simple_var").should == "/simple/simple_var"
+    end
+
+    it "should generate a named path route" do
+      route_set.generate(:simple, :named_simple_var => "the_var").should == "/named/simple/the_var"
+    end
+
+    it "should generate a route with options" do
+      route_set.generate(nil, :optional_var => "var").should == "/optional/var"
+    end
+
+    it "should generate a named route with options" do
+      route_set.generate(:optional).should == "/named/optional"
+      route_set.generate(:optional, :named_optional_var => "the_var").should == "/named/optional/the_var"
+    end
+  end
+end

data/spec/private/recognize_spec.rb

@@ -195,6 +195,14 @@ describe "Usher route recognition" do
     route_set.recognize(build_request({:method => 'get', :path => '/testing/asd.qwe/testing2/poi.zxc/oiu.asd'})).params.should == [[:id, 'asd.qwe'], [:id2, 'poi.zxc'], [:id3, 'oiu.asd']]
   end
   
+  it "should recognize a path with an optional compontnet" do
+    route_set.add_route("/:name(/:surname)", :conditions => {:method => 'get'})
+    result = route_set.recognize(build_request({:method => 'get', :path => '/homer'}))
+    result.params.should == [[:name, "homer"]]
+    result = route_set.recognize(build_request({:method => 'get', :path => "/homer/simpson"}))
+    result.params.should == [[:name, "homer"],[:surname, "simpson"]]
+  end  
+  
   it "should should raise if malformed variables are used" do
     route_set.add_route('/products/show/:id', :id => /\d+/, :conditions => {:method => 'get'})
     proc {route_set.recognize(build_request({:method => 'get', :path => '/products/show/qweasd', :domain => 'admin.host.com'}))}.should raise_error
@@ -215,6 +223,13 @@ describe "Usher route recognition" do
       route_set.recognize(build_request({:method => 'post', :path => '/foo/bar'})).should.nil?
     end
 
+    it "should not match partially when a route is not set as partially matched" do
+      route = route_set.add_route("/foo", :foo => :bar)
+      route_set.recognize(build_request(:path => "/foo")).path.route.should == route
+      route_set.recognize(build_request(:path => "/foo/bar")).should be_nil
+    end
+    
+
   end
 
   describe "dup safety" do
@@ -228,8 +243,8 @@ describe "Usher route recognition" do
     end
         
     it "should recognize the originals routes in the dup" do
-      route_set.recognize(build_request(:path => "/foo")).path.route.destination.should == {:foo =>"foo"}
-      @r2.recognize(      build_request(:path => "/foo")).path.route.destination.should == {:foo =>"foo"}
+      route_set.recognize(  build_request(:path => "/foo")).path.route.destination.should == {:foo =>"foo"}
+      @r2.recognize(        build_request(:path => "/foo")).path.route.destination.should == {:foo =>"foo"}
     end
 
     it "should not add routes added to the dup to the original" do
@@ -240,8 +255,8 @@ describe "Usher route recognition" do
     
     it "should not delete routes added to the dup to the original" do
       @r2.delete_route("/foo")
-      route_set.recognize(        build_request(:path => "/foo")).path.route.destination.should == {:foo => "foo"}
-      @r2.recognize(  build_request(:path => "/foo")).should == nil
+      route_set.recognize(  build_request(:path => "/foo")).path.route.destination.should == {:foo => "foo"}
+      @r2.recognize(        build_request(:path => "/foo")).should == nil
     end
     
     
@@ -263,4 +278,4 @@ describe "Usher route recognition" do
     end
     
   end
-end
+end