RDOX

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