Allows client to access auth token from command line specified file.

blimp/client/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/session/assignment_source.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "blimp/client/app/blimp_client_switches.h"
+#include "blimp/common/fake_commandline.h"
+#include "blimp/common/get_client_token.h"
 #include "blimp/common/protocol_version.h"
 #include "components/safe_json/testing_json_parser.h"
 #include "net/base/test_data_directory.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using testing::_;
 using testing::DoAll;
@@ skipping 46 matching lines @@
     ASSERT_FALSE(src_root.empty());
     cert_path_ = src_root.Append(kCertRelativePath);
     ASSERT_TRUE(base::ReadFileToString(cert_path_, &cert_pem_));
     net::CertificateList cert_list =
         net::X509Certificate::CreateCertificateListFromBytes(
             cert_pem_.data(), cert_pem_.size(),
             net::X509Certificate::FORMAT_PEM_CERT_SEQUENCE);
     ASSERT_FALSE(cert_list.empty());
     cert_ = std::move(cert_list[0]);
     ASSERT_TRUE(cert_);
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());

[Kevin M, 2016/05/11 00:39:57]

See what we're doing with kCertRelativePath to get an idea of how we can use the
test_client_token file.

[CJ, 2016/05/11 23:48:49]

Done.

+    CreateFileForSwitch(engine::kClientTokenPath, kTestClientToken);
   }
 
   // This expects the AssignmentSource::GetAssignment to return a custom
   // endpoint without having to hit the network.  This will typically be used
   // for testing that specifying an assignment via the command line works as
   // expected.
   void GetAlternateAssignment() {
     source_.GetAssignment("",
                           base::Bind(&AssignmentSourceTest::AssignmentResponse,
                                      base::Unretained(this)));
@@ skipping 94 matching lines @@
 AssignmentSourceTest::BuildAssignerResponse() {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
   dict->SetString("clientToken", kTestClientToken);
   dict->SetString("host", kTestIpAddressString);
   dict->SetInteger("port", kTestPort);
   dict->SetString("certificate", cert_pem_);
   return dict;
 }
 
 TEST_F(AssignmentSourceTest, TestTCPAlternateEndpointSuccess) {
+  auto cmd_line = CreateCommandLine(all_filepath_switches_);
   Assignment assignment;
   assignment.transport_protocol = Assignment::TransportProtocol::TCP;
   assignment.engine_endpoint = net::IPEndPoint(kTestIpAddress, kTestPort);
-  assignment.client_token = kDummyClientToken;
+  assignment.client_token = GetClientToken(cmd_line);
   assignment.cert = scoped_refptr<net::X509Certificate>(nullptr);
 
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kEngineIP, kTestIpAddressString);
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kEnginePort, std::to_string(kTestPort));
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kEngineTransport, kTcpTransportName);
 
   EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK,
                                         AssignmentEquals(assignment)))
       .Times(1);
 
   GetAlternateAssignment();
 }
 
 TEST_F(AssignmentSourceTest, TestSSLAlternateEndpointSuccess) {
+  auto cmd_line = CreateCommandLine(all_filepath_switches_);
   Assignment assignment;
   assignment.transport_protocol = Assignment::TransportProtocol::SSL;
   assignment.engine_endpoint = net::IPEndPoint(kTestIpAddress, kTestPort);
-  assignment.client_token = kDummyClientToken;
+  assignment.client_token = GetClientToken(cmd_line);
   assignment.cert = cert_;
 
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kEngineIP, kTestIpAddressString);
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kEnginePort, std::to_string(kTestPort));
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kEngineTransport, kSslTransportName);
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kEngineCertPath, cert_path_.value());
@@ skipping 144 matching lines @@
   EXPECT_CALL(*this, AssignmentResponse(
                          AssignmentSource::Result::RESULT_INVALID_CERT, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK,
                                          ValueToString(*response),
                                          kTestAuthToken, kEngineVersion);
 }
 
 }  // namespace
 }  // namespace client
 }  // namespace blimp