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/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"
 #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 113 matching lines @@
 void MockOAuth2TokenService::InvalidateAccessTokenImpl(
     const std::string& account_id,
     const std::string& client_id,
     const ScopeSet& scopes,
     const std::string& access_token) {
   SetTokenInvalid(access_token);
 }
 
 }  // 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 {
     if (!expected_error_)
       run_loop_.Quit();
     else
       FAIL();
   }
 
   // policy::UploadJob::Delegate:
@@ skipping 23 matching lines @@
     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::move(mime_boundary_generator), task_runner_));
 
     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));
     return upload_job;
   }
 
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
   base::RunLoop run_loop_;
   net::EmbeddedTestServer test_server_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
   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 {
  public:
   UploadFlowTest() {}
 
   // UploadJobTestBase:
   void SetUp() override {
     UploadJobTestBase::SetUp();
     test_server_.RegisterRequestHandler(
@@ skipping 36 matching lines @@
   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, 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();
 }
 
+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)));
 
   std::unique_ptr<UploadJob> upload_job = PrepareUploadJob(
       base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator));
   upload_job->Start();
   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() {}
 
   // UploadJobTestBase:
   void SetUp() override {
     UploadJobTestBase::SetUp();
     test_server_.RegisterRequestHandler(base::Bind(
         &UploadRequestTest::HandlePostRequest, base::Unretained(this)));
   }
@@ skipping 33 matching lines @@
       "customfield2: CUSTOM2\r\n"
       "\r\n"
       "**||--||PAYLOAD2||--||**\r\n--"
       "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA--\r\n");
 
   upload_job->Start();
   run_loop_.Run();
 }
 
 }  // namespace policy