doze 0.0.11

data/test/functional/base.rb

@@ -0,0 +1,159 @@
+require 'doze'
+require 'doze/media_type'
+
+# works around this error when newer test-unit gem present:
+# http://stackoverflow.com/questions/1145318/getting-uninitialized-constant-error-when-trying-to-run-tests
+begin; gem 'test-unit'; rescue NoMethodError, LoadError; end
+
+require 'test/unit'
+require 'rack/test'
+require 'mocha/setup'
+
+class Doze::MockResource
+  include Doze::Resource
+
+  attr_reader :extra_params, :data
+
+  def initialize(uri=nil, binary_data='')
+    @uri = uri
+    @binary_data = binary_data
+  end
+
+  def get
+    Doze::Entity.new(Doze::MediaType['text/html'], :binary_data => @binary_data)
+  end
+end
+
+module Doze::TestCase
+  include Rack::Test::Methods
+
+  TEST_CONFIG = {
+    :catch_application_errors => false,
+    :session_from_rack_env => proc {|env| env['REMOTE_USER']},
+    :session_authenticated => proc {|session| !session.nil?}
+  }
+
+  def app(config={})
+    @app ||= Doze::Application.new(root, TEST_CONFIG.merge(config))
+  end
+
+  attr_writer :root
+
+  def root
+    @root ||= Doze::MockResource.new("/")
+  end
+
+  def root_router(&b)
+    @root ||= mock_router(&b)
+  end
+
+  def get(path='/', env={}, &b)
+    path, env = '/', path if path.is_a?(Hash)
+    super(path, {}, env, &b)
+  end
+
+  def put(path='/', env={}, &b)
+    path, env = '/', path if path.is_a?(Hash)
+    super(path, {}, env, &b)
+  end
+
+  def post(path='/', env={}, &b)
+    path, env = '/', path if path.is_a?(Hash)
+    super(path, {}, env, &b)
+  end
+
+  def delete(path='/', env={}, &b)
+    path, env = '/', path if path.is_a?(Hash)
+    super(path, {}, env, &b)
+  end
+
+  def head(path='/', env={}, &b)
+    path, env = '/', path if path.is_a?(Hash)
+    super(path, {}, env, &b)
+  end
+
+  def other_request_method(method, path='/', env={}, &block)
+    path, env = '/', path if path.is_a?(Hash)
+    request(path, env.merge(:method => method, :params => {}), &block)
+  end
+
+  def mock_entity(binary_data, media_type='text/html', language=nil)
+    media_type = Doze::MediaType[media_type] if media_type.is_a?(String)
+    Doze::Entity.new(media_type, :binary_data => binary_data, :language => language)
+  end
+
+  def mock_resource(*p); Doze::MockResource.new(*p); end
+
+  def mock_router(superclass = Object, &block)
+    klass = Class.new(superclass)
+    klass.send(:include, Doze::Router)
+    klass.class_eval(&block) if block
+    klass.new
+  end
+
+  def assert_response_header(header, value, message=nil)
+    assert_block(build_message(message, "<?> was expected for last response header <?>", value, header)) do
+      r = last_response and v = r.headers[header] and v == value
+    end
+  end
+
+  def assert_response_header_includes(header, value, message=nil)
+    assert_block(build_message(message, "<?> was expected in last response header <?>", value, header)) do
+      r = last_response and v = r.headers[header] and v.split(/,\s+/).include?(value)
+    end
+  end
+
+  def assert_response_header_not_includes(header, value, message=nil)
+    assert_block(build_message(message, "<?> was not expected in last response header <?>", value, header)) do
+      !(r = last_response and v = r.headers[header] and v.split(/,\s+/).include?(value))
+    end
+  end
+
+  def assert_response_header_exists(header, message=nil)
+    assert_block(build_message(message, "<?> response header was expected", header)) do
+      r = last_response and !r.headers[header].nil?
+    end
+  end
+
+  def assert_no_response_header(header, message=nil)
+    assert_block(build_message(message, "<?> response header was not expected", header)) do
+      r = last_response and r.headers[header].nil?
+    end
+  end
+
+end
+
+# To be used for any test that defines new media types - cleans them up afterwards in the registry
+module Doze::MediaTypeTestCase
+  def setup
+    @media_type_name_lookup = Doze::MediaType::NAME_LOOKUP.dup
+    @media_type_by_extension = Doze::MediaType::BY_EXTENSION.dup
+    super
+  end
+
+  def teardown
+    super
+    Doze::MediaType::NAME_LOOKUP.replace(@media_type_name_lookup)
+    Doze::MediaType::BY_EXTENSION.replace(@media_type_by_extension)
+  end
+end
+
+class Rack::MockResponse
+
+  # Useful to have these helpers in MockResponse corresponding to those in request:
+
+  def media_type
+    content_type && content_type.split(/\s*[;,]\s*/, 2)[0].downcase
+  end
+
+  def media_type_params
+    return {} if content_type.nil?
+    content_type.split(/\s*[;,]\s*/)[1..-1].
+      collect { |s| s.split('=', 2) }.
+      inject({}) { |hash,(k,v)| hash[k.downcase] = v ; hash }
+  end
+
+  def content_charset
+    media_type_params['charset']
+  end
+end

