src/google_apis/drive/base_requests_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "google_apis/drive/base_requests.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/run_loop.h"
  11 #include "base/values.h"
  12 #include "google_apis/drive/dummy_auth_service.h"
  13 #include "google_apis/drive/request_sender.h"
  14 #include "google_apis/drive/test_util.h"
  15 #include "net/test/embedded_test_server/embedded_test_server.h"
  16 #include "net/test/embedded_test_server/http_request.h"
  17 #include "net/test/embedded_test_server/http_response.h"
  18 #include "net/url_request/url_request_test_util.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 namespace google_apis {
  22
  23 namespace {
  24
  25 const char kValidJsonString[] = "{ \"test\": 123 }";
  26 const char kInvalidJsonString[] = "$$$";
  27
  28 class FakeUrlFetchRequest : public UrlFetchRequestBase {
  29  public:
  30   FakeUrlFetchRequest(RequestSender* sender,
  31                       const EntryActionCallback& callback,
  32                       const GURL& url)
  33       : UrlFetchRequestBase(sender),
  34         callback_(callback),
  35         url_(url) {
  36   }
  37
  38   ~FakeUrlFetchRequest() override {}
  39
  40  protected:
  41   GURL GetURL() const override { return url_; }
  42   void ProcessURLFetchResults(const net::URLFetcher* source) override {
  43     callback_.Run(GetErrorCode());
  44   }
  45   void RunCallbackOnPrematureFailure(GDataErrorCode code) override {
  46     callback_.Run(code);
  47   }
  48
  49   EntryActionCallback callback_;
  50   GURL url_;
  51 };
  52
  53 }  // namespace
  54
  55 class BaseRequestsTest : public testing::Test {
  56  public:
  57   BaseRequestsTest() : response_code_(net::HTTP_OK) {}
  58
  59   virtual void SetUp() override {
  60     request_context_getter_ = new net::TestURLRequestContextGetter(
  61         message_loop_.message_loop_proxy());
  62
  63     sender_.reset(new RequestSender(new DummyAuthService,
  64                                     request_context_getter_.get(),
  65                                     message_loop_.message_loop_proxy(),
  66                                     std::string() /* custom user agent */));
  67
  68     ASSERT_TRUE(test_server_.InitializeAndWaitUntilReady());
  69     test_server_.RegisterRequestHandler(
  70         base::Bind(&BaseRequestsTest::HandleRequest, base::Unretained(this)));
  71   }
  72
  73   scoped_ptr<net::test_server::HttpResponse> HandleRequest(
  74       const net::test_server::HttpRequest& request) {
  75     scoped_ptr<net::test_server::BasicHttpResponse> response(
  76         new net::test_server::BasicHttpResponse);
  77     response->set_code(response_code_);
  78     response->set_content(response_body_);
  79     response->set_content_type("application/json");
  80     return response.Pass();
  81   }
  82
  83   base::MessageLoopForIO message_loop_;
  84   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
  85   scoped_ptr<RequestSender> sender_;
  86   net::test_server::EmbeddedTestServer test_server_;
  87
  88   net::HttpStatusCode response_code_;
  89   std::string response_body_;
  90 };
  91
  92 TEST_F(BaseRequestsTest, ParseValidJson) {
  93   scoped_ptr<base::Value> json(ParseJson(kValidJsonString));
  94
  95   base::DictionaryValue* root_dict = NULL;
  96   ASSERT_TRUE(json);
  97   ASSERT_TRUE(json->GetAsDictionary(&root_dict));
  98
  99   int int_value = 0;
 100   ASSERT_TRUE(root_dict->GetInteger("test", &int_value));
 101   EXPECT_EQ(123, int_value);
 102 }
 103
 104 TEST_F(BaseRequestsTest, ParseInvalidJson) {
 105   EXPECT_FALSE(ParseJson(kInvalidJsonString));
 106 }
 107
 108 TEST_F(BaseRequestsTest, UrlFetchRequestBaseResponseCodeOverride) {
 109   response_code_ = net::HTTP_FORBIDDEN;
 110   response_body_ =
 111       "{\"error\": {\n"
 112       "  \"errors\": [\n"
 113       "   {\n"
 114       "    \"domain\": \"usageLimits\",\n"
 115       "    \"reason\": \"rateLimitExceeded\",\n"
 116       "    \"message\": \"Rate Limit Exceeded\"\n"
 117       "   }\n"
 118       "  ],\n"
 119       "  \"code\": 403,\n"
 120       "  \"message\": \"Rate Limit Exceeded\"\n"
 121       " }\n"
 122       "}\n";
 123
 124   GDataErrorCode error = GDATA_OTHER_ERROR;
 125   base::RunLoop run_loop;
 126   sender_->StartRequestWithRetry(
 127       new FakeUrlFetchRequest(
 128           sender_.get(),
 129           test_util::CreateQuitCallback(
 130               &run_loop, test_util::CreateCopyResultCallback(&error)),
 131           test_server_.base_url()));
 132   run_loop.Run();
 133
 134   // HTTP_FORBIDDEN (403) is overridden by the error reason.
 135   EXPECT_EQ(HTTP_SERVICE_UNAVAILABLE, error);
 136 }
 137
 138 }  // namespace google_apis