Home | History | Annotate | Download | only in local_discovery 
      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 
     21 const char kSampleParsableJSON[] = "{ \"hello\" : 2 }";
     22 const char kSampleUnparsableJSON[] = "{ \"hello\" : }";
     23 const char kSampleJSONWithError[] = "{ \"error\" : \"unittest_example\" }";
     24 
     25 class MockPrivetURLFetcherDelegate : public PrivetURLFetcher::Delegate {
     26  public:
     27   virtual void OnError(PrivetURLFetcher* fetcher,
     28                        PrivetURLFetcher::ErrorType error) OVERRIDE {
     29     OnErrorInternal(error);
     30   }
     31 
     32   MOCK_METHOD1(OnErrorInternal, void(PrivetURLFetcher::ErrorType error));
     33 
     34   virtual void OnParsedJson(PrivetURLFetcher* fetcher,
     35                             const base::DictionaryValue* value,
     36                             bool has_error) OVERRIDE {
     37     saved_value_.reset(value->DeepCopy());
     38     OnParsedJsonInternal(has_error);
     39   }
     40 
     41   MOCK_METHOD1(OnParsedJsonInternal, void(bool has_error));
     42 
     43   const DictionaryValue* saved_value() { return saved_value_.get(); }
     44 
     45  private:
     46   scoped_ptr<DictionaryValue> saved_value_;
     47 };
     48 
     49 class PrivetURLFetcherTest : public ::testing::Test {
     50  public:
     51   PrivetURLFetcherTest() {
     52     request_context_= new net::TestURLRequestContextGetter(
     53         base::MessageLoopProxy::current());
     54     privet_urlfetcher_.reset(new PrivetURLFetcher(
     55         kSamplePrivetToken,
     56         GURL(kSamplePrivetURL),
     57         net::URLFetcher::POST,
     58         request_context_.get(),
     59         &delegate_));
     60   }
     61   virtual ~PrivetURLFetcherTest() {
     62   }
     63 
     64  protected:
     65   base::MessageLoop loop_;
     66   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
     67   net::TestURLFetcherFactory fetcher_factory_;
     68   scoped_ptr<PrivetURLFetcher> privet_urlfetcher_;
     69   StrictMock<MockPrivetURLFetcherDelegate> delegate_;
     70 };
     71 
     72 TEST_F(PrivetURLFetcherTest, FetchSuccess) {
     73   privet_urlfetcher_->Start();
     74   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
     75   ASSERT_TRUE(fetcher != NULL);
     76   fetcher->SetResponseString(kSampleParsableJSON);
     77   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
     78                                             net::OK));
     79   fetcher->set_response_code(200);
     80 
     81   EXPECT_CALL(delegate_, OnParsedJsonInternal(false));
     82   fetcher->delegate()->OnURLFetchComplete(fetcher);
     83 
     84   const base::DictionaryValue* value = delegate_.saved_value();
     85   int hello_value;
     86   ASSERT_TRUE(value != NULL);
     87   ASSERT_TRUE(value->GetInteger("hello", &hello_value));
     88   EXPECT_EQ(2, hello_value);
     89 }
     90 
     91 TEST_F(PrivetURLFetcherTest, URLFetcherError) {
     92   privet_urlfetcher_->Start();
     93   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
     94   ASSERT_TRUE(fetcher != NULL);
     95   fetcher->SetResponseString(kSampleParsableJSON);
     96   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
     97                                             net::ERR_TIMED_OUT));
     98   fetcher->set_response_code(-1);
     99 
    100   EXPECT_CALL(delegate_, OnErrorInternal(PrivetURLFetcher::URL_FETCH_ERROR));
    101   fetcher->delegate()->OnURLFetchComplete(fetcher);
    102 }
    103 
    104 TEST_F(PrivetURLFetcherTest, ResponseCodeError) {
    105   privet_urlfetcher_->Start();
    106   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
    107   ASSERT_TRUE(fetcher != NULL);
    108   fetcher->SetResponseString(kSampleParsableJSON);
    109   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
    110                                             net::OK));
    111   fetcher->set_response_code(404);
    112 
    113   EXPECT_CALL(delegate_,
    114               OnErrorInternal(PrivetURLFetcher::RESPONSE_CODE_ERROR));
    115   fetcher->delegate()->OnURLFetchComplete(fetcher);
    116 }
    117 
    118 TEST_F(PrivetURLFetcherTest, JsonParseError) {
    119   privet_urlfetcher_->Start();
    120   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
    121   ASSERT_TRUE(fetcher != NULL);
    122   fetcher->SetResponseString(kSampleUnparsableJSON);
    123   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
    124                                             net::OK));
    125   fetcher->set_response_code(200);
    126 
    127   EXPECT_CALL(delegate_,
    128               OnErrorInternal(PrivetURLFetcher::JSON_PARSE_ERROR));
    129   fetcher->delegate()->OnURLFetchComplete(fetcher);
    130 }
    131 
    132 TEST_F(PrivetURLFetcherTest, Header) {
    133   privet_urlfetcher_->Start();
    134   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
    135   ASSERT_TRUE(fetcher != NULL);
    136   net::HttpRequestHeaders headers;
    137   fetcher->GetExtraRequestHeaders(&headers);
    138 
    139   std::string header_token;
    140   ASSERT_TRUE(headers.GetHeader("X-Privet-Token", &header_token));
    141   EXPECT_EQ(kSamplePrivetToken, header_token);
    142 }
    143 
    144 TEST_F(PrivetURLFetcherTest, FetchHasError) {
    145   privet_urlfetcher_->Start();
    146   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
    147   ASSERT_TRUE(fetcher != NULL);
    148   fetcher->SetResponseString(kSampleJSONWithError);
    149   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
    150                                             net::OK));
    151   fetcher->set_response_code(200);
    152 
    153   EXPECT_CALL(delegate_, OnParsedJsonInternal(true));
    154   fetcher->delegate()->OnURLFetchComplete(fetcher);
    155 }
    156 
    157 }  // namespace
    158 
    159 }  // namespace local_discovery
    160