data/test/functional/cache_header_test.rb

@@ -0,0 +1,76 @@
+require 'functional/base'
+
+class CacheHeaderTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  def test_with_no_cache_headers
+    root.expects(:cacheable?).returns(nil).once
+    get
+    assert_nil last_response.headers['Cache-Control']
+    assert_nil last_response.headers['Expires']
+    assert_response_header_exists 'Etag'
+  end
+
+  def test_not_cacheable
+    root.expects(:cacheable?).returns(false).once
+    get
+    assert_response_header_includes 'Cache-Control', 'no-cache'
+    assert_response_header_includes 'Cache-Control', 'max-age=0'
+    assert Time.httpdate(last_response.headers['Expires']) < Time.now
+    assert_no_response_header 'Last-Modified'
+  end
+
+  def test_cacheable_but_no_expiry
+    root.expects(:cacheable?).returns(true).at_least_once
+    get
+    assert_response_header_not_includes 'Cache-Control', 'no-cache'
+    assert_response_header_not_includes 'Cache-Control', 'max-age'
+    assert_response_header_includes 'Cache-Control', 'public'
+    assert_nil last_response.headers['Expires']
+    assert_response_header_exists 'Etag'
+  end
+
+  def test_cacheable_with_expiry
+    root.expects(:cacheable?).returns(true).at_least_once
+    root.expects(:cache_expiry_period).returns(60).once
+    get
+    assert_response_header_includes 'Cache-Control', 'max-age=60'
+    assert_response_header_includes 'Cache-Control', 'public'
+    assert_in_delta Time.now+60, Time.httpdate(last_response.headers['Expires']), 1
+    assert_response_header_exists 'Etag'
+  end
+
+  def test_last_modified
+    while_ago = Time.now - 30
+    root.expects(:last_modified).returns(while_ago).at_least_once
+    get
+    assert_response_header 'Last-Modified', while_ago.httpdate
+  end
+
+  def test_private_cacheable
+    root.expects(:cacheable?).returns(true).once
+    root.expects(:publicly_cacheable?).returns(false).once
+    root.expects(:cache_expiry_period).returns(60).once
+    get
+    assert_response_header_includes 'Cache-Control', 'max-age=60'
+    assert_response_header_not_includes 'Cache-Control', 's-maxage'
+    assert_response_header_not_includes 'Cache-Control', 'public'
+    assert_response_header_includes 'Cache-Control', 'private'
+    assert_in_delta Time.now+60, Time.httpdate(last_response.headers['Expires']), 1
+    assert_response_header_exists 'Etag'
+  end
+
+  def test_cacheable_with_different_public_private_expiry
+    root.expects(:cacheable?).returns(true).at_least_once
+    root.expects(:cache_expiry_period).returns(60).once
+    root.expects(:public_cache_expiry_period).returns(30).once
+    get
+    assert_response_header_includes 'Cache-Control', 'max-age=60'
+    assert_response_header_includes 'Cache-Control', 's-maxage=30'
+    assert_response_header_includes 'Cache-Control', 'public'
+    assert_response_header_not_includes 'Cache-Control', 'private'
+    assert_in_delta Time.now+60, Time.httpdate(last_response.headers['Expires']), 1
+    assert_response_header_exists 'Etag'
+  end
+end

