// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
#include "include/cef_web_urlrequest.h"
#include "tests/unittests/test_handler.h"
// #define WEB_URLREQUEST_DEBUG
class TestResults {
public:
TestResults()
: errorCode(0),
contentLength(0),
statusCode(0),
redirectCount(0) {
}
int errorCode;
size_t contentLength;
int statusCode;
CefString statusText;
CefString contentLengthHeader;
CefString allHeaders;
CefResponse::HeaderMap headerMap;
int redirectCount;
TrackCallback
got_redirect,
got_deleted,
got_started,
got_headers,
got_loading,
got_done,
got_progress,
got_abort,
got_error;
};
class BrowserTestHandler : public TestHandler {
public:
// Cancel at state WUR_STATE_UNSENT means that no cancellation
// will occur since that state change is never fired.
BrowserTestHandler(TestResults &tr,
cef_weburlrequest_state_t cancelAtState = WUR_STATE_UNSENT)
: cancelAtState_(cancelAtState),
test_results_(tr) {
}
virtual void RunTest() OVERRIDE {
std::stringstream testHtml;
testHtml <<
"<html><body>"
"<h1>Testing Web Url Request...</h1>"
"</body></html>";
AddResource("http://tests/run.html", testHtml.str(), "text/html");
CreateBrowser("http://tests/run.html");
}
virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int httpStatusCode) {
StartTest();
}
void TestCompleted() {
DestroyTest();
}
virtual void StartTest() = 0;
cef_weburlrequest_state_t cancelAtState_;
TestResults& test_results_;
};
class TestWebURLRequestClient : public CefWebURLRequestClient {
public:
TestWebURLRequestClient(TestResults& tr, BrowserTestHandler* browser)
: test_results_(tr),
cancelAtState_(WUR_STATE_UNSENT),
browser_(browser) {
}
virtual ~TestWebURLRequestClient() {
test_results_.got_deleted.yes();
}
bool MaybeCancelRequest(CefRefPtr<CefWebURLRequest> requester,
RequestState state) {
if (cancelAtState_ == state) {
#ifdef WEB_URLREQUEST_DEBUG
printf(" Cancelling at state %d\n", cancelAtState_);
#endif
requester->Cancel();
return true;
}
return false;
}
void OnStateChange(CefRefPtr<CefWebURLRequest> requester,
RequestState state) {
#ifdef WEB_URLREQUEST_DEBUG
printf("OnStateChange(0x%p, %d)\n", requester.get(), state);
#endif
if (MaybeCancelRequest(requester, state))
return;
switch (state) {
case WUR_STATE_STARTED:
test_results_.got_started.yes();
break;
case WUR_STATE_HEADERS_RECEIVED:
test_results_.got_headers.yes();
break;
case WUR_STATE_LOADING:
test_results_.got_loading.yes();
break;
case WUR_STATE_DONE:
test_results_.got_done.yes();
if ( contents_.length() ) {
size_t len = contents_.length();
test_results_.contentLength = len;
#ifdef WEB_URLREQUEST_DEBUG
printf("Response: %lu - %s\n", len, contents_.c_str());
#endif
}
TestCompleted();
break;
case WUR_STATE_ABORT:
test_results_.got_abort.yes();
TestCompleted();
break;
default:
break;
}
}
void OnRedirect(CefRefPtr<CefWebURLRequest> requester,
CefRefPtr<CefRequest> request,
CefRefPtr<CefResponse> response) {
#ifdef WEB_URLREQUEST_DEBUG
printf("OnRedirect(0x%p, 0x%p, 0x%p)\n",
requester.get(), request.get(), response.get());
#endif
test_results_.got_redirect.yes();
++test_results_.redirectCount;
CefString url = request->GetURL();
#ifdef WEB_URLREQUEST_DEBUG
printf("URL = %s\n", url.ToString().c_str());
#endif
}
void OnHeadersReceived(CefRefPtr<CefWebURLRequest> requester,
CefRefPtr<CefResponse> response) {
#ifdef WEB_URLREQUEST_DEBUG
printf("OnHeadersReceived(0x%p, 0x%p)\n", requester.get(), response.get());
#endif
test_results_.statusCode = response->GetStatus();
test_results_.statusText = response->GetStatusText();
test_results_.contentLengthHeader = response->GetHeader("Content-Length");
response->GetHeaderMap(test_results_.headerMap);
}
void OnData(CefRefPtr<CefWebURLRequest> requester, const void *data,
int dataLength) {
#ifdef WEB_URLREQUEST_DEBUG
printf("OnData(0x%p, 0x%p, %d)\n", requester.get(), data, dataLength);
#endif
// Add data to buffer, create if not already
contents_.append(static_cast<const char*>(data), dataLength);
}
void TestCompleted() {
browser_->TestCompleted();
browser_ = NULL;
requester_ = NULL;
Release();
}
void OnProgress(CefRefPtr<CefWebURLRequest> requester,
uint64 bytesSent,
uint64 totalBytesToBeSent) {
#ifdef WEB_URLREQUEST_DEBUG
printf("OnProgress(0x%p, %d, %d)\n", requester.get(),
(unsigned int)bytesSent, (unsigned int)totalBytesToBeSent);
#endif
test_results_.got_progress.yes();
}
void OnError(CefRefPtr<CefWebURLRequest> requester,
CefWebURLRequestClient::ErrorCode errorCode) {
#ifdef WEB_URLREQUEST_DEBUG
printf("Error(0x%p, %d)\n", requester.get(), errorCode);
#endif
test_results_.errorCode = static_cast<int>(errorCode);
test_results_.got_error.yes();
TestCompleted();
}
bool Run(CefRefPtr<CefRequest> req, RequestState
cancelAtState = WUR_STATE_UNSENT) {
if ( requester_.get() )
return false;
cancelAtState_ = cancelAtState;
request_ = req;
// Keep ourselves alive... blanced in TestCompleted() when done.
AddRef();
requester_ = CefWebURLRequest::CreateWebURLRequest(request_, this);
#ifdef WEB_URLREQUEST_DEBUG
printf("Created requester at address 0x%p\n", requester_.get());
#endif
return requester_.get() != NULL;
}
protected:
TestResults& test_results_;
RequestState cancelAtState_;
CefRefPtr<BrowserTestHandler> browser_;
CefRefPtr<CefWebURLRequest> requester_;
CefRefPtr<CefRequest> request_;
std::string contents_;
IMPLEMENT_REFCOUNTING(TestWebURLRequestClient);
};
TEST(WebURLRequestTest, GET) {
class BrowserForTest : public BrowserTestHandler {
public:
explicit BrowserForTest(TestResults &tr) : BrowserTestHandler(tr) { }
void StartTest() {
CefRefPtr<CefRequest> req;
CefRefPtr<CefPostData> postdata;
CefRequest::HeaderMap headers;
req = CefRequest::CreateRequest();
CefString url(
"http://search.twitter.com/search.json?result_type=popular&q=webkit");
CefString method("GET");
req->Set(url, method, postdata, headers);
CefRefPtr<TestWebURLRequestClient> handler =
new TestWebURLRequestClient(test_results_, this);
req->SetFlags((CefRequest::RequestFlags)(
WUR_FLAG_SKIP_CACHE |
WUR_FLAG_REPORT_LOAD_TIMING |
WUR_FLAG_REPORT_RAW_HEADERS |
WUR_FLAG_REPORT_UPLOAD_PROGRESS));
ASSERT_TRUE(handler->Run(req));
}
};
TestResults tr;
CefRefPtr<BrowserTestHandler> browser = new BrowserForTest(tr);
browser->ExecuteTest();
EXPECT_TRUE(tr.got_started);
EXPECT_TRUE(tr.got_headers);
EXPECT_TRUE(tr.got_loading);
EXPECT_TRUE(tr.got_done);
EXPECT_TRUE(tr.got_deleted);
EXPECT_FALSE(tr.got_abort);
EXPECT_FALSE(tr.got_error);
EXPECT_FALSE(tr.got_redirect);
EXPECT_FALSE(tr.got_progress);
EXPECT_GT(tr.contentLength, static_cast<size_t>(0));
EXPECT_EQ(200, tr.statusCode);
}
TEST(WebURLRequestTest, POST) {
class BrowserForTest : public BrowserTestHandler {
public:
explicit BrowserForTest(TestResults &tr) : BrowserTestHandler(tr) { }
void StartTest() {
CefRefPtr<CefRequest> req;
CefRefPtr<CefPostData> postdata;
CefRefPtr<CefPostDataElement> postitem;
CefRequest::HeaderMap headers;
headers.insert(std::make_pair("Content-Type",
"application/x-www-form-urlencoded"));
req = CefRequest::CreateRequest();
CefString url("http://pastebin.com/api_public.php");
CefString method("POST");
postdata = CefPostData::CreatePostData();
postitem = CefPostDataElement::CreatePostDataElement();
static char posttext[] =
"paste_name=CEF%20Test%20Post&paste_code=testing a post call."
"&paste_expire_date=10M";
postitem->SetToBytes(strlen(posttext), posttext);
postdata->AddElement(postitem);
req->Set(url, method, postdata, headers);
CefRefPtr<TestWebURLRequestClient> handler =
new TestWebURLRequestClient(test_results_, this);
req->SetFlags((CefRequest::RequestFlags)(
WUR_FLAG_SKIP_CACHE |
WUR_FLAG_REPORT_LOAD_TIMING |
WUR_FLAG_REPORT_RAW_HEADERS |
WUR_FLAG_REPORT_UPLOAD_PROGRESS));
ASSERT_TRUE(handler->Run(req));
}
};
TestResults tr;
CefRefPtr<BrowserTestHandler> browser = new BrowserForTest(tr);
browser->ExecuteTest();
EXPECT_TRUE(tr.got_started);
EXPECT_TRUE(tr.got_headers);
EXPECT_TRUE(tr.got_loading);
EXPECT_TRUE(tr.got_done);
EXPECT_TRUE(tr.got_deleted);
EXPECT_FALSE(tr.got_redirect);
EXPECT_TRUE(tr.got_progress);
EXPECT_FALSE(tr.got_error);
EXPECT_FALSE(tr.got_abort);
EXPECT_GT(tr.contentLength, static_cast<size_t>(0));
EXPECT_EQ(200, tr.statusCode);
}
TEST(WebURLRequestTest, BADHOST) {
class BrowserForTest : public BrowserTestHandler {
public:
explicit BrowserForTest(TestResults &tr) : BrowserTestHandler(tr) { }
void StartTest() {
CefRefPtr<CefRequest> req;
CefRefPtr<CefPostData> postdata;
CefRefPtr<CefPostDataElement> postitem;
CefRequest::HeaderMap headers;
req = CefRequest::CreateRequest();
CefString url("http://this.host.does.not.exist/not/really/here");
CefString method("GET");
req->Set(url, method, postdata, headers);
CefRefPtr<TestWebURLRequestClient> handler =
new TestWebURLRequestClient(test_results_, this);
req->SetFlags((CefRequest::RequestFlags)(
WUR_FLAG_SKIP_CACHE |
WUR_FLAG_REPORT_LOAD_TIMING |
WUR_FLAG_REPORT_RAW_HEADERS |
WUR_FLAG_REPORT_UPLOAD_PROGRESS));
ASSERT_TRUE(handler->Run(req));
}
};
TestResults tr;
CefRefPtr<BrowserTestHandler> browser = new BrowserForTest(tr);
browser->ExecuteTest();
// NOTE: THIS TEST WILL FAIL IF YOUR ISP REDIRECTS YOU TO
// THEIR SEARCH PAGE ON NXDOMAIN ERRORS.
EXPECT_TRUE(tr.got_started);
EXPECT_FALSE(tr.got_headers);
EXPECT_FALSE(tr.got_loading);
EXPECT_FALSE(tr.got_done);
EXPECT_TRUE(tr.got_deleted);
EXPECT_FALSE(tr.got_redirect);
EXPECT_FALSE(tr.got_progress);
EXPECT_FALSE(tr.got_abort);
EXPECT_TRUE(tr.got_error);
EXPECT_EQ(ERR_NAME_NOT_RESOLVED, tr.errorCode);
EXPECT_EQ(static_cast<size_t>(0), tr.contentLength);
EXPECT_EQ(0, tr.statusCode);
}
#define COUNTOF_(ar) (sizeof(ar)/sizeof(ar[0]))
TEST(WebURLRequestTest, CANCEL) {
class BrowserForTest : public BrowserTestHandler {
public:
BrowserForTest(TestResults &tr, cef_weburlrequest_state_t cancelAtState)
: BrowserTestHandler(tr, cancelAtState) {
}
void StartTest() {
CefRefPtr<CefRequest> req;
CefRefPtr<CefPostData> postdata;
CefRefPtr<CefPostDataElement> postitem;
CefRequest::HeaderMap headers;
req = CefRequest::CreateRequest();
CefString url(
"http://search.twitter.com/search.json?result_type=popular&q=webkit");
CefString method("GET");
req->Set(url, method, postdata, headers);
CefRefPtr<TestWebURLRequestClient> handler =
new TestWebURLRequestClient(test_results_, this);
req->SetFlags((CefRequest::RequestFlags)(
WUR_FLAG_SKIP_CACHE |
WUR_FLAG_REPORT_LOAD_TIMING |
WUR_FLAG_REPORT_RAW_HEADERS |
WUR_FLAG_REPORT_UPLOAD_PROGRESS));
ASSERT_TRUE(handler->Run(req, cancelAtState_));
}
};
cef_weburlrequest_state_t cancelAt[] = {
WUR_STATE_STARTED,
WUR_STATE_HEADERS_RECEIVED
};
for (unsigned int i = 0; i < COUNTOF_(cancelAt); ++i) {
TestResults tr;
CefRefPtr<BrowserTestHandler> browser = new BrowserForTest(tr, cancelAt[i]);
browser->ExecuteTest();
EXPECT_TRUE(tr.got_abort) << "i = " << i;
EXPECT_TRUE(tr.got_deleted);
}
}
// Enable this test if you have installed the php test page.
#if 0
TEST(WebURLRequestTest, REDIRECT) {
/* // PHP Script for a local server to test this:
// You can run a zwamp server on windows to run this.
// http://sourceforge.net/projects/zwamp/
<?php
$max = isset($_GET['max']) ? $_GET['max'] : 2;
$step = isset($_GET['step']) ? $_GET['step'] : 1;
if ($step < $max)
{
$url = $_SERVER['PHP_SELF'];
++$step;
header( $_SERVER["SERVER_PROTOCOL"] . " 301 Permanently moved");
header("Location: $url?max=$max&step=$step", true, 301);
}
else
{
header("Content: text/plain");
echo "Redirect completed after $max times.";
}
?>
*/
class BrowserForTest : public BrowserTestHandler {
public:
explicit BrowserForTest(TestResults &tr) : BrowserTestHandler(tr) { }
void StartTest() {
CefRefPtr<CefRequest> req;
CefRefPtr<CefPostData> postdata;
CefRefPtr<CefPostDataElement> postitem;
CefRequest::HeaderMap headers;
req = CefRequest::CreateRequest();
CefString url("http://localhost/cef/redirect.php?max=4");
CefString method("GET");
req->Set(url, method, postdata, headers);
CefRefPtr<TestWebURLRequestClient> handler =
new TestWebURLRequestClient(test_results_, this);
req->SetFlags((CefRequest::RequestFlags)(
WUR_FLAG_SKIP_CACHE |
WUR_FLAG_REPORT_LOAD_TIMING |
WUR_FLAG_REPORT_RAW_HEADERS |
WUR_FLAG_REPORT_UPLOAD_PROGRESS));
ASSERT_TRUE(handler->Run(req, cancelAtState_));
}
};
TestResults tr;
CefRefPtr<BrowserForTest> browser = new BrowserForTest(tr);
browser->ExecuteTest();
EXPECT_TRUE(tr.got_started);
EXPECT_TRUE(tr.got_headers);
EXPECT_TRUE(tr.got_loading);
EXPECT_TRUE(tr.got_done);
EXPECT_TRUE(tr.got_deleted);
EXPECT_TRUE(tr.got_redirect);
EXPECT_FALSE(tr.got_progress);
EXPECT_FALSE(tr.got_error);
EXPECT_FALSE(tr.got_abort);
EXPECT_GT(tr.contentLength, static_cast<size_t>(0));
EXPECT_EQ(200, tr.statusCode);
EXPECT_EQ(3, tr.redirectCount);
}
#endif // 0