Retry uploading in UploadJobImpl when error occurs

chrome/browser/chromeos/policy/upload_job_unittest.cc

Index: chrome/browser/chromeos/policy/upload_job_unittest.cc
diff --git a/chrome/browser/chromeos/policy/upload_job_unittest.cc b/chrome/browser/chromeos/policy/upload_job_unittest.cc
index 501c4b5b20fbea56951b89707c58e0eb1c45e152..2d57beb89c8cd93a47a80bb6e9d35040f3140132 100644
--- a/chrome/browser/chromeos/policy/upload_job_unittest.cc
+++ b/chrome/browser/chromeos/policy/upload_job_unittest.cc
@@ -16,7 +16,7 @@
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
+#include "base/sequenced_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/policy/upload_job_impl.h"
@@ -154,7 +154,8 @@ class UploadJobTestBase : public testing::Test, public UploadJob::Delegate {
  public:
   UploadJobTestBase()
       : test_browser_thread_bundle_(
-            content::TestBrowserThreadBundle::IO_MAINLOOP) {}
+            content::TestBrowserThreadBundle::IO_MAINLOOP),
+        task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
   // policy::UploadJob::Delegate:
   void OnSuccess() override {
@@ -184,6 +185,8 @@ class UploadJobTestBase : public testing::Test, public UploadJob::Delegate {
         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:
@@ -198,7 +201,7 @@ class UploadJobTestBase : public testing::Test, public UploadJob::Delegate {
     std::unique_ptr<UploadJob> upload_job(
         new UploadJobImpl(GetServerURL(), kRobotAccountId, &oauth2_service_,
                           request_context_getter_.get(), this,
-                          std::move(mime_boundary_generator)));
+                          std::move(mime_boundary_generator), task_runner_));
 
     std::map<std::string, std::string> header_entries;
     header_entries.insert(std::make_pair(kCustomField1, "CUSTOM1"));
@@ -219,6 +222,9 @@ class UploadJobTestBase : public testing::Test, public UploadJob::Delegate {
   MockOAuth2TokenService oauth2_service_;
 
   std::unique_ptr<UploadJob::ErrorCode> expected_error_;
+
+  // TaskRunner used to run individual tests.
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;

[Andrew T Wilson (Slow), 2016/05/18 11:59:38]

Why do we need to track this in a member variable? Can this just be a local
variable in PrepareUploadJob(), since it's a refptr and UploadJobImpl should
hold its own reference (no need to keep it around in a member var)?

[Marton Hunyady, 2016/05/18 12:27:03]

Done.

 };
 
 class UploadFlowTest : public UploadJobTestBase {
@@ -230,10 +236,18 @@ class UploadFlowTest : public UploadJobTestBase {
     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");
@@ -247,10 +261,14 @@ class UploadFlowTest : public UploadJobTestBase {
 
     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) {
@@ -260,6 +278,7 @@ TEST_F(UploadFlowTest, SuccessfulUpload) {
       base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator));
   upload_job->Start();
   run_loop_.Run();
+  ASSERT_EQ(1, upload_attempt_count_);
 }
 
 TEST_F(UploadFlowTest, TokenExpired) {
@@ -270,11 +289,14 @@ TEST_F(UploadFlowTest, TokenExpired) {
       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)));
 
@@ -282,6 +304,20 @@ TEST_F(UploadFlowTest, TokenInvalid) {
       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) {
@@ -292,6 +328,24 @@ TEST_F(UploadFlowTest, TokenFetchFailure) {
       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

[Andrew T Wilson (Slow), 2016/05/18 11:59:38]

This is fine. Alternative would have been to expose this in the UploadJob header
file, but I think this is OK.

+  ASSERT_EQ(4, upload_attempt_count_);
 }
 
 class UploadRequestTest : public UploadJobTestBase {