data/test/functional/direct_response_test.rb

@@ -0,0 +1,16 @@
+require 'functional/base'
+
+class DirectResponseTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  def test_get_with_direct_response
+    resource = mock_resource
+    response = Doze::Response.new(456, {"X-Foo" => "Bar"}, "Yadda!")
+    root.expects(:get).returns(response)
+    get
+    assert_equal 456, last_response.status
+    assert_equal "Yadda!", last_response.body
+    assert_response_header 'X-Foo', 'Bar'
+  end
+end

data/test/functional/error_handling_test.rb

@@ -0,0 +1,131 @@
+require 'functional/base'
+
+class CustomErrorResource
+  include Doze::Resource
+  def initialize(status, message, extras={})
+    @status = status; @message = message
+  end
+end
+
+class FooException < StandardError
+end
+
+class ErrorHandlingTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  def test_default_error_resource
+    root.expects(:exists?).returns(false).at_least_once
+    get
+    assert_equal STATUS_NOT_FOUND, last_response.status
+    assert_match /not found/i, last_response.body
+  end
+
+  def test_default_error_resource_negotiation
+    root.expects(:exists?).returns(false).at_least_once
+    get('HTTP_ACCEPT' => 'application/json')
+    assert_equal STATUS_NOT_FOUND, last_response.status
+    assert_equal 'application/json', last_response.media_type
+
+    get('HTTP_ACCEPT' => 'application/yaml')
+    assert_equal STATUS_NOT_FOUND, last_response.status
+    assert_equal 'application/json', last_response.media_type
+
+    # Failure of negotiation should be ignored for an error resource, not result in a STATUS_NOT_ACCEPTABLE
+    get('HTTP_ACCEPT' => 'application/bollocks')
+    assert_not_equal STATUS_NOT_ACCEPTABLE, last_response.status
+    assert_match /not found/i, last_response.body
+  end
+
+  def test_custom_error_resource
+    e = CustomErrorResource.new(STATUS_NOT_FOUND, 'Not Found')
+    CustomErrorResource.expects(:new).with(STATUS_NOT_FOUND, 'Not Found', anything).returns(e).once
+    entity = Doze::Entity.new(Doze::MediaType['text/html'], :binary_data => "foo bar baz")
+    e.expects(:get).returns(entity).once
+
+    root.expects(:exists?).returns(false).at_least_once
+
+    app(:error_resource_class => CustomErrorResource)
+    get
+    assert_equal STATUS_NOT_FOUND, last_response.status
+    assert_equal 'text/html', last_response.media_type
+    assert_equal "foo bar baz", last_response.body
+  end
+
+  def test_custom_error_resource_can_access_original_error
+    e = CustomErrorResource.new(STATUS_NOT_FOUND, 'Not Found: Oi!')
+
+    CustomErrorResource.expects(:new).with(STATUS_NOT_FOUND, 'Not Found: Oi!', has_key(:error)).returns(e).once
+    entity = Doze::Entity.new(Doze::MediaType['text/html'], :binary_data => "foo bar baz")
+    e.expects(:get).returns(entity).once
+
+
+    app(:error_resource_class => CustomErrorResource)
+    root.expects(:get).raises(Doze::ResourceNotFoundError, 'Oi!')
+
+    get
+    assert_equal STATUS_NOT_FOUND, last_response.status
+    assert_equal 'text/html', last_response.media_type
+    assert_equal "foo bar baz", last_response.body
+  end
+
+  def test_error_without_error_resource
+    root.expects(:exists?).returns(false).at_least_once
+    app(:error_resource_class => nil)
+    get
+    assert_equal STATUS_NOT_FOUND, last_response.status
+    assert_equal 'text/plain', last_response.media_type
+    assert_match /not found/i, last_response.body
+  end
+
+  def test_exception_caught_from_resource_code
+    app(:error_resource_class => Doze::Resource::Error, :catch_application_errors => true)
+
+    root.expects(:get).raises(RuntimeError, 'Oi!')
+    get
+    assert_equal STATUS_INTERNAL_SERVER_ERROR, last_response.status
+    assert_match /internal server error/i, last_response.body
+  end
+
+  def test_exception_not_caught_from_resource_code
+    app(:error_resource_class => Doze::Resource::Error, :catch_application_errors => false)
+
+    root.expects(:get).raises(FooException, 'Oi!')
+    assert_raise(FooException) {get}
+  end
+
+  def test_exception_within_error_resource_code
+    app(:error_resource_class => CustomErrorResource, :catch_application_errors => true)
+
+    CustomErrorResource.any_instance.expects(:get).at_least_once.raises(FooException)
+
+    root.expects(:exists?).returns(false).at_least_once
+    get
+    assert_equal STATUS_INTERNAL_SERVER_ERROR, last_response.status
+  end
+
+  def test_exception_within_error_resource_code_after_catching_exception_from_resource_code
+    app(:error_resource_class => CustomErrorResource, :catch_application_errors => true)
+
+    root.expects(:get).raises(RuntimeError)
+    CustomErrorResource.any_instance.expects(:get).raises(FooException)
+
+    get
+    assert_equal STATUS_INTERNAL_SERVER_ERROR, last_response.status
+  end
+
+  def test_get_unavailable_resource
+    root.expects(:get).raises(Doze::ResourceUnavailableError.new)
+
+    get
+    assert_equal STATUS_SERVICE_UNAVAILABLE, last_response.status
+  end
+
+  def test_not_found_error
+    root.expects(:get).raises(Doze::ResourceNotFoundError.new)
+
+    get
+    assert_equal STATUS_NOT_FOUND, last_response.status
+  end
+
+end

