gcm_channel_status_request_unittest.cc revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
1// Copyright 2014 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 "base/message_loop/message_loop.h"
6#include "components/gcm_driver/gcm_channel_status_request.h"
7#include "components/gcm_driver/proto/gcm_channel_status.pb.h"
8#include "net/url_request/test_url_fetcher_factory.h"
9#include "net/url_request/url_request_test_util.h"
10#include "testing/gtest/include/gtest/gtest.h"
11
12namespace gcm {
13
14class GCMChannelStatusRequestTest : public testing::Test {
15 public:
16  GCMChannelStatusRequestTest();
17  virtual ~GCMChannelStatusRequestTest();
18
19 protected:
20  enum GCMStatus {
21    NOT_SPECIFIED,
22    GCM_ENABLED,
23    GCM_DISABLED,
24  };
25
26  void StartRequest();
27  void SetResponseStatusAndString(net::HttpStatusCode status_code,
28                                  const std::string& response_body);
29  void SetResponseProtoData(GCMStatus status, int poll_interval_seconds);
30  void CompleteFetch();
31  void OnRequestCompleted(bool enabled, int poll_interval_seconds);
32
33  scoped_ptr<GCMChannelStatusRequest> request_;
34  base::MessageLoop message_loop_;
35  net::TestURLFetcherFactory url_fetcher_factory_;
36  scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
37  bool request_callback_invoked_;
38  bool enabled_;
39  int poll_interval_seconds_;
40};
41
42GCMChannelStatusRequestTest::GCMChannelStatusRequestTest()
43    : url_request_context_getter_(new net::TestURLRequestContextGetter(
44           message_loop_.message_loop_proxy())),
45      request_callback_invoked_(false),
46      enabled_(true),
47      poll_interval_seconds_(0) {
48}
49
50GCMChannelStatusRequestTest::~GCMChannelStatusRequestTest() {
51}
52
53void GCMChannelStatusRequestTest::StartRequest() {
54  request_.reset(new GCMChannelStatusRequest(
55      url_request_context_getter_.get(),
56      base::Bind(&GCMChannelStatusRequestTest::OnRequestCompleted,
57                 base::Unretained(this))));
58  request_->Start();
59}
60
61void GCMChannelStatusRequestTest::SetResponseStatusAndString(
62    net::HttpStatusCode status_code,
63    const std::string& response_body) {
64  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
65  ASSERT_TRUE(fetcher);
66  fetcher->set_response_code(status_code);
67  fetcher->SetResponseString(response_body);
68}
69
70void GCMChannelStatusRequestTest::SetResponseProtoData(
71    GCMStatus status, int poll_interval_seconds) {
72  gcm_proto::ExperimentStatusResponse response_proto;
73  if (status != NOT_SPECIFIED)
74    response_proto.mutable_gcm_channel()->set_enabled(status == GCM_ENABLED);
75
76  // Zero |poll_interval_seconds| means the optional field is not set.
77  if (poll_interval_seconds)
78    response_proto.set_poll_interval_seconds(poll_interval_seconds);
79
80  std::string response_string;
81  response_proto.SerializeToString(&response_string);
82  SetResponseStatusAndString(net::HTTP_OK, response_string);
83}
84
85void GCMChannelStatusRequestTest::CompleteFetch() {
86  request_callback_invoked_ = false;
87  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
88  ASSERT_TRUE(fetcher);
89  fetcher->delegate()->OnURLFetchComplete(fetcher);
90}
91
92void GCMChannelStatusRequestTest::OnRequestCompleted(
93    bool enabled, int poll_interval_seconds) {
94  request_callback_invoked_ = true;
95  enabled_ = enabled;
96  poll_interval_seconds_ = poll_interval_seconds;
97}
98
99TEST_F(GCMChannelStatusRequestTest, ResponseHttpStatusNotOK) {
100  StartRequest();
101  SetResponseStatusAndString(net::HTTP_UNAUTHORIZED, "");
102  CompleteFetch();
103
104  EXPECT_FALSE(request_callback_invoked_);
105}
106
107TEST_F(GCMChannelStatusRequestTest, ResponseEmpty) {
108  StartRequest();
109  SetResponseStatusAndString(net::HTTP_OK, "");
110  CompleteFetch();
111
112  EXPECT_FALSE(request_callback_invoked_);
113}
114
115TEST_F(GCMChannelStatusRequestTest, ResponseNotInProtoFormat) {
116  StartRequest();
117  SetResponseStatusAndString(net::HTTP_OK, "foo");
118  CompleteFetch();
119
120  EXPECT_FALSE(request_callback_invoked_);
121}
122
123TEST_F(GCMChannelStatusRequestTest, ResponseEmptyProtoData) {
124  StartRequest();
125  SetResponseProtoData(NOT_SPECIFIED, 0);
126  CompleteFetch();
127
128  EXPECT_FALSE(request_callback_invoked_);
129}
130
131TEST_F(GCMChannelStatusRequestTest, ResponseWithDisabledStatus) {
132  StartRequest();
133  SetResponseProtoData(GCM_DISABLED, 0);
134  CompleteFetch();
135
136  EXPECT_TRUE(request_callback_invoked_);
137  EXPECT_FALSE(enabled_);
138  EXPECT_EQ(
139      GCMChannelStatusRequest::default_poll_interval_seconds(),
140      poll_interval_seconds_);
141}
142
143TEST_F(GCMChannelStatusRequestTest, ResponseWithEnabledStatus) {
144  StartRequest();
145  SetResponseProtoData(GCM_ENABLED, 0);
146  CompleteFetch();
147
148  EXPECT_TRUE(request_callback_invoked_);
149  EXPECT_TRUE(enabled_);
150  EXPECT_EQ(
151      GCMChannelStatusRequest::default_poll_interval_seconds(),
152      poll_interval_seconds_);
153}
154
155TEST_F(GCMChannelStatusRequestTest, ResponseWithPollInterval) {
156  // Setting a poll interval 15 minutes longer than the minimum interval we
157  // enforce.
158  int poll_interval_seconds =
159      GCMChannelStatusRequest::min_poll_interval_seconds() + 15 * 60;
160  StartRequest();
161  SetResponseProtoData(NOT_SPECIFIED, poll_interval_seconds);
162  CompleteFetch();
163
164  EXPECT_TRUE(request_callback_invoked_);
165  EXPECT_TRUE(enabled_);
166  EXPECT_EQ(poll_interval_seconds, poll_interval_seconds_);
167}
168
169TEST_F(GCMChannelStatusRequestTest, ResponseWithShortPollInterval) {
170  // Setting a poll interval 15 minutes shorter than the minimum interval we
171  // enforce.
172  int poll_interval_seconds =
173      GCMChannelStatusRequest::min_poll_interval_seconds() - 15 * 60;
174  StartRequest();
175  SetResponseProtoData(NOT_SPECIFIED, poll_interval_seconds);
176  CompleteFetch();
177
178  EXPECT_TRUE(request_callback_invoked_);
179  EXPECT_TRUE(enabled_);
180  EXPECT_EQ(GCMChannelStatusRequest::min_poll_interval_seconds(),
181            poll_interval_seconds_);
182}
183
184TEST_F(GCMChannelStatusRequestTest, ResponseWithDisabledStatusAndPollInterval) {
185  int poll_interval_seconds =
186      GCMChannelStatusRequest::min_poll_interval_seconds() + 15 * 60;
187  StartRequest();
188  SetResponseProtoData(GCM_DISABLED, poll_interval_seconds);
189  CompleteFetch();
190
191  EXPECT_TRUE(request_callback_invoked_);
192  EXPECT_FALSE(enabled_);
193  EXPECT_EQ(poll_interval_seconds, poll_interval_seconds_);
194}
195
196}  // namespace gcm
197