doze 0.0.11

data/test/functional/media_type_test.rb

@@ -0,0 +1,40 @@
+require 'functional/base'
+
+require 'doze/media_type'
+
+class MediaTypeTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+  include Doze::MediaTypeTestCase
+
+  def test_put_registered_media_type_same_instance
+    foobar = Doze::MediaType.register('application/x-foo-bar')
+    root.expects(:supports_put?).returns(true)
+    root.expects(:accepts_put_with_media_type?).returns(true)
+    root.expects(:put).with {|entity| entity.media_type.equal?(foobar)}.returns(nil).once
+    put('CONTENT_TYPE' => 'application/x-foo-bar', :input => 'foo')
+    assert_equal STATUS_NO_CONTENT, last_response.status
+  end
+
+  def test_put_unregistered_media_type_equal
+    boo = Doze::MediaType.new('application/x-boo')
+    root.expects(:supports_put?).returns(true)
+    root.expects(:accepts_put_with_media_type?).returns(true)
+    root.expects(:put).with {|entity| entity && entity.media_type == boo}.returns(nil).once
+    put('CONTENT_TYPE' => 'application/x-boo', :input => 'foo')
+    assert_equal STATUS_NO_CONTENT, last_response.status
+  end
+
+
+
+  def test_lookup_name
+    mt = Doze::MediaType.register("application/foo")
+    assert Doze::MediaType["application/foo"].equal?(mt)
+  end
+
+  def test_lookup_alias
+    mt = Doze::MediaType.register("application/foo", :aliases => ['bar/foo'])
+    assert_equal Doze::MediaType["bar/foo"], mt
+    assert_equal ['application/foo', 'bar/foo'], mt.names
+  end
+end

data/test/functional/method_support_test.rb

@@ -0,0 +1,49 @@
+require 'functional/base'
+
+class MethodSupportTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  def test_unrecognized_method
+    app(:recognized_methods => [:get,:put,:post,:delete])
+    root.expects(:supports_method?).never
+    assert_equal STATUS_NOT_IMPLEMENTED, other_request_method('FOO').status
+  end
+
+  def test_recognized_but_not_supported_method
+    app(:recognized_methods => [:foo,:bar])
+
+    seq = sequence('support_calls')
+    root.expects(:supports_method?).with(:foo).returns(false).at_least_once.in_sequence(seq)
+    root.expects(:supports_method?).with(:bar).returns(true).at_least_once.in_sequence(seq)
+
+    assert_equal STATUS_METHOD_NOT_ALLOWED, other_request_method('FOO').status
+    allow = last_response.headers['Allow'] and allow = allow.split(', ')
+    assert_equal ['BAR','OPTIONS'], allow.sort
+  end
+
+  def test_recognized_and_supported_method_via_supports_foo
+    app(:recognized_methods => [:foo,:bar])
+
+    root.expects(:supports_foo?).returns(true).at_least_once
+    root.expects(:accepts_method_with_media_type?).with(:foo, anything).returns(true).at_least_once
+    root.expects(:supports_bar?).never
+    root.expects(:other_method).with(:foo, anything).returns(nil).once
+    assert_equal STATUS_NO_CONTENT, other_request_method('FOO').status
+  end
+
+  def test_options_with_get_supported_with_head_and_options_handled_automatically
+    root.expects(:supports_get?).returns(true).once
+    assert_equal STATUS_NO_CONTENT, other_request_method('OPTIONS').status
+
+    allow = last_response.headers['Allow'] and allow = allow.split(', ')
+    assert_not_nil allow
+    assert_equal ['GET','HEAD','OPTIONS'], allow.sort
+  end
+
+  def test_options_on_missing_resource
+    assert_equal STATUS_NO_CONTENT, other_request_method('OPTIONS', '/blah').status
+    allow = last_response.headers['Allow'] and allow = allow.split(', ')
+    assert_equal ['OPTIONS'], allow
+  end
+end

data/test/functional/non_get_method_test.rb

