privet_url_fetcher_unittest.cc revision 7dbb3d5cf0c15f500944d211057644d6a2f37371 
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";
20
21const char kSampleParsableJSON[] = "{ \"hello\" : 2 }";
22const char kSampleUnparsableJSON[] = "{ \"hello\" : }";
23const char kSampleJSONWithError[] = "{ \"error\" : \"unittest_example\" }";
24
25class 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
49class 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
72TEST_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
91TEST_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
104TEST_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
118TEST_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
132TEST_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
144TEST_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