privet_url_fetcher_unittest.cc revision 0f1bc08d4cfcc34181b0b5cbf065c40f687bf740 
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  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
55class 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
78TEST_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
97TEST_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
110TEST_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
124TEST_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
138TEST_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
150TEST_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
171TEST_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
187