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..0b315688510523fade425d5f3882e8cc27ae4ed1 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"
@@ -150,11 +151,42 @@ void MockOAuth2TokenService::InvalidateAccessTokenImpl(
 
 }  // namespace
 
+// Mock thread runner which runs each tasks immediately.
+class ImmediateThreadTaskRunner : public base::SingleThreadTaskRunner {

[Andrew T Wilson (Slow), 2016/05/02 09:15:49]

Can you use TestSimpleTaskRunner instead?

[Marton Hunyady, 2016/05/04 11:26:41]

Unfortunately, I think no. Other possible solution may be to create a setter to
the retry delay and set this before running the tests.

+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
+ 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 +230,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 +251,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 {
@@ -275,6 +310,8 @@ TEST_F(UploadFlowTest, TokenExpired) {
 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)));
 
@@ -284,6 +321,18 @@ TEST_F(UploadFlowTest, TokenInvalid) {
   run_loop_.Run();
 }
 
+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();
+}
+
 TEST_F(UploadFlowTest, TokenFetchFailure) {
   SetExpectedError(std::unique_ptr<UploadJob::ErrorCode>(
       new UploadJob::ErrorCode(UploadJob::AUTHENTICATION_ERROR)));
@@ -294,6 +343,39 @@ TEST_F(UploadFlowTest, TokenFetchFailure) {
   run_loop_.Run();
 }
 
+class UploadServerErrorTest : public UploadJobTestBase {
+ public:
+  UploadServerErrorTest() {}
+
+  // UploadJobTestBase:
+  void SetUp() override {
+    UploadJobTestBase::SetUp();
+    test_server_.RegisterRequestHandler(base::Bind(
+        &UploadServerErrorTest::HandlePostRequest, base::Unretained(this)));
+  }
+
+  std::unique_ptr<net::test_server::HttpResponse> HandlePostRequest(
+      const net::test_server::HttpRequest& request) {
+    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);
+  }
+};
+
+TEST_F(UploadServerErrorTest, InternalServerError) {
+  oauth2_service_.SetTokenValid(kTokenValid);
+  oauth2_service_.AddTokenToQueue(kTokenValid);

[Andrew T Wilson (Slow), 2016/05/02 09:15:49]

Is there a test that ensures that we retry multiple times?

[Marton Hunyady, 2016/05/04 11:26:41]

Done.

+
+  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();
+}
+
 class UploadRequestTest : public UploadJobTestBase {
  public:
   UploadRequestTest() {}