src/apps/saved_devices_service_unittest.cc

   1 // Copyright 2014 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 "apps/saved_devices_service.h"
   6 #include "base/run_loop.h"
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "base/test/values_test_util.h"
   9 #include "chrome/browser/extensions/test_extension_environment.h"
  10 #include "chrome/test/base/testing_profile.h"
  11 #include "device/usb/usb_device.h"
  12 #include "device/usb/usb_device_handle.h"
  13 #include "extensions/browser/extension_prefs.h"
  14 #include "extensions/common/extension.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace apps {
  19
  20 namespace {
  21
  22 using device::UsbDevice;
  23 using device::UsbDeviceHandle;
  24 using device::UsbEndpointDirection;
  25 using device::UsbTransferCallback;
  26 using testing::Return;
  27
  28 class MockUsbDevice : public UsbDevice {
  29  public:
  30   MockUsbDevice(const std::string& serial_number, uint32 unique_id)
  31       : UsbDevice(0, 0, unique_id), serial_number_(serial_number) {}
  32
  33   MOCK_METHOD0(Open, scoped_refptr<UsbDeviceHandle>());
  34   MOCK_METHOD1(Close, bool(scoped_refptr<UsbDeviceHandle>));
  35 #if defined(OS_CHROMEOS)
  36   MOCK_METHOD2(RequestUsbAccess, void(int, const base::Callback<void(bool)>&));
  37 #endif
  38   MOCK_METHOD0(GetConfiguration, const device::UsbConfigDescriptor&());
  39   MOCK_METHOD1(GetManufacturer, bool(base::string16*));
  40   MOCK_METHOD1(GetProduct, bool(base::string16*));
  41
  42   bool GetSerialNumber(base::string16* serial) OVERRIDE {
  43     if (serial_number_.empty()) {
  44       return false;
  45     }
  46
  47     *serial = base::UTF8ToUTF16(serial_number_);
  48     return true;
  49   }
  50
  51   void NotifyDisconnect() { UsbDevice::NotifyDisconnect(); }
  52
  53  private:
  54   virtual ~MockUsbDevice() {}
  55
  56   const std::string serial_number_;
  57 };
  58 }
  59
  60 class SavedDevicesServiceTest : public testing::Test {
  61  protected:
  62   virtual void SetUp() OVERRIDE {
  63     testing::Test::SetUp();
  64     env_.GetExtensionPrefs();  // Force creation before adding extensions.
  65     extension_ = env_.MakeExtension(*base::test::ParseJson(
  66                                         "{"
  67                                         "  \"app\": {"
  68                                         "    \"background\": {"
  69                                         "      \"scripts\": [\"background.js\"]"
  70                                         "    }"
  71                                         "  },"
  72                                         "  \"permissions\": ["
  73                                         "    \"usb\""
  74                                         "  ]"
  75                                         "}"));
  76     service_ = SavedDevicesService::Get(env_.profile());
  77     device0 = new MockUsbDevice("ABCDE", 0);
  78     device1 = new MockUsbDevice("", 1);
  79     device2 = new MockUsbDevice("12345", 2);
  80     device3 = new MockUsbDevice("", 3);
  81   }
  82
  83   extensions::TestExtensionEnvironment env_;
  84   const extensions::Extension* extension_;
  85   SavedDevicesService* service_;
  86   scoped_refptr<MockUsbDevice> device0;
  87   scoped_refptr<MockUsbDevice> device1;
  88   scoped_refptr<MockUsbDevice> device2;
  89   scoped_refptr<MockUsbDevice> device3;
  90 };
  91
  92 TEST_F(SavedDevicesServiceTest, RegisterDevices) {
  93   SavedDevicesService::SavedDevices* saved_devices =
  94       service_->GetOrInsert(extension_->id());
  95
  96   base::string16 serial_number(base::ASCIIToUTF16("ABCDE"));
  97   saved_devices->RegisterDevice(device0, &serial_number);
  98   saved_devices->RegisterDevice(device1, NULL);
  99
 100   // This is necessary as writing out registered devices happens in a task on
 101   // the UI thread.
 102   base::RunLoop run_loop;
 103   run_loop.RunUntilIdle();
 104
 105   ASSERT_TRUE(saved_devices->IsRegistered(device0));
 106   ASSERT_TRUE(saved_devices->IsRegistered(device1));
 107   ASSERT_FALSE(saved_devices->IsRegistered(device2));
 108   ASSERT_FALSE(saved_devices->IsRegistered(device3));
 109
 110   std::vector<SavedDeviceEntry> device_entries =
 111       service_->GetAllDevices(extension_->id());
 112   ASSERT_EQ(1U, device_entries.size());
 113   ASSERT_EQ(base::ASCIIToUTF16("ABCDE"), device_entries[0].serial_number);
 114
 115   device1->NotifyDisconnect();
 116
 117   ASSERT_TRUE(saved_devices->IsRegistered(device0));
 118   ASSERT_FALSE(saved_devices->IsRegistered(device1));
 119   ASSERT_FALSE(saved_devices->IsRegistered(device2));
 120   ASSERT_FALSE(saved_devices->IsRegistered(device3));
 121
 122   service_->Clear(extension_->id());
 123
 124   // App is normally restarted, clearing its reference to the SavedDevices.
 125   saved_devices = service_->GetOrInsert(extension_->id());
 126   ASSERT_FALSE(saved_devices->IsRegistered(device0));
 127   device_entries = service_->GetAllDevices(extension_->id());
 128   ASSERT_EQ(0U, device_entries.size());
 129 }
 130
 131 TEST_F(SavedDevicesServiceTest, LoadPrefs) {
 132   scoped_ptr<base::Value> prefs_value = base::test::ParseJson(
 133       "["
 134       "  {"
 135       "    \"product_id\": 0,"
 136       "    \"serial_number\": \"ABCDE\","
 137       "    \"type\": \"usb\","
 138       "    \"vendor_id\": 0"
 139       "  }"
 140       "]");
 141   env_.GetExtensionPrefs()->UpdateExtensionPref(
 142       extension_->id(), "devices", prefs_value.release());
 143
 144   SavedDevicesService::SavedDevices* saved_devices =
 145       service_->GetOrInsert(extension_->id());
 146   ASSERT_TRUE(saved_devices->IsRegistered(device0));
 147   ASSERT_FALSE(saved_devices->IsRegistered(device1));
 148   ASSERT_FALSE(saved_devices->IsRegistered(device2));
 149   ASSERT_FALSE(saved_devices->IsRegistered(device3));
 150 }
 151
 152 }  // namespace apps