data/test/functional/get_and_conneg_test.rb

@@ -0,0 +1,182 @@
+require 'functional/base'
+
+class GetAndConnegTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+
+  def setup
+    @entities = [
+      mock_entity('<foo>Yalrightmate</foo>', 'text/html', 'en-gb'),
+      mock_entity("{foo: 'Yalrightmate'}", 'application/json', 'en-gb'),
+      mock_entity("--- \nfoo: Yalrightmate\n", 'application/yaml', 'en-gb'),
+
+      mock_entity('<foo>Wassup</foo>', 'text/html', 'en-us'),
+      mock_entity("{foo: 'Wassup'}", 'application/json', 'en-us'),
+      mock_entity("--- \nfoo: Wassup\n", 'application/yaml', 'en-us'),
+
+      mock_entity("<foo>Wie geht's</foo>", 'text/html', 'de'),
+      mock_entity('{"foo": "Wie geht\'s"}', 'application/json', 'de')
+      # no yaml in german
+    ]
+  end
+
+  def test_get
+    root.expects(:get).returns(mock_entity('foo', 'text/html')).once
+    assert_equal STATUS_OK, get.status
+    assert_equal 'foo', last_response.body
+    assert_equal 'text/html', last_response.media_type
+    assert_not_nil last_response.headers['Date']
+    assert_in_delta Time.now, Time.httpdate(last_response.headers['Date']), 1
+    assert_equal 'foo'.length, last_response.headers['Content-Length'].to_i
+    assert_nil last_response.headers['Content-Language']
+    assert !(last_response.headers['Vary'] || '').split(/,\s*/).include?('Accept')
+    assert !(last_response.headers['Vary'] || '').split(/,\s*/).include?('Accept-Language')
+  end
+
+  def test_not_exists_get
+    root.expects(:exists?).returns(false).once
+    root.expects(:get).never
+    assert_equal STATUS_NOT_FOUND, get.status
+  end
+
+  def test_get_with_media_type_variation_and_no_accept
+    root.expects(:get).returns([
+      mock_entity('<foo>fdgfdgfd</foo>', 'text/html'),
+      mock_entity("{foo: 'fdgfdgfd'}", 'application/json'),
+    ]).once
+    assert_equal STATUS_OK, get.status
+    assert_equal "<foo>fdgfdgfd</foo>", last_response.body
+    assert_equal 'text/html', last_response.media_type
+    assert last_response.headers['Vary'].split(/,\s*/).include?('Accept')
+  end
+
+  def test_get_with_multiple_entities_and_no_media_type_variation
+    root.expects(:get).returns([
+      mock_entity('<foo>fdgfdgfd</foo>', 'text/html'),
+      mock_entity('<foo>Yalrightmate</foo>', 'text/html')
+    ]).once
+    assert_equal STATUS_OK, get.status
+    assert !(last_response.headers['Vary'] || '').split(/,\s*/).include?('Accept')
+  end
+
+  def test_binary_data_never_called_on_undesired_entity
+    root.expects(:get).returns(@entities).once
+    @entities[0].expects(:binary_data).returns('<foo>Yalrightmate</foo>').at_least_once
+    @entities[1].expects(:binary_data).never
+    @entities[2].expects(:binary_data).never
+    assert_equal STATUS_OK, get('HTTP_ACCEPT' => 'text/html').status
+  end
+
+  # todo break this up a bit
+  def test_get_with_media_type_negotiation_and_various_accept
+    root.expects(:get).returns(@entities).at_least_once
+
+    assert_equal STATUS_OK, get('HTTP_ACCEPT' => 'application/json').status
+    assert_equal "{foo: 'Yalrightmate'}", last_response.body
+    assert_equal 'application/json', last_response.media_type
+    assert last_response.headers['Vary'].split(/,\s*/).include?('Accept')
+
+    assert_equal STATUS_NOT_ACCEPTABLE, get('HTTP_ACCEPT' => '*/*; q=0').status
+    assert_equal STATUS_NOT_ACCEPTABLE, get('HTTP_ACCEPT' => 'application/bollocks; q=1').status
+    assert_equal STATUS_OK, get('HTTP_ACCEPT' => 'text/*').status
+    assert_equal 'text/html', last_response.media_type
+    # orders by q-value, default of 1
+    assert_equal 'application/json', get('HTTP_ACCEPT' => 'application/json, text/html; q=0.5').media_type
+    assert_equal 'application/json', get('HTTP_ACCEPT' => 'application/json; q=0.8, text/html; q=0.5').media_type
+    assert_equal 'text/html', get('HTTP_ACCEPT' => 'application/json; q=0.4, text/html; q=0.5').media_type
+    # text/html is more specific than text/*
+    assert_equal STATUS_NOT_ACCEPTABLE, get('HTTP_ACCEPT' => 'text/*; q=0').status
+    assert_equal STATUS_OK, get('HTTP_ACCEPT' => 'text/*; q=0, text/html; q=1').status
+
+    assert_equal STATUS_OK, get('HTTP_ACCEPT' => 'text/*; q=0, */*; q=1').status
+    assert_not_equal 'text/html', last_response.media_type
+
+    # doesn't just look for the highest q-value that matches, but uses the matching rules and their specificities of matching to
+    # construct a media_type => q-value mapping and then uses that to prioritize what's available:
+    assert_equal 'application/yaml', get('HTTP_ACCEPT' => 'application/*; q=0.6, application/json; q=0.4').media_type
+    assert_equal 'application/json', get('HTTP_ACCEPT' => 'application/*; q=0.6, application/yaml; q=0.4').media_type
+  end
+
+  def test_get_with_language_variation_and_no_accept
+    root.expects(:get).returns([
+      mock_entity('<foo>Yalrightmate</foo>', 'text/html', 'en-gb'),
+      mock_entity('<foo>Wassup</foo>', 'text/html', 'en-us'),
+    ]).once
+
+    assert_equal STATUS_OK, get.status
+    assert_equal '<foo>Yalrightmate</foo>', last_response.body
+    assert_equal 'text/html', last_response.media_type
+    assert_equal 'en-gb', last_response.headers['Content-Language']
+    assert last_response.headers['Vary'].split(/,\s*/).include?('Accept-Language')
+  end
+
+  def test_get_with_non_language_entity
+    entity = mock_entity('{"1234": "5678"}', 'application/json', nil)
+    root.expects(:get).returns([entity]).once
+    assert_equal STATUS_OK, get('HTTP_ACCEPT_LANGUAGE' => 'en-gb').status
+    assert_equal nil, last_response.headers['Content-Language']
+  end
+
+  def test_get_with_language_and_non_language_entity
+    # no language preference is specified - should not prefer language over non-language, over other criterea
+    root.expects(:get).returns([
+      mock_entity('{"1234": "5678"}', 'application/json', 'en-gb'),
+      mock_entity('<foo></foo>', 'text/html', nil)
+    ]).once
+    assert_equal STATUS_OK, get('HTTP_ACCEPT' => 'text/html; q=1, application/json; q=0.5').status
+    assert_equal 'text/html', last_response.media_type
+  end
+
+  def test_get_with_multiple_entities_and_no_language_variation
+    root.expects(:get).returns([@entities[0], @entities[1]]).once
+    assert_equal STATUS_OK, get.status
+    assert !last_response.headers['Vary'].split(/,\s*/).include?('Accept-Language')
+  end
+
+  def test_get_with_language_negotiation_and_accept_language
+    root.expects(:get).returns(@entities).once
+
+    assert_equal STATUS_OK, get('HTTP_ACCEPT_LANGUAGE' => 'en-gb').status
+    assert_equal "<foo>Yalrightmate</foo>", last_response.body
+    assert_equal 'en-gb', last_response.headers['Content-Language']
+    assert last_response.headers['Vary'].split(/,\s*/).include?('Accept-Language')
+  end
+
+  def test_get_with_language_negotiation_and_various_accept_language
+    root.expects(:get).returns(@entities).at_least_once
+
+    assert_equal STATUS_OK, get('HTTP_ACCEPT_LANGUAGE' => 'en-gb').status
+    assert_equal 'en-gb', last_response.headers['Content-Language']
+    assert_equal STATUS_OK, get('HTTP_ACCEPT_LANGUAGE' => 'en').status
+    assert_equal 'en-gb', last_response.headers['Content-Language']
+    assert_equal STATUS_NOT_ACCEPTABLE, get('HTTP_ACCEPT_LANGUAGE' => 'en-au').status
+
+    assert_equal 'en-gb', get('HTTP_ACCEPT_LANGUAGE' => 'en-gb; q=0.7, en; q=0.5').headers['Content-Language']
+    assert_equal 'en-us', get('HTTP_ACCEPT_LANGUAGE' => 'en-us; q=0.7, en; q=0.5').headers['Content-Language']
+    assert_equal 'en-us', get('HTTP_ACCEPT_LANGUAGE' => 'en-gb; q=0.4, en; q=0.5').headers['Content-Language']
+    assert_equal 'en-gb', get('HTTP_ACCEPT_LANGUAGE' => 'en-us; q=0.4, en; q=0.5').headers['Content-Language']
+
+    assert_equal 'de', get('HTTP_ACCEPT_LANGUAGE' => 'de; q=0.9, *; q=0.5').headers['Content-Language']
+    assert_equal 'de', get('HTTP_ACCEPT_LANGUAGE' => '*; q=0.5, de').headers['Content-Language']
+  end
+
+  def test_get_with_both_negotiation
+    root.expects(:get).returns(@entities).at_least_once
+
+    assert_equal STATUS_OK, get('HTTP_ACCEPT_LANGUAGE' => 'en-gb', 'HTTP_ACCEPT' => 'text/html').status
+    assert_equal "<foo>Yalrightmate</foo>", last_response.body
+    assert_equal 'en-gb', last_response.headers['Content-Language']
+    assert last_response.headers['Vary'].split(/,\s*/).include?('Accept-Language')
+    assert last_response.headers['Vary'].split(/,\s*/).include?('Accept')
+
+    # check that q-values are multiplied to get a combined q-value. This relies on the fact that a german yaml version doesn't exist,
+    # so do we prioritise the preferred language over the preferred media type:
+    get('HTTP_ACCEPT_LANGUAGE' => 'de; q=0.9, en; q=0.1', 'HTTP_ACCEPT' => 'application/yaml; q=0.6, text/html; q=0.5')
+    assert_equal 'de', last_response.headers['Content-Language']
+    assert_equal 'text/html', last_response.media_type
+    # or vice versa:
+    get('HTTP_ACCEPT_LANGUAGE' => 'de; q=0.6, en; q=0.5', 'HTTP_ACCEPT' => 'application/yaml; q=0.9, text/html; q=0.1')
+    assert_equal 'en-gb', last_response.headers['Content-Language']
+    assert_equal 'application/yaml', last_response.media_type
+  end
+end

