Add AssignmentSource to BlimpClientContextImpl

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 "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 132 matching lines @@
     // Send the fake response back.
     fetcher->set_response_code(response_code);
     fetcher->set_status(net::URLRequestStatus::FromError(status));
     fetcher->SetResponseString(response);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     base::RunLoop().RunUntilIdle();
   }
 
   MOCK_METHOD2(AssignmentResponse,
-               void(AssignmentSource::Result, const Assignment&));
+               void(AssignmentRequestResult, const Assignment&));
 
  protected:
   Assignment BuildSslAssignment();
 
   // Builds simulated JSON response from the Assigner service.
   std::unique_ptr<base::DictionaryValue> BuildAssignerResponse();
 
   // Used to drive all AssignmentSource tasks.
   // MessageLoop is required by TestingJsonParser's self-deletion logic.
   // TODO(bauerb): Replace this with a TestSimpleTaskRunner once
@@ skipping 50 matching lines @@
   cmd_line->AppendSwitchASCII(switches::kEngineIP, kTestIpAddressString);
   cmd_line->AppendSwitchASCII(switches::kEnginePort,
                               std::to_string(kTestPort));
   cmd_line->AppendSwitchASCII(switches::kEngineTransport, kTcpTransportName);
   cmd_line->AppendSwitchASCII(kClientTokenPath, client_token_path_.value());
 
   assignment.client_token = GetClientToken(*cmd_line);
 
   CHECK_EQ("MyVoiceIsMyPassport", assignment.client_token);
 
-  EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK,
+  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.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::kEngineTransport, kSslTransportName);
   cmd_line->AppendSwitchASCII(switches::kEngineCertPath, cert_path_.value());
   cmd_line->AppendSwitchASCII(kClientTokenPath, client_token_path_.value());
 
   assignment.client_token = GetClientToken(*cmd_line);
 
-  EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK,
+  EXPECT_CALL(*this, AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_OK,
                                         AssignmentEquals(assignment)))
       .Times(1);
 
   GetAlternateAssignment();
 }
 
 TEST_F(AssignmentSourceTest, TestSuccess) {
   Assignment assignment = BuildSslAssignment();
 
-  EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK,
+  EXPECT_CALL(*this, AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_OK,
                                         AssignmentEquals(assignment)))
       .Times(1);
 
   GetNetworkAssignmentAndWaitForResponse(
       net::HTTP_OK, net::Error::OK, ValueToString(*BuildAssignerResponse()),
       kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestValidAfterError) {
   InSequence sequence;
   Assignment assignment = BuildSslAssignment();
 
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_NETWORK_FAILURE, _))
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_NETWORK_FAILURE, _))
       .Times(1)
       .RetiresOnSaturation();
 
-  EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK,
+  EXPECT_CALL(*this, AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_OK,
                                         AssignmentEquals(assignment)))
       .Times(1)
       .RetiresOnSaturation();
 
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK,
                                          net::Error::ERR_INSUFFICIENT_RESOURCES,
                                          "", kTestAuthToken, kProtocolVersion);
 
   GetNetworkAssignmentAndWaitForResponse(
       net::HTTP_OK, net::Error::OK, ValueToString(*BuildAssignerResponse()),
       kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestNetworkFailure) {
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_NETWORK_FAILURE, _));
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_NETWORK_FAILURE, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK,
                                          net::Error::ERR_INSUFFICIENT_RESOURCES,
                                          "", kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestBadRequest) {
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_BAD_REQUEST, _));
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_BAD_REQUEST, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_BAD_REQUEST, net::Error::OK,
                                          "", kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestUnauthorized) {
-  EXPECT_CALL(*this,
-              AssignmentResponse(
-                  AssignmentSource::Result::RESULT_EXPIRED_ACCESS_TOKEN, _));
+  EXPECT_CALL(*this, AssignmentResponse(
+                         ASSIGNMENT_REQUEST_RESULT_EXPIRED_ACCESS_TOKEN, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_UNAUTHORIZED, net::Error::OK,
                                          "", kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestForbidden) {
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_USER_INVALID, _));
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_USER_INVALID, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_FORBIDDEN, net::Error::OK,
                                          "", kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestTooManyRequests) {
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_OUT_OF_VMS, _));
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_OUT_OF_VMS, _));
   GetNetworkAssignmentAndWaitForResponse(static_cast<net::HttpStatusCode>(429),
                                          net::Error::OK, "", kTestAuthToken,
                                          kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestInternalServerError) {
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_SERVER_ERROR, _));
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_SERVER_ERROR, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_INTERNAL_SERVER_ERROR,
                                          net::Error::OK, "", kTestAuthToken,
                                          kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestUnexpectedNetCodeFallback) {
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_BAD_RESPONSE, _));
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_NOT_IMPLEMENTED,
                                          net::Error::OK, "", kTestAuthToken,
                                          kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestInvalidJsonResponse) {
   Assignment assignment = BuildSslAssignment();
 
   // Remove half the response.
   std::string response = ValueToString(*BuildAssignerResponse());
   response = response.substr(response.size() / 2);
 
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_BAD_RESPONSE, _));
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response,
                                          kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestMissingResponsePort) {
   std::unique_ptr<base::DictionaryValue> response = BuildAssignerResponse();
   response->Remove("port", nullptr);
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_BAD_RESPONSE, _));
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK,
                                          ValueToString(*response),
                                          kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestInvalidIPAddress) {
   std::unique_ptr<base::DictionaryValue> response = BuildAssignerResponse();
   response->SetString("host", "happywhales.test");
 
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_BAD_RESPONSE, _));
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK,
                                          ValueToString(*response),
                                          kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestMissingCert) {
   std::unique_ptr<base::DictionaryValue> response = BuildAssignerResponse();
   response->Remove("certificate", nullptr);
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_BAD_RESPONSE, _));
+  EXPECT_CALL(*this,
+              AssignmentResponse(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK,
                                          ValueToString(*response),
                                          kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestInvalidCert) {
   std::unique_ptr<base::DictionaryValue> response = BuildAssignerResponse();
   response->SetString("certificate", "h4x0rz!");
-  EXPECT_CALL(*this, AssignmentResponse(
-                         AssignmentSource::Result::RESULT_INVALID_CERT, _));
+  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