chrome/browser/sync/sync_stopped_reporter_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/sync/sync_stopped_reporter.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/run_loop.h"
   9 #include "base/test/test_simple_task_runner.h"
  10 #include "base/threading/non_thread_safe.h"
  11 #include "chrome/browser/sync/glue/local_device_info_provider_impl.h"
  12 #include "chrome/common/chrome_version_info.h"
  13 #include "net/http/http_status_code.h"
  14 #include "net/url_request/test_url_fetcher_factory.h"
  15 #include "net/url_request/url_request_test_util.h"
  16 #include "sync/protocol/sync.pb.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "url/gurl.h"
  19
  20 using browser_sync::SyncStoppedReporter;
  21
  22 const char kTestURL[] = "http://chromium.org/test";
  23 const char kTestURLTrailingSlash[] = "http://chromium.org/test/";
  24 const char kEventURL[] = "http://chromium.org/test/event";
  25
  26 const char kAuthToken[] = "multipass";
  27 const char kCacheGuid[] = "leeloo";
  28 const char kBirthday[] = "2263";
  29
  30 const char kAuthHeaderPrefix[] = "Bearer ";
  31
  32 class SyncStoppedReporterTest : public testing::Test {
  33  public:
  34   SyncStoppedReporterTest() {}
  35   ~SyncStoppedReporterTest() override {}
  36
  37   void SetUp() override {
  38     request_context_ = new net::TestURLRequestContextGetter(
  39         message_loop_.task_runner());
  40   }
  41
  42   void RequestFinishedCallback(const SyncStoppedReporter::Result& result) {
  43     request_result_ = result;
  44   }
  45
  46   GURL test_url() {
  47     return GURL(kTestURL);
  48   }
  49
  50   SyncStoppedReporter::ResultCallback callback() {
  51     return base::Bind(&SyncStoppedReporterTest::RequestFinishedCallback,
  52                       base::Unretained(this));
  53   }
  54
  55   const SyncStoppedReporter::Result& request_result() const {
  56     return request_result_;
  57   }
  58
  59   net::URLRequestContextGetter* request_context() {
  60     return request_context_.get();
  61   }
  62
  63   static std::string GetUserAgent() {
  64     chrome::VersionInfo version_info;
  65     return browser_sync::LocalDeviceInfoProviderImpl::MakeUserAgentForSyncApi(
  66         version_info);
  67   }
  68
  69  private:
  70   base::MessageLoop message_loop_;
  71   scoped_refptr<net::URLRequestContextGetter> request_context_;
  72   SyncStoppedReporter::Result request_result_;
  73
  74   DISALLOW_COPY_AND_ASSIGN(SyncStoppedReporterTest);
  75 };
  76
  77 // Test that the event URL gets constructed correctly.
  78 TEST_F(SyncStoppedReporterTest, EventURL) {
  79   net::TestURLFetcherFactory factory;
  80   SyncStoppedReporter ssr(GURL(kTestURL), request_context(), callback());
  81   ssr.ReportSyncStopped(kAuthToken, kCacheGuid, kBirthday);
  82   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
  83   EXPECT_EQ(kEventURL, fetcher->GetOriginalURL().spec());
  84 }
  85
  86 // Test that the event URL gets constructed correctly with a trailing slash.
  87 TEST_F(SyncStoppedReporterTest, EventURLWithSlash) {
  88   net::TestURLFetcherFactory factory;
  89   SyncStoppedReporter ssr(GURL(kTestURLTrailingSlash),
  90                           request_context(), callback());
  91   ssr.ReportSyncStopped(kAuthToken, kCacheGuid, kBirthday);
  92   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
  93   EXPECT_EQ(kEventURL, fetcher->GetOriginalURL().spec());
  94 }
  95
  96 // Test that the URLFetcher gets configured correctly.
  97 TEST_F(SyncStoppedReporterTest, FetcherConfiguration) {
  98   net::TestURLFetcherFactory factory;
  99   SyncStoppedReporter ssr(test_url(), request_context(), callback());
 100   ssr.ReportSyncStopped(kAuthToken, kCacheGuid, kBirthday);
 101   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
 102
 103   // Ensure the headers are set correctly.
 104   net::HttpRequestHeaders headers;
 105   std::string header;
 106   fetcher->GetExtraRequestHeaders(&headers);
 107   headers.GetHeader(net::HttpRequestHeaders::kAuthorization, &header);
 108   std::string auth_header(kAuthHeaderPrefix);
 109   auth_header.append(kAuthToken);
 110   EXPECT_EQ(auth_header, header);
 111   headers.GetHeader(net::HttpRequestHeaders::kUserAgent, &header);
 112   EXPECT_EQ(GetUserAgent(), header);
 113
 114   sync_pb::EventRequest event_request;
 115   event_request.ParseFromString(fetcher->upload_data());
 116
 117   EXPECT_EQ(kCacheGuid, event_request.sync_disabled().cache_guid());
 118   EXPECT_EQ(kBirthday, event_request.sync_disabled().store_birthday());
 119   EXPECT_EQ(kEventURL, fetcher->GetOriginalURL().spec());
 120 }
 121
 122 TEST_F(SyncStoppedReporterTest, HappyCase) {
 123   net::TestURLFetcherFactory factory;
 124   SyncStoppedReporter ssr(test_url(), request_context(), callback());
 125   ssr.ReportSyncStopped(kAuthToken, kCacheGuid, kBirthday);
 126   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
 127   fetcher->set_response_code(net::HTTP_OK);
 128   ssr.OnURLFetchComplete(fetcher);
 129   base::RunLoop run_loop;
 130   run_loop.RunUntilIdle();
 131   EXPECT_EQ(SyncStoppedReporter::RESULT_SUCCESS, request_result());
 132 }
 133
 134 TEST_F(SyncStoppedReporterTest, ServerNotFound) {
 135   net::TestURLFetcherFactory factory;
 136   SyncStoppedReporter ssr(test_url(), request_context(), callback());
 137   ssr.ReportSyncStopped(kAuthToken, kCacheGuid, kBirthday);
 138   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
 139   fetcher->set_response_code(net::HTTP_NOT_FOUND);
 140   ssr.OnURLFetchComplete(fetcher);
 141   base::RunLoop run_loop;
 142   run_loop.RunUntilIdle();
 143   EXPECT_EQ(SyncStoppedReporter::RESULT_ERROR, request_result());
 144 }
 145
 146 TEST_F(SyncStoppedReporterTest, DestructionDuringRequestHandler) {
 147   net::TestURLFetcherFactory factory;
 148   factory.set_remove_fetcher_on_delete(true);
 149   {
 150     SyncStoppedReporter ssr(test_url(), request_context(), callback());
 151     ssr.ReportSyncStopped(kAuthToken, kCacheGuid, kBirthday);
 152     EXPECT_FALSE(factory.GetFetcherByID(0) == nullptr);
 153   }
 154   EXPECT_TRUE(factory.GetFetcherByID(0) == nullptr);
 155 }
 156
 157 TEST_F(SyncStoppedReporterTest, Timeout) {
 158   SyncStoppedReporter ssr(test_url(), request_context(), callback());
 159
 160   // A task runner that can trigger the timeout immediately.
 161   scoped_refptr<base::TestSimpleTaskRunner> task_runner(
 162       new base::TestSimpleTaskRunner());
 163   ssr.SetTimerTaskRunnerForTest(task_runner);
 164
 165   // Begin request.
 166   ssr.ReportSyncStopped(kAuthToken, kCacheGuid, kBirthday);
 167
 168   // Trigger the timeout.
 169   ASSERT_TRUE(task_runner->HasPendingTask());
 170   task_runner->RunPendingTasks();
 171
 172   base::RunLoop run_loop;
 173   run_loop.RunUntilIdle();
 174   EXPECT_EQ(SyncStoppedReporter::RESULT_TIMEOUT, request_result());
 175 }
 176
 177 TEST_F(SyncStoppedReporterTest, NoCallback) {
 178   net::TestURLFetcherFactory factory;
 179   SyncStoppedReporter ssr(GURL(kTestURL), request_context(),
 180                           SyncStoppedReporter::ResultCallback());
 181   ssr.ReportSyncStopped(kAuthToken, kCacheGuid, kBirthday);
 182   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
 183   fetcher->set_response_code(net::HTTP_OK);
 184   ssr.OnURLFetchComplete(fetcher);
 185 }
 186
 187 TEST_F(SyncStoppedReporterTest, NoCallbackTimeout) {
 188   SyncStoppedReporter ssr(GURL(kTestURL), request_context(),
 189                           SyncStoppedReporter::ResultCallback());
 190
 191   // A task runner that can trigger the timeout immediately.
 192   scoped_refptr<base::TestSimpleTaskRunner> task_runner(
 193       new base::TestSimpleTaskRunner());
 194   ssr.SetTimerTaskRunnerForTest(task_runner);
 195
 196   // Begin request.
 197   ssr.ReportSyncStopped(kAuthToken, kCacheGuid, kBirthday);
 198
 199   // Trigger the timeout.
 200   ASSERT_TRUE(task_runner->HasPendingTask());
 201   task_runner->RunPendingTasks();
 202 }