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 "components/copresence/rpc/http_post.h"
6
7#include "base/test/test_simple_task_runner.h"
8#include "components/copresence/proto/data.pb.h"
9#include "net/base/url_util.h"
10#include "net/http/http_status_code.h"
11#include "net/url_request/test_url_fetcher_factory.h"
12#include "net/url_request/url_request_test_util.h"
13#include "testing/gtest/include/gtest/gtest.h"
14#include "url/gurl.h"
15
16namespace {
17
18const char kFakeServerHost[] = "test.server.google.com";
19const char kRPCName[] = "testRpc";
20const char kTracingToken[] = "trace me!";
21const char kApiKey[] = "unlock ALL the APIz";
22
23}  // namespace
24
25using google::protobuf::MessageLite;
26
27namespace copresence {
28
29class HttpPostTest : public testing::Test {
30 public:
31  HttpPostTest()
32      : received_response_code_(0) {
33    context_getter_ = new net::TestURLRequestContextGetter(
34        make_scoped_refptr(new base::TestSimpleTaskRunner));
35    proto_.set_client("test_client");
36    proto_.set_version_code(123);
37  }
38  virtual ~HttpPostTest() {}
39
40  // Record the response sent back to the client for verification.
41  void TestResponseCallback(int response_code,
42                            const std::string& response) {
43    received_response_code_ = response_code;
44    received_response_ = response;
45  }
46
47 protected:
48  bool ResponsePassedThrough(int response_code, const std::string& response) {
49    pending_post_ = new HttpPost(context_getter_.get(),
50                                 std::string("http://") + kFakeServerHost,
51                                 kRPCName,
52                                 "",
53                                 kApiKey,
54                                 proto_);
55    pending_post_->Start(base::Bind(&HttpPostTest::TestResponseCallback,
56                                    base::Unretained(this)));
57    net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(
58        HttpPost::kUrlFetcherId);
59    fetcher->set_response_code(response_code);
60    fetcher->SetResponseString(response);
61    fetcher->delegate()->OnURLFetchComplete(fetcher);
62    delete pending_post_;
63    return received_response_code_ == response_code &&
64           received_response_ == response;
65  }
66
67  net::TestURLFetcher* GetFetcher() {
68    return fetcher_factory_.GetFetcherByID(HttpPost::kUrlFetcherId);
69  }
70
71  const std::string GetApiKeySent() {
72    std::string api_key_sent;
73    net::GetValueForKeyInQuery(GetFetcher()->GetOriginalURL(),
74                               HttpPost::kApiKeyField,
75                               &api_key_sent);
76    return api_key_sent;
77  }
78
79  const std::string GetTracingTokenSent() {
80    std::string tracing_token_sent;
81    net::GetValueForKeyInQuery(GetFetcher()->GetOriginalURL(),
82                               HttpPost::kTracingField,
83                               &tracing_token_sent);
84    return tracing_token_sent;
85  }
86
87  net::TestURLFetcherFactory fetcher_factory_;
88  scoped_refptr<net::TestURLRequestContextGetter> context_getter_;
89
90  ClientVersion proto_;
91
92  int received_response_code_;
93  std::string received_response_;
94
95 private:
96  HttpPost* pending_post_;
97};
98
99TEST_F(HttpPostTest, OKResponse) {
100  // "Send" the proto to the "server".
101  HttpPost* post = new HttpPost(context_getter_.get(),
102                                std::string("http://") + kFakeServerHost,
103                                kRPCName,
104                                kTracingToken,
105                                kApiKey,
106                                proto_);
107  post->Start(base::Bind(&HttpPostTest::TestResponseCallback,
108                         base::Unretained(this)));
109
110  // Verify that the data was sent to the right place.
111  GURL requested_url = GetFetcher()->GetOriginalURL();
112  EXPECT_EQ(kFakeServerHost, requested_url.host());
113  EXPECT_EQ(std::string("/") + kRPCName, requested_url.path());
114
115  // Check query parameters.
116  EXPECT_EQ(kApiKey, GetApiKeySent());
117  EXPECT_EQ(std::string("token:") + kTracingToken, GetTracingTokenSent());
118
119  // Verify that the right data was sent.
120  std::string upload_data;
121  ASSERT_TRUE(proto_.SerializeToString(&upload_data));
122  EXPECT_EQ(upload_data, GetFetcher()->upload_data());
123
124  // Send a response and check that it's passed along correctly.
125  GetFetcher()->set_response_code(net::HTTP_OK);
126  GetFetcher()->SetResponseString("Hello World!");
127  GetFetcher()->delegate()->OnURLFetchComplete(GetFetcher());
128  EXPECT_EQ(net::HTTP_OK, received_response_code_);
129  EXPECT_EQ("Hello World!", received_response_);
130  delete post;
131}
132
133TEST_F(HttpPostTest, ErrorResponse) {
134  EXPECT_TRUE(ResponsePassedThrough(
135      net::HTTP_BAD_REQUEST, "Bad client. Shame on you."));
136  EXPECT_TRUE(ResponsePassedThrough(
137      net::HTTP_INTERNAL_SERVER_ERROR, "I'm dying. Forgive me."));
138  EXPECT_TRUE(ResponsePassedThrough(-1, ""));
139}
140
141}  // namespace copresence
142