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" | |
8 #include "base/json/json_reader.h" | 9 #include "base/json/json_reader.h" |
9 #include "base/json/json_writer.h" | 10 #include "base/json/json_writer.h" |
10 #include "base/test/test_simple_task_runner.h" | 11 #include "base/test/test_simple_task_runner.h" |
11 #include "base/thread_task_runner_handle.h" | 12 #include "base/thread_task_runner_handle.h" |
12 #include "base/values.h" | 13 #include "base/values.h" |
13 #include "blimp/client/app/blimp_client_switches.h" | 14 #include "blimp/client/app/blimp_client_switches.h" |
14 #include "blimp/common/protocol_version.h" | 15 #include "blimp/common/protocol_version.h" |
15 #include "net/url_request/test_url_fetcher_factory.h" | 16 #include "net/url_request/test_url_fetcher_factory.h" |
16 #include "testing/gmock/include/gmock/gmock.h" | 17 #include "testing/gmock/include/gmock/gmock.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
18 | 19 |
19 using testing::_; | 20 using testing::_; |
21 using testing::DoAll; | |
20 using testing::InSequence; | 22 using testing::InSequence; |
23 using testing::NotNull; | |
24 using testing::Return; | |
25 using testing::SetArgPointee; | |
21 | 26 |
22 namespace blimp { | 27 namespace blimp { |
23 namespace client { | 28 namespace client { |
24 namespace { | 29 namespace { |
25 | 30 |
31 const char kCertificatePEMEncoded[] = | |
32 "-----BEGIN CERTIFICATE-----\n" | |
33 "MIIDNzCCAh+gAwIBAgIJAM6Wyzih3bLNMA0GCSqGSIb3DQEBCwUAMDIxEjAQBgNV\n" | |
34 "BAMMCWtldmluLmNvbTEPMA0GA1UECgwGR29vZ2xlMQswCQYDVQQGEwJVUzAeFw0x\n" | |
35 "NjAyMTkyMTU3NDZaFw0xNzAyMTgyMTU3NDZaMDIxEjAQBgNVBAMMCWtldmluLmNv\n" | |
36 "bTEPMA0GA1UECgwGR29vZ2xlMQswCQYDVQQGEwJVUzCCASIwDQYJKoZIhvcNAQEB\n" | |
37 "BQADggEPADCCAQoCggEBALTLD9KDNKM5qSLzYct+zndPB8cFCtOIbvW7LFlwLqm7\n" | |
38 "w2xTOaaWhMPcbWJAo5Z+93q+vwNuNaenuENnKiJ7HFX0nyBUXjOSh8ds5JAA8+MW\n" | |
39 "qFM5r/+/Ww9mH3/Yhta/bzTIrt35SMclfcytH1YfACDenXNxYPA+GqFfcZnx7eat\n" | |
40 "Af0EvMi375Xf2qCROghuDfaPeY6FnqVNHhqFCB79f8UQmciO2cJsI3vMSLSAfoXQ\n" | |
41 "g3Fl4m6Q0PYFKPLECVxh9FLdqlAMBgxJIM2XhLXqR9qbrpCUlq/BVa2kmLcY061E\n" | |
42 "maTlrjVbtgqm5xJzXyCV1ZNBIdmfBZbO/OOOf4UFDgcCAwEAAaNQME4wHQYDVR0O\n" | |
43 "BBYEFCvDRIJ15+pept6O/OdVnNChxk8WMB8GA1UdIwQYMBaAFCvDRIJ15+pept6O\n" | |
44 "/OdVnNChxk8WMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAI+fgjIl\n" | |
45 "s0QFFAw+6lupC5BkFwXp5kgnD80mbvq9jeCmd8Rzs46XhI1CsKtODNRpjcqKAakW\n" | |
46 "PPIMExT1kUpHrbzs4fMbEPTYQryjRk29UNV6gPm264XHJNzOfh4vvV2u8F1Glb5j\n" | |
47 "Lcipt9+jGFMTcSRZ6fUtAaSl0LxXTCyzqQb86IQgxxWkW61ow99D+I/x1U+gE/w1\n" | |
48 "8NfudsmClORGinEwy5ZepmwQHDZjpnwauLoJuo3TbTLj6BY4AFPS+VD1ySvec6Lk\n" | |
49 "OkI7+7+kmbrqn0OJKIUVtw/0t9qMyPH+B87uyvgSd3J/xURnPEnIbpmrqM3bAdP6\n" | |
50 "j05XNhHVBefITMI=\n" | |
51 "-----END CERTIFICATE-----"; | |
52 | |
53 const char kCertPath[] = "/path/to/cert.pem"; | |
54 | |
26 MATCHER_P(AssignmentEquals, assignment, "") { | 55 MATCHER_P(AssignmentEquals, assignment, "") { |
27 return arg.transport_protocol == assignment.transport_protocol && | 56 return arg.transport_protocol == assignment.transport_protocol && |
28 arg.ip_endpoint == assignment.ip_endpoint && | 57 arg.ip_endpoint == assignment.ip_endpoint && |
29 arg.client_token == assignment.client_token && | 58 arg.client_token == assignment.client_token && |
30 arg.certificate == assignment.certificate && | 59 (!assignment.cert || arg.cert->Equals(assignment.cert.get())); |
31 arg.certificate_fingerprint == assignment.certificate_fingerprint; | |
32 } | 60 } |
33 | 61 |
62 class MockFileReader : public FileReader { | |
Ryan Sleevi
2016/02/23 00:49:45
If this is the whole reason for abstracting the Fi
Kevin M
2016/02/23 01:58:25
Done.
| |
63 public: | |
64 MockFileReader() {} | |
65 ~MockFileReader() override {} | |
66 | |
67 MOCK_METHOD2(ReadFileToString, | |
68 bool(const base::FilePath& path, std::string* output)); | |
69 }; | |
70 | |
34 net::IPEndPoint BuildIPEndPoint(const std::string& ip, int port) { | 71 net::IPEndPoint BuildIPEndPoint(const std::string& ip, int port) { |
35 net::IPAddress ip_address; | 72 net::IPAddress ip_address; |
36 EXPECT_TRUE(ip_address.AssignFromIPLiteral(ip)); | 73 EXPECT_TRUE(ip_address.AssignFromIPLiteral(ip)); |
74 return net::IPEndPoint(ip_address, port); | |
75 } | |
37 | 76 |
38 return net::IPEndPoint(ip_address, port); | 77 scoped_refptr<net::X509Certificate> ParseCert(const std::string& cert_str) { |
78 net::CertificateList cert_list = | |
79 net::X509Certificate::CreateCertificateListFromBytes( | |
80 kCertificatePEMEncoded, arraysize(kCertificatePEMEncoded), | |
81 net::X509Certificate::FORMAT_PEM_CERT_SEQUENCE); | |
82 CHECK_EQ(1u, cert_list.size()); | |
Ryan Sleevi
2016/02/23 00:49:45
Seems like this is duplicating logic/preconditions
Kevin M
2016/02/23 01:58:25
This seems pretty trivial to me, and PEM certifica
| |
83 return cert_list[0]; | |
39 } | 84 } |
40 | 85 |
41 Assignment BuildValidAssignment() { | 86 Assignment BuildValidAssignment() { |
42 Assignment assignment; | 87 Assignment assignment; |
43 assignment.transport_protocol = Assignment::TransportProtocol::SSL; | 88 assignment.transport_protocol = Assignment::TransportProtocol::SSL; |
44 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); | 89 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); |
45 assignment.client_token = "SecretT0kenz"; | 90 assignment.client_token = "SecretT0kenz"; |
46 assignment.certificate_fingerprint = "WhaleWhaleWhale"; | 91 assignment.cert = ParseCert(kCertificatePEMEncoded); |
47 assignment.certificate = "whaaaaaaaaaaaaale"; | |
48 return assignment; | 92 return assignment; |
49 } | 93 } |
50 | 94 |
51 std::string BuildResponseFromAssignment(const Assignment& assignment) { | 95 // Builds simulated JSON response from the Assigner service. |
96 // |assignment|: The Assignment to convert. | |
97 // |expected_cert_str|: The PEM encoded certificate to include in the response. | |
98 std::string BuildResponseFromAssignment(const Assignment& assignment, | |
99 const std::string& expected_cert_str) { | |
52 base::DictionaryValue dict; | 100 base::DictionaryValue dict; |
53 dict.SetString("clientToken", assignment.client_token); | 101 dict.SetString("clientToken", assignment.client_token); |
54 dict.SetString("host", assignment.ip_endpoint.address().ToString()); | 102 dict.SetString("host", assignment.ip_endpoint.address().ToString()); |
55 dict.SetInteger("port", assignment.ip_endpoint.port()); | 103 dict.SetInteger("port", assignment.ip_endpoint.port()); |
56 dict.SetString("certificateFingerprint", assignment.certificate_fingerprint); | 104 dict.SetString("certificate", expected_cert_str); |
57 dict.SetString("certificate", assignment.certificate); | |
58 | 105 |
59 std::string json; | 106 std::string json; |
60 base::JSONWriter::Write(dict, &json); | 107 base::JSONWriter::Write(dict, &json); |
61 return json; | 108 return json; |
62 } | 109 } |
63 | 110 |
64 class AssignmentSourceTest : public testing::Test { | 111 class AssignmentSourceTest : public testing::Test { |
65 public: | 112 public: |
66 AssignmentSourceTest() | 113 AssignmentSourceTest() |
67 : task_runner_(new base::TestSimpleTaskRunner), | 114 : task_runner_(new base::TestSimpleTaskRunner), |
68 task_runner_handle_(task_runner_), | 115 task_runner_handle_(task_runner_), |
69 source_(task_runner_, task_runner_) {} | 116 source_(task_runner_) { |
117 scoped_ptr<MockFileReader> mock_reader(new MockFileReader); | |
118 mock_reader_ = mock_reader.get(); | |
119 source_.SetFileReaderForTest(std::move(mock_reader)); | |
120 } | |
70 | 121 |
71 // This expects the AssignmentSource::GetAssignment to return a custom | 122 // This expects the AssignmentSource::GetAssignment to return a custom |
72 // endpoint without having to hit the network. This will typically be used | 123 // 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 | 124 // for testing that specifying an assignment via the command line works as |
74 // expected. | 125 // expected. |
75 void GetAlternateAssignment() { | 126 void GetAlternateAssignment() { |
76 source_.GetAssignment("", | 127 source_.GetAssignment("", |
77 base::Bind(&AssignmentSourceTest::AssignmentResponse, | 128 base::Bind(&AssignmentSourceTest::AssignmentResponse, |
78 base::Unretained(this))); | 129 base::Unretained(this))); |
79 EXPECT_EQ(nullptr, factory_.GetFetcherByID(0)); | 130 EXPECT_EQ(nullptr, factory_.GetFetcherByID(0)); |
80 task_runner_->RunUntilIdle(); | 131 task_runner_->RunUntilIdle(); |
81 } | 132 } |
82 | 133 |
83 // See net/base/net_errors.h for possible status errors. | 134 // See net/base/net_errors.h for possible status errors. |
84 void GetNetworkAssignmentAndWaitForResponse( | 135 void GetNetworkAssignmentAndWaitForResponse( |
85 net::HttpStatusCode response_code, | 136 net::HttpStatusCode response_code, |
86 int status, | 137 int status, |
87 const std::string& response, | 138 const std::string& response, |
88 const std::string& client_auth_token, | 139 const std::string& client_auth_token, |
89 const std::string& protocol_version) { | 140 const std::string& protocol_version) { |
90 source_.GetAssignment(client_auth_token, | 141 source_.GetAssignment(client_auth_token, |
91 base::Bind(&AssignmentSourceTest::AssignmentResponse, | 142 base::Bind(&AssignmentSourceTest::AssignmentResponse, |
92 base::Unretained(this))); | 143 base::Unretained(this))); |
144 task_runner_->RunUntilIdle(); | |
93 | 145 |
94 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); | 146 net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0); |
95 | 147 |
96 task_runner_->RunUntilIdle(); | |
97 | |
98 EXPECT_NE(nullptr, fetcher); | 148 EXPECT_NE(nullptr, fetcher); |
99 EXPECT_EQ(kDefaultAssignerURL, fetcher->GetOriginalURL().spec()); | 149 EXPECT_EQ(kDefaultAssignerURL, fetcher->GetOriginalURL().spec()); |
100 | 150 |
101 // Check that the request has a valid protocol_version. | 151 // Check that the request has a valid protocol_version. |
102 scoped_ptr<base::Value> json = | 152 scoped_ptr<base::Value> json = |
103 base::JSONReader::Read(fetcher->upload_data()); | 153 base::JSONReader::Read(fetcher->upload_data()); |
104 EXPECT_NE(nullptr, json.get()); | 154 EXPECT_NE(nullptr, json.get()); |
105 | 155 |
106 const base::DictionaryValue* dict; | 156 const base::DictionaryValue* dict; |
107 EXPECT_TRUE(json->GetAsDictionary(&dict)); | 157 EXPECT_TRUE(json->GetAsDictionary(&dict)); |
(...skipping 17 matching lines...) Expand all Loading... | |
125 fetcher->SetResponseString(response); | 175 fetcher->SetResponseString(response); |
126 fetcher->delegate()->OnURLFetchComplete(fetcher); | 176 fetcher->delegate()->OnURLFetchComplete(fetcher); |
127 | 177 |
128 task_runner_->RunUntilIdle(); | 178 task_runner_->RunUntilIdle(); |
129 } | 179 } |
130 | 180 |
131 MOCK_METHOD2(AssignmentResponse, | 181 MOCK_METHOD2(AssignmentResponse, |
132 void(AssignmentSource::Result, const Assignment&)); | 182 void(AssignmentSource::Result, const Assignment&)); |
133 | 183 |
134 protected: | 184 protected: |
185 MockFileReader* mock_reader_; | |
186 | |
135 // Used to drive all AssignmentSource tasks. | 187 // Used to drive all AssignmentSource tasks. |
136 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | 188 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; |
137 base::ThreadTaskRunnerHandle task_runner_handle_; | 189 base::ThreadTaskRunnerHandle task_runner_handle_; |
138 | 190 |
139 net::TestURLFetcherFactory factory_; | 191 net::TestURLFetcherFactory factory_; |
140 | 192 |
141 AssignmentSource source_; | 193 AssignmentSource source_; |
142 }; | 194 }; |
143 | 195 |
144 TEST_F(AssignmentSourceTest, TestTCPAlternateEndpointSuccess) { | 196 TEST_F(AssignmentSourceTest, TestTCPAlternateEndpointSuccess) { |
145 Assignment assignment; | 197 Assignment assignment; |
146 assignment.transport_protocol = Assignment::TransportProtocol::TCP; | 198 assignment.transport_protocol = Assignment::TransportProtocol::TCP; |
147 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); | 199 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); |
148 assignment.client_token = kDummyClientToken; | 200 assignment.client_token = kDummyClientToken; |
201 assignment.cert = scoped_refptr<net::X509Certificate>(nullptr); | |
149 | 202 |
150 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 203 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
151 switches::kBlimpletEndpoint, "tcp:100.150.200.250:500"); | 204 switches::kEngineEndpoint, "tcp:100.150.200.250:500"); |
152 | 205 |
153 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | 206 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
154 AssignmentEquals(assignment))) | 207 AssignmentEquals(assignment))) |
155 .Times(1); | 208 .Times(1); |
156 | 209 |
157 GetAlternateAssignment(); | 210 GetAlternateAssignment(); |
158 } | 211 } |
159 | 212 |
160 TEST_F(AssignmentSourceTest, TestSSLAlternateEndpointSuccess) { | 213 TEST_F(AssignmentSourceTest, TestSSLAlternateEndpointSuccess) { |
161 Assignment assignment; | 214 Assignment assignment; |
162 assignment.transport_protocol = Assignment::TransportProtocol::SSL; | 215 assignment.transport_protocol = Assignment::TransportProtocol::SSL; |
163 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); | 216 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); |
164 assignment.client_token = kDummyClientToken; | 217 assignment.client_token = kDummyClientToken; |
218 assignment.cert = ParseCert(kCertificatePEMEncoded); | |
165 | 219 |
166 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 220 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
167 switches::kBlimpletEndpoint, "ssl:100.150.200.250:500"); | 221 switches::kEngineEndpoint, "ssl:100.150.200.250:500"); |
222 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | |
223 switches::kEngineCertPath, kCertPath); | |
168 | 224 |
225 EXPECT_CALL(*mock_reader_, | |
226 ReadFileToString(base::FilePath(kCertPath), NotNull())) | |
227 .WillOnce(DoAll(SetArgPointee<1>(kCertificatePEMEncoded), Return(true))); | |
169 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | 228 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
170 AssignmentEquals(assignment))) | 229 AssignmentEquals(assignment))) |
171 .Times(1); | 230 .Times(1); |
172 | 231 |
173 GetAlternateAssignment(); | 232 GetAlternateAssignment(); |
174 } | 233 } |
175 | 234 |
176 TEST_F(AssignmentSourceTest, TestQUICAlternateEndpointSuccess) { | 235 TEST_F(AssignmentSourceTest, TestQUICAlternateEndpointSuccess) { |
177 Assignment assignment; | 236 Assignment assignment; |
178 assignment.transport_protocol = Assignment::TransportProtocol::QUIC; | 237 assignment.transport_protocol = Assignment::TransportProtocol::QUIC; |
179 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); | 238 assignment.ip_endpoint = BuildIPEndPoint("100.150.200.250", 500); |
180 assignment.client_token = kDummyClientToken; | 239 assignment.client_token = kDummyClientToken; |
240 assignment.cert = ParseCert(kCertificatePEMEncoded); | |
181 | 241 |
182 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 242 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
183 switches::kBlimpletEndpoint, "quic:100.150.200.250:500"); | 243 switches::kEngineEndpoint, "quic:100.150.200.250:500"); |
244 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | |
245 switches::kEngineCertPath, kCertPath); | |
184 | 246 |
247 EXPECT_CALL(*mock_reader_, | |
248 ReadFileToString(base::FilePath(kCertPath), NotNull())) | |
249 .WillOnce(DoAll(SetArgPointee<1>(kCertificatePEMEncoded), Return(true))); | |
185 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | 250 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
186 AssignmentEquals(assignment))) | 251 AssignmentEquals(assignment))) |
187 .Times(1); | 252 .Times(1); |
188 | 253 |
189 GetAlternateAssignment(); | 254 GetAlternateAssignment(); |
190 } | 255 } |
191 | 256 |
192 TEST_F(AssignmentSourceTest, TestSuccess) { | 257 TEST_F(AssignmentSourceTest, TestSuccess) { |
193 Assignment assignment = BuildValidAssignment(); | 258 Assignment assignment = BuildValidAssignment(); |
194 | 259 |
195 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | 260 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
196 AssignmentEquals(assignment))) | 261 AssignmentEquals(assignment))) |
197 .Times(1); | 262 .Times(1); |
198 | 263 |
199 GetNetworkAssignmentAndWaitForResponse( | 264 GetNetworkAssignmentAndWaitForResponse( |
200 net::HTTP_OK, net::Error::OK, BuildResponseFromAssignment(assignment), | 265 net::HTTP_OK, net::Error::OK, |
266 BuildResponseFromAssignment(assignment, kCertificatePEMEncoded), | |
201 "UserAuthT0kenz", kEngineVersion); | 267 "UserAuthT0kenz", kEngineVersion); |
202 } | 268 } |
203 | 269 |
204 TEST_F(AssignmentSourceTest, TestSecondRequestInterruptsFirst) { | 270 TEST_F(AssignmentSourceTest, TestSecondRequestInterruptsFirst) { |
205 InSequence sequence; | 271 InSequence sequence; |
206 Assignment assignment = BuildValidAssignment(); | 272 Assignment assignment = BuildValidAssignment(); |
207 | 273 |
208 source_.GetAssignment("", | 274 source_.GetAssignment("", |
209 base::Bind(&AssignmentSourceTest::AssignmentResponse, | 275 base::Bind(&AssignmentSourceTest::AssignmentResponse, |
210 base::Unretained(this))); | 276 base::Unretained(this))); |
211 | 277 |
212 EXPECT_CALL(*this, AssignmentResponse( | 278 EXPECT_CALL(*this, AssignmentResponse( |
213 AssignmentSource::Result::RESULT_SERVER_INTERRUPTED, | 279 AssignmentSource::Result::RESULT_SERVER_INTERRUPTED, |
214 AssignmentEquals(Assignment()))) | 280 AssignmentEquals(Assignment()))) |
215 .Times(1) | 281 .Times(1) |
216 .RetiresOnSaturation(); | 282 .RetiresOnSaturation(); |
217 | 283 |
218 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | 284 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
219 AssignmentEquals(assignment))) | 285 AssignmentEquals(assignment))) |
220 .Times(1) | 286 .Times(1) |
221 .RetiresOnSaturation(); | 287 .RetiresOnSaturation(); |
222 | 288 |
223 GetNetworkAssignmentAndWaitForResponse( | 289 GetNetworkAssignmentAndWaitForResponse( |
224 net::HTTP_OK, net::Error::OK, BuildResponseFromAssignment(assignment), | 290 net::HTTP_OK, net::Error::OK, |
291 BuildResponseFromAssignment(assignment, kCertificatePEMEncoded), | |
225 "UserAuthT0kenz", kEngineVersion); | 292 "UserAuthT0kenz", kEngineVersion); |
226 } | 293 } |
227 | 294 |
228 TEST_F(AssignmentSourceTest, TestValidAfterError) { | 295 TEST_F(AssignmentSourceTest, TestValidAfterError) { |
229 InSequence sequence; | 296 InSequence sequence; |
230 Assignment assignment = BuildValidAssignment(); | 297 Assignment assignment = BuildValidAssignment(); |
231 | 298 |
232 EXPECT_CALL(*this, AssignmentResponse( | 299 EXPECT_CALL(*this, AssignmentResponse( |
233 AssignmentSource::Result::RESULT_NETWORK_FAILURE, _)) | 300 AssignmentSource::Result::RESULT_NETWORK_FAILURE, _)) |
234 .Times(1) | 301 .Times(1) |
235 .RetiresOnSaturation(); | 302 .RetiresOnSaturation(); |
236 | 303 |
237 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, | 304 EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK, |
238 AssignmentEquals(assignment))) | 305 AssignmentEquals(assignment))) |
239 .Times(1) | 306 .Times(1) |
240 .RetiresOnSaturation(); | 307 .RetiresOnSaturation(); |
241 | 308 |
242 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, | 309 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, |
243 net::Error::ERR_INSUFFICIENT_RESOURCES, | 310 net::Error::ERR_INSUFFICIENT_RESOURCES, |
244 "", "UserAuthT0kenz", kEngineVersion); | 311 "", "UserAuthT0kenz", kEngineVersion); |
245 | 312 |
246 GetNetworkAssignmentAndWaitForResponse( | 313 GetNetworkAssignmentAndWaitForResponse( |
247 net::HTTP_OK, net::Error::OK, BuildResponseFromAssignment(assignment), | 314 net::HTTP_OK, net::Error::OK, |
315 BuildResponseFromAssignment(assignment, kCertificatePEMEncoded), | |
248 "UserAuthT0kenz", kEngineVersion); | 316 "UserAuthT0kenz", kEngineVersion); |
249 } | 317 } |
250 | 318 |
251 TEST_F(AssignmentSourceTest, TestNetworkFailure) { | 319 TEST_F(AssignmentSourceTest, TestNetworkFailure) { |
252 EXPECT_CALL(*this, AssignmentResponse( | 320 EXPECT_CALL(*this, AssignmentResponse( |
253 AssignmentSource::Result::RESULT_NETWORK_FAILURE, _)); | 321 AssignmentSource::Result::RESULT_NETWORK_FAILURE, _)); |
254 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, | 322 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, |
255 net::Error::ERR_INSUFFICIENT_RESOURCES, | 323 net::Error::ERR_INSUFFICIENT_RESOURCES, |
256 "", "UserAuthT0kenz", kEngineVersion); | 324 "", "UserAuthT0kenz", kEngineVersion); |
257 } | 325 } |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
299 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); | 367 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
300 GetNetworkAssignmentAndWaitForResponse(net::HTTP_NOT_IMPLEMENTED, | 368 GetNetworkAssignmentAndWaitForResponse(net::HTTP_NOT_IMPLEMENTED, |
301 net::Error::OK, "", "UserAuthT0kenz", | 369 net::Error::OK, "", "UserAuthT0kenz", |
302 kEngineVersion); | 370 kEngineVersion); |
303 } | 371 } |
304 | 372 |
305 TEST_F(AssignmentSourceTest, TestInvalidJsonResponse) { | 373 TEST_F(AssignmentSourceTest, TestInvalidJsonResponse) { |
306 Assignment assignment = BuildValidAssignment(); | 374 Assignment assignment = BuildValidAssignment(); |
307 | 375 |
308 // Remove half the response. | 376 // Remove half the response. |
309 std::string response = BuildResponseFromAssignment(assignment); | 377 std::string response = |
378 BuildResponseFromAssignment(assignment, kCertificatePEMEncoded); | |
310 response = response.substr(response.size() / 2); | 379 response = response.substr(response.size() / 2); |
311 | 380 |
312 EXPECT_CALL(*this, AssignmentResponse( | 381 EXPECT_CALL(*this, AssignmentResponse( |
313 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); | 382 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
314 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, | 383 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, |
315 "UserAuthT0kenz", kEngineVersion); | 384 "UserAuthT0kenz", kEngineVersion); |
316 } | 385 } |
317 | 386 |
318 TEST_F(AssignmentSourceTest, TestMissingResponsePort) { | 387 TEST_F(AssignmentSourceTest, TestMissingResponsePort) { |
319 // Purposely do not add the 'port' field to the response. | 388 // Purposely do not add the 'port' field to the response. |
320 base::DictionaryValue dict; | 389 base::DictionaryValue dict; |
321 dict.SetString("clientToken", "SecretT0kenz"); | 390 dict.SetString("clientToken", "SecretT0kenz"); |
322 dict.SetString("host", "happywhales"); | 391 dict.SetString("host", "happywhales"); |
323 dict.SetString("certificateFingerprint", "WhaleWhaleWhale"); | |
324 dict.SetString("certificate", "whaaaaaaaaaaaaale"); | 392 dict.SetString("certificate", "whaaaaaaaaaaaaale"); |
325 | 393 |
326 std::string response; | 394 std::string response; |
327 base::JSONWriter::Write(dict, &response); | 395 base::JSONWriter::Write(dict, &response); |
328 | 396 |
329 EXPECT_CALL(*this, AssignmentResponse( | 397 EXPECT_CALL(*this, AssignmentResponse( |
330 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); | 398 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
331 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, | 399 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, |
332 "UserAuthT0kenz", kEngineVersion); | 400 "UserAuthT0kenz", kEngineVersion); |
333 } | 401 } |
334 | 402 |
335 TEST_F(AssignmentSourceTest, TestInvalidIPAddress) { | 403 TEST_F(AssignmentSourceTest, TestInvalidIPAddress) { |
336 // Purposely add an invalid IP field to the response. | 404 // Purposely add an invalid IP field to the response. |
337 base::DictionaryValue dict; | 405 base::DictionaryValue dict; |
338 dict.SetString("clientToken", "SecretT0kenz"); | 406 dict.SetString("clientToken", "SecretT0kenz"); |
339 dict.SetString("host", "happywhales"); | 407 dict.SetString("host", "happywhales"); |
340 dict.SetInteger("port", 500); | 408 dict.SetInteger("port", 500); |
341 dict.SetString("certificateFingerprint", "WhaleWhaleWhale"); | |
342 dict.SetString("certificate", "whaaaaaaaaaaaaale"); | 409 dict.SetString("certificate", "whaaaaaaaaaaaaale"); |
343 | 410 |
344 std::string response; | 411 std::string response; |
345 base::JSONWriter::Write(dict, &response); | 412 base::JSONWriter::Write(dict, &response); |
346 | 413 |
347 EXPECT_CALL(*this, AssignmentResponse( | 414 EXPECT_CALL(*this, AssignmentResponse( |
348 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); | 415 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); |
349 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, | 416 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, |
350 "UserAuthT0kenz", kEngineVersion); | 417 "UserAuthT0kenz", kEngineVersion); |
351 } | 418 } |
352 | 419 |
420 TEST_F(AssignmentSourceTest, TestMissingCert) { | |
421 base::DictionaryValue dict; | |
422 dict.SetString("clientToken", "SecretT0kenz"); | |
423 dict.SetString("host", "127.0.0.1"); | |
424 dict.SetInteger("port", 500); | |
425 | |
426 std::string response; | |
427 base::JSONWriter::Write(dict, &response); | |
428 | |
429 EXPECT_CALL(*this, AssignmentResponse( | |
430 AssignmentSource::Result::RESULT_BAD_RESPONSE, _)); | |
431 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, | |
432 "UserAuthT0kenz", kEngineVersion); | |
433 } | |
434 | |
435 TEST_F(AssignmentSourceTest, TestInvalidCert) { | |
436 base::DictionaryValue dict; | |
437 dict.SetString("clientToken", "SecretT0kenz"); | |
438 dict.SetString("host", "127.0.0.1"); | |
439 dict.SetInteger("port", 500); | |
440 dict.SetString("certificate", "h4x0r c3r7"); | |
441 | |
442 std::string response; | |
443 base::JSONWriter::Write(dict, &response); | |
444 | |
445 EXPECT_CALL(*this, AssignmentResponse( | |
446 AssignmentSource::Result::RESULT_INVALID_CERT, _)); | |
447 GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response, | |
448 "UserAuthT0kenz", kEngineVersion); | |
449 } | |
450 | |
353 } // namespace | 451 } // namespace |
354 } // namespace client | 452 } // namespace client |
355 } // namespace blimp | 453 } // namespace blimp |
OLD | NEW |