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..2b3733bdc580d821502cb324422bab235cbde997 100644
--- a/chrome/browser/chromeos/policy/upload_job_unittest.cc
+++ b/chrome/browser/chromeos/policy/upload_job_unittest.cc
@@ -17,6 +17,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/policy/upload_job_impl.h"
@@ -28,6 +29,7 @@
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_request_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
@@ -150,11 +152,42 @@ void MockOAuth2TokenService::InvalidateAccessTokenImpl(
 
 }  // namespace
 
+// Mock thread runner which runs each tasks immediately.
+class ImmediateThreadTaskRunner : public base::SingleThreadTaskRunner {

[Andrew T Wilson (Slow), 2016/05/10 22:00:42]

I still don't understand why this is required (why you can't use
TestSimpleTaskRunner - maybe add a comment to this effect)?

[Marton Hunyady, 2016/05/11 12:55:31]

I removed it and made it possible to set the delays for the tests separately, so
now I'm using base::ThreadTaskRunnerHandle::Get() as task runner for the tests.

The problem with TestSimpleTaskRunner is that I didn't find a way to run the
tasks posted to that automatically until run_loop_.Quit() is called from the
callbacks.

+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;

[Andrew T Wilson (Slow), 2016/05/10 22:00:42]

What is the intended scope of this member variable? Maybe make it explicit (put
it under public or protected or whatever)

+
+ public:
+  ImmediateThreadTaskRunner()
+      : task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
+
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       const base::Closure& task,
+                       base::TimeDelta delay) override {
+    return task_runner_->PostTask(from_here, task);
+  }
+
+  bool RunsTasksOnCurrentThread() const override {
+    return task_runner_->RunsTasksOnCurrentThread();
+  }
+
+  bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                                  const base::Closure& task,
+                                  base::TimeDelta delay) override {
+    return task_runner_->PostTask(from_here, task);
+  }
+
+ protected:
+  ~ImmediateThreadTaskRunner() override {}
+
+  DISALLOW_COPY_AND_ASSIGN(ImmediateThreadTaskRunner);
+};
+
 class UploadJobTestBase : public testing::Test, public UploadJob::Delegate {
  public:
   UploadJobTestBase()
       : test_browser_thread_bundle_(
-            content::TestBrowserThreadBundle::IO_MAINLOOP) {}
+            content::TestBrowserThreadBundle::IO_MAINLOOP),
+        task_runner_(new ImmediateThreadTaskRunner) {}
 
   // policy::UploadJob::Delegate:
   void OnSuccess() override {
@@ -198,7 +231,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 +252,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<ImmediateThreadTaskRunner> task_runner_;
 };
 
 class UploadFlowTest : public UploadJobTestBase {
@@ -230,10 +266,12 @@ class UploadFlowTest : public UploadJobTestBase {
     UploadJobTestBase::SetUp();
     test_server_.RegisterRequestHandler(
         base::Bind(&UploadFlowTest::HandlePostRequest, base::Unretained(this)));
+    upload_attempt_count_ = 0;
   }
 
   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");
@@ -251,6 +289,9 @@ class UploadFlowTest : public UploadJobTestBase {
                            : net::HTTP_UNAUTHORIZED);
     return std::move(response);
   }
+
+ protected:
+  int upload_attempt_count_;
 };
 
 TEST_F(UploadFlowTest, SuccessfulUpload) {
@@ -260,6 +301,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 +312,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 +327,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 +351,49 @@ 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_);
+}
+
+class UploadServerErrorTest : public UploadJobTestBase {

[Andrew T Wilson (Slow), 2016/05/10 22:00:42]

Could you use UploadFlowTest() but have some member variable that makes
HandlePostRequest return INTERNAL_SERVER_ERROR, rather than making another test
class?

This is fine as-is, although it does have some code duplication between the two
classes it might be nice to avoid.

[Marton Hunyady, 2016/05/11 12:55:31]

Done, removed it.

+ public:
+  UploadServerErrorTest() {}
+
+  // UploadJobTestBase:
+  void SetUp() override {
+    UploadJobTestBase::SetUp();
+    test_server_.RegisterRequestHandler(base::Bind(
+        &UploadServerErrorTest::HandlePostRequest, base::Unretained(this)));
+    upload_attempt_count_ = 0;
+  }
+
+  std::unique_ptr<net::test_server::HttpResponse> HandlePostRequest(
+      const net::test_server::HttpRequest& request) {
+    upload_attempt_count_++;
+    std::unique_ptr<net::test_server::BasicHttpResponse> response(
+        new net::test_server::BasicHttpResponse);
+    response->set_code(net::HTTP_INTERNAL_SERVER_ERROR);
+    return std::move(response);
+  }
+
+ protected:
+  int upload_attempt_count_;
+};
+
+TEST_F(UploadServerErrorTest, InternalServerError) {
+  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 {