route_exists([$method, $path], $test_name)

    route_exists [GET => '/'], "GET / is handled";

route_doesnt_exist([$method, $path], $test_name)

    route_doesnt_exist [GET => '/bogus_path'], "GET /bogus_path is not handled";

response_exists([$method, $path], $test_name)

Asserts that a response is found for the given request (note that even though a route for that path might not exist, a response can be found during request processing, because of filters).

    response_exists [GET => '/path_that_gets_redirected_to_home'],
        "response found for unknown path";

response_doesnt_exist([$method, $path], $test_name)

Asserts that no response is found when processing the given request.

    response_doesnt_exist [GET => '/unknown_path'],
        "response not found for unknown path";

response_status_is([$method, $path], $status, $test_name)

    response_status_is [GET => '/'], 200, "response for GET / is 200";

response_status_isnt([$method, $path], $status, $test_name)

    response_status_isnt [GET => '/'], 404, "response for GET / is not a 404";

response_content_is([$method, $path], $expected, $test_name)

    response_content_is [GET => '/'], "Hello, World",
        "got expected response content for GET /";

response_content_isnt([$method, $path], $not_expected, $test_name)

    response_content_isnt [GET => '/'], "Hello, World",
        "got expected response content for GET /";

response_content_is_deeply([$method, $path], $expected_struct, $test_name)

If the two structures are different, it will display the place where they start differing.

    response_content_is_deeply [GET => '/complex_struct'],
        { foo => 42, bar => 24},
        "got expected response structure for GET /complex_struct";

response_content_like([$method, $path], $regexp, $test_name)

    response_content_like [GET => '/'], qr/Hello, World/,
        "response content looks good for GET /";

response_content_unlike([$method, $path], $regexp, $test_name)

    response_content_unlike [GET => '/'], qr/Page not found/,
        "response content looks good for GET /";

response_headers_are_deeply([$method, $path], $expected, $test_name)

    response_headers_are_deeply [GET => '/'], [ 'X-Powered-By' => 'Dancer 1.150' ];

response_headers_include([$method, $path], $expected, $test_name)

    response_headers_include [GET => '/'], [ 'Content-Type' => 'text/plain' ];

response_redirect_location_is([$method, $path], $expected, $test_name)

    response_redirect_location_is [GET => '/'], 'http://localhost/index.html';

response_redirect_location_like([$method, $path], $regexp, $test_name)

    response_redirect_location_like [GET => '/'], qr/some_pattern/;

dancer_response($method, $path, { params => $params, body => $body, headers => $headers, files => [{filename => '/path/to/file', name => 'my_file'}] })

Only $method and $path are required.

$params is a hashref, $body can be a string or a hashref and $headers can be an arrayref or a HTTP::Headers object, $files is an arrayref of hashref, containing some files to upload.

$params always populates the query string, even for POST requests. $body always populates the request body.

Currently, Dancer::Test cannot cope with both body and files passed in the same call.

A good reason to use this function is for testing POST requests. Since POST requests may not be idempotent, it is necessary to capture the content and status in one shot. Calling the response_status_is and response_content_is functions in succession would make two requests, each of which could alter the state of the application and cause Schrodinger's cat to die.

    my $response = dancer_response POST => '/widgets';
    is $response->{status}, 202, "response for POST /widgets is 202";
    is $response->{content}, "Widget #1 has been scheduled for creation",
        "response content looks good for first POST /widgets";

    $response = dancer_response POST => '/widgets';
    is $response->{status}, 202, "response for POST /widgets is 202";
    is $response->{content}, "Widget #2 has been scheduled for creation",
        "response content looks good for second POST /widgets";

It's possible to test file uploads:

    post '/upload' => sub { return upload('image')->content };

    $response = dancer_response(POST => '/upload', {files => [{name => 'image', filename => '/path/to/image.jpg'}]});

In addition, you can supply the file contents as the "data" key:

    my $data  = 'A test string that will pretend to be file contents.';
    $response = dancer_response(POST => '/upload', {
        files => [{name => 'test', filename => "filename.ext", data => $data}]
    });

read_logs

    my $logs = read_logs;

Returns an array ref of all log messages issued by the app since the last call to "read_logs".

For example:

    warning "Danger!  Warning!";
    debug   "I like pie.";

    is_deeply read_logs, [
        { level => "warning", message => "Danger!  Warning!" },
        { level => "debug",   message => "I like pie.", }
    ];

    error "Put out the light.";

    is_deeply read_logs, [
        { level => "error", message => "Put out the light." },
    ];

See Dancer::Logger::Capture for more details.