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

components/cryptauth/cryptauth_enroller_impl_unittest.cc

 // Copyright 2015 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_enroller_impl.h"
+#include "components/cryptauth/cryptauth_enroller_impl.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "components/proximity_auth/cryptauth/cryptauth_enrollment_utils.h"
-#include "components/proximity_auth/cryptauth/fake_secure_message_delegate.h"
-#include "components/proximity_auth/cryptauth/mock_cryptauth_client.h"
+#include "components/cryptauth/cryptauth_enrollment_utils.h"
+#include "components/cryptauth/fake_secure_message_delegate.h"
+#include "components/cryptauth/mock_cryptauth_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::Return;
 
-namespace proximity_auth {
+namespace cryptauth {
 
 namespace {
 
 const char kAccessTokenUsed[] = "access token used by CryptAuthClient";
 
 const char kClientSessionPublicKey[] = "throw away after one use";
 const char kServerSessionPublicKey[] = "disposables are not eco-friendly";
 
 cryptauth::InvocationReason kInvocationReason =
     cryptauth::INVOCATION_REASON_MANUAL;
@@ skipping 62 matching lines @@
                        bool verified,
                        const std::string& payload,
                        const securemessage::Header& header) {
   *verified_out = verified;
   *payload_out = payload;
   *header_out = header;
 }
 
 }  // namespace
 
-class ProximityAuthCryptAuthEnrollerTest
+class CryptAuthEnrollerTest
     : public testing::Test,
       public MockCryptAuthClientFactory::Observer {
  public:
-  ProximityAuthCryptAuthEnrollerTest()
+  CryptAuthEnrollerTest()
       : client_factory_(new MockCryptAuthClientFactory(
             MockCryptAuthClientFactory::MockType::MAKE_NICE_MOCKS)),
         secure_message_delegate_(new FakeSecureMessageDelegate()),
         enroller_(base::WrapUnique(client_factory_),
                   base::WrapUnique(secure_message_delegate_)) {
     client_factory_->AddObserver(this);
 
     // This call is actually synchronous.
     secure_message_delegate_->GenerateKeyPair(
-        base::Bind(&ProximityAuthCryptAuthEnrollerTest::OnKeyPairGenerated,
+        base::Bind(&CryptAuthEnrollerTest::OnKeyPairGenerated,
                    base::Unretained(this)));
   }
 
   // Starts the enroller.
   void StartEnroller(const cryptauth::GcmDeviceInfo& device_info) {
     secure_message_delegate_->set_next_public_key(kClientSessionPublicKey);
     enroller_result_.reset();
     enroller_.Enroll(
         user_public_key_, user_private_key_, device_info, kInvocationReason,
-        base::Bind(&ProximityAuthCryptAuthEnrollerTest::OnEnrollerCompleted,
+        base::Bind(&CryptAuthEnrollerTest::OnEnrollerCompleted,
                    base::Unretained(this)));
   }
 
   // Verifies that |serialized_message| is a valid SecureMessage sent with the
   // FinishEnrollment API call.
   void ValidateEnrollmentMessage(const std::string& serialized_message) {
     // Derive the session symmetric key.
     std::string server_session_private_key =
         secure_message_delegate_->GetPrivateKeyForPublicKey(
             kServerSessionPublicKey);
@@ skipping 45 matching lines @@
     EXPECT_EQ(user_public_key_, device_info.user_public_key());
     EXPECT_EQ(user_public_key_, device_info.key_handle());
     EXPECT_EQ(kEnrollmentSessionId, device_info.enrollment_session_id());
   }
 
  protected:
   // MockCryptAuthClientFactory::Observer:
   void OnCryptAuthClientCreated(MockCryptAuthClient* client) override {
     ON_CALL(*client, SetupEnrollment(_, _, _))
         .WillByDefault(Invoke(
-            this, &ProximityAuthCryptAuthEnrollerTest::OnSetupEnrollment));
+            this, &CryptAuthEnrollerTest::OnSetupEnrollment));
 
     ON_CALL(*client, FinishEnrollment(_, _, _))
         .WillByDefault(Invoke(
-            this, &ProximityAuthCryptAuthEnrollerTest::OnFinishEnrollment));
+            this, &CryptAuthEnrollerTest::OnFinishEnrollment));
 
     ON_CALL(*client, GetAccessTokenUsed())
         .WillByDefault(Return(kAccessTokenUsed));
   }
 
   void OnKeyPairGenerated(const std::string& public_key,
                           const std::string& private_key) {
     user_public_key_ = public_key;
     user_private_key_ = private_key;
   }
@@ skipping 46 matching lines @@
   // Stores the result of running |enroller_|.
   std::unique_ptr<bool> enroller_result_;
 
   // Stored callbacks and requests for SetupEnrollment and FinishEnrollment.
   std::unique_ptr<cryptauth::SetupEnrollmentRequest> setup_request_;
   std::unique_ptr<cryptauth::FinishEnrollmentRequest> finish_request_;
   CryptAuthClient::SetupEnrollmentCallback setup_callback_;
   CryptAuthClient::FinishEnrollmentCallback finish_callback_;
   CryptAuthClient::ErrorCallback error_callback_;
 
