blob: 3987313d0bcb69a8b230f1f7f1f4bf3f7c15ca69 [file] [log] [blame]
// Copyright 2014 The Chromium 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 "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "chromeos/geolocation/geoposition.h"
#include "chromeos/timezone/timezone_provider.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_status_code.h"
#include "net/url_request/test_url_fetcher_factory.h"
#include "net/url_request/url_fetcher_impl.h"
#include "net/url_request/url_request_status.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace {
const int kRequestRetryIntervalMilliSeconds = 200;
// This should be different from default to prevent TimeZoneRequest
// from modifying it.
const char kTestTimeZoneProviderUrl[] =
"https://localhost/maps/api/timezone/json?";
const char kSimpleResponseBody[] =
"{\n"
" \"dstOffset\" : 0.0,\n"
" \"rawOffset\" : -28800.0,\n"
" \"status\" : \"OK\",\n"
" \"timeZoneId\" : \"America/Los_Angeles\",\n"
" \"timeZoneName\" : \"Pacific Standard Time\"\n"
"}";
struct SimpleRequest {
SimpleRequest()
: url("https://localhost/maps/api/timezone/"
"json?location=39.603481,-119.682251&timestamp=1331161200&sensor="
"false"),
http_response(kSimpleResponseBody) {
position.latitude = 39.6034810;
position.longitude = -119.6822510;
position.accuracy = 1;
position.error_code = 0;
position.timestamp = base::Time::FromTimeT(1331161200);
position.status = chromeos::Geoposition::STATUS_NONE;
EXPECT_EQ(
"latitude=39.603481, longitude=-119.682251, accuracy=1.000000, "
"error_code=0, error_message='', status=0 (NONE)",
position.ToString());
timezone.dstOffset = 0;
timezone.rawOffset = -28800;
timezone.timeZoneId = "America/Los_Angeles";
timezone.timeZoneName = "Pacific Standard Time";
timezone.error_message.erase();
timezone.status = chromeos::TimeZoneResponseData::OK;
EXPECT_EQ(
"dstOffset=0.000000, rawOffset=-28800.000000, "
"timeZoneId='America/Los_Angeles', timeZoneName='Pacific Standard "
"Time', error_message='', status=0 (OK)",
timezone.ToStringForDebug());
}
GURL url;
chromeos::Geoposition position;
std::string http_response;
chromeos::TimeZoneResponseData timezone;
};
} // anonymous namespace
namespace chromeos {
// This is helper class for net::FakeURLFetcherFactory.
class TestTimeZoneAPIURLFetcherCallback {
public:
TestTimeZoneAPIURLFetcherCallback(const GURL& url,
const size_t require_retries,
const std::string& response,
TimeZoneProvider* provider)
: url_(url),
require_retries_(require_retries),
response_(response),
factory_(NULL),
attempts_(0),
provider_(provider) {}
scoped_ptr<net::FakeURLFetcher> CreateURLFetcher(
const GURL& url,
net::URLFetcherDelegate* delegate,
const std::string& response_data,
net::HttpStatusCode response_code,
net::URLRequestStatus::Status status) {
EXPECT_EQ(provider_->requests_.size(), 1U);
TimeZoneRequest* timezone_request = provider_->requests_[0];
const base::TimeDelta base_retry_interval =
base::TimeDelta::FromMilliseconds(kRequestRetryIntervalMilliSeconds);
timezone_request->set_retry_sleep_on_server_error_for_testing(
base_retry_interval);
timezone_request->set_retry_sleep_on_bad_response_for_testing(
base_retry_interval);
++attempts_;
if (attempts_ > require_retries_) {
response_code = net::HTTP_OK;
status = net::URLRequestStatus::SUCCESS;
factory_->SetFakeResponse(url, response_, response_code, status);
}
scoped_ptr<net::FakeURLFetcher> fetcher(new net::FakeURLFetcher(
url, delegate, response_, response_code, status));
scoped_refptr<net::HttpResponseHeaders> download_headers =
new net::HttpResponseHeaders(std::string());
download_headers->AddHeader("Content-Type: application/json");
fetcher->set_response_headers(download_headers);
return fetcher.Pass();
}
void Initialize(net::FakeURLFetcherFactory* factory) {
factory_ = factory;
factory_->SetFakeResponse(url_,
std::string(),
net::HTTP_INTERNAL_SERVER_ERROR,
net::URLRequestStatus::FAILED);
}
size_t attempts() const { return attempts_; }
private:
const GURL url_;
// Respond with OK on required retry attempt.
const size_t require_retries_;
std::string response_;
net::FakeURLFetcherFactory* factory_;
size_t attempts_;
TimeZoneProvider* provider_;
DISALLOW_COPY_AND_ASSIGN(TestTimeZoneAPIURLFetcherCallback);
};
// This implements fake TimeZone API remote endpoint.
// Response data is served to TimeZoneProvider via
// net::FakeURLFetcher.
class TimeZoneAPIFetcherFactory {
public:
TimeZoneAPIFetcherFactory(const GURL& url,
const std::string& response,
const size_t require_retries,
TimeZoneProvider* provider) {
url_callback_.reset(new TestTimeZoneAPIURLFetcherCallback(
url, require_retries, response, provider));
net::URLFetcherImpl::set_factory(NULL);
fetcher_factory_.reset(new net::FakeURLFetcherFactory(
NULL,
base::Bind(&TestTimeZoneAPIURLFetcherCallback::CreateURLFetcher,
base::Unretained(url_callback_.get()))));
url_callback_->Initialize(fetcher_factory_.get());
}
size_t attempts() const { return url_callback_->attempts(); }
private:
scoped_ptr<TestTimeZoneAPIURLFetcherCallback> url_callback_;
scoped_ptr<net::FakeURLFetcherFactory> fetcher_factory_;
DISALLOW_COPY_AND_ASSIGN(TimeZoneAPIFetcherFactory);
};
class TimeZoneReceiver {
public:
TimeZoneReceiver() : server_error_(false) {}
void OnRequestDone(scoped_ptr<TimeZoneResponseData> timezone,
bool server_error) {
timezone_ = timezone.Pass();
server_error_ = server_error;
message_loop_runner_->Quit();
}
void WaitUntilRequestDone() {
message_loop_runner_.reset(new base::RunLoop);
message_loop_runner_->Run();
}
const TimeZoneResponseData* timezone() const { return timezone_.get(); }
bool server_error() const { return server_error_; }
private:
scoped_ptr<TimeZoneResponseData> timezone_;
bool server_error_;
scoped_ptr<base::RunLoop> message_loop_runner_;
};
class TimeZoneTest : public testing::Test {
private:
base::MessageLoop message_loop_;
};
TEST_F(TimeZoneTest, ResponseOK) {
TimeZoneProvider provider(NULL, GURL(kTestTimeZoneProviderUrl));
const SimpleRequest simple_request;
TimeZoneAPIFetcherFactory url_factory(simple_request.url,
simple_request.http_response,
0 /* require_retries */,
&provider);
TimeZoneReceiver receiver;
provider.RequestTimezone(simple_request.position,
false,
base::TimeDelta::FromSeconds(1),
base::Bind(&TimeZoneReceiver::OnRequestDone,
base::Unretained(&receiver)));
receiver.WaitUntilRequestDone();
EXPECT_EQ(simple_request.timezone.ToStringForDebug(),
receiver.timezone()->ToStringForDebug());
EXPECT_FALSE(receiver.server_error());
EXPECT_EQ(1U, url_factory.attempts());
}
TEST_F(TimeZoneTest, ResponseOKWithRetries) {
TimeZoneProvider provider(NULL, GURL(kTestTimeZoneProviderUrl));
const SimpleRequest simple_request;
TimeZoneAPIFetcherFactory url_factory(simple_request.url,
simple_request.http_response,
3 /* require_retries */,
&provider);
TimeZoneReceiver receiver;
provider.RequestTimezone(simple_request.position,
false,
base::TimeDelta::FromSeconds(1),
base::Bind(&TimeZoneReceiver::OnRequestDone,
base::Unretained(&receiver)));
receiver.WaitUntilRequestDone();
EXPECT_EQ(simple_request.timezone.ToStringForDebug(),
receiver.timezone()->ToStringForDebug());
EXPECT_FALSE(receiver.server_error());
EXPECT_EQ(4U, url_factory.attempts());
}
TEST_F(TimeZoneTest, InvalidResponse) {
TimeZoneProvider provider(NULL, GURL(kTestTimeZoneProviderUrl));
const SimpleRequest simple_request;
TimeZoneAPIFetcherFactory url_factory(simple_request.url,
"invalid JSON string",
0 /* require_retries */,
&provider);
TimeZoneReceiver receiver;
const int timeout_seconds = 1;
size_t expected_retries = static_cast<size_t>(
timeout_seconds * 1000 / kRequestRetryIntervalMilliSeconds);
ASSERT_GE(expected_retries, 2U);
provider.RequestTimezone(simple_request.position,
false,
base::TimeDelta::FromSeconds(timeout_seconds),
base::Bind(&TimeZoneReceiver::OnRequestDone,
base::Unretained(&receiver)));
receiver.WaitUntilRequestDone();
EXPECT_EQ(
"dstOffset=0.000000, rawOffset=0.000000, timeZoneId='', timeZoneName='', "
"error_message='TimeZone provider at 'https://localhost/' : JSONReader "
"failed: Line: 1, column: 1, Unexpected token..', status=6 "
"(REQUEST_ERROR)",
receiver.timezone()->ToStringForDebug());
EXPECT_FALSE(receiver.server_error());
EXPECT_GE(url_factory.attempts(), 2U);
if (url_factory.attempts() > expected_retries + 1) {
LOG(WARNING) << "TimeZoneTest::InvalidResponse: Too many attempts ("
<< url_factory.attempts() << "), no more then "
<< expected_retries + 1 << " expected.";
}
if (url_factory.attempts() < expected_retries - 1) {
LOG(WARNING) << "TimeZoneTest::InvalidResponse: Too less attempts ("
<< url_factory.attempts() << "), greater then "
<< expected_retries - 1 << " expected.";
}
}
} // namespace chromeos