OLD | NEW |
(Empty) | |
| 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 |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "blimp/client/session/assignment_source.h" |
| 6 |
| 7 #include "base/command_line.h" |
| 8 #include "base/json/json_reader.h" |
| 9 #include "base/json/json_writer.h" |
| 10 #include "base/test/test_simple_task_runner.h" |
| 11 #include "base/thread_task_runner_handle.h" |
| 12 #include "base/values.h" |
| 13 #include "blimp/client/app/blimp_client_switches.h" |
| 14 #include "blimp/common/protocol_version.h" |
| 15 #include "net/url_request/test_url_fetcher_factory.h" |
| 16 #include "testing/gmock/include/gmock/gmock.h" |
| 17 #include "testing/gtest/include/gtest/gtest.h" |
| 18 |
| 19 using testing::_; |
| 20 using testing::InSequence; |
| 21 |
| 22 namespace blimp { |
| 23 namespace client { |
| 24 namespace { |
| 25 |
| 26 MATCHER_P(AssignmentEquals, assignment, "") { |
| 27 return arg.transport_protocol == assignment.transport_protocol && |
| 28 arg.ip_endpoint == assignment.ip_endpoint && |
| 29 arg.client_token == assignment.client_token && |
| 30 arg.certificate == assignment.certificate && |
| 31 arg.certificate_fingerprint == assignment.certificate_fingerprint; |
| 32 } |
| 33 |
| 34 net::IPEndPoint BuildIPEndPoint(const std::string& ip, int port) { |
| 35 net::IPAddress ip_address; |
| 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; |
| 60 base::JSONWriter::Write(dict, &json); |
| 61 return json; |
| 62 } |
| 63 |
| 64 class AssignmentSourceTest : public testing::Test { |
| 65 public: |
| 66 AssignmentSourceTest() |
| 67 : task_runner_(new base::TestSimpleTaskRunner), |
| 68 task_runner_handle_(task_runner_), |
| 69 source_(task_runner_, task_runner_) {} |
| 70 |
| 71 // This expects the AssignmentSource::GetAssignment to return a custom |
| 72 // 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 |
| 74 // expected. |
| 75 void GetAlternateAssignment() { |
| 76 source_.GetAssignment("", |
| 77 base::Bind(&AssignmentSourceTest::AssignmentResponse, |
| 78 base::Unretained(this))); |
| 79 EXPECT_EQ(nullptr, factory_.GetFetcherByID(0)); |
| 80 task_runner_->RunUntilIdle(); |
| 81 } |
| 82 |
| 83 // See net/base/net_errors.h for possible status errors. |
| 84 void GetNetworkAssignmentAndWaitForResponse( |
| 85 net::HttpStatusCode response_code, |
| 86 int status, |
| 87 const std::string& response, |
| 88 const std::string& client_auth_token, |
| 89 const std::string& protocol_version) { |
| 90 source_.GetAssignment(client_auth_token, |
| 91 base::Bind(&AssignmentSourceTest::AssignmentResponse, |
| 92 base::Unretained(this))); |
| 93 |
| 94 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); |
| 95 |
| 96 task_runner_->RunUntilIdle(); |
| 97 |
| 98 EXPECT_NE(nullptr, fetcher); |
| 99 EXPECT_EQ(kDefaultAssignerURL, fetcher->GetOriginalURL().spec()); |
| 100 |
| 101 // Check that the request has a valid protocol_version. |
| 102 scoped_ptr<base::Value> json = |
| 103 base::JSONReader::Read(fetcher->upload_data()); |
| 104 EXPECT_NE(nullptr, json.get()); |
| 105 |
| 106 const base::DictionaryValue* dict; |
| 107 EXPECT_TRUE(json->GetAsDictionary(&dict)); |
| 108 |
| 109 std::string uploaded_protocol_version; |
| 110 EXPECT_TRUE( |
| 111 dict->GetString("protocol_version", &uploaded_protocol_version)); |
| 112 EXPECT_EQ(protocol_version, uploaded_protocol_version); |
| 113 |
| 114 // Check that the request has a valid authentication header. |
| 115 net::HttpRequestHeaders headers; |
| 116 fetcher->GetExtraRequestHeaders(&headers); |
| 117 |
| 118 std::string authorization; |
| 119 EXPECT_TRUE(headers.GetHeader("Authorization", &authorization)); |
| 120 EXPECT_EQ("Bearer " + client_auth_token, authorization); |
| 121 |
| 122 // Send the fake response back. |
| 123 fetcher->set_response_code(response_code); |
| 124 fetcher->set_status(net::URLRequestStatus::FromError(status)); |
| 125 fetcher->SetResponseString(response); |
| 126 fetcher->delegate()->OnURLFetchComplete(fetcher); |
| 127 |
| 128 task_runner_->RunUntilIdle(); |
| 129 } |
| 130 |
| 131 MOCK_METHOD2(AssignmentResponse, |
| 132 void(AssignmentSource::Result, const Assignment&)); |
| 133 |
| 134 protected: |
| 135 // Used to drive all AssignmentSource tasks. |
| 136 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; |
| 137 base::ThreadTaskRunnerHandle task_runner_handle_; |
| 138 |
| 139 net::TestURLFetcherFactory factory_; |
| 140 |
| 141 AssignmentSource source_; |
| 142 }; |
| 143 |
| 144 TEST_F(AssignmentSourceTest, TestTCPAlternateEndpointSuccess) { |
| 145 Assignment assignment; |
| 146 assignment.transport_protocol = Assignment::TransportProtocol::TCP; |
| 147 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); |
| 148 assignment.client_token = kDummyClientToken; |
| 149 |
| 150 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| 151 switches::kBlimpletEndpoint, "tcp:100.150.200.250:500"); |
| 152 |
| 153 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
| 154 AssignmentEquals(assignment))) |
| 155 .Times(1); |
| 156 |
| 157 GetAlternateAssignment(); |
| 158 } |
| 159 |
| 160 TEST_F(AssignmentSourceTest, TestSSLAlternateEndpointSuccess) { |
| 161 Assignment assignment; |
| 162 assignment.transport_protocol = Assignment::TransportProtocol::SSL; |
| 163 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); |
| 164 assignment.client_token = kDummyClientToken; |
| 165 |
| 166 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| 167 switches::kBlimpletEndpoint, "ssl:100.150.200.250:500"); |
| 168 |
| 169 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
| 170 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); |
| 188 |
| 189 GetAlternateAssignment(); |
| 190 } |
| 191 |
| 192 TEST_F(AssignmentSourceTest, TestSuccess) { |
| 193 Assignment assignment = BuildValidAssignment(); |
| 194 |
| 195 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
| 196 AssignmentEquals(assignment))) |
| 197 .Times(1); |
| 198 |
| 199 GetNetworkAssignmentAndWaitForResponse( |
| 200 net::HTTP_OK, net::Error::OK, BuildResponseFromAssignment(assignment), |
| 201 "UserAuthT0kenz", 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 } |
| 227 |
| 228 TEST_F(AssignmentSourceTest, TestValidAfterError) { |
| 229 InSequence sequence; |
| 230 Assignment assignment = BuildValidAssignment(); |
| 231 |
| 232 EXPECT_CALL(*this, AssignmentResponse( |
| 233 AssignmentSource::Result::RESULT_NETWORK_FAILURE, _)) |
| 234 .Times(1) |
| 235 .RetiresOnSaturation(); |
| 236 |
| 237 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
| 238 AssignmentEquals(assignment))) |
| 239 .Times(1) |
| 240 .RetiresOnSaturation(); |
| 241 |
| 242 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, |
| 243 net::Error::ERR_INSUFFICIENT_RESOURCES, |
| 244 "", "UserAuthT0kenz", kEngineVersion); |
| 245 |
| 246 GetNetworkAssignmentAndWaitForResponse( |
| 247 net::HTTP_OK, net::Error::OK, BuildResponseFromAssignment(assignment), |
| 248 "UserAuthT0kenz", kEngineVersion); |
| 249 } |
| 250 |
| 251 TEST_F(AssignmentSourceTest, TestNetworkFailure) { |
| 252 EXPECT_CALL(*this, AssignmentResponse( |
| 253 AssignmentSource::Result::RESULT_NETWORK_FAILURE, _)); |
| 254 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, |
| 255 net::Error::ERR_INSUFFICIENT_RESOURCES, |
| 256 "", "UserAuthT0kenz", kEngineVersion); |
| 257 } |
| 258 |
| 259 TEST_F(AssignmentSourceTest, TestBadRequest) { |
| 260 EXPECT_CALL(*this, AssignmentResponse( |
| 261 AssignmentSource::Result::RESULT_BAD_REQUEST, _)); |
| 262 GetNetworkAssignmentAndWaitForResponse(net::HTTP_BAD_REQUEST, net::Error::OK, |
| 263 "", "UserAuthT0kenz", kEngineVersion); |
| 264 } |
| 265 |
| 266 TEST_F(AssignmentSourceTest, TestUnauthorized) { |
| 267 EXPECT_CALL(*this, |
| 268 AssignmentResponse( |
| 269 AssignmentSource::Result::RESULT_EXPIRED_ACCESS_TOKEN, _)); |
| 270 GetNetworkAssignmentAndWaitForResponse(net::HTTP_UNAUTHORIZED, net::Error::OK, |
| 271 "", "UserAuthT0kenz", kEngineVersion); |
| 272 } |
| 273 |
| 274 TEST_F(AssignmentSourceTest, TestForbidden) { |
| 275 EXPECT_CALL(*this, AssignmentResponse( |
| 276 AssignmentSource::Result::RESULT_USER_INVALID, _)); |
| 277 GetNetworkAssignmentAndWaitForResponse(net::HTTP_FORBIDDEN, net::Error::OK, |
| 278 "", "UserAuthT0kenz", kEngineVersion); |
| 279 } |
| 280 |
| 281 TEST_F(AssignmentSourceTest, TestTooManyRequests) { |
| 282 EXPECT_CALL(*this, AssignmentResponse( |
| 283 AssignmentSource::Result::RESULT_OUT_OF_VMS, _)); |
| 284 GetNetworkAssignmentAndWaitForResponse(static_cast<net::HttpStatusCode>(429), |
| 285 net::Error::OK, "", "UserAuthT0kenz", |
| 286 kEngineVersion); |
| 287 } |
| 288 |
| 289 TEST_F(AssignmentSourceTest, TestInternalServerError) { |
| 290 EXPECT_CALL(*this, AssignmentResponse( |
| 291 AssignmentSource::Result::RESULT_SERVER_ERROR, _)); |
| 292 GetNetworkAssignmentAndWaitForResponse(net::HTTP_INTERNAL_SERVER_ERROR, |
| 293 net::Error::OK, "", "UserAuthT0kenz", |
| 294 kEngineVersion); |
| 295 } |
| 296 |
| 297 TEST_F(AssignmentSourceTest, TestUnexpectedNetCodeFallback) { |
| 298 EXPECT_CALL(*this, AssignmentResponse( |
| 299 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
| 300 GetNetworkAssignmentAndWaitForResponse(net::HTTP_NOT_IMPLEMENTED, |
| 301 net::Error::OK, "", "UserAuthT0kenz", |
| 302 kEngineVersion); |
| 303 } |
| 304 |
| 305 TEST_F(AssignmentSourceTest, TestInvalidJsonResponse) { |
| 306 Assignment assignment = BuildValidAssignment(); |
| 307 |
| 308 // Remove half the response. |
| 309 std::string response = BuildResponseFromAssignment(assignment); |
| 310 response = response.substr(response.size() / 2); |
| 311 |
| 312 EXPECT_CALL(*this, AssignmentResponse( |
| 313 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
| 314 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, |
| 315 "UserAuthT0kenz", kEngineVersion); |
| 316 } |
| 317 |
| 318 TEST_F(AssignmentSourceTest, TestMissingResponsePort) { |
| 319 // Purposely do not add the 'port' field to the response. |
| 320 base::DictionaryValue dict; |
| 321 dict.SetString("clientToken", "SecretT0kenz"); |
| 322 dict.SetString("host", "happywhales"); |
| 323 dict.SetString("certificateFingerprint", "WhaleWhaleWhale"); |
| 324 dict.SetString("certificate", "whaaaaaaaaaaaaale"); |
| 325 |
| 326 std::string response; |
| 327 base::JSONWriter::Write(dict, &response); |
| 328 |
| 329 EXPECT_CALL(*this, AssignmentResponse( |
| 330 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
| 331 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, |
| 332 "UserAuthT0kenz", kEngineVersion); |
| 333 } |
| 334 |
| 335 TEST_F(AssignmentSourceTest, TestInvalidIPAddress) { |
| 336 // Purposely add an invalid IP field to the response. |
| 337 base::DictionaryValue dict; |
| 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( |
| 348 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
| 349 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, |
| 350 "UserAuthT0kenz", kEngineVersion); |
| 351 } |
| 352 |
| 353 } // namespace |
| 354 } // namespace client |
| 355 } // namespace blimp |
OLD | NEW |