Use Chromium BUILD to approximate Blimp protocol version, and check it.

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/strings/string_number_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "blimp/client/app/blimp_client_switches.h"
 #include "blimp/common/get_client_token.h"
 #include "blimp/common/protocol_version.h"
 #include "blimp/common/switches.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"
@@ skipping 74 matching lines @@
     EXPECT_EQ(nullptr, factory_.GetFetcherByID(0));
     base::RunLoop().RunUntilIdle();
   }
 
   // See net/base/net_errors.h for possible status errors.
   void GetNetworkAssignmentAndWaitForResponse(
       net::HttpStatusCode response_code,
       int status,
       const std::string& response,
       const std::string& client_auth_token,
-      const std::string& protocol_version) {
+      const int protocol_version) {
     source_.GetAssignment(client_auth_token,
                           base::Bind(&AssignmentSourceTest::AssignmentResponse,
                                      base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
 
     net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
 
     EXPECT_NE(nullptr, fetcher);
     EXPECT_EQ(kAssignerUrl, fetcher->GetOriginalURL().spec());
 
     // Check that the request has a valid protocol_version.
     std::unique_ptr<base::Value> json =
         base::JSONReader::Read(fetcher->upload_data());
     EXPECT_NE(nullptr, json.get());
 
     const base::DictionaryValue* dict;
     EXPECT_TRUE(json->GetAsDictionary(&dict));
 
     std::string uploaded_protocol_version;
     EXPECT_TRUE(
         dict->GetString("protocol_version", &uploaded_protocol_version));
-    EXPECT_EQ(protocol_version, uploaded_protocol_version);
+    std::string expected_protocol_version = base::IntToString(protocol_version);
+    EXPECT_EQ(expected_protocol_version, uploaded_protocol_version);
 
     // Check that the request has a valid authentication header.
     net::HttpRequestHeaders headers;
     fetcher->GetExtraRequestHeaders(&headers);
 
     std::string authorization;
     EXPECT_TRUE(headers.GetHeader("Authorization", &authorization));
     EXPECT_EQ("Bearer " + client_auth_token, authorization);
 
     // Send the fake response back.
@@ skipping 110 matching lines @@
 
 TEST_F(AssignmentSourceTest, TestSuccess) {
   Assignment assignment = BuildSslAssignment();
 
   EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK,
                                         AssignmentEquals(assignment)))
       .Times(1);
 
   GetNetworkAssignmentAndWaitForResponse(
       net::HTTP_OK, net::Error::OK, ValueToString(*BuildAssignerResponse()),
-      kTestAuthToken, kEngineVersion);
+      kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestValidAfterError) {
   InSequence sequence;
   Assignment assignment = BuildSslAssignment();
 
   EXPECT_CALL(*this, AssignmentResponse(
                          AssignmentSource::Result::RESULT_NETWORK_FAILURE, _))
       .Times(1)
       .RetiresOnSaturation();
 
   EXPECT_CALL(*this, AssignmentResponse(AssignmentSource::Result::RESULT_OK,
                                         AssignmentEquals(assignment)))
       .Times(1)
       .RetiresOnSaturation();
 
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK,
                                          net::Error::ERR_INSUFFICIENT_RESOURCES,
-                                         "", kTestAuthToken, kEngineVersion);
+                                         "", kTestAuthToken, kProtocolVersion);
 
   GetNetworkAssignmentAndWaitForResponse(
       net::HTTP_OK, net::Error::OK, ValueToString(*BuildAssignerResponse()),
-      kTestAuthToken, kEngineVersion);
+      kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestNetworkFailure) {
   EXPECT_CALL(*this, AssignmentResponse(
                          AssignmentSource::Result::RESULT_NETWORK_FAILURE, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK,
                                          net::Error::ERR_INSUFFICIENT_RESOURCES,
-                                         "", kTestAuthToken, kEngineVersion);
+                                         "", kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestBadRequest) {
   EXPECT_CALL(*this, AssignmentResponse(
                          AssignmentSource::Result::RESULT_BAD_REQUEST, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_BAD_REQUEST, net::Error::OK,
-                                         "", kTestAuthToken, kEngineVersion);
+                                         "", kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestUnauthorized) {
   EXPECT_CALL(*this,
               AssignmentResponse(
                   AssignmentSource::Result::RESULT_EXPIRED_ACCESS_TOKEN, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_UNAUTHORIZED, net::Error::OK,
-                                         "", kTestAuthToken, kEngineVersion);
+                                         "", kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestForbidden) {
   EXPECT_CALL(*this, AssignmentResponse(
                          AssignmentSource::Result::RESULT_USER_INVALID, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_FORBIDDEN, net::Error::OK,
-                                         "", kTestAuthToken, kEngineVersion);
+                                         "", kTestAuthToken, kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestTooManyRequests) {
   EXPECT_CALL(*this, AssignmentResponse(
                          AssignmentSource::Result::RESULT_OUT_OF_VMS, _));
   GetNetworkAssignmentAndWaitForResponse(static_cast<net::HttpStatusCode>(429),
                                          net::Error::OK, "", kTestAuthToken,
-                                         kEngineVersion);
+                                         kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestInternalServerError) {
   EXPECT_CALL(*this, AssignmentResponse(
                          AssignmentSource::Result::RESULT_SERVER_ERROR, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_INTERNAL_SERVER_ERROR,
                                          net::Error::OK, "", kTestAuthToken,
-                                         kEngineVersion);
+                                         kProtocolVersion);
 }
 
 TEST_F(AssignmentSourceTest, TestUnexpectedNetCodeFallback) {
   EXPECT_CALL(*this, AssignmentResponse(
                          AssignmentSource::Result::RESULT_BAD_RESPONSE, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_NOT_IMPLEMENTED,
                                          net::Error::OK, "", kTestAuthToken,
-                                         kEngineVersion);
+                                         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, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK, response,
-                                         kTestAuthToken, kEngineVersion);
+                                         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, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK,
                                          ValueToString(*response),
-                                         kTestAuthToken, kEngineVersion);
+                                         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, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK,
                                          ValueToString(*response),
-                                         kTestAuthToken, kEngineVersion);
+                                         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, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK,
                                          ValueToString(*response),
-                                         kTestAuthToken, kEngineVersion);
+                                         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, _));
   GetNetworkAssignmentAndWaitForResponse(net::HTTP_OK, net::Error::OK,
                                          ValueToString(*response),
-                                         kTestAuthToken, kEngineVersion);
+                                         kTestAuthToken, kProtocolVersion);
 }
 
 }  // namespace
 }  // namespace client
 }  // namespace blimp