data/test/functional/media_type_extensions_test.rb

@@ -0,0 +1,102 @@
+require 'functional/base'
+require 'doze/application'
+
+class MediaTypeExtensionsTest < Test::Unit::TestCase
+  include Doze::Utils
+  include Doze::TestCase
+  include Doze::MediaTypeTestCase
+
+  def test_get
+    app(:media_type_extensions => true)
+
+    foo_mt = Doze::MediaType.register('application/foo', :extension => 'foo')
+    bar_mt = Doze::MediaType.register('application/bar', :extension => 'bar')
+    baz_mt = Doze::MediaType.register('application/baz', :extension => 'baz')
+
+    entities = [mock_entity('foo', foo_mt), mock_entity('bar', bar_mt)]
+    root.expects(:get).returns(entities).at_least_once
+
+    get "/.foo"
+    assert_equal "foo", last_response.body
+    assert_equal "application/foo", last_response.media_type
+
+    get "/.bar"
+    assert_equal "bar", last_response.body
+    assert_equal "application/bar", last_response.media_type
+
+    get "/.baz"
+    assert_equal STATUS_NOT_FOUND, last_response.status
+
+    get "/.nob"
+    assert_equal STATUS_NOT_FOUND, last_response.status
+  end
+
+  def PENDING_test_put_with_different_supported_media_type
+    app(:media_type_extensions => true)
+
+    foo_mt = Doze::MediaType.register('application/foo', :extension => 'foo')
+    bar_mt = Doze::MediaType.register('application/bar', :extension => 'bar')
+
+    root.expects(:supports_put?).returns(true)
+    root.expects(:put).never
+    root.stubs(:accepts_method_with_media_type? => true)
+
+    put "/.bar", :input => 'foo', 'CONTENT_TYPE' => 'application/foo'
+    assert_equal STATUS_UNSUPPORTED_MEDIA_TYPE, last_response.status
+  end
+
+  def test_put_with_same_supported_media_type
+    app(:media_type_extensions => true)
+
+    foo_mt = Doze::MediaType.register('application/foo', :extension => 'foo')
+    bar_mt = Doze::MediaType.register('application/bar', :extension => 'bar')
+
+    root.expects(:supports_put?).returns(true)
+    root.expects(:accepts_method_with_media_type?).with(:put, anything).returns(true)
+    root.expects(:put).with {|e| e.media_type.name == 'application/foo'}
+
+    put "/.foo", :input => 'foo', 'CONTENT_TYPE' => 'application/foo'
+    assert last_response.successful?
+  end
+
+  def test_post
+    app(:media_type_extensions => true)
+
+    foo_mt = Doze::MediaType.register('application/foo', :extension => 'foo')
+    bar_mt = Doze::MediaType.register('application/bar', :extension => 'bar')
+
+    result = mock_resource
+    entities = [mock_entity('foo', foo_mt), mock_entity('bar', bar_mt)]
+    result.expects(:get).returns(entities)
+
+    root.expects(:supports_post?).returns(true)
+    root.expects(:accepts_method_with_media_type?).with(:post, anything).returns(true)
+    root.expects(:post).returns(result)
+
+    post "/.bar", :input => 'foo', 'CONTENT_TYPE' => 'application/foo'
+    assert last_response.successful?
+    assert_equal "bar", last_response.body
+    assert_equal "application/bar", last_response.media_type
+  end
+
+  def test_affects_representation_selected_for_error_resources
+    app(:catch_application_errors => true, :media_type_extensions => true)
+
+    root.expects(:get).raises(RuntimeError, "test error")
+
+    get("/.json")
+    assert_equal STATUS_INTERNAL_SERVER_ERROR, last_response.status
+    assert_equal 'application/json', last_response.media_type
+  end
+
+  def test_affects_representation_of_not_found_error_when_requested_media_type_not_available
+    app(:media_type_extensions => true)
+
+    root.expects(:get).returns([mock_entity('foo', 'text/html')])
+
+    get("/.json")
+    assert_equal STATUS_NOT_FOUND, last_response.status
+    assert_equal 'application/json', last_response.media_type
+  end
+end
+