Skip to content

GitLab

T
tangled
Commit ba30df56 authored by Regan Hsu's avatar Regan Hsu Committed by Commit Bot
Browse files
Options

[CrOS MultiDevice] Add test double for DeviceCapabilityManager. 

Add FakeDeviceCapabilityManager, DeviceCapabilityManagerImpl,
and a factory for DeviceCapabilityManager.

Make DeviceCapabilityManager a pure virtual base class.

Bug: 752273
Change-Id: Ibf29b3a2cf893c2144315134e751884460ea3cd7
Reviewed-on: https://chromium-review.googlesource.com/671196
Commit-Queue: Regan Hsu <hsuregan@google.com>
Reviewed-by: default avatarKyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#503650}
parent 58efe2ac
Show whitespace changes
Inline Side-by-side
Showing with 410 additions and 186 deletions
components/cryptauth/BUILD.gn
View file @ ba30df56
......@@ -39,8 +39,9 @@ static_library("cryptauth") {
"cryptauth_service.h",
"data_with_timestamp.cc",
"data_with_timestamp.h",
"device_capability_manager.cc",
"device_capability_manager.h",
"device_capability_manager_impl.cc",
"device_capability_manager_impl.h",
"device_to_device_authenticator.cc",
"device_to_device_authenticator.h",
"device_to_device_initiator_helper.cc",
......@@ -119,6 +120,8 @@ static_library("test_support") {
"fake_cryptauth_gcm_manager.h",
"fake_cryptauth_service.cc",
"fake_cryptauth_service.h",
"fake_device_capability_manager.cc",
"fake_device_capability_manager.h",
"fake_remote_device_provider.cc",
"fake_remote_device_provider.h",
"fake_secure_channel.cc",
......@@ -165,7 +168,7 @@ source_set("unit_tests") {
"cryptauth_enroller_impl_unittest.cc",
"cryptauth_enrollment_manager_unittest.cc",
"cryptauth_gcm_manager_impl_unittest.cc",
"device_capability_manager_unittest.cc",
"device_capability_manager_impl_unittest.cc",
"device_to_device_authenticator_unittest.cc",
"device_to_device_operations_unittest.cc",
"device_to_device_secure_context_unittest.cc",
......
components/cryptauth/device_capability_manager.h
View file @ ba30df56
......@@ -5,12 +5,7 @@
#ifndef COMPONENTS_CRYPTAUTH_DEVICE_CAPABILITY_MANAGER_H_
#define COMPONENTS_CRYPTAUTH_DEVICE_CAPABILITY_MANAGER_H_
#include "base/bind.h"
#include "base/callback_forward.h"
#include "base/containers/queue.h"
#include "base/memory/ptr_util.h"
#include "base/memory/weak_ptr.h"
#include "components/cryptauth/cryptauth_client.h"
#include "base/callback.h"
#include "components/cryptauth/proto/cryptauth_api.pb.h"
namespace cryptauth {
......@@ -18,124 +13,33 @@ namespace cryptauth {
// DeviceCapabilityManager sends requests to the back-end which enable/disable
// device capabilities and finds devices which contain those capabilities. Here,
// the term "capability" refers to the ability of a device to use a given
// feature (e.g. EasyUnlock or Magic Tether).
// feature (e.g. EasyUnlock or Instant Tethering).
class DeviceCapabilityManager {
public:
// CAPABILITY_UNLOCK_KEY refers to EasyUnlock.
enum class Capability { CAPABILITY_UNLOCK_KEY };
DeviceCapabilityManager(CryptAuthClientFactory* cryptauth_client_factory);
virtual ~DeviceCapabilityManager(){};
~DeviceCapabilityManager();
// Enables or disables |capability| for the device corresponding to
// |public_key|. In error cases, |error_callback| is invoked with an error
// string.
void SetCapabilityEnabled(
virtual void SetCapabilityEnabled(
const std::string& public_key,
Capability capability,
bool enabled,
const base::Closure& success_callback,
const base::Callback<void(const std::string&)>& error_callback);
const base::Callback<void(const std::string&)>& error_callback) = 0;
// Fetches metadata about the device which are eligible for |capability|. In
// error cases, |error_callback| is invoked with an error string.
void FindEligibleDevicesForCapability(
virtual void FindEligibleDevicesForCapability(
Capability capability,
const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
const std::vector<IneligibleDevice>&)>&
success_callback,
const base::Callback<void(const std::string&)>& error_callback);
const base::Callback<void(const std::string&)>& error_callback) = 0;
// Determines whether a device with |public_key| is promotable for
// |capability|. In error cases, |error_callback| is invoked with an error
// string.
void IsCapabilityPromotable(
virtual void IsCapabilityPromotable(
const std::string& public_key,
Capability capability,
const base::Callback<void(bool)>& success_callback,
const base::Callback<void(const std::string&)>& error_callback);
private:
enum class RequestType {
SET_CAPABILITY_ENABLED,
FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY,
IS_CAPABILITY_PROMOTABLE
};
struct Request {
// Used for SET_CAPABILITY_ENABLED Requests.
Request(RequestType request_type,
Capability capability,
std::string public_key,
bool enabled,
const base::Closure& set_capability_callback,
const base::Callback<void(const std::string&)>& error_callback);
// Used for FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY Requests.
Request(RequestType request_type,
Capability capability,
const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
const std::vector<IneligibleDevice>&)>&
find_eligible_devices_callback,
const base::Callback<void(const std::string&)>& error_callback);
// Used for IS_CAPABILITY_PROMOTABLE Requests.
Request(RequestType request_type,
Capability capability,
std::string public_key,
const base::Callback<void(bool)> is_device_promotable_callback,
const base::Callback<void(const std::string&)>& error_callback);
~Request();
// Defined for every request.
RequestType request_type;
base::Callback<void(const std::string&)> error_callback;
Capability capability;
// Defined for SET_CAPABILITY_ENABLED and IS_CAPABILITY_PROMOTABLE;
// otherwise, unused.
std::string public_key;
// Defined if |request_type_| is SET_CAPABILITY_ENABLED; otherwise, unused.
base::Closure set_capability_callback;
bool enabled;
// Defined if |request_type_| is FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY;
// otherwise, unused.
base::Callback<void(const std::vector<ExternalDeviceInfo>&,
const std::vector<IneligibleDevice>&)>
find_eligible_devices_callback;
// Defined if |request_type_| is IS_CAPABILITY_PROMOTABLE; otherwise,
// unused.
base::Callback<void(bool)> is_device_promotable_callback;
};
void CreateNewCryptAuthClient();
void ProcessSetCapabilityEnabledRequest();
void ProcessFindEligibleDevicesForCapability();
void ProcessIsCapabilityPromotableRequest();
void SetUnlockKeyCapability();
void FindEligibleUnlockDevices();
void IsDeviceUnlockPromotable();
void OnToggleEasyUnlockResponse(const ToggleEasyUnlockResponse& response);
void OnFindEligibleUnlockDevicesResponse(
const FindEligibleUnlockDevicesResponse& response);
void OnIsDeviceUnlockPromotableResponse(
const FindEligibleForPromotionResponse& response);
void OnErrorResponse(const std::string& response);
void ProcessRequestQueue();
std::unique_ptr<CryptAuthClient> current_cryptauth_client_;
std::unique_ptr<Request> current_request_;
base::queue<std::unique_ptr<Request>> pending_requests_;
CryptAuthClientFactory* crypt_auth_client_factory_;
base::WeakPtrFactory<DeviceCapabilityManager> weak_ptr_factory_;
const base::Callback<void(const std::string&)>& error_callback) = 0;
};
} // namespace cryptauth
......
components/cryptauth/device_capability_manager.cc → components/cryptauth/device_capability_manager_impl.cc
View file @ ba30df56
......@@ -2,21 +2,47 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/cryptauth/device_capability_manager.h"
#include "components/cryptauth/device_capability_manager_impl.h"
#include "base/logging.h"
#include "components/cryptauth/proto/cryptauth_api.pb.h"
namespace cryptauth {
DeviceCapabilityManager::DeviceCapabilityManager(
// static
DeviceCapabilityManagerImpl::Factory*
DeviceCapabilityManagerImpl::Factory::factory_instance_ = nullptr;
// static
std::unique_ptr<DeviceCapabilityManager>
DeviceCapabilityManagerImpl::Factory::NewInstance(
CryptAuthClientFactory* cryptauth_client_factory) {
if (!factory_instance_) {
factory_instance_ = new Factory();
}
return factory_instance_->BuildInstance(cryptauth_client_factory);
}
void DeviceCapabilityManagerImpl::Factory::SetInstanceForTesting(
Factory* factory) {
factory_instance_ = factory;
}
std::unique_ptr<DeviceCapabilityManager>
DeviceCapabilityManagerImpl::Factory::BuildInstance(
CryptAuthClientFactory* cryptauth_client_factory) {
return base::WrapUnique(
new DeviceCapabilityManagerImpl(cryptauth_client_factory));
}
DeviceCapabilityManagerImpl::DeviceCapabilityManagerImpl(
CryptAuthClientFactory* cryptauth_client_factory)
: crypt_auth_client_factory_(cryptauth_client_factory),
weak_ptr_factory_(this) {}
DeviceCapabilityManager::~DeviceCapabilityManager() {}
DeviceCapabilityManagerImpl::~DeviceCapabilityManagerImpl() {}
void DeviceCapabilityManager::SetCapabilityEnabled(
void DeviceCapabilityManagerImpl::SetCapabilityEnabled(
const std::string& public_key,
Capability capability,
bool enabled,
......@@ -28,7 +54,7 @@ void DeviceCapabilityManager::SetCapabilityEnabled(
ProcessRequestQueue();
}
void DeviceCapabilityManager::FindEligibleDevicesForCapability(
void DeviceCapabilityManagerImpl::FindEligibleDevicesForCapability(
Capability capability,
const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
const std::vector<IneligibleDevice>&)>&
......@@ -40,7 +66,7 @@ void DeviceCapabilityManager::FindEligibleDevicesForCapability(
ProcessRequestQueue();
}
void DeviceCapabilityManager::IsCapabilityPromotable(
void DeviceCapabilityManagerImpl::IsCapabilityPromotable(
const std::string& public_key,
Capability capability,
const base::Callback<void(bool)>& success_callback,
......@@ -51,7 +77,7 @@ void DeviceCapabilityManager::IsCapabilityPromotable(
ProcessRequestQueue();
}
DeviceCapabilityManager::Request::Request(
DeviceCapabilityManagerImpl::Request::Request(
RequestType request_type,
Capability capability,
std::string public_key,
......@@ -65,7 +91,7 @@ DeviceCapabilityManager::Request::Request(
set_capability_callback(set_capability_callback),
enabled(enabled) {}
DeviceCapabilityManager::Request::Request(
DeviceCapabilityManagerImpl::Request::Request(
RequestType request_type,
Capability capability,
const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
......@@ -77,7 +103,7 @@ DeviceCapabilityManager::Request::Request(
capability(capability),
find_eligible_devices_callback(find_eligible_devices_callback) {}
DeviceCapabilityManager::Request::Request(
DeviceCapabilityManagerImpl::Request::Request(
RequestType request_type,
Capability capability,
std::string public_key,
......@@ -89,29 +115,29 @@ DeviceCapabilityManager::Request::Request(
public_key(public_key),
is_device_promotable_callback(is_device_promotable_callback) {}
DeviceCapabilityManager::Request::~Request() {}
DeviceCapabilityManagerImpl::Request::~Request() {}
void DeviceCapabilityManager::CreateNewCryptAuthClient() {
void DeviceCapabilityManagerImpl::CreateNewCryptAuthClient() {
DCHECK(!current_cryptauth_client_);
current_cryptauth_client_ = crypt_auth_client_factory_->CreateInstance();
}
void DeviceCapabilityManager::ProcessSetCapabilityEnabledRequest() {
void DeviceCapabilityManagerImpl::ProcessSetCapabilityEnabledRequest() {
DCHECK(current_request_->capability == Capability::CAPABILITY_UNLOCK_KEY);
SetUnlockKeyCapability();
}
void DeviceCapabilityManager::ProcessFindEligibleDevicesForCapability() {
void DeviceCapabilityManagerImpl::ProcessFindEligibleDevicesForCapability() {
DCHECK(current_request_->capability == Capability::CAPABILITY_UNLOCK_KEY);
FindEligibleUnlockDevices();
}
void DeviceCapabilityManager::ProcessIsCapabilityPromotableRequest() {
void DeviceCapabilityManagerImpl::ProcessIsCapabilityPromotableRequest() {
DCHECK(current_request_->capability == Capability::CAPABILITY_UNLOCK_KEY);
IsDeviceUnlockPromotable();
}
void DeviceCapabilityManager::SetUnlockKeyCapability() {
void DeviceCapabilityManagerImpl::SetUnlockKeyCapability() {
CreateNewCryptAuthClient();
ToggleEasyUnlockRequest request;
......@@ -121,24 +147,25 @@ void DeviceCapabilityManager::SetUnlockKeyCapability() {
current_cryptauth_client_->ToggleEasyUnlock(
request,
base::Bind(&DeviceCapabilityManager::OnToggleEasyUnlockResponse,
base::Bind(&DeviceCapabilityManagerImpl::OnToggleEasyUnlockResponse,
weak_ptr_factory_.GetWeakPtr()),
base::Bind(&DeviceCapabilityManager::OnErrorResponse,
base::Bind(&DeviceCapabilityManagerImpl::OnErrorResponse,
weak_ptr_factory_.GetWeakPtr()));
}
void DeviceCapabilityManager::FindEligibleUnlockDevices() {
void DeviceCapabilityManagerImpl::FindEligibleUnlockDevices() {
CreateNewCryptAuthClient();
current_cryptauth_client_->FindEligibleUnlockDevices(
FindEligibleUnlockDevicesRequest(),
base::Bind(&DeviceCapabilityManager::OnFindEligibleUnlockDevicesResponse,
base::Bind(
&DeviceCapabilityManagerImpl::OnFindEligibleUnlockDevicesResponse,
weak_ptr_factory_.GetWeakPtr()),
base::Bind(&DeviceCapabilityManager::OnErrorResponse,
base::Bind(&DeviceCapabilityManagerImpl::OnErrorResponse,
weak_ptr_factory_.GetWeakPtr()));
}
void DeviceCapabilityManager::IsDeviceUnlockPromotable() {
void DeviceCapabilityManagerImpl::IsDeviceUnlockPromotable() {
CreateNewCryptAuthClient();
FindEligibleForPromotionRequest request;
......@@ -146,13 +173,14 @@ void DeviceCapabilityManager::IsDeviceUnlockPromotable() {
current_cryptauth_client_->FindEligibleForPromotion(
request,
base::Bind(&DeviceCapabilityManager::OnIsDeviceUnlockPromotableResponse,
base::Bind(
&DeviceCapabilityManagerImpl::OnIsDeviceUnlockPromotableResponse,
weak_ptr_factory_.GetWeakPtr()),
base::Bind(&DeviceCapabilityManager::OnErrorResponse,
base::Bind(&DeviceCapabilityManagerImpl::OnErrorResponse,
weak_ptr_factory_.GetWeakPtr()));
}
void DeviceCapabilityManager::OnToggleEasyUnlockResponse(
void DeviceCapabilityManagerImpl::OnToggleEasyUnlockResponse(
const ToggleEasyUnlockResponse& response) {
current_cryptauth_client_.reset();
current_request_->set_capability_callback.Run();
......@@ -160,7 +188,7 @@ void DeviceCapabilityManager::OnToggleEasyUnlockResponse(
ProcessRequestQueue();
}
void DeviceCapabilityManager::OnFindEligibleUnlockDevicesResponse(
void DeviceCapabilityManagerImpl::OnFindEligibleUnlockDevicesResponse(
const FindEligibleUnlockDevicesResponse& response) {
current_cryptauth_client_.reset();
current_request_->find_eligible_devices_callback.Run(
......@@ -172,7 +200,7 @@ void DeviceCapabilityManager::OnFindEligibleUnlockDevicesResponse(
ProcessRequestQueue();
}
void DeviceCapabilityManager::OnIsDeviceUnlockPromotableResponse(
void DeviceCapabilityManagerImpl::OnIsDeviceUnlockPromotableResponse(
const FindEligibleForPromotionResponse& response) {
current_cryptauth_client_.reset();
current_request_->is_device_promotable_callback.Run(
......@@ -181,14 +209,14 @@ void DeviceCapabilityManager::OnIsDeviceUnlockPromotableResponse(
ProcessRequestQueue();
}
void DeviceCapabilityManager::OnErrorResponse(const std::string& response) {
void DeviceCapabilityManagerImpl::OnErrorResponse(const std::string& response) {
current_cryptauth_client_.reset();
current_request_->error_callback.Run(response);
current_request_.reset();
ProcessRequestQueue();
}
void DeviceCapabilityManager::ProcessRequestQueue() {
void DeviceCapabilityManagerImpl::ProcessRequestQueue() {
if (current_request_ || pending_requests_.empty())
return;
......
components/cryptauth/device_capability_manager_impl.h 0 → 100644
View file @ ba30df56
// Copyright 2017 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.
#ifndef COMPONENTS_CRYPTAUTH_DEVICE_CAPABILITY_MANAGER_IMPL_H_
#define COMPONENTS_CRYPTAUTH_DEVICE_CAPABILITY_MANAGER_IMPL_H_
#include "base/bind.h"
#include "base/callback_forward.h"
#include "base/containers/queue.h"
#include "base/memory/ptr_util.h"
#include "base/memory/weak_ptr.h"
#include "components/cryptauth/cryptauth_client.h"
#include "components/cryptauth/device_capability_manager.h"
#include "components/cryptauth/proto/cryptauth_api.pb.h"
namespace cryptauth {
using Capability = DeviceCapabilityManager::Capability;
// Concrete DeviceCapabilityManager implementation.
class DeviceCapabilityManagerImpl : public DeviceCapabilityManager {
public:
class Factory {
public:
static std::unique_ptr<DeviceCapabilityManager> NewInstance(
CryptAuthClientFactory* cryptauth_client_factory);
static void SetInstanceForTesting(Factory* factory);
protected:
virtual std::unique_ptr<DeviceCapabilityManager> BuildInstance(
CryptAuthClientFactory* cryptauth_client_factory);
private:
static Factory* factory_instance_;
};
DeviceCapabilityManagerImpl(CryptAuthClientFactory* cryptauth_client_factory);
~DeviceCapabilityManagerImpl() override;
// Enables or disables |capability| for the device corresponding to
// |public_key|. In error cases, |error_callback| is invoked with an error
// string.
void SetCapabilityEnabled(
const std::string& public_key,
Capability capability,
bool enabled,
const base::Closure& success_callback,
const base::Callback<void(const std::string&)>& error_callback) override;
// Fetches metadata about the device which are eligible for |capability|. In
// error cases, |error_callback| is invoked with an error string.
void FindEligibleDevicesForCapability(
Capability capability,
const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
const std::vector<IneligibleDevice>&)>&
success_callback,
const base::Callback<void(const std::string&)>& error_callback) override;
// Determines whether a device with |public_key| is promotable for
// |capability|. In error cases, |error_callback| is invoked with an error
// string.
void IsCapabilityPromotable(
const std::string& public_key,
Capability capability,
const base::Callback<void(bool)>& success_callback,
const base::Callback<void(const std::string&)>& error_callback) override;
private:
enum class RequestType {
SET_CAPABILITY_ENABLED,
FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY,
IS_CAPABILITY_PROMOTABLE
};
struct Request {
// Used for SET_CAPABILITY_ENABLED Requests.
Request(RequestType request_type,
Capability capability,
std::string public_key,
bool enabled,
const base::Closure& set_capability_callback,
const base::Callback<void(const std::string&)>& error_callback);
// Used for FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY Requests.
Request(RequestType request_type,
Capability capability,
const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
const std::vector<IneligibleDevice>&)>&
find_eligible_devices_callback,
const base::Callback<void(const std::string&)>& error_callback);
// Used for IS_CAPABILITY_PROMOTABLE Requests.
Request(RequestType request_type,
Capability capability,
std::string public_key,
const base::Callback<void(bool)> is_device_promotable_callback,
const base::Callback<void(const std::string&)>& error_callback);
~Request();
// Defined for every request.
RequestType request_type;
base::Callback<void(const std::string&)> error_callback;
Capability capability;
// Defined for SET_CAPABILITY_ENABLED and IS_CAPABILITY_PROMOTABLE;
// otherwise, unused.
std::string public_key;
// Defined if |request_type_| is SET_CAPABILITY_ENABLED; otherwise, unused.
base::Closure set_capability_callback;
bool enabled;
// Defined if |request_type_| is FIND_ELIGIBLE_DEVICES_FOR_CAPABILITY;
// otherwise, unused.
base::Callback<void(const std::vector<ExternalDeviceInfo>&,
const std::vector<IneligibleDevice>&)>
find_eligible_devices_callback;
// Defined if |request_type_| is IS_CAPABILITY_PROMOTABLE; otherwise,
// unused.
base::Callback<void(bool)> is_device_promotable_callback;
};
void CreateNewCryptAuthClient();
void ProcessSetCapabilityEnabledRequest();
void ProcessFindEligibleDevicesForCapability();
void ProcessIsCapabilityPromotableRequest();
void SetUnlockKeyCapability();
void FindEligibleUnlockDevices();
void IsDeviceUnlockPromotable();
void OnToggleEasyUnlockResponse(const ToggleEasyUnlockResponse& response);
void OnFindEligibleUnlockDevicesResponse(
const FindEligibleUnlockDevicesResponse& response);
void OnIsDeviceUnlockPromotableResponse(
const FindEligibleForPromotionResponse& response);
void OnErrorResponse(const std::string& response);
void ProcessRequestQueue();
std::unique_ptr<CryptAuthClient> current_cryptauth_client_;
std::unique_ptr<Request> current_request_;
base::queue<std::unique_ptr<Request>> pending_requests_;
CryptAuthClientFactory* crypt_auth_client_factory_;
base::WeakPtrFactory<DeviceCapabilityManagerImpl> weak_ptr_factory_;
};
} // namespace cryptauth
#endif // COMPONENTS_CRYPTAUTH_DEVICE_CAPABILITY_MANAGER_IMPL_H_
components/cryptauth/device_capability_manager_unittest.cc → components/cryptauth/device_capability_manager_impl_unittest.cc
View file @ ba30df56
......@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/cryptauth/device_capability_manager.h"
#include "components/cryptauth/device_capability_manager_impl.h"
#include <stddef.h>
......@@ -51,11 +51,11 @@ CreateExternalDeviceInfosForRemoteDevices(
} // namespace
class DeviceCapabilityManagerTest
class DeviceCapabilityManagerImplTest
: public testing::Test,
public MockCryptAuthClientFactory::Observer {
public:
DeviceCapabilityManagerTest()
DeviceCapabilityManagerImplTest()
: all_test_external_device_infos_(
CreateExternalDeviceInfosForRemoteDevices(
cryptauth::GenerateTestRemoteDevices(5))),
......@@ -72,20 +72,22 @@ class DeviceCapabilityManagerTest
base::MakeUnique<MockCryptAuthClientFactory>(
MockCryptAuthClientFactory::MockType::MAKE_NICE_MOCKS);
mock_cryptauth_client_factory_->AddObserver(this);
device_capability_manager_ = base::MakeUnique<DeviceCapabilityManager>(
device_capability_manager_ = base::MakeUnique<DeviceCapabilityManagerImpl>(
mock_cryptauth_client_factory_.get());
}
void OnCryptAuthClientCreated(MockCryptAuthClient* client) override {
ON_CALL(*client, ToggleEasyUnlock(_, _, _))
.WillByDefault(
Invoke(this, &DeviceCapabilityManagerTest::MockToggleEasyUnlock));
.WillByDefault(Invoke(
this, &DeviceCapabilityManagerImplTest::MockToggleEasyUnlock));
ON_CALL(*client, FindEligibleUnlockDevices(_, _, _))
.WillByDefault(Invoke(
this, &DeviceCapabilityManagerTest::MockFindEligibleUnlockDevices));
this,
&DeviceCapabilityManagerImplTest::MockFindEligibleUnlockDevices));
ON_CALL(*client, FindEligibleForPromotion(_, _, _))
.WillByDefault(Invoke(
this, &DeviceCapabilityManagerTest::MockFindEligibleForPromotion));
this,
&DeviceCapabilityManagerImplTest::MockFindEligibleForPromotion));
}
// Mock CryptAuthClient::ToggleEasyUnlock() implementation.
......@@ -160,37 +162,37 @@ class DeviceCapabilityManagerTest
result_ineligible_devices_.clear();
}
void SetCapabilityEnabled(DeviceCapabilityManager::Capability capability,
void SetCapabilityEnabled(DeviceCapabilityManagerImpl::Capability capability,
const ExternalDeviceInfo& device_info,
bool enable) {
device_capability_manager_->SetCapabilityEnabled(
device_info.public_key(), capability, enable,
base::Bind(&DeviceCapabilityManagerTest::
base::Bind(&DeviceCapabilityManagerImplTest::
TestSuccessSetCapabilityKeyUnlockCallback,
base::Unretained(this)),
base::Bind(&DeviceCapabilityManagerTest::TestErrorCallback,
base::Bind(&DeviceCapabilityManagerImplTest::TestErrorCallback,
base::Unretained(this)));
}
void FindEligibleDevicesForCapability(
DeviceCapabilityManager::Capability capability) {
DeviceCapabilityManagerImpl::Capability capability) {
device_capability_manager_->FindEligibleDevicesForCapability(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
base::Bind(&DeviceCapabilityManagerTest::
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
base::Bind(&DeviceCapabilityManagerImplTest::
TestSuccessFindEligibleUnlockDevicesCallback,
base::Unretained(this)),
base::Bind(&DeviceCapabilityManagerTest::TestErrorCallback,
base::Bind(&DeviceCapabilityManagerImplTest::TestErrorCallback,
base::Unretained(this)));
}
void IsPromotableDevice(DeviceCapabilityManager::Capability capability,
void IsPromotableDevice(DeviceCapabilityManagerImpl::Capability capability,
const std::string& public_key) {
device_capability_manager_->IsCapabilityPromotable(
public_key, capability,
base::Bind(&DeviceCapabilityManagerTest::
base::Bind(&DeviceCapabilityManagerImplTest::
TestSuccessFindEligibleForPromotionDeviceCallback,
base::Unretained(this)),
base::Bind(&DeviceCapabilityManagerTest::TestErrorCallback,
base::Bind(&DeviceCapabilityManagerImplTest::TestErrorCallback,
base::Unretained(this)));
}
......@@ -265,7 +267,7 @@ class DeviceCapabilityManagerTest
const std::vector<ExternalDeviceInfo> test_ineligible_external_devices_infos_;
std::unique_ptr<MockCryptAuthClientFactory> mock_cryptauth_client_factory_;
std::unique_ptr<cryptauth::DeviceCapabilityManager>
std::unique_ptr<cryptauth::DeviceCapabilityManagerImpl>
device_capability_manager_;
CryptAuthClient::ToggleEasyUnlockCallback toggle_easy_unlock_callback_;
CryptAuthClient::FindEligibleUnlockDevicesCallback
......@@ -287,23 +289,25 @@ class DeviceCapabilityManagerTest
bool result_eligible_for_promotion_;
private:
DISALLOW_COPY_AND_ASSIGN(DeviceCapabilityManagerTest);
DISALLOW_COPY_AND_ASSIGN(DeviceCapabilityManagerImplTest);
};
TEST_F(DeviceCapabilityManagerTest, TestOrderUponMultipleRequests) {
TEST_F(DeviceCapabilityManagerImplTest, TestOrderUponMultipleRequests) {
SetCapabilityEnabled(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[0], true /* enable */);
FindEligibleDevicesForCapability(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY);
IsPromotableDevice(DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY);
IsPromotableDevice(
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[0].public_key());
SetCapabilityEnabled(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[1], true /* enable */);
FindEligibleDevicesForCapability(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY);
IsPromotableDevice(DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY);
IsPromotableDevice(
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[1].public_key());
InvokeSetCapabilityKeyUnlockCallback();
......@@ -331,15 +335,15 @@ TEST_F(DeviceCapabilityManagerTest, TestOrderUponMultipleRequests) {
EXPECT_TRUE(GetEligibleForPromotionAndReset());
}
TEST_F(DeviceCapabilityManagerTest, TestMultipleSetUnlocksRequests) {
TEST_F(DeviceCapabilityManagerImplTest, TestMultipleSetUnlocksRequests) {
SetCapabilityEnabled(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[0], true /* enable */);
SetCapabilityEnabled(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[1], true /* enable */);
SetCapabilityEnabled(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[2], true /* enable */);
InvokeErrorCallback();
......@@ -352,14 +356,14 @@ TEST_F(DeviceCapabilityManagerTest, TestMultipleSetUnlocksRequests) {
EXPECT_EQ(kSuccessResult, GetResultAndReset());
}
TEST_F(DeviceCapabilityManagerTest,
TEST_F(DeviceCapabilityManagerImplTest,
TestMultipleFindEligibleForUnlockDevicesRequests) {
FindEligibleDevicesForCapability(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY);
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY);
FindEligibleDevicesForCapability(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY);
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY);
FindEligibleDevicesForCapability(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY);
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY);
InvokeFindEligibleUnlockDevicesCallback(
CreateFindEligibleUnlockDevicesResponse());
......@@ -375,12 +379,15 @@ TEST_F(DeviceCapabilityManagerTest,
VerifyDeviceEligibility();
}
TEST_F(DeviceCapabilityManagerTest, TestMultipleIsPromotableRequests) {
IsPromotableDevice(DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
TEST_F(DeviceCapabilityManagerImplTest, TestMultipleIsPromotableRequests) {
IsPromotableDevice(
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[0].public_key());
IsPromotableDevice(DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
IsPromotableDevice(
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[1].public_key());
IsPromotableDevice(DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
IsPromotableDevice(
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[2].public_key());
InvokeFindEligibleForPromotionCallback(true /*eligible*/);
......@@ -395,13 +402,14 @@ TEST_F(DeviceCapabilityManagerTest, TestMultipleIsPromotableRequests) {
EXPECT_EQ(kErrorFindEligibleForPromotion, GetResultAndReset());
}
TEST_F(DeviceCapabilityManagerTest, TestOrderViaMultipleErrors) {
TEST_F(DeviceCapabilityManagerImplTest, TestOrderViaMultipleErrors) {
SetCapabilityEnabled(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[0], true /* enable */);
FindEligibleDevicesForCapability(
DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY);
IsPromotableDevice(DeviceCapabilityManager::Capability::CAPABILITY_UNLOCK_KEY,
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY);
IsPromotableDevice(
DeviceCapabilityManagerImpl::Capability::CAPABILITY_UNLOCK_KEY,
test_eligible_external_devices_infos_[0].public_key());
InvokeErrorCallback();
......
components/cryptauth/fake_device_capability_manager.cc 0 → 100644
View file @ ba30df56
// Copyright 2017 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/cryptauth/fake_device_capability_manager.h"
namespace cryptauth {
FakeDeviceCapabilityManager::FakeDeviceCapabilityManager() {}
FakeDeviceCapabilityManager::~FakeDeviceCapabilityManager() {}
void FakeDeviceCapabilityManager::SetCapabilityEnabled(
const std::string& public_key,
Capability capability,
bool enabled,
const base::Closure& success_callback,
const base::Callback<void(const std::string&)>& error_callback) {
if (set_capability_enabled_error_code_.empty()) {
success_callback.Run();
return;
}
error_callback.Run(std::move(set_capability_enabled_error_code_));
}
void FakeDeviceCapabilityManager::FindEligibleDevicesForCapability(
Capability capability,
const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
const std::vector<IneligibleDevice>&)>&
success_callback,
const base::Callback<void(const std::string&)>& error_callback) {
if (find_eligible_devices_for_capability_error_code_.empty()) {
success_callback.Run(external_device_infos_, ineligible_devices_);
return;
}
error_callback.Run(find_eligible_devices_for_capability_error_code_);
}
void FakeDeviceCapabilityManager::IsCapabilityPromotable(
const std::string& public_key,
Capability capability,
const base::Callback<void(bool)>& success_callback,
const base::Callback<void(const std::string&)>& error_callback) {
if (is_capability_promotable_error_code_.empty()) {
success_callback.Run(true /* capability is promotable */);
return;
}
error_callback.Run(is_capability_promotable_error_code_);
}
} // namespace cryptauth
\ No newline at end of file
components/cryptauth/fake_device_capability_manager.h 0 → 100644
View file @ ba30df56
// Copyright 2017 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.
#ifndef COMPONENTS_CRYPTAUTH_FAKE_DEVICE_CAPABILITY_MANAGER_H_
#define COMPONENTS_CRYPTAUTH_FAKE_DEVICE_CAPABILITY_MANAGER_H_
#include "base/callback.h"
#include "components/cryptauth/device_capability_manager.h"
#include "components/cryptauth/proto/cryptauth_api.pb.h"
namespace cryptauth {
using Capability = DeviceCapabilityManager::Capability;
// Test double for Device Capability Manager.
class FakeDeviceCapabilityManager : public cryptauth::DeviceCapabilityManager {
public:
FakeDeviceCapabilityManager();
~FakeDeviceCapabilityManager() override;
void set_find_eligible_devices_for_capability_error_code(
std::string error_code) {
find_eligible_devices_for_capability_error_code_ = error_code;
}
void set_capability_enabled_error_code(std::string error_code) {
set_capability_enabled_error_code_ = error_code;
LOG(ERROR) << set_capability_enabled_error_code_;
}
void set_is_capability_promotable_error_code(std::string error_code) {
is_capability_promotable_error_code_ = error_code;
}
void set_external_device_info(
std::vector<ExternalDeviceInfo> external_device_infos) {
external_device_infos_ = external_device_infos;
}
void set_ineligible_devices(
std::vector<IneligibleDevice> ineligible_devices) {
ineligible_devices_ = ineligible_devices;
}
// cryptauth::DeviceCapabilityManager:
void SetCapabilityEnabled(
const std::string& public_key,
Capability capability,
bool enabled,
const base::Closure& success_callback,
const base::Callback<void(const std::string&)>& error_callback) override;
void FindEligibleDevicesForCapability(
Capability capability,
const base::Callback<void(const std::vector<ExternalDeviceInfo>&,
const std::vector<IneligibleDevice>&)>&
success_callback,
const base::Callback<void(const std::string&)>& error_callback) override;
void IsCapabilityPromotable(
const std::string& public_key,
Capability capability,
const base::Callback<void(bool)>& success_callback,
const base::Callback<void(const std::string&)>& error_callback) override;
std::string set_capability_enabled_error_code_;
std::string find_eligible_devices_for_capability_error_code_;
std::string is_capability_promotable_error_code_;
std::vector<ExternalDeviceInfo> external_device_infos_;
std::vector<IneligibleDevice> ineligible_devices_;
};
} // namespace cryptauth
#endif // COMPONENTS_CRYPTAUTH_FAKE_DEVICE_CAPABILITY_MANAGER_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment