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