OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "blimp/client/session/assignment_source.h" | 5 #include "blimp/client/session/assignment_source.h" |
6 | 6 |
7 #include "base/command_line.h" | 7 #include "base/command_line.h" |
| 8 #include "base/files/file_path.h" |
| 9 #include "base/files/file_util.h" |
8 #include "base/json/json_reader.h" | 10 #include "base/json/json_reader.h" |
9 #include "base/json/json_writer.h" | 11 #include "base/json/json_writer.h" |
| 12 #include "base/message_loop/message_loop.h" |
| 13 #include "base/path_service.h" |
| 14 #include "base/run_loop.h" |
10 #include "base/test/test_simple_task_runner.h" | 15 #include "base/test/test_simple_task_runner.h" |
11 #include "base/thread_task_runner_handle.h" | 16 #include "base/thread_task_runner_handle.h" |
12 #include "base/values.h" | 17 #include "base/values.h" |
13 #include "blimp/client/app/blimp_client_switches.h" | 18 #include "blimp/client/app/blimp_client_switches.h" |
14 #include "blimp/common/protocol_version.h" | 19 #include "blimp/common/protocol_version.h" |
| 20 #include "components/safe_json/testing_json_parser.h" |
| 21 #include "net/base/test_data_directory.h" |
15 #include "net/url_request/test_url_fetcher_factory.h" | 22 #include "net/url_request/test_url_fetcher_factory.h" |
16 #include "testing/gmock/include/gmock/gmock.h" | 23 #include "testing/gmock/include/gmock/gmock.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 24 #include "testing/gtest/include/gtest/gtest.h" |
18 | 25 |
19 using testing::_; | 26 using testing::_; |
| 27 using testing::DoAll; |
20 using testing::InSequence; | 28 using testing::InSequence; |
| 29 using testing::NotNull; |
| 30 using testing::Return; |
| 31 using testing::SetArgPointee; |
21 | 32 |
22 namespace blimp { | 33 namespace blimp { |
23 namespace client { | 34 namespace client { |
24 namespace { | 35 namespace { |
25 | 36 |
| 37 const uint8_t kTestIpAddress[] = {127, 0, 0, 1}; |
| 38 const uint16_t kTestPort = 8086; |
| 39 const char kTestIpAddressString[] = "127.0.0.1"; |
| 40 const char kTcpTransportName[] = "tcp"; |
| 41 const char kSslTransportName[] = "ssl"; |
| 42 const char kCertRelativePath[] = |
| 43 "blimp/client/session/test_selfsigned_cert.pem"; |
| 44 const char kTestClientToken[] = "secrett0ken"; |
| 45 const char kTestAuthToken[] = "UserAuthT0kenz"; |
| 46 |
26 MATCHER_P(AssignmentEquals, assignment, "") { | 47 MATCHER_P(AssignmentEquals, assignment, "") { |
27 return arg.transport_protocol == assignment.transport_protocol && | 48 return arg.transport_protocol == assignment.transport_protocol && |
28 arg.ip_endpoint == assignment.ip_endpoint && | 49 arg.engine_endpoint == assignment.engine_endpoint && |
29 arg.client_token == assignment.client_token && | 50 arg.client_token == assignment.client_token && |
30 arg.certificate == assignment.certificate && | 51 ((!assignment.cert && !arg.cert) || |
31 arg.certificate_fingerprint == assignment.certificate_fingerprint; | 52 (arg.cert && assignment.cert && |
| 53 arg.cert->Equals(assignment.cert.get()))); |
32 } | 54 } |
33 | 55 |
34 net::IPEndPoint BuildIPEndPoint(const std::string& ip, int port) { | 56 // Converts |value| to a JSON string. |
35 net::IPAddress ip_address; | 57 std::string ValueToString(const base::Value& value) { |
36 EXPECT_TRUE(ip_address.AssignFromIPLiteral(ip)); | |
37 | |
38 return net::IPEndPoint(ip_address, port); | |
39 } | |
40 | |
41 Assignment BuildValidAssignment() { | |
42 Assignment assignment; | |
43 assignment.transport_protocol = Assignment::TransportProtocol::SSL; | |
44 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); | |
45 assignment.client_token = "SecretT0kenz"; | |
46 assignment.certificate_fingerprint = "WhaleWhaleWhale"; | |
47 assignment.certificate = "whaaaaaaaaaaaaale"; | |
48 return assignment; | |
49 } | |
50 | |
51 std::string BuildResponseFromAssignment(const Assignment& assignment) { | |
52 base::DictionaryValue dict; | |
53 dict.SetString("clientToken", assignment.client_token); | |
54 dict.SetString("host", assignment.ip_endpoint.address().ToString()); | |
55 dict.SetInteger("port", assignment.ip_endpoint.port()); | |
56 dict.SetString("certificateFingerprint", assignment.certificate_fingerprint); | |
57 dict.SetString("certificate", assignment.certificate); | |
58 | |
59 std::string json; | 58 std::string json; |
60 base::JSONWriter::Write(dict, &json); | 59 base::JSONWriter::Write(value, &json); |
61 return json; | 60 return json; |
62 } | 61 } |
63 | 62 |
64 class AssignmentSourceTest : public testing::Test { | 63 class AssignmentSourceTest : public testing::Test { |
65 public: | 64 public: |
66 AssignmentSourceTest() | 65 AssignmentSourceTest() |
67 : task_runner_(new base::TestSimpleTaskRunner), | 66 : source_(message_loop_.task_runner(), message_loop_.task_runner()) {} |
68 task_runner_handle_(task_runner_), | 67 |
69 source_(task_runner_, task_runner_) {} | 68 void SetUp() override { |
| 69 base::FilePath src_root; |
| 70 PathService::Get(base::DIR_SOURCE_ROOT, &src_root); |
| 71 ASSERT_FALSE(src_root.empty()); |
| 72 cert_path_ = src_root.Append(kCertRelativePath); |
| 73 ASSERT_TRUE(base::ReadFileToString(cert_path_, &cert_pem_)); |
| 74 net::CertificateList cert_list = |
| 75 net::X509Certificate::CreateCertificateListFromBytes( |
| 76 cert_pem_.data(), cert_pem_.size(), |
| 77 net::X509Certificate::FORMAT_PEM_CERT_SEQUENCE); |
| 78 ASSERT_FALSE(cert_list.empty()); |
| 79 cert_ = std::move(cert_list[0]); |
| 80 ASSERT_TRUE(cert_); |
| 81 } |
70 | 82 |
71 // This expects the AssignmentSource::GetAssignment to return a custom | 83 // This expects the AssignmentSource::GetAssignment to return a custom |
72 // endpoint without having to hit the network. This will typically be used | 84 // endpoint without having to hit the network. This will typically be used |
73 // for testing that specifying an assignment via the command line works as | 85 // for testing that specifying an assignment via the command line works as |
74 // expected. | 86 // expected. |
75 void GetAlternateAssignment() { | 87 void GetAlternateAssignment() { |
76 source_.GetAssignment("", | 88 source_.GetAssignment("", |
77 base::Bind(&AssignmentSourceTest::AssignmentResponse, | 89 base::Bind(&AssignmentSourceTest::AssignmentResponse, |
78 base::Unretained(this))); | 90 base::Unretained(this))); |
79 EXPECT_EQ(nullptr, factory_.GetFetcherByID(0)); | 91 EXPECT_EQ(nullptr, factory_.GetFetcherByID(0)); |
80 task_runner_->RunUntilIdle(); | 92 base::RunLoop().RunUntilIdle(); |
81 } | 93 } |
82 | 94 |
83 // See net/base/net_errors.h for possible status errors. | 95 // See net/base/net_errors.h for possible status errors. |
84 void GetNetworkAssignmentAndWaitForResponse( | 96 void GetNetworkAssignmentAndWaitForResponse( |
85 net::HttpStatusCode response_code, | 97 net::HttpStatusCode response_code, |
86 int status, | 98 int status, |
87 const std::string& response, | 99 const std::string& response, |
88 const std::string& client_auth_token, | 100 const std::string& client_auth_token, |
89 const std::string& protocol_version) { | 101 const std::string& protocol_version) { |
90 source_.GetAssignment(client_auth_token, | 102 source_.GetAssignment(client_auth_token, |
91 base::Bind(&AssignmentSourceTest::AssignmentResponse, | 103 base::Bind(&AssignmentSourceTest::AssignmentResponse, |
92 base::Unretained(this))); | 104 base::Unretained(this))); |
| 105 base::RunLoop().RunUntilIdle(); |
93 | 106 |
94 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); | 107 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); |
95 | 108 |
96 task_runner_->RunUntilIdle(); | |
97 | |
98 EXPECT_NE(nullptr, fetcher); | 109 EXPECT_NE(nullptr, fetcher); |
99 EXPECT_EQ(kDefaultAssignerURL, fetcher->GetOriginalURL().spec()); | 110 EXPECT_EQ(kDefaultAssignerURL, fetcher->GetOriginalURL().spec()); |
100 | 111 |
101 // Check that the request has a valid protocol_version. | 112 // Check that the request has a valid protocol_version. |
102 scoped_ptr<base::Value> json = | 113 scoped_ptr<base::Value> json = |
103 base::JSONReader::Read(fetcher->upload_data()); | 114 base::JSONReader::Read(fetcher->upload_data()); |
104 EXPECT_NE(nullptr, json.get()); | 115 EXPECT_NE(nullptr, json.get()); |
105 | 116 |
106 const base::DictionaryValue* dict; | 117 const base::DictionaryValue* dict; |
107 EXPECT_TRUE(json->GetAsDictionary(&dict)); | 118 EXPECT_TRUE(json->GetAsDictionary(&dict)); |
(...skipping 10 matching lines...) Expand all Loading... |
118 std::string authorization; | 129 std::string authorization; |
119 EXPECT_TRUE(headers.GetHeader("Authorization", &authorization)); | 130 EXPECT_TRUE(headers.GetHeader("Authorization", &authorization)); |
120 EXPECT_EQ("Bearer " + client_auth_token, authorization); | 131 EXPECT_EQ("Bearer " + client_auth_token, authorization); |
121 | 132 |
122 // Send the fake response back. | 133 // Send the fake response back. |
123 fetcher->set_response_code(response_code); | 134 fetcher->set_response_code(response_code); |
124 fetcher->set_status(net::URLRequestStatus::FromError(status)); | 135 fetcher->set_status(net::URLRequestStatus::FromError(status)); |
125 fetcher->SetResponseString(response); | 136 fetcher->SetResponseString(response); |
126 fetcher->delegate()->OnURLFetchComplete(fetcher); | 137 fetcher->delegate()->OnURLFetchComplete(fetcher); |
127 | 138 |
128 task_runner_->RunUntilIdle(); | 139 base::RunLoop().RunUntilIdle(); |
129 } | 140 } |
130 | 141 |
131 MOCK_METHOD2(AssignmentResponse, | 142 MOCK_METHOD2(AssignmentResponse, |
132 void(AssignmentSource::Result, const Assignment&)); | 143 void(AssignmentSource::Result, const Assignment&)); |
133 | 144 |
134 protected: | 145 protected: |
| 146 Assignment BuildSslAssignment(); |
| 147 |
| 148 // Builds simulated JSON response from the Assigner service. |
| 149 scoped_ptr<base::DictionaryValue> BuildAssignerResponse(); |
| 150 |
135 // Used to drive all AssignmentSource tasks. | 151 // Used to drive all AssignmentSource tasks. |
136 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | 152 // MessageLoop is required by TestingJsonParser's self-deletion logic. |
137 base::ThreadTaskRunnerHandle task_runner_handle_; | 153 // TODO(bauerb): Replace this with a TestSimpleTaskRunner once |
| 154 // TestingJsonParser no longer requires having a MessageLoop. |
| 155 base::MessageLoop message_loop_; |
138 | 156 |
139 net::TestURLFetcherFactory factory_; | 157 net::TestURLFetcherFactory factory_; |
140 | 158 |
| 159 // Path to the PEM-encoded certificate chain. |
| 160 base::FilePath cert_path_; |
| 161 |
| 162 // Payload of PEM certificate chain at |cert_path_|. |
| 163 std::string cert_pem_; |
| 164 |
| 165 // X509 certificate decoded from |cert_path_|. |
| 166 scoped_refptr<net::X509Certificate> cert_; |
| 167 |
141 AssignmentSource source_; | 168 AssignmentSource source_; |
| 169 |
| 170 // Allows safe_json to parse JSON in-process, instead of depending on a |
| 171 // utility proces. |
| 172 safe_json::TestingJsonParser::ScopedFactoryOverride json_parsing_factory_; |
142 }; | 173 }; |
143 | 174 |
| 175 Assignment AssignmentSourceTest::BuildSslAssignment() { |
| 176 Assignment assignment; |
| 177 assignment.transport_protocol = Assignment::TransportProtocol::SSL; |
| 178 assignment.engine_endpoint = net::IPEndPoint(kTestIpAddress, kTestPort); |
| 179 assignment.client_token = kTestClientToken; |
| 180 assignment.cert = cert_; |
| 181 return assignment; |
| 182 } |
| 183 |
| 184 scoped_ptr<base::DictionaryValue> |
| 185 AssignmentSourceTest::BuildAssignerResponse() { |
| 186 scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue); |
| 187 dict->SetString("clientToken", kTestClientToken); |
| 188 dict->SetString("host", kTestIpAddressString); |
| 189 dict->SetInteger("port", kTestPort); |
| 190 dict->SetString("certificate", cert_pem_); |
| 191 return dict; |
| 192 } |
| 193 |
144 TEST_F(AssignmentSourceTest, TestTCPAlternateEndpointSuccess) { | 194 TEST_F(AssignmentSourceTest, TestTCPAlternateEndpointSuccess) { |
145 Assignment assignment; | 195 Assignment assignment; |
146 assignment.transport_protocol = Assignment::TransportProtocol::TCP; | 196 assignment.transport_protocol = Assignment::TransportProtocol::TCP; |
147 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); | 197 assignment.engine_endpoint = net::IPEndPoint(kTestIpAddress, kTestPort); |
148 assignment.client_token = kDummyClientToken; | 198 assignment.client_token = kDummyClientToken; |
| 199 assignment.cert = scoped_refptr<net::X509Certificate>(nullptr); |
149 | 200 |
150 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 201 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
151 switches::kBlimpletEndpoint, "tcp:100.150.200.250:500"); | 202 switches::kEngineIP, kTestIpAddressString); |
| 203 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| 204 switches::kEnginePort, std::to_string(kTestPort)); |
| 205 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| 206 switches::kEngineTransport, kTcpTransportName); |
152 | 207 |
153 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | 208 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
154 AssignmentEquals(assignment))) | 209 AssignmentEquals(assignment))) |
155 .Times(1); | 210 .Times(1); |
156 | 211 |
157 GetAlternateAssignment(); | 212 GetAlternateAssignment(); |
158 } | 213 } |
159 | 214 |
160 TEST_F(AssignmentSourceTest, TestSSLAlternateEndpointSuccess) { | 215 TEST_F(AssignmentSourceTest, TestSSLAlternateEndpointSuccess) { |
161 Assignment assignment; | 216 Assignment assignment; |
162 assignment.transport_protocol = Assignment::TransportProtocol::SSL; | 217 assignment.transport_protocol = Assignment::TransportProtocol::SSL; |
163 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); | 218 assignment.engine_endpoint = net::IPEndPoint(kTestIpAddress, kTestPort); |
164 assignment.client_token = kDummyClientToken; | 219 assignment.client_token = kDummyClientToken; |
| 220 assignment.cert = cert_; |
165 | 221 |
166 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 222 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
167 switches::kBlimpletEndpoint, "ssl:100.150.200.250:500"); | 223 switches::kEngineIP, kTestIpAddressString); |
| 224 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| 225 switches::kEnginePort, std::to_string(kTestPort)); |
| 226 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| 227 switches::kEngineTransport, kSslTransportName); |
| 228 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| 229 switches::kEngineCertPath, cert_path_.value()); |
168 | 230 |
169 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | 231 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
170 AssignmentEquals(assignment))) | 232 AssignmentEquals(assignment))) |
171 .Times(1); | |
172 | |
173 GetAlternateAssignment(); | |
174 } | |
175 | |
176 TEST_F(AssignmentSourceTest, TestQUICAlternateEndpointSuccess) { | |
177 Assignment assignment; | |
178 assignment.transport_protocol = Assignment::TransportProtocol::QUIC; | |
179 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); | |
180 assignment.client_token = kDummyClientToken; | |
181 | |
182 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | |
183 switches::kBlimpletEndpoint, "quic:100.150.200.250:500"); | |
184 | |
185 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | |
186 AssignmentEquals(assignment))) | |
187 .Times(1); | 233 .Times(1); |
188 | 234 |
189 GetAlternateAssignment(); | 235 GetAlternateAssignment(); |
190 } | 236 } |
191 | 237 |
192 TEST_F(AssignmentSourceTest, TestSuccess) { | 238 TEST_F(AssignmentSourceTest, TestSuccess) { |
193 Assignment assignment = BuildValidAssignment(); | 239 Assignment assignment = BuildSslAssignment(); |
194 | 240 |
195 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | 241 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
196 AssignmentEquals(assignment))) | 242 AssignmentEquals(assignment))) |
197 .Times(1); | 243 .Times(1); |
198 | 244 |
199 GetNetworkAssignmentAndWaitForResponse( | 245 GetNetworkAssignmentAndWaitForResponse( |
200 net::HTTP_OK, net::Error::OK, BuildResponseFromAssignment(assignment), | 246 net::HTTP_OK, net::Error::OK, ValueToString(*BuildAssignerResponse()), |
201 "UserAuthT0kenz", kEngineVersion); | 247 kTestAuthToken, kEngineVersion); |
202 } | |
203 | |
204 TEST_F(AssignmentSourceTest, TestSecondRequestInterruptsFirst) { | |
205 InSequence sequence; | |
206 Assignment assignment = BuildValidAssignment(); | |
207 | |
208 source_.GetAssignment("", | |
209 base::Bind(&AssignmentSourceTest::AssignmentResponse, | |
210 base::Unretained(this))); | |
211 | |
212 EXPECT_CALL(*this, AssignmentResponse( | |
213 AssignmentSource::Result::RESULT_SERVER_INTERRUPTED, | |
214 AssignmentEquals(Assignment()))) | |
215 .Times(1) | |
216 .RetiresOnSaturation(); | |
217 | |
218 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | |
219 AssignmentEquals(assignment))) | |
220 .Times(1) | |
221 .RetiresOnSaturation(); | |
222 | |
223 GetNetworkAssignmentAndWaitForResponse( | |
224 net::HTTP_OK, net::Error::OK, BuildResponseFromAssignment(assignment), | |
225 "UserAuthT0kenz", kEngineVersion); | |
226 } | 248 } |
227 | 249 |
228 TEST_F(AssignmentSourceTest, TestValidAfterError) { | 250 TEST_F(AssignmentSourceTest, TestValidAfterError) { |
229 InSequence sequence; | 251 InSequence sequence; |
230 Assignment assignment = BuildValidAssignment(); | 252 Assignment assignment = BuildSslAssignment(); |
231 | 253 |
232 EXPECT_CALL(*this, AssignmentResponse( | 254 EXPECT_CALL(*this, AssignmentResponse( |
233 AssignmentSource::Result::RESULT_NETWORK_FAILURE, _)) | 255 AssignmentSource::Result::RESULT_NETWORK_FAILURE, _)) |
234 .Times(1) | 256 .Times(1) |
235 .RetiresOnSaturation(); | 257 .RetiresOnSaturation(); |
236 | 258 |
237 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | 259 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
238 AssignmentEquals(assignment))) | 260 AssignmentEquals(assignment))) |
239 .Times(1) | 261 .Times(1) |
240 .RetiresOnSaturation(); | 262 .RetiresOnSaturation(); |
241 | 263 |
242 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, | 264 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, |
243 net::Error::ERR_INSUFFICIENT_RESOURCES, | 265 net::Error::ERR_INSUFFICIENT_RESOURCES, |
244 "", "UserAuthT0kenz", kEngineVersion); | 266 "", kTestAuthToken, kEngineVersion); |
245 | 267 |
246 GetNetworkAssignmentAndWaitForResponse( | 268 GetNetworkAssignmentAndWaitForResponse( |
247 net::HTTP_OK, net::Error::OK, BuildResponseFromAssignment(assignment), | 269 net::HTTP_OK, net::Error::OK, ValueToString(*BuildAssignerResponse()), |
248 "UserAuthT0kenz", kEngineVersion); | 270 kTestAuthToken, kEngineVersion); |
249 } | 271 } |
250 | 272 |
251 TEST_F(AssignmentSourceTest, TestNetworkFailure) { | 273 TEST_F(AssignmentSourceTest, TestNetworkFailure) { |
252 EXPECT_CALL(*this, AssignmentResponse( | 274 EXPECT_CALL(*this, AssignmentResponse( |
253 AssignmentSource::Result::RESULT_NETWORK_FAILURE, _)); | 275 AssignmentSource::Result::RESULT_NETWORK_FAILURE, _)); |
254 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, | 276 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, |
255 net::Error::ERR_INSUFFICIENT_RESOURCES, | 277 net::Error::ERR_INSUFFICIENT_RESOURCES, |
256 "", "UserAuthT0kenz", kEngineVersion); | 278 "", kTestAuthToken, kEngineVersion); |
257 } | 279 } |
258 | 280 |
259 TEST_F(AssignmentSourceTest, TestBadRequest) { | 281 TEST_F(AssignmentSourceTest, TestBadRequest) { |
260 EXPECT_CALL(*this, AssignmentResponse( | 282 EXPECT_CALL(*this, AssignmentResponse( |
261 AssignmentSource::Result::RESULT_BAD_REQUEST, _)); | 283 AssignmentSource::Result::RESULT_BAD_REQUEST, _)); |
262 GetNetworkAssignmentAndWaitForResponse(net::HTTP_BAD_REQUEST, net::Error::OK, | 284 GetNetworkAssignmentAndWaitForResponse(net::HTTP_BAD_REQUEST, net::Error::OK, |
263 "", "UserAuthT0kenz", kEngineVersion); | 285 "", kTestAuthToken, kEngineVersion); |
264 } | 286 } |
265 | 287 |
266 TEST_F(AssignmentSourceTest, TestUnauthorized) { | 288 TEST_F(AssignmentSourceTest, TestUnauthorized) { |
267 EXPECT_CALL(*this, | 289 EXPECT_CALL(*this, |
268 AssignmentResponse( | 290 AssignmentResponse( |
269 AssignmentSource::Result::RESULT_EXPIRED_ACCESS_TOKEN, _)); | 291 AssignmentSource::Result::RESULT_EXPIRED_ACCESS_TOKEN, _)); |
270 GetNetworkAssignmentAndWaitForResponse(net::HTTP_UNAUTHORIZED, net::Error::OK, | 292 GetNetworkAssignmentAndWaitForResponse(net::HTTP_UNAUTHORIZED, net::Error::OK, |
271 "", "UserAuthT0kenz", kEngineVersion); | 293 "", kTestAuthToken, kEngineVersion); |
272 } | 294 } |
273 | 295 |
274 TEST_F(AssignmentSourceTest, TestForbidden) { | 296 TEST_F(AssignmentSourceTest, TestForbidden) { |
275 EXPECT_CALL(*this, AssignmentResponse( | 297 EXPECT_CALL(*this, AssignmentResponse( |
276 AssignmentSource::Result::RESULT_USER_INVALID, _)); | 298 AssignmentSource::Result::RESULT_USER_INVALID, _)); |
277 GetNetworkAssignmentAndWaitForResponse(net::HTTP_FORBIDDEN, net::Error::OK, | 299 GetNetworkAssignmentAndWaitForResponse(net::HTTP_FORBIDDEN, net::Error::OK, |
278 "", "UserAuthT0kenz", kEngineVersion); | 300 "", kTestAuthToken, kEngineVersion); |
279 } | 301 } |
280 | 302 |
281 TEST_F(AssignmentSourceTest, TestTooManyRequests) { | 303 TEST_F(AssignmentSourceTest, TestTooManyRequests) { |
282 EXPECT_CALL(*this, AssignmentResponse( | 304 EXPECT_CALL(*this, AssignmentResponse( |
283 AssignmentSource::Result::RESULT_OUT_OF_VMS, _)); | 305 AssignmentSource::Result::RESULT_OUT_OF_VMS, _)); |
284 GetNetworkAssignmentAndWaitForResponse(static_cast<net::HttpStatusCode>(429), | 306 GetNetworkAssignmentAndWaitForResponse(static_cast<net::HttpStatusCode>(429), |
285 net::Error::OK, "", "UserAuthT0kenz", | 307 net::Error::OK, "", kTestAuthToken, |
286 kEngineVersion); | 308 kEngineVersion); |
287 } | 309 } |
288 | 310 |
289 TEST_F(AssignmentSourceTest, TestInternalServerError) { | 311 TEST_F(AssignmentSourceTest, TestInternalServerError) { |
290 EXPECT_CALL(*this, AssignmentResponse( | 312 EXPECT_CALL(*this, AssignmentResponse( |
291 AssignmentSource::Result::RESULT_SERVER_ERROR, _)); | 313 AssignmentSource::Result::RESULT_SERVER_ERROR, _)); |
292 GetNetworkAssignmentAndWaitForResponse(net::HTTP_INTERNAL_SERVER_ERROR, | 314 GetNetworkAssignmentAndWaitForResponse(net::HTTP_INTERNAL_SERVER_ERROR, |
293 net::Error::OK, "", "UserAuthT0kenz", | 315 net::Error::OK, "", kTestAuthToken, |
294 kEngineVersion); | 316 kEngineVersion); |
295 } | 317 } |
296 | 318 |
297 TEST_F(AssignmentSourceTest, TestUnexpectedNetCodeFallback) { | 319 TEST_F(AssignmentSourceTest, TestUnexpectedNetCodeFallback) { |
298 EXPECT_CALL(*this, AssignmentResponse( | 320 EXPECT_CALL(*this, AssignmentResponse( |
299 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); | 321 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
300 GetNetworkAssignmentAndWaitForResponse(net::HTTP_NOT_IMPLEMENTED, | 322 GetNetworkAssignmentAndWaitForResponse(net::HTTP_NOT_IMPLEMENTED, |
301 net::Error::OK, "", "UserAuthT0kenz", | 323 net::Error::OK, "", kTestAuthToken, |
302 kEngineVersion); | 324 kEngineVersion); |
303 } | 325 } |
304 | 326 |
305 TEST_F(AssignmentSourceTest, TestInvalidJsonResponse) { | 327 TEST_F(AssignmentSourceTest, TestInvalidJsonResponse) { |
306 Assignment assignment = BuildValidAssignment(); | 328 Assignment assignment = BuildSslAssignment(); |
307 | 329 |
308 // Remove half the response. | 330 // Remove half the response. |
309 std::string response = BuildResponseFromAssignment(assignment); | 331 std::string response = ValueToString(*BuildAssignerResponse()); |
310 response = response.substr(response.size() / 2); | 332 response = response.substr(response.size() / 2); |
311 | 333 |
312 EXPECT_CALL(*this, AssignmentResponse( | 334 EXPECT_CALL(*this, AssignmentResponse( |
313 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); | 335 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
314 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, | 336 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, |
315 "UserAuthT0kenz", kEngineVersion); | 337 kTestAuthToken, kEngineVersion); |
316 } | 338 } |
317 | 339 |
318 TEST_F(AssignmentSourceTest, TestMissingResponsePort) { | 340 TEST_F(AssignmentSourceTest, TestMissingResponsePort) { |
319 // Purposely do not add the 'port' field to the response. | 341 scoped_ptr<base::DictionaryValue> response = BuildAssignerResponse(); |
320 base::DictionaryValue dict; | 342 response->Remove("port", nullptr); |
321 dict.SetString("clientToken", "SecretT0kenz"); | 343 EXPECT_CALL(*this, AssignmentResponse( |
322 dict.SetString("host", "happywhales"); | 344 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
323 dict.SetString("certificateFingerprint", "WhaleWhaleWhale"); | 345 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, |
324 dict.SetString("certificate", "whaaaaaaaaaaaaale"); | 346 ValueToString(*response), |
| 347 kTestAuthToken, kEngineVersion); |
| 348 } |
325 | 349 |
326 std::string response; | 350 TEST_F(AssignmentSourceTest, TestInvalidIPAddress) { |
327 base::JSONWriter::Write(dict, &response); | 351 scoped_ptr<base::DictionaryValue> response = BuildAssignerResponse(); |
| 352 response->SetString("host", "happywhales.test"); |
328 | 353 |
329 EXPECT_CALL(*this, AssignmentResponse( | 354 EXPECT_CALL(*this, AssignmentResponse( |
330 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); | 355 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
331 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, | 356 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, |
332 "UserAuthT0kenz", kEngineVersion); | 357 ValueToString(*response), |
| 358 kTestAuthToken, kEngineVersion); |
333 } | 359 } |
334 | 360 |
335 TEST_F(AssignmentSourceTest, TestInvalidIPAddress) { | 361 TEST_F(AssignmentSourceTest, TestMissingCert) { |
336 // Purposely add an invalid IP field to the response. | 362 scoped_ptr<base::DictionaryValue> response = BuildAssignerResponse(); |
337 base::DictionaryValue dict; | 363 response->Remove("certificate", nullptr); |
338 dict.SetString("clientToken", "SecretT0kenz"); | |
339 dict.SetString("host", "happywhales"); | |
340 dict.SetInteger("port", 500); | |
341 dict.SetString("certificateFingerprint", "WhaleWhaleWhale"); | |
342 dict.SetString("certificate", "whaaaaaaaaaaaaale"); | |
343 | |
344 std::string response; | |
345 base::JSONWriter::Write(dict, &response); | |
346 | |
347 EXPECT_CALL(*this, AssignmentResponse( | 364 EXPECT_CALL(*this, AssignmentResponse( |
348 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); | 365 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
349 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, | 366 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, |
350 "UserAuthT0kenz", kEngineVersion); | 367 ValueToString(*response), |
| 368 kTestAuthToken, kEngineVersion); |
| 369 } |
| 370 |
| 371 TEST_F(AssignmentSourceTest, TestInvalidCert) { |
| 372 scoped_ptr<base::DictionaryValue> response = BuildAssignerResponse(); |
| 373 response->SetString("certificate", "h4x0rz!"); |
| 374 EXPECT_CALL(*this, AssignmentResponse( |
| 375 AssignmentSource::Result::RESULT_INVALID_CERT, _)); |
| 376 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, |
| 377 ValueToString(*response), |
| 378 kTestAuthToken, kEngineVersion); |
351 } | 379 } |
352 | 380 |
353 } // namespace | 381 } // namespace |
354 } // namespace client | 382 } // namespace client |
355 } // namespace blimp | 383 } // namespace blimp |
OLD | NEW |