
== 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

== 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::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 handle the lack of an acceptable encoding

== 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
* 404s if it can't find the file

== Rack::Handler
* has registered default handlers
* should get unregistered handler by name
* should register custom handler

== 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 body errors
* notices input handling errors
* notices error handling errors

== 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::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

== 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
* 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

== 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 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

== 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::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 capitalize on all accesses
* should capitalize correctly
* 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 provide a .run

197 specifications, 3 empty (886 requirements), 0 failures