-  DISALLOW_COPY_AND_ASSIGN(ProximityAuthCryptAuthEnrollerTest);
+  DISALLOW_COPY_AND_ASSIGN(CryptAuthEnrollerTest);
 };
 
-TEST_F(ProximityAuthCryptAuthEnrollerTest, EnrollmentSucceeds) {
+TEST_F(CryptAuthEnrollerTest, EnrollmentSucceeds) {
   StartEnroller(GetDeviceInfo());
 
   // Handle SetupEnrollment request.
   EXPECT_TRUE(setup_request_.get());
   EXPECT_EQ(kInvocationReason, setup_request_->invocation_reason());
   ASSERT_EQ(1, setup_request_->types_size());
   EXPECT_EQ(kSupportedEnrollmentTypeGcmV1, setup_request_->types(0));
   ASSERT_FALSE(setup_callback_.is_null());
   setup_callback_.Run(GetSetupEnrollmentResponse(true));
 
   // Handle FinishEnrollment request.
   EXPECT_TRUE(finish_request_.get());
   EXPECT_EQ(kEnrollmentSessionId, finish_request_->enrollment_session_id());
   EXPECT_EQ(kClientSessionPublicKey, finish_request_->device_ephemeral_key());
   ValidateEnrollmentMessage(finish_request_->enrollment_message());
   EXPECT_EQ(kInvocationReason, finish_request_->invocation_reason());
 
   ASSERT_FALSE(finish_callback_.is_null());
   finish_callback_.Run(GetFinishEnrollmentResponse(true));
 
   ASSERT_TRUE(enroller_result_.get());
   EXPECT_TRUE(*enroller_result_);
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollerTest, SetupEnrollmentApiCallError) {
+TEST_F(CryptAuthEnrollerTest, SetupEnrollmentApiCallError) {
   StartEnroller(GetDeviceInfo());
 
   EXPECT_TRUE(setup_request_.get());
   ASSERT_FALSE(error_callback_.is_null());
   error_callback_.Run("Setup enrollment failed network");
 
   EXPECT_TRUE(finish_callback_.is_null());
   ASSERT_TRUE(enroller_result_.get());
   EXPECT_FALSE(*enroller_result_);
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollerTest, SetupEnrollmentBadStatus) {
+TEST_F(CryptAuthEnrollerTest, SetupEnrollmentBadStatus) {
   StartEnroller(GetDeviceInfo());
 
   EXPECT_TRUE(setup_request_.get());
   setup_callback_.Run(GetSetupEnrollmentResponse(false));
 
   EXPECT_TRUE(finish_callback_.is_null());
   ASSERT_TRUE(enroller_result_.get());
   EXPECT_FALSE(*enroller_result_);
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollerTest, SetupEnrollmentNoInfosReturned) {
+TEST_F(CryptAuthEnrollerTest, SetupEnrollmentNoInfosReturned) {
   StartEnroller(GetDeviceInfo());
   EXPECT_TRUE(setup_request_.get());
   cryptauth::SetupEnrollmentResponse response;
   response.set_status(kResponseStatusOk);
   setup_callback_.Run(response);
 
   EXPECT_TRUE(finish_callback_.is_null());
   ASSERT_TRUE(enroller_result_.get());
   EXPECT_FALSE(*enroller_result_);
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollerTest, FinishEnrollmentApiCallError) {
+TEST_F(CryptAuthEnrollerTest, FinishEnrollmentApiCallError) {
   StartEnroller(GetDeviceInfo());
   setup_callback_.Run(GetSetupEnrollmentResponse(true));
   ASSERT_FALSE(error_callback_.is_null());
   error_callback_.Run("finish enrollment oauth error");
   ASSERT_TRUE(enroller_result_.get());
   EXPECT_FALSE(*enroller_result_);
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollerTest, FinishEnrollmentBadStatus) {
+TEST_F(CryptAuthEnrollerTest, FinishEnrollmentBadStatus) {
   StartEnroller(GetDeviceInfo());
   setup_callback_.Run(GetSetupEnrollmentResponse(true));
   ASSERT_FALSE(finish_callback_.is_null());
   finish_callback_.Run(GetFinishEnrollmentResponse(false));
   ASSERT_TRUE(enroller_result_.get());
   EXPECT_FALSE(*enroller_result_);
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollerTest, ReuseEnroller) {
+TEST_F(CryptAuthEnrollerTest, ReuseEnroller) {
   StartEnroller(GetDeviceInfo());
   setup_callback_.Run(GetSetupEnrollmentResponse(true));
   finish_callback_.Run(GetFinishEnrollmentResponse(true));
   EXPECT_TRUE(*enroller_result_);
 
   StartEnroller(GetDeviceInfo());
   EXPECT_FALSE(*enroller_result_);
 }
 
-TEST_F(ProximityAuthCryptAuthEnrollerTest, IncompleteDeviceInfo) {
+TEST_F(CryptAuthEnrollerTest, IncompleteDeviceInfo) {
   StartEnroller(cryptauth::GcmDeviceInfo());
   ASSERT_TRUE(enroller_result_.get());
   EXPECT_FALSE(*enroller_result_);
 }
 
-}  // namespace proximity_auth
+}  // namespace cryptauth