== Rack::Auth::Basic * should challenge correctly when no credentials are specified * should rechallenge if incorrect credentials are specified * should return application output if correct credentials are specified * should return 400 Bad Request if different auth scheme used == Rack::Auth::Digest::MD5 * should challenge when no credentials are specified * should return application output if correct credentials given * should return application output if correct credentials given (hashed passwords) * should rechallenge if incorrect username given * should rechallenge if incorrect password given * should rechallenge with stale parameter if nonce is stale * should return 400 Bad Request if incorrect qop given * should return 400 Bad Request if incorrect uri given * should return 400 Bad Request if different auth scheme used == Rack::Auth::OpenID * realm uri should be absolute and have a path * uri options should be absolute * return_to should be absolute and be under the realm * extensions should be a module * extensions should have required constants defined * extensions should have Request and Response defined and inherit from OpenID::Extension * extensions should have NS_URI defined and be a string of an absolute http uri == Rack::Builder * chains apps by default * has implicit #to_app * supports blocks on use * has explicit #to_app * apps are initialized once == Rack::Adapter::Camping * works with GET * works with POST == Rack::Cascade * should dispatch onward on 404 by default * should dispatch onward on whatever is passed * should fail if empty * should append new app == Rack::Handler::CGI * startup (empty) * should respond * should be a lighttpd * should have rack headers * should have CGI headers on GET * should have CGI headers on POST * should support HTTP auth * should set status * shutdown == Rack::CommonLogger * should log to rack.errors by default * should log to anything with << == Rack::ConditionalGet * should set a 304 status and truncate body when If-Modified-Since hits * should set a 304 status and truncate body when If-None-Match hits * should not affect non-GET/HEAD requests == Rack::ContentLength * sets Content-Length on String bodies if none is set * sets Content-Length on Array bodies if none is set * does not set Content-Length on variable length bodies * does not change Content-Length if it is already set * does not set Content-Length on 304 responses * does not set Content-Length when Transfer-Encoding is chunked == Rack::Deflater * should be able to deflate bodies that respond to each * should be able to deflate String bodies * should be able to gzip bodies that respond to each * should be able to fallback to no deflation * should be able to skip when there is no response entity body * should handle the lack of an acceptable encoding * should handle gzip response with Last-Modified header * should do nothing when no-transform Cache-Control directive present == Rack::Directory * serves directory indices * passes to app if file found * serves uri with URL encoded filenames * does not allow directory traversal * 404s if it can't find the file == Rack::Handler::FastCGI * startup (empty) * should respond * should be a lighttpd * should have rack headers * should have CGI headers on GET * should have CGI headers on POST * should support HTTP auth * should set status * shutdown == Rack::File * serves files * sets Last-Modified header * serves files with URL encoded filenames * does not allow directory traversal * does not allow directory traversal with encoded periods * 404s if it can't find the file * detects SystemCallErrors == Rack::Handler * has registered default handlers * should get unregistered handler by name * should register custom handler == Rack::Head * response (empty) * passes GET, POST, PUT, DELETE, OPTIONS, TRACE requests * removes body from HEAD requests == Rack::Lint * passes valid request * notices fatal errors * notices environment errors * notices input errors * notices error errors * notices status errors * notices header errors * notices content-type errors * notices content-length errors * notices body errors * notices input handling errors * notices error handling errors * notices HEAD errors == Rack::Lint::InputWrapper * delegates :size to underlying IO object * delegates :rewind to underlying IO object == Rack::Lobster::LambdaLobster * should be a single lambda * should look like a lobster * should be flippable == Rack::Lobster * should look like a lobster * should be flippable * should provide crashing for testing purposes == Rack::MethodOverride * should not affect GET requests * _method parameter should modify REQUEST_METHOD for POST requests * X-HTTP-Method-Override header should modify REQUEST_METHOD for POST requests * should not modify REQUEST_METHOD if the method is unknown * should not modify REQUEST_METHOD when _method is nil * should store the original REQUEST_METHOD prior to overriding == Rack::MockRequest * should return a MockResponse * should be able to only return the environment * should provide sensible defaults * should allow GET/POST/PUT/DELETE * should allow posting * should use all parts of an URL * should behave valid according to the Rack spec == Rack::MockResponse * should provide access to the HTTP status * should provide access to the HTTP headers * should provide access to the HTTP body * should provide access to the Rack errors * should optionally make Rack errors fatal == Rack::Handler::Mongrel * should respond * should be a Mongrel * should have rack headers * should have CGI headers on GET * should have CGI headers on POST * should support HTTP auth * should set status * should provide a .run * should provide a .run that maps a hash * should provide a .run that maps a urlmap * should provide a .run that maps a urlmap restricting by host * should stream #each part of the response == Rack::Recursive * should allow for subrequests * should raise error on requests not below the app * should support forwarding == Rack::Request * wraps the rack variables * can figure out the correct host * can parse the query string * can parse POST data * can parse POST data with explicit content type * does not parse POST data when media type is not form-data * rewinds input after parsing POST data * does not rewind unwindable CGI input * can get value by key from params with #[] * can set value to key on params with #[]= * values_at answers values by keys in order given * referrer should be extracted correct * can cache, but invalidates the cache * can figure out if called via XHR * can parse cookies * parses cookies according to RFC 2109 * provides setters * provides the original env * can restore the URL * can restore the full path * can handle multiple media type parameters * can parse multipart form data * can parse big multipart form data * can detect invalid multipart form data * should work around buggy 1.8.* Tempfile equality * does conform to the Rack spec * should parse Accept-Encoding correctly * should provide ip information == Rack::Response * has sensible default values * can be written to * can set and read headers * can set cookies * formats the Cookie expiration date accordingly to RFC 2109 * can set secure cookies * can delete cookies * has a useful constructor * has a constructor that can take a block * doesn't return invalid responses * knows if it's empty * should provide access to the HTTP status * should provide access to the HTTP headers == Rack::Session::Cookie * creates a new cookie * loads from a cookie * survives broken cookies * barks on too big cookies * creates a new cookie with integrity hash * loads from a cookie wih integrity hash * ignores tampered with session cookies == Rack::Session::Memcache * startup (empty) * faults on no connection * creates a new cookie * determines session from a cookie * survives broken cookies * maintains freshness * multithread: should cleanly merge sessions * shutdown == Rack::Session::Pool * creates a new cookie * determines session from a cookie * survives broken cookies * maintains freshness * multithread: should merge sessions == Rack::ShowExceptions * catches exceptions == Rack::ShowStatus * should provide a default status message * should let the app provide additional information * should not replace existing messages * should pass on original headers * should replace existing messages if there is detail == Rack::Static * serves files * 404s if url root is known but it can't find the file * calls down the chain if url root is not known == Rack::Handler::Thin * should respond * should be a Thin * should have rack headers * should have CGI headers on GET * should have CGI headers on POST * should support HTTP auth * should set status == Rack::URLMap * dispatches paths correctly * dispatches hosts correctly * should be nestable * should route root apps correctly == Rack::Utils * should escape correctly * should unescape correctly * should parse query strings correctly * should build query strings correctly * should figure out which encodings are acceptable == Rack::Utils::HeaderHash * should retain header case * should check existence of keys case insensitively * should merge case-insensitively * should overwrite case insensitively and assume the new key's case * should be converted to real Hash == Rack::Utils::Context * should perform checks on both arguments * should set context correctly * should alter app on recontexting * should run different apps == Rack::Handler::WEBrick * should respond * should be a WEBrick * should have rack headers * should have CGI headers on GET * should have CGI headers on POST * should support HTTP auth * should set status * should correctly set cookies * should provide a .run 244 specifications, 4 empty (1004 requirements), 0 failures