@@ -0,0 +1,173 @@
+require 'functional/base'
+
+class NonGetMethodTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+  include Doze::MediaTypeTestCase
+
+  def setup
+    super
+    @foo = Doze::MediaType.new('text/foo')
+    @bar = Doze::MediaType.new('text/bar')
+  end
+
+  def test_put_with_unacceptable_media_type
+    root.expects(:supports_put?).returns(true)
+    root.expects(:accepts_put_with_media_type?).with do |a|
+      a.is_a?(Doze::Entity) && a.media_type == @foo &&
+      a.binary_data_stream.respond_to?(:read) && a.binary_data_stream.read == 'foo' &&
+      a.binary_data == 'foo'
+    end.returns(false)
+    root.expects(:put).never
+    put('CONTENT_TYPE' => 'text/foo', :input => 'foo')
+    assert_equal STATUS_UNSUPPORTED_MEDIA_TYPE, last_response.status
+  end
+
+  def test_put
+    root.expects(:supports_put?).returns(true)
+    root.expects(:accepts_put_with_media_type?).with {|a| a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(true)
+    root.expects(:put).with do |value|
+      value.is_a?(Doze::Entity) and
+      value.binary_data == 'foo' and value.media_type == @foo and value.encoding == 'foobar'
+    end.returns(nil).once
+
+    put('CONTENT_TYPE' => 'text/foo; charset=foobar', :input => 'foo')
+    assert_equal STATUS_NO_CONTENT, last_response.status
+  end
+
+  def test_put_where_not_exists
+    root.expects(:exists?).returns(false)
+    root.expects(:supports_put?).returns(true)
+    root.expects(:accepts_put_with_media_type?).with {|a| a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(true)
+    root.expects(:put).returns(nil).once
+
+    put('CONTENT_TYPE' => 'text/foo; charset=foobar', :input => 'foo')
+    assert_equal STATUS_CREATED, last_response.status
+  end
+
+  def test_post_with_unacceptable_media_type
+    root.expects(:supports_post?).returns(true)
+    root.expects(:accepts_post_with_media_type?).with {|a| a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(false)
+    root.expects(:post).never
+    post('CONTENT_TYPE' => 'text/foo', :input => 'foo')
+    assert_equal STATUS_UNSUPPORTED_MEDIA_TYPE, last_response.status
+  end
+
+  def test_post_returning_created_resource
+    root.expects(:supports_post?).returns(true)
+    root.expects(:accepts_post_with_media_type?).with {|a| a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(true)
+    created = mock_resource('/uri', 'foo')
+    root.expects(:post).with do |value|
+      value.is_a?(Doze::Entity) and
+      value.binary_data == 'foob' and value.media_type == @foo and value.encoding == 'foobar'
+    end.returns(created).once
+
+    post('CONTENT_TYPE' => 'text/foo; charset=foobar', :input => 'foob')
+    assert_equal STATUS_CREATED, last_response.status
+    assert_response_header 'Location', 'http://example.org/uri'
+    assert_equal 'foo', last_response.body
+  end
+
+  def test_post_returning_nothing
+    root.expects(:supports_post?).returns(true)
+    root.expects(:accepts_post_with_media_type?).with {|a| a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(true)
+    root.expects(:post).returns(nil).once
+
+    post('CONTENT_TYPE' => 'text/foo; charset=foobar', :input => 'foob')
+    assert_equal STATUS_NO_CONTENT, last_response.status
+  end
+
+  def test_post_with_extra_arity_gets_session
+    root.expects(:supports_post?).returns(true)
+    root.expects(:accepts_post_with_media_type?).with {|a| a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(true)
+
+    # Because mocha doesn't set the arity right
+    def root.post(a, b)
+      post_actually_called(a, b)
+    end
+    root.expects(:post_actually_called).with(instance_of(Doze::Entity), "user").once
+
+    post('REMOTE_USER' => 'user', 'CONTENT_TYPE' => 'text/foo; charset=foobar', :input => 'foob')
+    assert_equal STATUS_NO_CONTENT, last_response.status
+  end
+
+  def test_post_returning_entity
+    root.expects(:supports_post?).returns(true)
+    root.expects(:accepts_post_with_media_type?).with {|a| a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(true)
+    root.expects(:post).returns(mock_entity('bar', @bar)).once
+
+    post('CONTENT_TYPE' => 'text/foo; charset=foobar', :input => 'foob')
+    assert_equal STATUS_OK, last_response.status
+    assert_equal 'bar', last_response.body
+    assert_equal 'text/bar', last_response.media_type
+  end
+
+  def test_post_returning_anonymous_resource
+    root.expects(:supports_post?).returns(true)
+    root.expects(:accepts_post_with_media_type?).with {|a| a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(true)
+    resource = mock_resource(nil)
+    resource.expects(:get).returns(mock_entity('bar', @bar))
+    root.expects(:post).returns(resource).once
+
+    post('CONTENT_TYPE' => 'text/foo; charset=foobar', :input => 'foob')
+    assert_equal STATUS_OK, last_response.status
+    assert_equal 'bar', last_response.body
+    assert_equal 'text/bar', last_response.media_type
+  end
+
+  def test_delete
+    root.expects(:supports_delete?).returns(true)
+    root.expects(:accepts_delete_with_media_type?).never
+    root.expects(:delete_resource).returns(nil).once
+
+    delete
+    assert_equal STATUS_NO_CONTENT, last_response.status
+    assert last_response.body.empty?
+  end
+
+  def test_other_method_with_no_response
+    # PATCH used as an example here
+    app(:recognized_methods => [:get,:post,:put,:delete,:patch])
+
+    root.expects(:supports_patch?).returns(true)
+    root.expects(:accepts_method_with_media_type?).with {|m,a| m == :patch && a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(true)
+    root.expects(:patch).with do |value|
+      value.is_a?(Doze::Entity) and
+      value.binary_data == 'foob' and value.media_type == @foo and value.encoding == 'foobar'
+    end.returns(nil).once
+
+    other_request_method('PATCH', {'CONTENT_TYPE' => 'text/foo; charset=foobar', :input => 'foob'})
+    assert_equal STATUS_NO_CONTENT, last_response.status
+  end
+
+  def test_other_method_with_anonymous_resource_response
+    # PATCH used as an example here
+    app(:recognized_methods => [:get,:post,:put,:delete,:patch])
+
+    root.expects(:supports_patch?).returns(true)
+    root.expects(:accepts_method_with_media_type?).with {|m,a| m == :patch && a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(true)
+    resource = mock_resource(nil)
+    resource.expects(:get).returns(mock_entity('bar', @bar))
+    root.expects(:patch).returns(resource).once
+
+    other_request_method('PATCH', {'CONTENT_TYPE' => 'text/foo; charset=foobar', :input => 'foob'})
+    assert_equal STATUS_OK, last_response.status
+    assert_equal 'bar', last_response.body
+    assert_equal 'text/bar', last_response.media_type
+  end
+
+  def test_other_method_with_resource_response
+    # PATCH used as an example here
+    app(:recognized_methods => [:get,:post,:put,:delete,:patch])
+
+    root.expects(:supports_patch?).returns(true)
+    root.expects(:accepts_method_with_media_type?).with {|m,a| m == :patch && a.is_a?(Doze::Entity) && a.media_type == @foo}.returns(true)
+    resource = mock_resource('/foo', 'bar')
+    root.expects(:patch).returns(resource).once
+
+    other_request_method('PATCH', {'CONTENT_TYPE' => 'text/foo; charset=foobar', :input => 'foob'})
+    assert_equal STATUS_CREATED, last_response.status
+    assert_response_header 'Location', 'http://example.org/foo'
+    assert_equal 'bar', last_response.body
+  end
+end

data/test/functional/precondition_test.rb

@@ -0,0 +1,84 @@
+require 'functional/base'
+
+class PreconditionTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  def setup
+    @last_modified = Time.now - 30
+    root.expects(:last_modified).returns(@last_modified).at_least_once
+  end
+
+  def test_if_modified_since
+    get('HTTP_IF_MODIFIED_SINCE' => (@last_modified-10).httpdate)
+    assert_equal STATUS_OK, last_response.status
+    get('HTTP_IF_MODIFIED_SINCE' => (@last_modified+10).httpdate)
+    assert_equal STATUS_NOT_MODIFIED, last_response.status
+  end
+
+  def test_if_unmodified_since
+    get('HTTP_IF_UNMODIFIED_SINCE' => (@last_modified+10).httpdate)
+    assert_equal STATUS_OK, last_response.status
+    get('HTTP_IF_UNMODIFIED_SINCE' => (@last_modified-10).httpdate)
+    assert_equal STATUS_PRECONDITION_FAILED, last_response.status
+  end
+
+  def test_status_for_non_get
+    root.expects(:supports_post?).returns(true).at_least_once
+    root.expects(:supports_put?).returns(true).at_least_once
+    root.expects(:supports_delete?).returns(true).at_least_once
+    root.expects(:accepts_method_with_media_type?).returns(true).at_least_once
+    root.expects(:post).never
+    root.expects(:put).never
+    root.expects(:delete).never
+
+    assert_equal STATUS_PRECONDITION_FAILED, post('HTTP_IF_UNMODIFIED_SINCE' => (@last_modified-10).httpdate).status
+    assert_equal STATUS_PRECONDITION_FAILED, put('HTTP_IF_UNMODIFIED_SINCE' => (@last_modified-10).httpdate).status
+    assert_equal STATUS_PRECONDITION_FAILED, delete('HTTP_IF_UNMODIFIED_SINCE' => (@last_modified-10).httpdate).status
+    assert_equal STATUS_PRECONDITION_FAILED, post('HTTP_IF_MODIFIED_SINCE' => (@last_modified+10).httpdate).status
+    assert_equal STATUS_PRECONDITION_FAILED, put('HTTP_IF_MODIFIED_SINCE' => (@last_modified+10).httpdate).status
+    assert_equal STATUS_PRECONDITION_FAILED, delete('HTTP_IF_MODIFIED_SINCE' => (@last_modified+10).httpdate).status
+  end
+end
+
+class EntityPreconditionTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  def setup
+    @last_modified = Time.now - 30
+    root.expects(:last_modified).returns(@last_modified).at_least_once
+
+    @entity = mock_entity('foo')
+    @etag = '123abc'
+    @entity.expects(:etag).returns(@etag).at_least_once
+    root.expects(:get).returns(@entity).at_least_once
+  end
+
+  def test_if_match
+    get('HTTP_IF_MATCH' => quote(@etag))
+    assert_equal STATUS_OK, last_response.status
+    get('HTTP_IF_MATCH' => quote("not-the-etag"))
+    assert_equal STATUS_PRECONDITION_FAILED, last_response.status
+  end
+
+  def test_if_none_match
+    get('HTTP_IF_NONE_MATCH' => quote(@etag))
+    assert_equal STATUS_NOT_MODIFIED, last_response.status
+    get('HTTP_IF_NONE_MATCH' => quote("not-the-etag"))
+    assert_equal STATUS_OK, last_response.status
+  end
+
+  def test_non_get_method_not_called_when_precondition_fails
+    root.expects(:supports_post?).returns(true).once
+    root.expects(:supports_put?).returns(true).once
+    root.expects(:supports_delete?).returns(true).once
+    root.expects(:accepts_method_with_media_type?).returns(true).at_least_once
+    root.expects(:post).never
+    root.expects(:put).never
+    root.expects(:delete).never
+    assert_equal STATUS_PRECONDITION_FAILED, post('HTTP_IF_MATCH' => quote('not-the-etag')).status
+    assert_equal STATUS_PRECONDITION_FAILED, put('HTTP_IF_MATCH' => quote('not-the-etag')).status
+    assert_equal STATUS_PRECONDITION_FAILED, delete('HTTP_IF_MATCH' => quote('not-the-etag')).status
+  end
+end

data/test/functional/raw_path_info_test.rb

@@ -0,0 +1,69 @@
+require "test/unit"
+require 'mocha/setup'
+require 'doze/request'
+
+class RawPathInfoTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  def mock_request(path, host="localhost", scheme="http", port=-1, context="")
+
+    port_str = if port == -1 then "" ; else ":#{port}" ; end
+
+    path_parts = ["/", context, path].join("")
+    if path_parts[0...2] == "//" then path_parts = path_parts[1..-1] end
+
+    url = stub()
+    url.stubs(:toString).returns("#{scheme}://#{host}#{port_str}#{path_parts}")
+
+    s_request = stub("")
+    s_request.stubs(:getRequestURL).returns(url)
+    s_request.stubs(:getContextPath).returns(context)
+
+    app = stub()
+    env = stub()
+    env.stubs(:[]).with('java.servlet_request').returns(s_request)
+    Doze::Request.new(app, env)
+  end
+
+  def test_bland_path
+    dr = mock_request("/path/is/good")
+    assert_equal dr.raw_path_info, "/path/is/good"
+  end
+
+  def test_path_with_host_and_port
+    dr = mock_request("/how/do", "x23.awesome-server.playlouder---com.com", 5432)
+    assert_equal dr.raw_path_info, "/how/do"
+  end
+
+  def test_path_with_naughty_chars
+    dr = mock_request("/how/do%20", "awesome-server", 5432)
+    assert_equal dr.raw_path_info, "/how/do%20"
+  end
+
+  def test_context_is_chomped
+    ['bob', 'bob-y', 'the%20bobster'].each do |context|
+      dr = mock_request('/path-s/of/life', 'www.awesome.com', 'https', 8080, context)
+      assert_equal dr.raw_path_info, "/path-s/of/life"
+    end
+  end
+
+  def test_searchpart_excluded
+    {
+      '/path' => '/path', '?false=true' => '/', '/path?you=suck&bob&nick=awesome' => '/path'
+    }.each do |raw, exp_raw_path_info|
+      dr = mock_request(raw, 'some.host-rocks', 'http', 1234)
+      assert_equal dr.raw_path_info, exp_raw_path_info
+    end
+  end
+
+  def test_servlet_is_missing
+    app = stub()
+    env = stub()
+    env.stubs(:[]).with('java.servlet_request').returns(nil)
+    dr = Doze::Request.new(app, env)
+    dr.expects(:path_info).twice.returns("/omg/im/a/path")
+    assert_equal dr.raw_path_info, dr.path_info
+  end
+
+end

data/test/functional/resource_representation_test.rb

@@ -0,0 +1,14 @@
+require 'functional/base'
+
+class ResourceRepresentationTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  def test_get_with_resource_representation
+    resource = mock_resource('/foo/bar')
+    root.expects(:get).returns(resource)
+    get
+    assert_equal STATUS_SEE_OTHER, last_response.status
+    assert_response_header 'Location', 'http://example.org/foo/bar'
+  end
+end

data/test/functional/router_test.rb

@@ -0,0 +1,196 @@
+require 'functional/base'
+
+class RouterInterfaceTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  # tests how the basic Router interface is exposed by the framework
+
+  def test_router_no_match
+    root_router.expects(:perform_routing).with('/foo', nil, '').returns(nil).once
+    assert_equal STATUS_NOT_FOUND, get('/foo').status
+  end
+
+  def test_router_match_resource_with_no_trailing_path
+    resource = mock_resource('/foo')
+    root_router.expects(:perform_routing).with('/foo', nil, '').returns([resource, '/foo', nil]).once
+    resource.expects(:get).returns(mock_entity('foo', 'text/html')).once
+    assert_equal STATUS_OK, get('/foo').status
+  end
+
+  def test_router_match_resource_but_with_trailing
+    # here we route to a resource, but there is some trailing path which can't be routed any further
+    resource = mock_resource('/foo')
+    root_router.expects(:perform_routing).with('/foo/bar', nil, '').returns([resource, '/foo', '/bar']).once
+    resource.expects(:get).never
+    assert_equal STATUS_NOT_FOUND, get('/foo/bar').status
+  end
+
+  def test_router_match_router_with_trailing_then_resource
+    # here we route to another router which is matched but with some trailing path that's passed on to it.
+
+    second_router = mock_router
+    resource = mock_resource('/foo/bar')
+
+    root_router.expects(:perform_routing).with('/foo/bar', nil, '').returns([second_router, '/foo', '/bar']).once
+    second_router.expects(:perform_routing).with('/bar', nil, '/foo').returns([resource, '/foo/bar', nil]).once
+
+    resource.expects(:get).returns(mock_entity('foo', 'text/html')).once
+    assert_equal STATUS_OK, get('/foo/bar').status
+  end
+
+  def test_router_match_router_resource_with_trailing_then_resource
+    # as above but this time our second router is also a resource - check that it does actually act as a router
+
+    second_router = mock_router(Doze::MockResource)
+    resource = mock_resource('/foo/bar')
+
+    root_router.expects(:perform_routing).with('/foo/bar', nil, '').returns([second_router, '/foo', '/bar']).once
+    second_router.expects(:perform_routing).with('/bar', nil, '/foo').returns([resource, '/foo/bar', nil]).once
+
+    second_router.expects(:get).never
+    resource.expects(:get).returns(mock_entity('foo', 'text/html')).once
+    assert_equal STATUS_OK, get('/foo/bar').status
+  end
+
+  def test_router_match_router_resource_with_no_trailing
+    resource = mock_router(Doze::MockResource)
+
+    root_router.expects(:perform_routing).with('/foo', nil, '').returns([resource, '/foo', nil]).once
+    resource.expects(:perform_routing).never
+    resource.expects(:get).returns(mock_entity('foo', 'text/html')).once
+
+    assert_equal STATUS_OK, get('/foo').status
+  end
+
+  def test_router_gets_passed_user
+    root_router.expects(:perform_routing).with('/foo', 'Mack', '').returns(nil).once
+    assert_equal STATUS_NOT_FOUND, get('/foo', 'REMOTE_USER' => 'Mack').status
+  end
+end
+
+
+class RouterDefaultImplementationTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  # tests the default implementation of Router based on routes defined in class method helpers
+
+  def test_route_fixed_uri_to_resource_class
+    resource = mock_resource('/foo')
+    resource.expects(:get).returns(mock_entity('foo', 'text/html')).once
+    klass = Class.new
+    klass.expects(:new).with("/foo").returns(resource)
+
+    root_router do
+      route '/foo', :to => klass
+    end
+
+    assert_equal STATUS_OK, get('/foo').status
+  end
+
+  def test_route_fixed_uri_to_resource_instance
+    resource = mock_resource('/foo')
+    resource.expects(:get).returns(mock_entity('foo', 'text/html')).once
+
+    root_router do
+      route '/foo', :to => resource
+    end
+
+    assert_equal STATUS_OK, get('/foo').status
+  end
+
+  def test_route_with_params_to_block_returning_resource
+    root_router do
+      route('/foo/{x}/{y}') do |router, uri, params|
+        Doze::MockResource.new(uri, [uri, params].inspect)
+      end
+    end
+
+    get('/foo/abc/123')
+
+    assert_equal STATUS_OK, last_response.status
+    assert_equal(['/foo/abc/123', {:x => 'abc', :y => '123'}].inspect, last_response.body)
+  end
+
+  # More complex two-level routing scenario with params at both levels
+  def test_route_with_params_to_block_returning_router_routing_to_resource_with_more_params
+    root_router do
+      route('/foo/{x}') do |router1, uri1, params1|
+
+        Class.new do
+          include Doze::Router
+          route("/{y}") do |router2, uri2, params2|
+            Doze::MockResource.new(uri2, [uri1, params1, uri2, params2].inspect)
+          end
+        end.new
+      end
+    end
+
+    get('/foo/abc/123')
+
+    assert_equal STATUS_OK, last_response.status
+    # bit of a messy way to test it but this was getting fiddly to mock nicely
+    # expecting [uri1, params1, uri2, params2].inspect  from above
+    assert_equal(['/foo/abc', {:x => 'abc'}, '/foo/abc/123', {:y => '123'}].inspect, last_response.body)
+  end
+
+  def test_route_with_special_param_regexp
+    root_router do
+      route('/foo/{x}', :regexps => {:x => /\d+/}) do |router, uri, params|
+        Doze::MockResource.new(uri, params[:x])
+      end
+    end
+
+    assert_equal STATUS_NOT_FOUND, get('/foo/abc').status
+    assert_equal STATUS_OK, get('/foo/123').status
+    assert_equal "123", last_response.body
+  end
+
+  def test_route_with_uri_template_passed_directly
+    root_router do
+      route(Doze::URITemplate.compile('/foo/{x}', :x => /\d+/)) do |router, uri, params|
+        Doze::MockResource.new(uri, params[:x])
+      end
+    end
+
+    assert_equal STATUS_NOT_FOUND, get('/foo/abc').status
+    assert_equal STATUS_OK, get('/foo/123').status
+    assert_equal "123", last_response.body
+  end
+
+  def test_user_specific_route
+    root_router do
+      route('/foo/{x}/{y}', :session_specific => true) do |router, uri, params, user|
+        Doze::MockResource.new(uri, [uri, params, user].inspect)
+      end
+    end
+
+    get('/foo/abc/123', 'REMOTE_USER' => 'Mo')
+
+    assert_equal STATUS_OK, last_response.status
+    assert_equal(['/foo/abc/123', {:x => 'abc', :y => '123'}, 'Mo'].inspect, last_response.body)
+  end
+
+  def test_propagate_static_routes
+    klass = Class.new
+    klass.send(:include, Doze::Router)
+    router = mock_router
+    router2 = mock_router
+
+    root_router do
+      route "/bar", :uniquely_to => klass
+      route "/baz", :uniquely_to => router
+      route "/baz", :to => router2
+    end
+
+    root_router.propagate_static_routes("/foo")
+
+    assert_equal "/foo", root_router.router_uri_prefix
+
+    assert_equal "/foo/bar", klass.router_uri_prefix
+    assert_equal "/foo/bar", klass.new.router_uri_prefix
+    assert_equal "/foo/baz", router.router_uri_prefix
+    assert_equal nil, router2.router_uri_prefix
+  end
+end