chrome/browser/chromeos/printer_detector/printer_detector_unittest.cc

   1 // Copyright (c) 2012 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 "chrome/browser/chromeos/printer_detector/printer_detector.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/run_loop.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
  12 #include "chrome/browser/chromeos/printer_detector/printer_detector_factory.h"
  13 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  14 #include "chrome/browser/extensions/test_extension_system.h"
  15 #include "chrome/browser/notifications/notification.h"
  16 #include "chrome/browser/notifications/notification_test_util.h"
  17 #include "chrome/browser/notifications/notification_ui_manager.h"
  18 #include "chrome/test/base/testing_profile.h"
  19 #include "components/user_manager/fake_user_manager.h"
  20 #include "content/public/test/test_browser_thread_bundle.h"
  21 #include "device/core/device_client.h"
  22 #include "device/usb/mock_usb_service.h"
  23 #include "device/usb/usb_descriptors.h"
  24 #include "device/usb/usb_device.h"
  25 #include "device/usb/usb_service.h"
  26 #include "extensions/browser/extension_registry.h"
  27 #include "extensions/common/extension_builder.h"
  28 #include "extensions/common/value_builder.h"
  29 #include "testing/gtest/include/gtest/gtest.h"
  30
  31 using extensions::DictionaryBuilder;
  32 using extensions::ListBuilder;
  33
  34 namespace chromeos {
  35
  36 namespace {
  37
  38 const uint8 kPrinterInterfaceClass = 7;
  39
  40 const char kTestUserId[] = "test_user";
  41
  42 const char kPrinterAppExistsDelegateIDTemplate[] =
  43     "system.printer.printer_provider_exists/%s:%s";
  44
  45 const char kPrinterAppNotFoundDelegateIDTemplate[] =
  46     "system.printer.no_printer_provider_found/%s:%s";
  47
  48 class FakeUsbDevice : public device::UsbDevice {
  49  public:
  50   FakeUsbDevice(uint16 vendor_id, uint16 product_id, uint8 interface_class)
  51       : device::UsbDevice(vendor_id,
  52                           product_id,
  53                           base::ASCIIToUTF16("Google"),
  54                           base::ASCIIToUTF16("A product"),
  55                           base::ASCIIToUTF16("")) {
  56     config_.reset(new device::UsbConfigDescriptor);
  57     device::UsbInterfaceDescriptor interface;
  58     interface.interface_number = 1;
  59     interface.interface_class = interface_class;
  60     config_->interfaces.push_back(interface);
  61   }
  62
  63  private:
  64   ~FakeUsbDevice() override {}
  65
  66   // device::UsbDevice overrides:
  67   void Open(const OpenCallback& callback) override {
  68     ADD_FAILURE() << "Not reached";
  69   }
  70
  71   bool Close(scoped_refptr<device::UsbDeviceHandle> handle) override {
  72     ADD_FAILURE() << "Not reached";
  73     return false;
  74   }
  75
  76   const device::UsbConfigDescriptor* GetActiveConfiguration() override {
  77     return config_.get();
  78   }
  79
  80   scoped_ptr<device::UsbConfigDescriptor> config_;
  81
  82   DISALLOW_COPY_AND_ASSIGN(FakeUsbDevice);
  83 };
  84
  85 class FakeDeviceClient : public device::DeviceClient {
  86  public:
  87   FakeDeviceClient() : usb_service_(nullptr) {}
  88
  89   ~FakeDeviceClient() override {}
  90
  91   // device::DeviceClient implementation:
  92   device::UsbService* GetUsbService() override {
  93     EXPECT_TRUE(usb_service_);
  94     return usb_service_;
  95   }
  96
  97   void set_usb_service(device::UsbService* service) { usb_service_ = service; }
  98
  99  private:
 100   device::UsbService* usb_service_;
 101
 102   DISALLOW_COPY_AND_ASSIGN(FakeDeviceClient);
 103 };
 104
 105 scoped_ptr<KeyedService> CreatePrinterDetector(
 106     content::BrowserContext* context) {
 107   return scoped_ptr<KeyedService>(
 108       new chromeos::PrinterDetector(Profile::FromBrowserContext(context)));
 109 }
 110
 111 }  // namespace
 112
 113 // TODO(tbarzic): Rename this test.
 114 class PrinterDetectorAppSearchEnabledTest : public testing::Test {
 115  public:
 116   PrinterDetectorAppSearchEnabledTest()
 117       : user_manager_(new user_manager::FakeUserManager()),
 118         user_manager_enabler_(user_manager_) {}
 119
 120   ~PrinterDetectorAppSearchEnabledTest() override = default;
 121
 122   void SetUp() override {
 123     device_client_.set_usb_service(&usb_service_);
 124     // Make sure the profile is created after adding the switch and setting up
 125     // device client.
 126     profile_.reset(new TestingProfile());
 127     chromeos::PrinterDetectorFactory::GetInstance()->SetTestingFactoryAndUse(
 128         profile_.get(), &CreatePrinterDetector);
 129     AddTestUser();
 130     SetExtensionSystemReady(profile_.get());
 131   }
 132
 133  protected:
 134   void SetExtensionSystemReady(TestingProfile* profile) {
 135     extensions::TestExtensionSystem* test_extension_system =
 136         static_cast<extensions::TestExtensionSystem*>(
 137             extensions::ExtensionSystem::Get(profile));
 138     test_extension_system->SetReady();
 139     base::RunLoop().RunUntilIdle();
 140   }
 141
 142   void AddTestUser() {
 143     const user_manager::User* user = user_manager_->AddUser(kTestUserId);
 144     profile_->set_profile_name(kTestUserId);
 145     chromeos::ProfileHelper::Get()->SetUserToProfileMappingForTesting(
 146         user, profile_.get());
 147     chromeos::PrinterDetectorFactory::GetInstance()
 148         ->Get(profile_.get())
 149         ->SetNotificationUIManagerForTesting(&notification_ui_manager_);
 150   }
 151
 152   void InvokeUsbAdded(uint16 vendor_id,
 153                       uint16 product_id,
 154                       uint8 interface_class) {
 155     usb_service_.AddDevice(
 156         new FakeUsbDevice(vendor_id, product_id, interface_class));
 157   }
 158
 159   // Creates a test extension with the provided permissions.
 160   scoped_refptr<extensions::Extension> CreateTestExtension(
 161       ListBuilder& permissions_builder,
 162       DictionaryBuilder& usb_printers_builder) {
 163     return extensions::ExtensionBuilder()
 164         .SetID("fake_extension_id")
 165         .SetManifest(
 166              DictionaryBuilder()
 167                  .Set("name", "Printer provider extension")
 168                  .Set("manifest_version", 2)
 169                  .Set("version", "1.0")
 170                  // Needed to enable usb API.
 171                  .Set("app", DictionaryBuilder().Set(
 172                                  "background",
 173                                  DictionaryBuilder().Set(
 174                                      "scripts", ListBuilder().Append("bg.js"))))
 175                  .Set("permissions", permissions_builder)
 176                  .Set("usb_printers", usb_printers_builder))
 177         .Build();
 178   }
 179
 180   content::TestBrowserThreadBundle thread_bundle_;
 181   StubNotificationUIManager notification_ui_manager_;
 182   user_manager::FakeUserManager* user_manager_;
 183   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
 184   device::MockUsbService usb_service_;
 185   scoped_ptr<TestingProfile> profile_;
 186   FakeDeviceClient device_client_;
 187
 188   DISALLOW_COPY_AND_ASSIGN(PrinterDetectorAppSearchEnabledTest);
 189 };
 190
 191 TEST_F(PrinterDetectorAppSearchEnabledTest, ShowFindAppNotification) {
 192   InvokeUsbAdded(123, 456, kPrinterInterfaceClass);
 193
 194   ASSERT_EQ(1u, notification_ui_manager_.GetNotificationCount());
 195   const Notification& notification =
 196       notification_ui_manager_.GetNotificationAt(0);
 197   EXPECT_EQ("123:456", notification.tag());
 198   EXPECT_EQ(
 199       base::StringPrintf(kPrinterAppNotFoundDelegateIDTemplate, "123", "456"),
 200       notification.delegate_id());
 201 }
 202
 203 TEST_F(PrinterDetectorAppSearchEnabledTest, ShowAppFoundNotification) {
 204   scoped_refptr<extensions::Extension> extension = CreateTestExtension(
 205       ListBuilder()
 206           .Append("usb")
 207           .Append("printerProvider")
 208           .Append(DictionaryBuilder().Set(
 209               "usbDevices", ListBuilder().Append(DictionaryBuilder()
 210                                                      .Set("vendorId", 123)
 211                                                      .Set("productId", 456))))
 212           .Pass(),
 213       DictionaryBuilder().Set("filters", ListBuilder().Pass()).Pass());
 214   ASSERT_TRUE(extensions::ExtensionRegistry::Get(profile_.get())
 215                   ->AddEnabled(extension));
 216
 217   InvokeUsbAdded(123, 456, kPrinterInterfaceClass);
 218
 219   ASSERT_EQ(1u, notification_ui_manager_.GetNotificationCount());
 220   const Notification& notification =
 221       notification_ui_manager_.GetNotificationAt(0);
 222   EXPECT_EQ("123:456", notification.tag());
 223   EXPECT_EQ(
 224       base::StringPrintf(kPrinterAppExistsDelegateIDTemplate, "123", "456"),
 225       notification.delegate_id());
 226 }
 227
 228 TEST_F(PrinterDetectorAppSearchEnabledTest,
 229        UsbHandlerExists_NotPrinterProvider) {
 230   scoped_refptr<extensions::Extension> extension = CreateTestExtension(
 231       ListBuilder()
 232           .Append("usb")
 233           .Append(DictionaryBuilder().Set(
 234               "usbDevices", ListBuilder().Append(DictionaryBuilder()
 235                                                      .Set("vendorId", 123)
 236                                                      .Set("productId", 756))))
 237           .Pass(),
 238       DictionaryBuilder().Set("filters", ListBuilder().Pass()).Pass());
 239   ASSERT_TRUE(extensions::ExtensionRegistry::Get(profile_.get())
 240                   ->AddEnabled(extension));
 241
 242   InvokeUsbAdded(123, 756, kPrinterInterfaceClass);
 243
 244   ASSERT_EQ(1u, notification_ui_manager_.GetNotificationCount());
 245   const Notification& notification =
 246       notification_ui_manager_.GetNotificationAt(0);
 247   EXPECT_EQ("123:756", notification.tag());
 248   EXPECT_EQ(
 249       base::StringPrintf(kPrinterAppNotFoundDelegateIDTemplate, "123", "756"),
 250       notification.delegate_id());
 251 }
 252
 253 TEST_F(PrinterDetectorAppSearchEnabledTest,
 254        PrinterProvider_DifferentUsbProductId) {
 255   scoped_refptr<extensions::Extension> extension = CreateTestExtension(
 256       ListBuilder()
 257           .Append("usb")
 258           .Append("printerProvider")
 259           .Append(DictionaryBuilder().Set(
 260               "usbDevices", ListBuilder().Append(DictionaryBuilder()
 261                                                      .Set("vendorId", 123)
 262                                                      .Set("productId", 001))))
 263           .Pass(),
 264       DictionaryBuilder().Set("filters", ListBuilder().Pass()).Pass());
 265   ASSERT_TRUE(extensions::ExtensionRegistry::Get(profile_.get())
 266                   ->AddEnabled(extension));
 267
 268   InvokeUsbAdded(123, 456, kPrinterInterfaceClass);
 269
 270   ASSERT_EQ(1u, notification_ui_manager_.GetNotificationCount());
 271   const Notification& notification =
 272       notification_ui_manager_.GetNotificationAt(0);
 273   EXPECT_EQ("123:456", notification.tag());
 274   EXPECT_EQ(
 275       base::StringPrintf(kPrinterAppNotFoundDelegateIDTemplate, "123", "456"),
 276       notification.delegate_id());
 277 }
 278
 279 TEST_F(PrinterDetectorAppSearchEnabledTest,
 280        PrinterProvider_UsbPrinters_NotFound) {
 281   scoped_refptr<extensions::Extension> extension =
 282       CreateTestExtension(
 283           ListBuilder().Append("usb").Append("printerProvider").Pass(),
 284           DictionaryBuilder().Set(
 285               "filters", ListBuilder().Append(DictionaryBuilder()
 286                                                   .Set("vendorId", 123)
 287                                                   .Set("productId", 001))))
 288           .Pass();
 289   ASSERT_TRUE(extensions::ExtensionRegistry::Get(profile_.get())
 290                   ->AddEnabled(extension));
 291
 292   InvokeUsbAdded(123, 456, kPrinterInterfaceClass);
 293
 294   ASSERT_EQ(1u, notification_ui_manager_.GetNotificationCount());
 295   const Notification& notification =
 296       notification_ui_manager_.GetNotificationAt(0);
 297   EXPECT_EQ("123:456", notification.tag());
 298   EXPECT_EQ(
 299       base::StringPrintf(kPrinterAppNotFoundDelegateIDTemplate, "123", "456"),
 300       notification.delegate_id());
 301 }
 302
 303 TEST_F(PrinterDetectorAppSearchEnabledTest,
 304        PrinterProvider_UsbPrinters_WithProductId) {
 305   scoped_refptr<extensions::Extension> extension =
 306       CreateTestExtension(
 307           ListBuilder().Append("usb").Append("printerProvider").Pass(),
 308           DictionaryBuilder().Set(
 309               "filters", ListBuilder().Append(DictionaryBuilder()
 310                                                   .Set("vendorId", 123)
 311                                                   .Set("productId", 456))))
 312           .Pass();
 313   ASSERT_TRUE(extensions::ExtensionRegistry::Get(profile_.get())
 314                   ->AddEnabled(extension));
 315
 316   InvokeUsbAdded(123, 456, kPrinterInterfaceClass);
 317
 318   ASSERT_EQ(1u, notification_ui_manager_.GetNotificationCount());
 319   const Notification& notification =
 320       notification_ui_manager_.GetNotificationAt(0);
 321   EXPECT_EQ("123:456", notification.tag());
 322   EXPECT_EQ(
 323       base::StringPrintf(kPrinterAppExistsDelegateIDTemplate, "123", "456"),
 324       notification.delegate_id());
 325 }
 326
 327 TEST_F(PrinterDetectorAppSearchEnabledTest,
 328        PrinterProvider_UsbPrinters_WithInterfaceClass) {
 329   scoped_refptr<extensions::Extension> extension =
 330       CreateTestExtension(
 331           ListBuilder().Append("usb").Append("printerProvider").Pass(),
 332           DictionaryBuilder().Set(
 333               "filters",
 334               ListBuilder().Append(
 335                   DictionaryBuilder()
 336                       .Set("vendorId", 123)
 337                       .Set("interfaceClass", kPrinterInterfaceClass)))).Pass();
 338   ASSERT_TRUE(extensions::ExtensionRegistry::Get(profile_.get())
 339                   ->AddEnabled(extension));
 340
 341   InvokeUsbAdded(123, 456, kPrinterInterfaceClass);
 342
 343   ASSERT_EQ(1u, notification_ui_manager_.GetNotificationCount());
 344   const Notification& notification =
 345       notification_ui_manager_.GetNotificationAt(0);
 346   EXPECT_EQ("123:456", notification.tag());
 347   EXPECT_EQ(
 348       base::StringPrintf(kPrinterAppExistsDelegateIDTemplate, "123", "456"),
 349       notification.delegate_id());
 350 }
 351
 352 TEST_F(PrinterDetectorAppSearchEnabledTest, IgnoreNonPrinters) {
 353   scoped_refptr<extensions::Extension> extension =
 354       CreateTestExtension(
 355           ListBuilder().Append("usb").Append("printerProvider").Pass(),
 356           DictionaryBuilder().Set(
 357               "filters",
 358               ListBuilder().Append(
 359                   DictionaryBuilder()
 360                       .Set("vendorId", 123)
 361                       .Set("interfaceClass", kPrinterInterfaceClass)))).Pass();
 362   ASSERT_TRUE(extensions::ExtensionRegistry::Get(profile_.get())
 363                   ->AddEnabled(extension));
 364
 365   InvokeUsbAdded(123, 456, 1);
 366
 367   ASSERT_EQ(0u, notification_ui_manager_.GetNotificationCount());
 368 }
 369
 370 }  // namespace chromeos