Retry uploading in UploadJobImpl when error occurs

chrome/browser/chromeos/policy/upload_job_unittest.cc

 // Copyright (c) 2015 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 "chrome/browser/chromeos/policy/upload_job.h"
 
 #include <stddef.h>
 
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/policy/upload_job_impl.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/http/http_status_code.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
@@ skipping 147 matching lines @@
   void SetExpectedError(std::unique_ptr<UploadJob::ErrorCode> expected_error) {
     expected_error_ = std::move(expected_error);
   }
 
   // testing::Test:
   void SetUp() override {
     request_context_getter_ = new net::TestURLRequestContextGetter(
         base::ThreadTaskRunnerHandle::Get());
     oauth2_service_.AddAccount("robot@gmail.com");
     ASSERT_TRUE(test_server_.Start());
+    // Set retry delay to prevent timeouts
+    policy::UploadJobImpl::SetRetryDelayForTesting(0);
   }
 
   // testing::Test:
   void TearDown() override {
     ASSERT_TRUE(test_server_.ShutdownAndWaitUntilComplete());
   }
 
  protected:
   std::unique_ptr<UploadJob> PrepareUploadJob(
       std::unique_ptr<UploadJobImpl::MimeBoundaryGenerator>
           mime_boundary_generator) {
-    std::unique_ptr<UploadJob> upload_job(
-        new UploadJobImpl(GetServerURL(), kRobotAccountId, &oauth2_service_,
-                          request_context_getter_.get(), this,
-                          std::move(mime_boundary_generator)));
+    std::unique_ptr<UploadJob> upload_job(new UploadJobImpl(
+        GetServerURL(), kRobotAccountId, &oauth2_service_,
+        request_context_getter_.get(), this, std::move(mime_boundary_generator),
+        base::ThreadTaskRunnerHandle::Get()));
 
     std::map<std::string, std::string> header_entries;
     header_entries.insert(std::make_pair(kCustomField1, "CUSTOM1"));
     std::unique_ptr<std::string> data(new std::string(kTestPayload1));
     upload_job->AddDataSegment("Name1", "file1.ext", header_entries,
                                std::move(data));
 
     header_entries.insert(std::make_pair(kCustomField2, "CUSTOM2"));
     std::unique_ptr<std::string> data2(new std::string(kTestPayload2));
     upload_job->AddDataSegment("Name2", "", header_entries, std::move(data2));
@@ skipping 11 matching lines @@
 
 class UploadFlowTest : public UploadJobTestBase {
  public:
   UploadFlowTest() {}
 
   // UploadJobTestBase:
   void SetUp() override {
     UploadJobTestBase::SetUp();
     test_server_.RegisterRequestHandler(
         base::Bind(&UploadFlowTest::HandlePostRequest, base::Unretained(this)));
+    upload_attempt_count_ = 0;
+  }
+
+  // Sets the response code which will be returned when no other problems occur.
+  // Default is |net::HTTP_OK|
+  void SetResponseDefaultStatusCode(net::HttpStatusCode code) {
+    default_status_code_ = code;
   }
 
   std::unique_ptr<net::test_server::HttpResponse> HandlePostRequest(
       const net::test_server::HttpRequest& request) {
+    upload_attempt_count_++;
     EXPECT_TRUE(request.headers.find("Authorization") != request.headers.end());
     const std::string authorization_header =
         request.headers.at("Authorization");
     std::unique_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
     const size_t pos = authorization_header.find(" ");
     if (pos == std::string::npos) {
       response->set_code(net::HTTP_UNAUTHORIZED);
       return std::move(response);
     }
 
     const std::string token = authorization_header.substr(pos + 1);
     response->set_code(oauth2_service_.IsTokenValid(token)
-                           ? net::HTTP_OK
+                           ? default_status_code_
                            : net::HTTP_UNAUTHORIZED);
     return std::move(response);
   }
+
+ protected:
+  int upload_attempt_count_;
+  net::HttpStatusCode default_status_code_ = net::HTTP_OK;
 };
 
 TEST_F(UploadFlowTest, SuccessfulUpload) {
   oauth2_service_.SetTokenValid(kTokenValid);
   oauth2_service_.AddTokenToQueue(kTokenValid);
   std::unique_ptr<UploadJob> upload_job = PrepareUploadJob(
       base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator));
   upload_job->Start();
   run_loop_.Run();
+  ASSERT_EQ(1, upload_attempt_count_);
 }
 
 TEST_F(UploadFlowTest, TokenExpired) {
   oauth2_service_.SetTokenValid(kTokenValid);
   oauth2_service_.AddTokenToQueue(kTokenExpired);
   oauth2_service_.AddTokenToQueue(kTokenValid);
   std::unique_ptr<UploadJob> upload_job = PrepareUploadJob(
       base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator));
   upload_job->Start();
   run_loop_.Run();
