components/webusb/webusb_detector_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/webusb/webusb_detector.h"
   6
   7 #include "base/macros.h"
   8 #include "base/strings/string16.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "components/webusb/webusb_browser_client.h"
  11 #include "device/core/device_client.h"
  12 #include "device/usb/mock_usb_device.h"
  13 #include "device/usb/mock_usb_service.h"
  14 #include "device/usb/usb_device.h"
  15 #include "device/usb/usb_service.h"
  16 #include "testing/gmock/include/gmock/gmock.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "url/gurl.h"
  19
  20 namespace {
  21
  22 // usb device product name
  23 const char* kProductName_1 = "Google Product A";
  24 const char* kProductName_2 = "Google Product B";
  25 const char* kProductName_3 = "Google Product C";
  26
  27 // usb device landing page
  28 const char* kLandingPage_1 = "https://www.google.com/A";
  29 const char* kLandingPage_2 = "https://www.google.com/B";
  30 const char* kLandingPage_3 = "https://www.google.com/C";
  31
  32 }  // namespace
  33
  34 namespace webusb {
  35
  36 namespace {
  37
  38 class TestDeviceClient : public device::DeviceClient {
  39  public:
  40   TestDeviceClient() : device::DeviceClient() {}
  41   ~TestDeviceClient() override {}
  42
  43   device::MockUsbService& mock_usb_service() { return usb_service_; }
  44
  45  private:
  46   device::UsbService* GetUsbService() override { return &usb_service_; }
  47
  48   device::MockUsbService usb_service_;
  49 };
  50
  51 class MockWebUsbBrowserClient : public webusb::WebUsbBrowserClient {
  52  public:
  53   MockWebUsbBrowserClient() {}
  54
  55   ~MockWebUsbBrowserClient() override {}
  56
  57   // webusb::WebUsbBrowserClient implementation
  58   MOCK_METHOD3(OnDeviceAdded,
  59                void(const base::string16& product_name,
  60                     const GURL& landing_page,
  61                     const std::string& notification_id));
  62
  63   // webusb::WebUsbBrowserClient implementation
  64   MOCK_METHOD1(OnDeviceRemoved, void(const std::string& notification_id));
  65
  66  private:
  67   DISALLOW_COPY_AND_ASSIGN(MockWebUsbBrowserClient);
  68 };
  69
  70 }  // namespace
  71
  72 class WebUsbDetectorTest : public testing::Test {
  73  public:
  74   WebUsbDetectorTest() {}
  75
  76   ~WebUsbDetectorTest() override = default;
  77
  78  protected:
  79   TestDeviceClient device_client_;
  80   MockWebUsbBrowserClient mock_webusb_browser_client_;
  81
  82   DISALLOW_COPY_AND_ASSIGN(WebUsbDetectorTest);
  83 };
  84
  85 TEST_F(WebUsbDetectorTest, UsbDeviceAdded) {
  86   base::string16 product_name = base::UTF8ToUTF16(kProductName_1);
  87   GURL landing_page(kLandingPage_1);
  88   scoped_refptr<device::MockUsbDevice> device(new device::MockUsbDevice(
  89       0, 1, "Google", kProductName_1, "002", landing_page));
  90   std::string guid = device->guid();
  91
  92   EXPECT_CALL(mock_webusb_browser_client_,
  93               OnDeviceAdded(product_name, landing_page, guid))
  94       .Times(1);
  95   EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(testing::_))
  96       .Times(0);
  97
  98   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
  99
 100   device_client_.mock_usb_service().AddDevice(device);
 101 }
 102
 103 TEST_F(WebUsbDetectorTest, UsbDeviceAddedAndRemoved) {
 104   base::string16 product_name = base::UTF8ToUTF16(kProductName_1);
 105   GURL landing_page(kLandingPage_1);
 106   scoped_refptr<device::MockUsbDevice> device(new device::MockUsbDevice(
 107       0, 1, "Google", kProductName_1, "002", landing_page));
 108   std::string guid = device->guid();
 109
 110   {
 111     testing::InSequence s;
 112     EXPECT_CALL(mock_webusb_browser_client_,
 113                 OnDeviceAdded(product_name, landing_page, guid))
 114         .Times(1);
 115     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid)).Times(1);
 116   }
 117
 118   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
 119
 120   device_client_.mock_usb_service().AddDevice(device);
 121   device_client_.mock_usb_service().RemoveDevice(device);
 122 }
 123
 124 TEST_F(WebUsbDetectorTest, UsbDeviceWithoutProductNameAddedAndRemoved) {
 125   std::string product_name = "";
 126   GURL landing_page(kLandingPage_1);
 127   scoped_refptr<device::MockUsbDevice> device(new device::MockUsbDevice(
 128       0, 1, "Google", product_name, "002", landing_page));
 129   std::string guid = device->guid();
 130
 131   EXPECT_CALL(mock_webusb_browser_client_,
 132               OnDeviceAdded(testing::_, testing::_, testing::_))
 133       .Times(0);
 134   EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid)).Times(1);
 135
 136   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
 137
 138   device_client_.mock_usb_service().AddDevice(device);
 139   device_client_.mock_usb_service().RemoveDevice(device);
 140 }
 141
 142 TEST_F(WebUsbDetectorTest, UsbDeviceWithoutLandingPageAddedAndRemoved) {
 143   GURL landing_page("");
 144   scoped_refptr<device::MockUsbDevice> device(new device::MockUsbDevice(
 145       0, 1, "Google", kProductName_1, "002", landing_page));
 146   std::string guid = device->guid();
 147
 148   EXPECT_CALL(mock_webusb_browser_client_,
 149               OnDeviceAdded(testing::_, testing::_, testing::_))
 150       .Times(0);
 151   EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid)).Times(1);
 152
 153   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
 154
 155   device_client_.mock_usb_service().AddDevice(device);
 156   device_client_.mock_usb_service().RemoveDevice(device);
 157 }
 158
 159 TEST_F(WebUsbDetectorTest, WebUsbBrowserClientIsNullptr) {
 160   GURL landing_page(kLandingPage_1);
 161   scoped_refptr<device::MockUsbDevice> device(new device::MockUsbDevice(
 162       0, 1, "Google", kProductName_1, "002", landing_page));
 163
 164   EXPECT_CALL(mock_webusb_browser_client_,
 165               OnDeviceAdded(testing::_, testing::_, testing::_))
 166       .Times(0);
 167   EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(testing::_))
 168       .Times(0);
 169
 170   webusb::WebUsbDetector webusb_detector(nullptr);
 171
 172   device_client_.mock_usb_service().AddDevice(device);
 173   device_client_.mock_usb_service().RemoveDevice(device);
 174 }
 175
 176 TEST_F(WebUsbDetectorTest, NoUsbService) {
 177   GURL landing_page(kLandingPage_1);
 178   scoped_refptr<device::MockUsbDevice> device(new device::MockUsbDevice(
 179       0, 1, "Google", kProductName_1, "002", landing_page));
 180
 181   EXPECT_CALL(mock_webusb_browser_client_,
 182               OnDeviceAdded(testing::_, testing::_, testing::_))
 183       .Times(0);
 184   EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(testing::_))
 185       .Times(0);
 186
 187   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
 188 }
 189
 190 TEST_F(WebUsbDetectorTest, UsbDeviceWasThereBeforeAndThenRemoved) {
 191   GURL landing_page(kLandingPage_1);
 192   scoped_refptr<device::MockUsbDevice> device(new device::MockUsbDevice(
 193       0, 1, "Google", kProductName_1, "002", landing_page));
 194   std::string guid = device->guid();
 195
 196   EXPECT_CALL(mock_webusb_browser_client_,
 197               OnDeviceAdded(testing::_, testing::_, testing::_))
 198       .Times(0);
 199   EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid)).Times(1);
 200
 201   // usb device was added before webusb_detector was created
 202   device_client_.mock_usb_service().AddDevice(device);
 203
 204   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
 205
 206   device_client_.mock_usb_service().RemoveDevice(device);
 207 }
 208
 209 TEST_F(
 210     WebUsbDetectorTest,
 211     ThreeUsbDevicesWereThereBeforeAndThenRemovedBeforeWebUsbDetectorWasCreated) {
 212   base::string16 product_name_1 = base::UTF8ToUTF16(kProductName_1);
 213   GURL landing_page_1(kLandingPage_1);
 214   scoped_refptr<device::MockUsbDevice> device_1(new device::MockUsbDevice(
 215       0, 1, "Google", kProductName_1, "002", landing_page_1));
 216   std::string guid_1 = device_1->guid();
 217
 218   base::string16 product_name_2 = base::UTF8ToUTF16(kProductName_2);
 219   GURL landing_page_2(kLandingPage_2);
 220   scoped_refptr<device::MockUsbDevice> device_2(new device::MockUsbDevice(
 221       3, 4, "Google", kProductName_2, "005", landing_page_2));
 222   std::string guid_2 = device_2->guid();
 223
 224   base::string16 product_name_3 = base::UTF8ToUTF16(kProductName_3);
 225   GURL landing_page_3(kLandingPage_3);
 226   scoped_refptr<device::MockUsbDevice> device_3(new device::MockUsbDevice(
 227       6, 7, "Google", kProductName_3, "008", landing_page_3));
 228   std::string guid_3 = device_3->guid();
 229
 230   EXPECT_CALL(mock_webusb_browser_client_,
 231               OnDeviceAdded(product_name_1, landing_page_1, guid_1))
 232       .Times(0);
 233   EXPECT_CALL(mock_webusb_browser_client_,
 234               OnDeviceAdded(product_name_2, landing_page_2, guid_2))
 235       .Times(0);
 236   EXPECT_CALL(mock_webusb_browser_client_,
 237               OnDeviceAdded(product_name_3, landing_page_3, guid_3))
 238       .Times(0);
 239
 240   EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_1)).Times(0);
 241   EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_2)).Times(0);
 242   EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_3)).Times(0);
 243
 244   // three usb devices were added and removed before webusb_detector was
 245   // created
 246   device_client_.mock_usb_service().AddDevice(device_1);
 247   device_client_.mock_usb_service().AddDevice(device_2);
 248   device_client_.mock_usb_service().AddDevice(device_3);
 249
 250   device_client_.mock_usb_service().RemoveDevice(device_1);
 251   device_client_.mock_usb_service().RemoveDevice(device_2);
 252   device_client_.mock_usb_service().RemoveDevice(device_3);
 253
 254   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
 255 }
 256
 257 TEST_F(
 258     WebUsbDetectorTest,
 259     ThreeUsbDevicesWereThereBeforeAndThenRemovedAfterWebUsbDetectorWasCreated) {
 260   base::string16 product_name_1 = base::UTF8ToUTF16(kProductName_1);
 261   GURL landing_page_1(kLandingPage_1);
 262   scoped_refptr<device::MockUsbDevice> device_1(new device::MockUsbDevice(
 263       0, 1, "Google", kProductName_1, "002", landing_page_1));
 264   std::string guid_1 = device_1->guid();
 265
 266   base::string16 product_name_2 = base::UTF8ToUTF16(kProductName_2);
 267   GURL landing_page_2(kLandingPage_2);
 268   scoped_refptr<device::MockUsbDevice> device_2(new device::MockUsbDevice(
 269       3, 4, "Google", kProductName_2, "005", landing_page_2));
 270   std::string guid_2 = device_2->guid();
 271
 272   base::string16 product_name_3 = base::UTF8ToUTF16(kProductName_3);
 273   GURL landing_page_3(kLandingPage_3);
 274   scoped_refptr<device::MockUsbDevice> device_3(new device::MockUsbDevice(
 275       6, 7, "Google", kProductName_3, "008", landing_page_3));
 276   std::string guid_3 = device_3->guid();
 277
 278   EXPECT_CALL(mock_webusb_browser_client_,
 279               OnDeviceAdded(product_name_1, landing_page_1, guid_1))
 280       .Times(0);
 281   EXPECT_CALL(mock_webusb_browser_client_,
 282               OnDeviceAdded(product_name_2, landing_page_2, guid_2))
 283       .Times(0);
 284   EXPECT_CALL(mock_webusb_browser_client_,
 285               OnDeviceAdded(product_name_3, landing_page_3, guid_3))
 286       .Times(0);
 287
 288   {
 289     testing::InSequence s;
 290
 291     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_1)).Times(1);
 292     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_2)).Times(1);
 293     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_3)).Times(1);
 294   }
 295
 296   // three usb devices were added before webusb_detector was created
 297   device_client_.mock_usb_service().AddDevice(device_1);
 298   device_client_.mock_usb_service().AddDevice(device_2);
 299   device_client_.mock_usb_service().AddDevice(device_3);
 300
 301   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
 302
 303   device_client_.mock_usb_service().RemoveDevice(device_1);
 304   device_client_.mock_usb_service().RemoveDevice(device_2);
 305   device_client_.mock_usb_service().RemoveDevice(device_3);
 306 }
 307
 308 TEST_F(WebUsbDetectorTest,
 309        TwoUsbDevicesWereThereBeforeAndThenRemovedAndNewUsbDeviceAdded) {
 310   base::string16 product_name_1 = base::UTF8ToUTF16(kProductName_1);
 311   GURL landing_page_1(kLandingPage_1);
 312   scoped_refptr<device::MockUsbDevice> device_1(new device::MockUsbDevice(
 313       0, 1, "Google", kProductName_1, "002", landing_page_1));
 314   std::string guid_1 = device_1->guid();
 315
 316   base::string16 product_name_2 = base::UTF8ToUTF16(kProductName_2);
 317   GURL landing_page_2(kLandingPage_2);
 318   scoped_refptr<device::MockUsbDevice> device_2(new device::MockUsbDevice(
 319       3, 4, "Google", kProductName_2, "005", landing_page_2));
 320   std::string guid_2 = device_2->guid();
 321
 322   base::string16 product_name_3 = base::UTF8ToUTF16(kProductName_3);
 323   GURL landing_page_3(kLandingPage_3);
 324   scoped_refptr<device::MockUsbDevice> device_3(new device::MockUsbDevice(
 325       6, 7, "Google", kProductName_3, "008", landing_page_3));
 326   std::string guid_3 = device_3->guid();
 327
 328   EXPECT_CALL(mock_webusb_browser_client_,
 329               OnDeviceAdded(product_name_1, landing_page_1, guid_1))
 330       .Times(0);
 331   EXPECT_CALL(mock_webusb_browser_client_,
 332               OnDeviceAdded(product_name_3, landing_page_3, guid_3))
 333       .Times(0);
 334
 335   {
 336     testing::InSequence s;
 337
 338     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_1)).Times(1);
 339     EXPECT_CALL(mock_webusb_browser_client_,
 340                 OnDeviceAdded(product_name_2, landing_page_2, guid_2))
 341         .Times(1);
 342     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_3)).Times(1);
 343     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_2)).Times(1);
 344   }
 345
 346   // two usb devices were added before webusb_detector was created
 347   device_client_.mock_usb_service().AddDevice(device_1);
 348   device_client_.mock_usb_service().AddDevice(device_3);
 349
 350   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
 351
 352   device_client_.mock_usb_service().RemoveDevice(device_1);
 353   device_client_.mock_usb_service().AddDevice(device_2);
 354   device_client_.mock_usb_service().RemoveDevice(device_3);
 355   device_client_.mock_usb_service().RemoveDevice(device_2);
 356 }
 357
 358 TEST_F(WebUsbDetectorTest, ThreeUsbDevicesAddedAndRemoved) {
 359   base::string16 product_name_1 = base::UTF8ToUTF16(kProductName_1);
 360   GURL landing_page_1(kLandingPage_1);
 361   scoped_refptr<device::MockUsbDevice> device_1(new device::MockUsbDevice(
 362       0, 1, "Google", kProductName_1, "002", landing_page_1));
 363   std::string guid_1 = device_1->guid();
 364
 365   base::string16 product_name_2 = base::UTF8ToUTF16(kProductName_2);
 366   GURL landing_page_2(kLandingPage_2);
 367   scoped_refptr<device::MockUsbDevice> device_2(new device::MockUsbDevice(
 368       3, 4, "Google", kProductName_2, "005", landing_page_2));
 369   std::string guid_2 = device_2->guid();
 370
 371   base::string16 product_name_3 = base::UTF8ToUTF16(kProductName_3);
 372   GURL landing_page_3(kLandingPage_3);
 373   scoped_refptr<device::MockUsbDevice> device_3(new device::MockUsbDevice(
 374       6, 7, "Google", kProductName_3, "008", landing_page_3));
 375   std::string guid_3 = device_3->guid();
 376
 377   {
 378     testing::InSequence s;
 379
 380     EXPECT_CALL(mock_webusb_browser_client_,
 381                 OnDeviceAdded(product_name_1, landing_page_1, guid_1))
 382         .Times(1);
 383     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_1)).Times(1);
 384
 385     EXPECT_CALL(mock_webusb_browser_client_,
 386                 OnDeviceAdded(product_name_2, landing_page_2, guid_2))
 387         .Times(1);
 388     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_2)).Times(1);
 389
 390     EXPECT_CALL(mock_webusb_browser_client_,
 391                 OnDeviceAdded(product_name_3, landing_page_3, guid_3))
 392         .Times(1);
 393     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_3)).Times(1);
 394   }
 395
 396   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
 397
 398   device_client_.mock_usb_service().AddDevice(device_1);
 399   device_client_.mock_usb_service().RemoveDevice(device_1);
 400   device_client_.mock_usb_service().AddDevice(device_2);
 401   device_client_.mock_usb_service().RemoveDevice(device_2);
 402   device_client_.mock_usb_service().AddDevice(device_3);
 403   device_client_.mock_usb_service().RemoveDevice(device_3);
 404 }
 405
 406 TEST_F(WebUsbDetectorTest, ThreeUsbDeviceAddedAndRemovedDifferentOrder) {
 407   base::string16 product_name_1 = base::UTF8ToUTF16(kProductName_1);
 408   GURL landing_page_1(kLandingPage_1);
 409   scoped_refptr<device::MockUsbDevice> device_1(new device::MockUsbDevice(
 410       0, 1, "Google", kProductName_1, "002", landing_page_1));
 411   std::string guid_1 = device_1->guid();
 412
 413   base::string16 product_name_2 = base::UTF8ToUTF16(kProductName_2);
 414   GURL landing_page_2(kLandingPage_2);
 415   scoped_refptr<device::MockUsbDevice> device_2(new device::MockUsbDevice(
 416       3, 4, "Google", kProductName_2, "005", landing_page_2));
 417   std::string guid_2 = device_2->guid();
 418
 419   base::string16 product_name_3 = base::UTF8ToUTF16(kProductName_3);
 420   GURL landing_page_3(kLandingPage_3);
 421   scoped_refptr<device::MockUsbDevice> device_3(new device::MockUsbDevice(
 422       6, 7, "Google", kProductName_3, "008", landing_page_3));
 423   std::string guid_3 = device_3->guid();
 424
 425   {
 426     testing::InSequence s;
 427
 428     EXPECT_CALL(mock_webusb_browser_client_,
 429                 OnDeviceAdded(product_name_1, landing_page_1, guid_1))
 430         .Times(1);
 431
 432     EXPECT_CALL(mock_webusb_browser_client_,
 433                 OnDeviceAdded(product_name_2, landing_page_2, guid_2))
 434         .Times(1);
 435
 436     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_2)).Times(1);
 437
 438     EXPECT_CALL(mock_webusb_browser_client_,
 439                 OnDeviceAdded(product_name_3, landing_page_3, guid_3))
 440         .Times(1);
 441
 442     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_1)).Times(1);
 443
 444     EXPECT_CALL(mock_webusb_browser_client_, OnDeviceRemoved(guid_3)).Times(1);
 445   }
 446
 447   webusb::WebUsbDetector webusb_detector(&mock_webusb_browser_client_);
 448
 449   device_client_.mock_usb_service().AddDevice(device_1);
 450   device_client_.mock_usb_service().AddDevice(device_2);
 451   device_client_.mock_usb_service().RemoveDevice(device_2);
 452   device_client_.mock_usb_service().AddDevice(device_3);
 453   device_client_.mock_usb_service().RemoveDevice(device_1);
 454   device_client_.mock_usb_service().RemoveDevice(device_3);
 455 }
 456
 457 }  // namespace webusb