Index: device/u2f/u2f_hid_device_unittest.cc |
diff --git a/device/u2f/u2f_hid_device_unittest.cc b/device/u2f/u2f_hid_device_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..e3125df3c669f0a44c1f1afc01b2c88a4840e9ba |
--- /dev/null |
+++ b/device/u2f/u2f_hid_device_unittest.cc |
@@ -0,0 +1,316 @@ |
+// 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 <list> |
+ |
+#include "base/bind.h" |
+#include "base/memory/ptr_util.h" |
+#include "base/run_loop.h" |
+#include "base/test/test_io_thread.h" |
+#include "base/threading/thread_task_runner_handle.h" |
+#include "device/base/mock_device_client.h" |
+#include "device/hid/hid_connection.h" |
+#include "device/hid/hid_device_filter.h" |
+#include "device/hid/mock_hid_service.h" |
+#include "device/test/test_device_client.h" |
+#include "testing/gmock/include/gmock/gmock.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+#include "u2f_apdu_command.h" |
+#include "u2f_apdu_response.h" |
+#include "u2f_hid_device.h" |
+#include "u2f_packet.h" |
+ |
+namespace { |
+ |
+#if defined(OS_MACOSX) |
+const uint64_t kTestDeviceId = 42; |
+#else |
+const char* kTestDeviceId = "device"; |
+#endif |
+ |
+void ResponseCallback(scoped_refptr<device::U2fApduResponse>* output, |
+ bool success, |
+ scoped_refptr<device::U2fApduResponse> response) { |
+ *output = response; |
+} |
+ |
+class MockHidErrorConnection : public device::HidConnection { |
+ public: |
+ explicit MockHidErrorConnection( |
+ scoped_refptr<device::HidDeviceInfo> device_info) |
+ : device::HidConnection(device_info) {} |
+ |
+ void PlatformClose() override {} |
+ |
+ void PlatformRead(const ReadCallback& callback) override {} |
+ |
+ void PlatformWrite(scoped_refptr<net::IOBuffer> buffer, |
+ size_t size, |
+ const WriteCallback& callback) override { |
+ callback.Run(false); |
+ } |
+ |
+ void PlatformGetFeatureReport(uint8_t report_id, |
+ const ReadCallback& callback) override {} |
+ |
+ void PlatformSendFeatureReport(scoped_refptr<net::IOBuffer> buffer, |
+ size_t size, |
+ const WriteCallback& callback) override {} |
+ |
+ private: |
+ ~MockHidErrorConnection() override {} |
+}; |
+ |
+} // namespace |
+ |
+namespace device { |
+ |
+class U2fDeviceEnumerate { |
+ public: |
+ U2fDeviceEnumerate() |
+ : closure_(), |
+ callback_(base::Bind(&U2fDeviceEnumerate::ReceivedCallback, |
+ base::Unretained(this))), |
+ run_loop_() {} |
+ ~U2fDeviceEnumerate() {} |
+ |
+ void ReceivedCallback( |
+ const std::vector<scoped_refptr<HidDeviceInfo>>& devices) { |
+ std::list<std::unique_ptr<U2fHidDevice>> u2f_devices; |
+ filter_.SetUsagePage(0xf1d0); |
+ for (auto device_info : devices) { |
+ if (filter_.Matches(device_info)) |
+ u2f_devices.push_front(base::MakeUnique<U2fHidDevice>(device_info)); |
+ } |
+ devices_ = std::move(u2f_devices); |
+ closure_.Run(); |
+ } |
+ |
+ std::list<std::unique_ptr<U2fHidDevice>>& WaitForCallback() { |
+ closure_ = run_loop_.QuitClosure(); |
+ run_loop_.Run(); |
+ return devices_; |
+ } |
+ |
+ const HidService::GetDevicesCallback& callback() { return callback_; } |
+ |
+ private: |
+ HidDeviceFilter filter_; |
+ std::list<std::unique_ptr<U2fHidDevice>> devices_; |
+ base::Closure closure_; |
+ HidService::GetDevicesCallback callback_; |
+ base::RunLoop run_loop_; |
+}; |
+ |
+class TestVersionCallback { |
+ public: |
+ TestVersionCallback() |
+ : closure_(), |
+ callback_(base::Bind(&TestVersionCallback::ReceivedCallback, |
+ base::Unretained(this))), |
+ run_loop_() {} |
+ ~TestVersionCallback() {} |
+ |
+ void ReceivedCallback(bool success, U2fDevice::ProtocolVersion version) { |
+ version_ = version; |
+ closure_.Run(); |
+ } |
+ |
+ U2fDevice::ProtocolVersion WaitForCallback() { |
+ closure_ = run_loop_.QuitClosure(); |
+ run_loop_.Run(); |
+ return version_; |
+ } |
+ |
+ const U2fDevice::VersionCallback& callback() { return callback_; } |
+ |
+ private: |
+ U2fDevice::ProtocolVersion version_; |
+ base::Closure closure_; |
+ U2fDevice::VersionCallback callback_; |
+ base::RunLoop run_loop_; |
+}; |
+ |
+class TestDeviceCallback { |
+ public: |
+ TestDeviceCallback() |
+ : closure_(), |
+ callback_(base::Bind(&TestDeviceCallback::ReceivedCallback, |
+ base::Unretained(this))), |
+ run_loop_() {} |
+ ~TestDeviceCallback() {} |
+ |
+ void ReceivedCallback(bool success, scoped_refptr<U2fApduResponse> response) { |
+ response_ = response; |
+ closure_.Run(); |
+ } |
+ |
+ scoped_refptr<U2fApduResponse> WaitForCallback() { |
+ closure_ = run_loop_.QuitClosure(); |
+ run_loop_.Run(); |
+ return response_; |
+ } |
+ |
+ const U2fDevice::DeviceCallback& callback() { return callback_; } |
+ |
+ private: |
+ scoped_refptr<U2fApduResponse> response_; |
+ base::Closure closure_; |
+ U2fDevice::DeviceCallback callback_; |
+ base::RunLoop run_loop_; |
+}; |
+ |
+class U2fHidDeviceTest : public testing::Test { |
+ public: |
+ void SetUp() override { |
+ message_loop_.reset(new base::MessageLoopForUI()); |
+ io_thread_.reset(new base::TestIOThread(base::TestIOThread::kAutoStart)); |
+ device_client_.reset( |
+ new device::TestDeviceClient(io_thread_->task_runner())); |
+ } |
+ |
+ protected: |
+ std::unique_ptr<base::MessageLoopForUI> message_loop_; |
+ std::unique_ptr<base::TestIOThread> io_thread_; |
+ std::unique_ptr<device::TestDeviceClient> device_client_; |
+}; |
+ |
+TEST_F(U2fHidDeviceTest, TestHidDeviceVersion) { |
+ if (!U2fHidDevice::IsTestEnabled()) |
+ return; |
+ |
+ U2fDeviceEnumerate callback; |
+ HidService* hid_service = DeviceClient::Get()->GetHidService(); |
+ hid_service->GetDevices(callback.callback()); |
+ std::list<std::unique_ptr<U2fHidDevice>>& u2f_devices = |
+ callback.WaitForCallback(); |
+ |
+ for (auto& device : u2f_devices) { |
+ TestVersionCallback vc; |
+ device->Version(vc.callback()); |
+ U2fDevice::ProtocolVersion version = vc.WaitForCallback(); |
+ EXPECT_EQ(version, U2fDevice::ProtocolVersion::U2F_V2); |
+ } |
+}; |
+ |
+TEST_F(U2fHidDeviceTest, TestMultipleRequests) { |
+ if (!U2fHidDevice::IsTestEnabled()) |
+ return; |
+ |
+ U2fDeviceEnumerate callback; |
+ HidService* hid_service = DeviceClient::Get()->GetHidService(); |
+ hid_service->GetDevices(callback.callback()); |
+ std::list<std::unique_ptr<U2fHidDevice>>& u2f_devices = |
+ callback.WaitForCallback(); |
+ |
+ for (auto& device : u2f_devices) { |
+ TestVersionCallback vc; |
+ TestVersionCallback vc2; |
+ // Call version twice to check message queueing |
+ device->Version(vc.callback()); |
+ device->Version(vc2.callback()); |
+ U2fDevice::ProtocolVersion version = vc.WaitForCallback(); |
+ EXPECT_EQ(version, U2fDevice::ProtocolVersion::U2F_V2); |
+ version = vc2.WaitForCallback(); |
+ EXPECT_EQ(version, U2fDevice::ProtocolVersion::U2F_V2); |
+ } |
+}; |
+ |
+TEST_F(U2fHidDeviceTest, TestConnectionFailure) { |
+ // Setup and enumerate mock device |
+ auto client = base::MakeUnique<MockDeviceClient>(); |
+ U2fDeviceEnumerate callback; |
+ MockHidService* hid_service = client->hid_service(); |
+ HidCollectionInfo c_info; |
+ c_info.usage = HidUsageAndPage(1, static_cast<HidUsageAndPage::Page>(0xf1d0)); |
+ scoped_refptr<HidDeviceInfo> device0 = |
+ new HidDeviceInfo(kTestDeviceId, 0, 0, "Test Fido Device", "123FIDO", |
+ kHIDBusTypeUSB, c_info, 64, 64, 0); |
+ hid_service->AddDevice(device0); |
+ hid_service->FirstEnumerationComplete(); |
+ hid_service->GetDevices(callback.callback()); |
+ std::list<std::unique_ptr<U2fHidDevice>>& u2f_devices = |
+ callback.WaitForCallback(); |
+ |
+ ASSERT_EQ(static_cast<size_t>(1), u2f_devices.size()); |
+ auto& device = u2f_devices.front(); |
+ // Put device in IDLE state |
+ TestDeviceCallback cb0; |
+ device->state_ = U2fHidDevice::State::IDLE; |
+ |
+ // Manually delete connection |
+ device->connection_ = nullptr; |
+ // Add pending transactions manually and ensure they are processed |
+ scoped_refptr<U2fApduResponse> response1( |
+ U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0}))); |
+ device->pending_transactions_.push_back( |
+ {U2fApduCommand::CreateVersion(), |
+ base::Bind(&ResponseCallback, &response1)}); |
+ scoped_refptr<U2fApduResponse> response2( |
+ U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0}))); |
+ device->pending_transactions_.push_back( |
+ {U2fApduCommand::CreateVersion(), |
+ base::Bind(&ResponseCallback, &response2)}); |
+ scoped_refptr<U2fApduResponse> response3( |
+ U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0}))); |
+ device->DeviceTransact(U2fApduCommand::CreateVersion(), |
+ base::Bind(&ResponseCallback, &response3)); |
+ EXPECT_EQ(U2fHidDevice::State::DEVICE_ERROR, device->state_); |
+ EXPECT_EQ(nullptr, response1); |
+ EXPECT_EQ(nullptr, response2); |
+ EXPECT_EQ(nullptr, response3); |
+}; |
+ |
+TEST_F(U2fHidDeviceTest, TestDeviceError) { |
+ // Setup and enumerate mock device |
+ auto client = base::MakeUnique<MockDeviceClient>(); |
+ U2fDeviceEnumerate callback; |
+ MockHidService* hid_service = client->hid_service(); |
+ HidCollectionInfo c_info; |
+ c_info.usage = HidUsageAndPage(1, static_cast<HidUsageAndPage::Page>(0xf1d0)); |
+ scoped_refptr<HidDeviceInfo> device0 = |
+ new HidDeviceInfo(kTestDeviceId, 0, 0, "Test Fido Device", "123FIDO", |
+ kHIDBusTypeUSB, c_info, 64, 64, 0); |
+ hid_service->AddDevice(device0); |
+ hid_service->FirstEnumerationComplete(); |
+ hid_service->GetDevices(callback.callback()); |
+ std::list<std::unique_ptr<U2fHidDevice>>& u2f_devices = |
+ callback.WaitForCallback(); |
+ |
+ ASSERT_EQ(static_cast<size_t>(1), u2f_devices.size()); |
+ auto& device = u2f_devices.front(); |
+ // Mock connection where writes always fail |
+ scoped_refptr<MockHidErrorConnection> connection( |
+ new MockHidErrorConnection(device0)); |
+ device->connection_ = connection; |
+ device->state_ = U2fHidDevice::State::IDLE; |
+ scoped_refptr<U2fApduResponse> response0( |
+ U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0}))); |
+ device->DeviceTransact(U2fApduCommand::CreateVersion(), |
+ base::Bind(&ResponseCallback, &response0)); |
+ EXPECT_EQ(nullptr, response0); |
+ EXPECT_EQ(U2fHidDevice::State::DEVICE_ERROR, device->state_); |
+ |
+ // Add pending transactions manually and ensure they are processed |
+ scoped_refptr<U2fApduResponse> response1( |
+ U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0}))); |
+ device->pending_transactions_.push_back( |
+ {U2fApduCommand::CreateVersion(), |
+ base::Bind(&ResponseCallback, &response1)}); |
+ scoped_refptr<U2fApduResponse> response2( |
+ U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0}))); |
+ device->pending_transactions_.push_back( |
+ {U2fApduCommand::CreateVersion(), |
+ base::Bind(&ResponseCallback, &response2)}); |
+ scoped_refptr<U2fApduResponse> response3( |
+ U2fApduResponse::CreateFromMessage(std::vector<uint8_t>({0x0, 0x0}))); |
+ device->DeviceTransact(U2fApduCommand::CreateVersion(), |
+ base::Bind(&ResponseCallback, &response3)); |
+ EXPECT_EQ(U2fHidDevice::State::DEVICE_ERROR, device->state_); |
+ EXPECT_EQ(nullptr, response1); |
+ EXPECT_EQ(nullptr, response2); |
+ EXPECT_EQ(nullptr, response3); |
+}; |
+ |
+} // namespace device |