Moved //components/proximity_auth/cryptauth to //components/cryptauth.

components/cryptauth/cryptauth_client_impl_unittest.cc

 // Copyright 2014 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 "components/proximity_auth/cryptauth/cryptauth_client_impl.h"
+#include "components/cryptauth/cryptauth_client_impl.h"
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/null_task_runner.h"
-#include "components/proximity_auth/cryptauth/cryptauth_access_token_fetcher.h"
-#include "components/proximity_auth/cryptauth/cryptauth_api_call_flow.h"
+#include "components/cryptauth/cryptauth_access_token_fetcher.h"
+#include "components/cryptauth/cryptauth_api_call_flow.h"
+#include "components/cryptauth/switches.h"
 #include "components/proximity_auth/cryptauth/proto/cryptauth_api.pb.h"
-#include "components/proximity_auth/cryptauth/switches.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 
-namespace proximity_auth {
+namespace cryptauth {
 
 namespace {
 
 const char kTestGoogleApisUrl[] = "https://www.testgoogleapis.com";
 const char kAccessToken[] = "access_token";
 const char kPublicKey1[] = "public_key1";
 const char kPublicKey2[] = "public_key2";
 const char kBluetoothAddress1[] = "AA:AA:AA:AA:AA:AA";
 const char kBluetoothAddress2[] = "BB:BB:BB:BB:BB:BB";
 
@@ skipping 46 matching lines @@
 }
 
 // Callback that saves the result returned by CryptAuthClient.
 template <class T>
 void SaveResult(T* out, const T& result) {
   *out = result;
 }
 
 }  // namespace
 
-class ProximityAuthCryptAuthClientTest : public testing::Test {
+class CryptAuthClientTest : public testing::Test {
  protected:
-  ProximityAuthCryptAuthClientTest()
+  CryptAuthClientTest()
       : access_token_fetcher_(new FakeCryptAuthAccessTokenFetcher()),
         api_call_flow_(new StrictMock<MockCryptAuthApiCallFlow>()),
         url_request_context_(
             new net::TestURLRequestContextGetter(new base::NullTaskRunner())),
         serialized_request_(std::string()) {}
 
   void SetUp() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kCryptAuthHTTPHost, kTestGoogleApisUrl);
 
@@ skipping 40 matching lines @@
   StrictMock<MockCryptAuthApiCallFlow>* api_call_flow_;
 
   scoped_refptr<net::URLRequestContextGetter> url_request_context_;
   std::unique_ptr<CryptAuthClient> client_;
 
   std::string serialized_request_;
   CryptAuthApiCallFlow::ResultCallback flow_result_callback_;
   CryptAuthApiCallFlow::ErrorCallback flow_error_callback_;
 };
 
-TEST_F(ProximityAuthCryptAuthClientTest, GetMyDevicesSuccess) {
+TEST_F(CryptAuthClientTest, GetMyDevicesSuccess) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   cryptauth::GetMyDevicesResponse result_proto;
   cryptauth::GetMyDevicesRequest request_proto;
   request_proto.set_allow_stale_read(true);
   client_->GetMyDevices(
       request_proto,
       base::Bind(&SaveResult<cryptauth::GetMyDevicesResponse>, &result_proto),
@@ skipping 19 matching lines @@
 
   // Check that the result received in callback is the same as the response.
   ASSERT_EQ(2, result_proto.devices_size());
   EXPECT_EQ(kPublicKey1, result_proto.devices(0).public_key());
   EXPECT_TRUE(result_proto.devices(0).unlock_key());
   EXPECT_EQ(kBluetoothAddress1, result_proto.devices(0).bluetooth_address());
   EXPECT_EQ(kPublicKey2, result_proto.devices(1).public_key());
   EXPECT_TRUE(result_proto.devices(1).unlockable());
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, GetMyDevicesFailure) {
+TEST_F(CryptAuthClientTest, GetMyDevicesFailure) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   std::string error_message;
   client_->GetMyDevices(cryptauth::GetMyDevicesRequest(),
                         base::Bind(&NotCalled<cryptauth::GetMyDevicesResponse>),
                         base::Bind(&SaveResult<std::string>, &error_message));
 
   std::string kStatus500Error("HTTP status: 500");
   FailApiCallFlow(kStatus500Error);
   EXPECT_EQ(kStatus500Error, error_message);
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, FindEligibleUnlockDevicesSuccess) {
+TEST_F(CryptAuthClientTest, FindEligibleUnlockDevicesSuccess) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "findeligibleunlockdevices?alt=proto");
 
   cryptauth::FindEligibleUnlockDevicesResponse result_proto;
   cryptauth::FindEligibleUnlockDevicesRequest request_proto;
   request_proto.set_callback_bluetooth_address(kBluetoothAddress2);
   client_->FindEligibleUnlockDevices(
       request_proto,
       base::Bind(&SaveResult<cryptauth::FindEligibleUnlockDevicesResponse>,
@@ skipping 22 matching lines @@
   ASSERT_EQ(1, result_proto.eligible_devices_size());
   EXPECT_EQ(kPublicKey1, result_proto.eligible_devices(0).public_key());
   ASSERT_EQ(1, result_proto.ineligible_devices_size());
   EXPECT_EQ(kPublicKey2,
             result_proto.ineligible_devices(0).device().public_key());
   ASSERT_EQ(1, result_proto.ineligible_devices(0).reasons_size());
   EXPECT_EQ(kIneligibilityReason,
             result_proto.ineligible_devices(0).reasons(0));
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, FindEligibleUnlockDevicesFailure) {
+TEST_F(CryptAuthClientTest, FindEligibleUnlockDevicesFailure) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "findeligibleunlockdevices?alt=proto");
 
   std::string error_message;
   cryptauth::FindEligibleUnlockDevicesRequest request_proto;
   request_proto.set_callback_bluetooth_address(kBluetoothAddress1);
   client_->FindEligibleUnlockDevices(
       request_proto,
       base::Bind(&NotCalled<cryptauth::FindEligibleUnlockDevicesResponse>),
       base::Bind(&SaveResult<std::string>, &error_message));
 
   std::string kStatus403Error("HTTP status: 403");
   FailApiCallFlow(kStatus403Error);
   EXPECT_EQ(kStatus403Error, error_message);
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, SendDeviceSyncTickleSuccess) {
+TEST_F(CryptAuthClientTest, SendDeviceSyncTickleSuccess) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "senddevicesynctickle?alt=proto");
 
   cryptauth::SendDeviceSyncTickleResponse result_proto;
   client_->SendDeviceSyncTickle(
       cryptauth::SendDeviceSyncTickleRequest(),
       base::Bind(&SaveResult<cryptauth::SendDeviceSyncTickleResponse>,
                  &result_proto),
       base::Bind(&NotCalled<std::string>));
 
   cryptauth::SendDeviceSyncTickleRequest expected_request;
   EXPECT_TRUE(expected_request.ParseFromString(serialized_request_));
 
   cryptauth::SendDeviceSyncTickleResponse response_proto;
   FinishApiCallFlow(&response_proto);
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, ToggleEasyUnlockSuccess) {
+TEST_F(CryptAuthClientTest, ToggleEasyUnlockSuccess) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "toggleeasyunlock?alt=proto");
 
   cryptauth::ToggleEasyUnlockResponse result_proto;
   cryptauth::ToggleEasyUnlockRequest request_proto;
   request_proto.set_enable(true);
   request_proto.set_apply_to_all(false);
   request_proto.set_public_key(kPublicKey1);
   client_->ToggleEasyUnlock(
       request_proto,
       base::Bind(&SaveResult<cryptauth::ToggleEasyUnlockResponse>,
                  &result_proto),
       base::Bind(&NotCalled<std::string>));
 
   cryptauth::ToggleEasyUnlockRequest expected_request;
   EXPECT_TRUE(expected_request.ParseFromString(serialized_request_));
   EXPECT_TRUE(expected_request.enable());
   EXPECT_EQ(kPublicKey1, expected_request.public_key());
   EXPECT_FALSE(expected_request.apply_to_all());
 
   cryptauth::ToggleEasyUnlockResponse response_proto;
   FinishApiCallFlow(&response_proto);
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, SetupEnrollmentSuccess) {
+TEST_F(CryptAuthClientTest, SetupEnrollmentSuccess) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/enrollment/"
       "setup?alt=proto");
 
   std::string kApplicationId = "mkaes";
   std::vector<std::string> supported_protocols;
   supported_protocols.push_back("gcmV1");
   supported_protocols.push_back("testProtocol");
 
   cryptauth::SetupEnrollmentResponse result_proto;
