GRPC Stream implementation of HeliumStream

blimp/client/core/session/assignment_source_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "blimp/client/core/session/assignment_source.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 37 matching lines @@
 const char kSslTransportName[] = "ssl";
 const char kCertRelativePath[] =
     "blimp/client/core/session/test_selfsigned_cert.pem";
 const char kTestClientAuthToken[] = "secrett0ken";
 const char kTestAuthToken[] = "UserAuthT0kenz";
 const char kAssignerUrl[] = "http://www.assigner.test/";
 const char kTestClientAuthTokenPath[] = "blimp/test/data/test_client_token";
 
 MATCHER_P(AssignmentEquals, assignment, "") {
   return arg.transport_protocol == assignment.transport_protocol &&
-         arg.engine_endpoint == assignment.engine_endpoint &&
+         arg.assignment_options.engine_endpoint ==
+             assignment.assignment_options.engine_endpoint &&
          arg.client_auth_token == assignment.client_auth_token &&
          ((!assignment.cert && !arg.cert) ||
           (arg.cert && assignment.cert &&
            arg.cert->Equals(assignment.cert.get())));
 }
 
 // Converts |value| to a JSON string.
 std::string ValueToString(const base::Value& value) {
   std::string json;
   base::JSONWriter::Write(value, &json);
@@ skipping 115 matching lines @@
   AssignmentSource source_;
 
   // Allows safe_json to parse JSON in-process, instead of depending on a
   // utility proces.
   safe_json::TestingJsonParser::ScopedFactoryOverride json_parsing_factory_;
 };
 
 Assignment AssignmentSourceTest::BuildSslAssignment() {
   Assignment assignment;
   assignment.transport_protocol = Assignment::TransportProtocol::SSL;
-  assignment.engine_endpoint = net::IPEndPoint(kTestIpAddress, kTestPort);
+  assignment.assignment_options.engine_endpoint =
+      net::IPEndPoint(kTestIpAddress, kTestPort);
   assignment.client_auth_token = kTestClientAuthToken;
   assignment.cert = cert_;
   return assignment;
 }
 
 std::unique_ptr<base::DictionaryValue>
 AssignmentSourceTest::BuildAssignerResponse() {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
   dict->SetString("clientToken", kTestClientAuthToken);
   dict->SetString("host", kTestIpAddressString);
   dict->SetInteger("port", kTestPort);
   dict->SetString("certificate", cert_pem_);
   return dict;
 }
 
 TEST_F(AssignmentSourceTest, TestTCPAlternateEndpointSuccess) {
   Assignment assignment;
   assignment.transport_protocol = Assignment::TransportProtocol::TCP;
-  assignment.engine_endpoint = net::IPEndPoint(kTestIpAddress, kTestPort);
+  assignment.assignment_options.engine_endpoint =
+      net::IPEndPoint(kTestIpAddress, kTestPort);
   assignment.cert = scoped_refptr<net::X509Certificate>(nullptr);
 
   auto* cmd_line = base::CommandLine::ForCurrentProcess();
   cmd_line->AppendSwitchASCII(switches::kEngineIP, kTestIpAddressString);
-  cmd_line->AppendSwitchASCII(switches::kEnginePort,
-                              std::to_string(kTestPort));
+  cmd_line->AppendSwitchASCII(switches::kEnginePort, std::to_string(kTestPort));
   cmd_line->AppendSwitchASCII(switches::kEngineTransport, kTcpTransportName);
   cmd_line->AppendSwitchASCII(kClientAuthTokenPath,
                               client_auth_token_path_.value());
 
   assignment.client_auth_token = GetClientAuthToken(*cmd_line);
 
   CHECK_EQ("MyVoiceIsMyPassport", assignment.client_auth_token);
 
   EXPECT_CALL(*this, AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_OK,
                                         AssignmentEquals(assignment)))
       .Times(1);
 
   GetAlternateAssignment();
 }
 
 TEST_F(AssignmentSourceTest, TestSSLAlternateEndpointSuccess) {
   Assignment assignment;
   assignment.transport_protocol = Assignment::TransportProtocol::SSL;
-  assignment.engine_endpoint = net::IPEndPoint(kTestIpAddress, kTestPort);
+  assignment.assignment_options.engine_endpoint =
+      net::IPEndPoint(kTestIpAddress, kTestPort);
   assignment.cert = cert_;
 
   auto* cmd_line = base::CommandLine::ForCurrentProcess();
 
   cmd_line->AppendSwitchASCII(switches::kEngineIP, kTestIpAddressString);
-  cmd_line->AppendSwitchASCII(switches::kEnginePort,
-                              std::to_string(kTestPort));
+  cmd_line->AppendSwitchASCII(switches::kEnginePort, std::to_string(kTestPort));
   cmd_line->AppendSwitchASCII(switches::kEngineTransport, kSslTransportName);
   cmd_line->AppendSwitchASCII(switches::kEngineCertPath, cert_path_.value());
   cmd_line->AppendSwitchASCII(kClientAuthTokenPath,
                               client_auth_token_path_.value());
 
   assignment.client_auth_token = GetClientAuthToken(*cmd_line);
 
   EXPECT_CALL(*this, AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_OK,
                                         AssignmentEquals(assignment)))
       .Times(1);
@@ skipping 139 matching lines @@
   EXPECT_CALL(*this,
               AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_INVALID_CERT, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK,
                                          ValueToString(*response),
                                          kTestAuthToken, kProtocolVersion);
 }
 
 }  // namespace
 }  // namespace client
 }  // namespace blimp