+  ASSERT_EQ(2, upload_attempt_count_);
 }
 
 TEST_F(UploadFlowTest, TokenInvalid) {
   oauth2_service_.AddTokenToQueue(kTokenInvalid);
   oauth2_service_.AddTokenToQueue(kTokenInvalid);
+  oauth2_service_.AddTokenToQueue(kTokenInvalid);
+  oauth2_service_.AddTokenToQueue(kTokenInvalid);
   SetExpectedError(std::unique_ptr<UploadJob::ErrorCode>(
       new UploadJob::ErrorCode(UploadJob::AUTHENTICATION_ERROR)));
 
   std::unique_ptr<UploadJob> upload_job = PrepareUploadJob(
       base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator));
   upload_job->Start();
   run_loop_.Run();
+  ASSERT_EQ(4, upload_attempt_count_);
+}
+
+TEST_F(UploadFlowTest, TokenMultipleTries) {
+  oauth2_service_.SetTokenValid(kTokenValid);
+  oauth2_service_.AddTokenToQueue(kTokenInvalid);
+  oauth2_service_.AddTokenToQueue(kTokenInvalid);
+  oauth2_service_.AddTokenToQueue(kTokenValid);
+
+  std::unique_ptr<UploadJob> upload_job = PrepareUploadJob(
+      base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator));
+  upload_job->Start();
+  run_loop_.Run();
+  ASSERT_EQ(3, upload_attempt_count_);
 }
 
 TEST_F(UploadFlowTest, TokenFetchFailure) {
   SetExpectedError(std::unique_ptr<UploadJob::ErrorCode>(
       new UploadJob::ErrorCode(UploadJob::AUTHENTICATION_ERROR)));
 
   std::unique_ptr<UploadJob> upload_job = PrepareUploadJob(
       base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator));
   upload_job->Start();
   run_loop_.Run();
+  // Without a token we don't try to upload
+  ASSERT_EQ(0, upload_attempt_count_);
+}
+
+TEST_F(UploadFlowTest, InternalServerError) {
+  SetResponseDefaultStatusCode(net::HTTP_INTERNAL_SERVER_ERROR);
+  oauth2_service_.SetTokenValid(kTokenValid);
+  oauth2_service_.AddTokenToQueue(kTokenValid);
+
+  SetExpectedError(std::unique_ptr<UploadJob::ErrorCode>(
+      new UploadJob::ErrorCode(UploadJob::SERVER_ERROR)));
+
+  std::unique_ptr<UploadJob> upload_job = PrepareUploadJob(
+      base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator));
+  upload_job->Start();
+  run_loop_.Run();
+  // kMaxAttempts
+  ASSERT_EQ(4, upload_attempt_count_);
 }
 
 class UploadRequestTest : public UploadJobTestBase {
  public:
   UploadRequestTest() {}
 
   // UploadJobTestBase:
   void SetUp() override {
     UploadJobTestBase::SetUp();
     test_server_.RegisterRequestHandler(base::Bind(
@@ skipping 35 matching lines @@
       "customfield2: CUSTOM2\r\n"
       "\r\n"
       "**||--||PAYLOAD2||--||**\r\n--"
       "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA--\r\n");
 
   upload_job->Start();
   run_loop_.Run();
 }
 
 }  // namespace policy