@@ skipping 25 matching lines @@
   }
 
   // Check that the returned proto is the same as the one just created.
   EXPECT_EQ("OK", result_proto.status());
   ASSERT_EQ(1, result_proto.infos_size());
   EXPECT_EQ("gcmV1", result_proto.infos(0).type());
   EXPECT_EQ("session_id", result_proto.infos(0).enrollment_session_id());
   EXPECT_EQ("ephemeral_key", result_proto.infos(0).server_ephemeral_key());
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, FinishEnrollmentSuccess) {
+TEST_F(CryptAuthClientTest, FinishEnrollmentSuccess) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/enrollment/"
       "finish?alt=proto");
 
   const char kEnrollmentSessionId[] = "enrollment_session_id";
   const char kEnrollmentMessage[] = "enrollment_message";
   const char kDeviceEphemeralKey[] = "device_ephermal_key";
   cryptauth::FinishEnrollmentResponse result_proto;
   cryptauth::FinishEnrollmentRequest request_proto;
   request_proto.set_enrollment_session_id(kEnrollmentSessionId);
@@ skipping 12 matching lines @@
   EXPECT_EQ(kDeviceEphemeralKey, expected_request.device_ephemeral_key());
 
   {
     cryptauth::FinishEnrollmentResponse response_proto;
     response_proto.set_status("OK");
     FinishApiCallFlow(&response_proto);
   }
   EXPECT_EQ("OK", result_proto.status());
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, FetchAccessTokenFailure) {
+TEST_F(CryptAuthClientTest, FetchAccessTokenFailure) {
   access_token_fetcher_->set_access_token("");
 
   std::string error_message;
   client_->GetMyDevices(cryptauth::GetMyDevicesRequest(),
                         base::Bind(&NotCalled<cryptauth::GetMyDevicesResponse>),
                         base::Bind(&SaveResult<std::string>, &error_message));
 
   EXPECT_EQ("Failed to get a valid access token.", error_message);
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, ParseResponseProtoFailure) {
+TEST_F(CryptAuthClientTest, ParseResponseProtoFailure) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   std::string error_message;
   client_->GetMyDevices(cryptauth::GetMyDevicesRequest(),
                         base::Bind(&NotCalled<cryptauth::GetMyDevicesResponse>),
                         base::Bind(&SaveResult<std::string>, &error_message));
 
   flow_result_callback_.Run("Not a valid serialized response message.");
   EXPECT_EQ("Failed to parse response proto.", error_message);
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest,
+TEST_F(CryptAuthClientTest,
        MakeSecondRequestBeforeFirstRequestSucceeds) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   // Make first request.
   cryptauth::GetMyDevicesResponse result_proto;
   client_->GetMyDevices(
       cryptauth::GetMyDevicesRequest(),
       base::Bind(&SaveResult<cryptauth::GetMyDevicesResponse>, &result_proto),
@@ skipping 15 matching lines @@
     cryptauth::GetMyDevicesResponse response_proto;
     response_proto.add_devices();
     response_proto.mutable_devices(0)->set_public_key(kPublicKey1);
     FinishApiCallFlow(&response_proto);
   }
 
   ASSERT_EQ(1, result_proto.devices_size());
   EXPECT_EQ(kPublicKey1, result_proto.devices(0).public_key());
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest,
+TEST_F(CryptAuthClientTest,
        MakeSecondRequestBeforeFirstRequestFails) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   // Make first request.
   std::string error_message;
   client_->GetMyDevices(cryptauth::GetMyDevicesRequest(),
                         base::Bind(&NotCalled<cryptauth::GetMyDevicesResponse>),
                         base::Bind(&SaveResult<std::string>, &error_message));
 
   // With request pending, make second request.
   {
     std::string error_message;
     client_->FindEligibleUnlockDevices(
         cryptauth::FindEligibleUnlockDevicesRequest(),
         base::Bind(&NotCalled<cryptauth::FindEligibleUnlockDevicesResponse>),
         base::Bind(&SaveResult<std::string>, &error_message));
     EXPECT_EQ("Client has been used for another request. Do not reuse.",
               error_message);
   }
 
   // Fail first request.
   std::string kStatus429Error = "HTTP status: 429";
   FailApiCallFlow(kStatus429Error);
   EXPECT_EQ(kStatus429Error, error_message);
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest,
+TEST_F(CryptAuthClientTest,
        MakeSecondRequestAfterFirstRequestSucceeds) {
   // Make first request successfully.
   {
     ExpectRequest(
         "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
         "getmydevices?alt=proto");
     cryptauth::GetMyDevicesResponse result_proto;
     client_->GetMyDevices(
         cryptauth::GetMyDevicesRequest(),
         base::Bind(&SaveResult<cryptauth::GetMyDevicesResponse>, &result_proto),
@@ skipping 12 matching lines @@
     std::string error_message;
     client_->FindEligibleUnlockDevices(
         cryptauth::FindEligibleUnlockDevicesRequest(),
         base::Bind(&NotCalled<cryptauth::FindEligibleUnlockDevicesResponse>),
         base::Bind(&SaveResult<std::string>, &error_message));
     EXPECT_EQ("Client has been used for another request. Do not reuse.",
               error_message);
   }
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, DeviceClassifierIsSet) {
+TEST_F(CryptAuthClientTest, DeviceClassifierIsSet) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   cryptauth::GetMyDevicesResponse result_proto;
   cryptauth::GetMyDevicesRequest request_proto;
   request_proto.set_allow_stale_read(true);
   client_->GetMyDevices(
       request_proto,
       base::Bind(&SaveResult<cryptauth::GetMyDevicesResponse>, &result_proto),
       base::Bind(&NotCalled<std::string>));
   cryptauth::GetMyDevicesRequest expected_request;
   EXPECT_TRUE(expected_request.ParseFromString(serialized_request_));
 
   const cryptauth::DeviceClassifier& device_classifier =
       expected_request.device_classifier();
   EXPECT_EQ(kDeviceOsVersionCode, device_classifier.device_os_version_code());
   EXPECT_EQ(kDeviceSoftwareVersionCode,
             device_classifier.device_software_version_code());
   EXPECT_EQ(kDeviceSoftwarePackage,
             device_classifier.device_software_package());
   EXPECT_EQ(kDeviceType, device_classifier.device_type());
 }
 
-TEST_F(ProximityAuthCryptAuthClientTest, GetAccessTokenUsed) {
+TEST_F(CryptAuthClientTest, GetAccessTokenUsed) {
   EXPECT_TRUE(client_->GetAccessTokenUsed().empty());
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   cryptauth::GetMyDevicesResponse result_proto;
   cryptauth::GetMyDevicesRequest request_proto;
   request_proto.set_allow_stale_read(true);
   client_->GetMyDevices(
       request_proto,
       base::Bind(&SaveResult<cryptauth::GetMyDevicesResponse>, &result_proto),
       base::Bind(&NotCalled<std::string>));
   EXPECT_EQ(kAccessToken, client_->GetAccessTokenUsed());
 }
 
-}  // namespace proximity_auth
+}  // namespace cryptauth