src/chrome/browser/local_discovery/privet_url_fetcher_unittest.cc

   1 // Copyright 2013 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 "chrome/browser/local_discovery/privet_url_fetcher.h"
   6 #include "net/url_request/test_url_fetcher_factory.h"
   7 #include "net/url_request/url_request_test_util.h"
   8 #include "testing/gmock/include/gmock/gmock.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 using testing::StrictMock;
  12
  13 namespace local_discovery {
  14
  15 namespace {
  16
  17 const char kSamplePrivetURL[] =
  18     "http://10.0.0.8:7676/privet/register?action=start";
  19 const char kSamplePrivetToken[] = "MyToken";
  20 const char kEmptyPrivetToken[] = "\"\"";
  21
  22 const char kSampleParsableJSON[] = "{ \"hello\" : 2 }";
  23 const char kSampleUnparsableJSON[] = "{ \"hello\" : }";
  24 const char kSampleJSONWithError[] = "{ \"error\" : \"unittest_example\" }";
  25
  26 class MockPrivetURLFetcherDelegate : public PrivetURLFetcher::Delegate {
  27  public:
  28   virtual void OnError(PrivetURLFetcher* fetcher,
  29                        PrivetURLFetcher::ErrorType error) OVERRIDE {
  30     OnErrorInternal(error);
  31   }
  32
  33   MOCK_METHOD1(OnErrorInternal, void(PrivetURLFetcher::ErrorType error));
  34
  35   virtual void OnParsedJson(PrivetURLFetcher* fetcher,
  36                             const base::DictionaryValue* value,
  37                             bool has_error) OVERRIDE {
  38     saved_value_.reset(value->DeepCopy());
  39     OnParsedJsonInternal(has_error);
  40   }
  41
  42   MOCK_METHOD1(OnParsedJsonInternal, void(bool has_error));
  43
  44   virtual void OnNeedPrivetToken(
  45       PrivetURLFetcher* fetcher,
  46       const PrivetURLFetcher::TokenCallback& callback) {
  47   }
  48
  49   const DictionaryValue* saved_value() { return saved_value_.get(); }
  50
  51  private:
  52   scoped_ptr<DictionaryValue> saved_value_;
  53 };
  54
  55 class PrivetURLFetcherTest : public ::testing::Test {
  56  public:
  57   PrivetURLFetcherTest() {
  58     request_context_= new net::TestURLRequestContextGetter(
  59         base::MessageLoopProxy::current());
  60     privet_urlfetcher_.reset(new PrivetURLFetcher(
  61         kSamplePrivetToken,
  62         GURL(kSamplePrivetURL),
  63         net::URLFetcher::POST,
  64         request_context_.get(),
  65         &delegate_));
  66   }
  67   virtual ~PrivetURLFetcherTest() {
  68   }
  69
  70  protected:
  71   base::MessageLoop loop_;
  72   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
  73   net::TestURLFetcherFactory fetcher_factory_;
  74   scoped_ptr<PrivetURLFetcher> privet_urlfetcher_;
  75   StrictMock<MockPrivetURLFetcherDelegate> delegate_;
  76 };
  77
  78 TEST_F(PrivetURLFetcherTest, FetchSuccess) {
  79   privet_urlfetcher_->Start();
  80   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
  81   ASSERT_TRUE(fetcher != NULL);
  82   fetcher->SetResponseString(kSampleParsableJSON);
  83   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
  84                                             net::OK));
  85   fetcher->set_response_code(200);
  86
  87   EXPECT_CALL(delegate_, OnParsedJsonInternal(false));
  88   fetcher->delegate()->OnURLFetchComplete(fetcher);
  89
  90   const base::DictionaryValue* value = delegate_.saved_value();
  91   int hello_value;
  92   ASSERT_TRUE(value != NULL);
  93   ASSERT_TRUE(value->GetInteger("hello", &hello_value));
  94   EXPECT_EQ(2, hello_value);
  95 }
  96
  97 TEST_F(PrivetURLFetcherTest, URLFetcherError) {
  98   privet_urlfetcher_->Start();
  99   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 100   ASSERT_TRUE(fetcher != NULL);
 101   fetcher->SetResponseString(kSampleParsableJSON);
 102   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
 103                                             net::ERR_TIMED_OUT));
 104   fetcher->set_response_code(-1);
 105
 106   EXPECT_CALL(delegate_, OnErrorInternal(PrivetURLFetcher::URL_FETCH_ERROR));
 107   fetcher->delegate()->OnURLFetchComplete(fetcher);
 108 }
 109
 110 TEST_F(PrivetURLFetcherTest, ResponseCodeError) {
 111   privet_urlfetcher_->Start();
 112   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 113   ASSERT_TRUE(fetcher != NULL);
 114   fetcher->SetResponseString(kSampleParsableJSON);
 115   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 116                                             net::OK));
 117   fetcher->set_response_code(404);
 118
 119   EXPECT_CALL(delegate_,
 120               OnErrorInternal(PrivetURLFetcher::RESPONSE_CODE_ERROR));
 121   fetcher->delegate()->OnURLFetchComplete(fetcher);
 122 }
 123
 124 TEST_F(PrivetURLFetcherTest, JsonParseError) {
 125   privet_urlfetcher_->Start();
 126   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 127   ASSERT_TRUE(fetcher != NULL);
 128   fetcher->SetResponseString(kSampleUnparsableJSON);
 129   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 130                                             net::OK));
 131   fetcher->set_response_code(200);
 132
 133   EXPECT_CALL(delegate_,
 134               OnErrorInternal(PrivetURLFetcher::JSON_PARSE_ERROR));
 135   fetcher->delegate()->OnURLFetchComplete(fetcher);
 136 }
 137
 138 TEST_F(PrivetURLFetcherTest, Header) {
 139   privet_urlfetcher_->Start();
 140   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 141   ASSERT_TRUE(fetcher != NULL);
 142   net::HttpRequestHeaders headers;
 143   fetcher->GetExtraRequestHeaders(&headers);
 144
 145   std::string header_token;
 146   ASSERT_TRUE(headers.GetHeader("X-Privet-Token", &header_token));
 147   EXPECT_EQ(kSamplePrivetToken, header_token);
 148 }
 149
 150 TEST_F(PrivetURLFetcherTest, Header2) {
 151   privet_urlfetcher_.reset(new PrivetURLFetcher(
 152       "",
 153       GURL(kSamplePrivetURL),
 154       net::URLFetcher::POST,
 155       request_context_.get(),
 156       &delegate_));
 157
 158   privet_urlfetcher_->AllowEmptyPrivetToken();
 159   privet_urlfetcher_->Start();
 160
 161   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 162   ASSERT_TRUE(fetcher != NULL);
 163   net::HttpRequestHeaders headers;
 164   fetcher->GetExtraRequestHeaders(&headers);
 165
 166   std::string header_token;
 167   ASSERT_TRUE(headers.GetHeader("X-Privet-Token", &header_token));
 168   EXPECT_EQ(kEmptyPrivetToken, header_token);
 169 }
 170
 171 TEST_F(PrivetURLFetcherTest, FetchHasError) {
 172   privet_urlfetcher_->Start();
 173   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 174   ASSERT_TRUE(fetcher != NULL);
 175   fetcher->SetResponseString(kSampleJSONWithError);
 176   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
 177                                             net::OK));
 178   fetcher->set_response_code(200);
 179
 180   EXPECT_CALL(delegate_, OnParsedJsonInternal(true));
 181   fetcher->delegate()->OnURLFetchComplete(fetcher);
 182 }
 183
 184 }  // namespace
 185
 186 }  // namespace local_discovery