components/storage_monitor/image_capture_device_manager_unittest.mm

   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 #import <Foundation/Foundation.h>
   6 #import <ImageCaptureCore/ImageCaptureCore.h>
   7
   8 #include "base/files/file_path.h"
   9 #include "base/files/file_util.h"
  10 #include "base/files/scoped_temp_dir.h"
  11 #include "base/mac/foundation_util.h"
  12 #include "base/mac/sdk_forward_declarations.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/run_loop.h"
  15 #include "components/storage_monitor/image_capture_device.h"
  16 #include "components/storage_monitor/image_capture_device_manager.h"
  17 #include "components/storage_monitor/test_storage_monitor.h"
  18 #include "content/public/browser/browser_thread.h"
  19 #include "content/public/test/test_browser_thread_bundle.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 namespace {
  23
  24 const char kDeviceId[] = "id";
  25 const char kTestFileContents[] = "test";
  26
  27 }  // namespace
  28
  29 // Private ICCameraDevice method needed to properly initialize the object.
  30 @interface NSObject (PrivateAPIICCameraDevice)
  31 - (id)initWithDictionary:(id)properties;
  32 @end
  33
  34 @interface MockICCameraDevice : ICCameraDevice {
  35  @private
  36   base::scoped_nsobject<NSMutableArray> allMediaFiles_;
  37 }
  38
  39 - (void)addMediaFile:(ICCameraFile*)file;
  40
  41 @end
  42
  43 @implementation MockICCameraDevice
  44
  45 - (id)init {
  46   if ((self = [super initWithDictionary:[NSDictionary dictionary]])) {
  47   }
  48   return self;
  49 }
  50
  51 - (NSString*)mountPoint {
  52   return @"mountPoint";
  53 }
  54
  55 - (NSString*)name {
  56   return @"name";
  57 }
  58
  59 - (NSString*)UUIDString {
  60   return base::SysUTF8ToNSString(kDeviceId);
  61 }
  62
  63 - (ICDeviceType)type {
  64   return ICDeviceTypeCamera;
  65 }
  66
  67 - (void)requestOpenSession {
  68 }
  69
  70 - (void)requestCloseSession {
  71 }
  72
  73 - (NSArray*)mediaFiles {
  74   return allMediaFiles_;
  75 }
  76
  77 - (void)addMediaFile:(ICCameraFile*)file {
  78   if (!allMediaFiles_.get())
  79     allMediaFiles_.reset([[NSMutableArray alloc] init]);
  80   [allMediaFiles_ addObject:file];
  81 }
  82
  83 // This method does approximately what the internal ImageCapture platform
  84 // library is observed to do: take the download save-as filename and mangle
  85 // it to attach an extension, then return that new filename to the caller
  86 // in the options.
  87 - (void)requestDownloadFile:(ICCameraFile*)file
  88                     options:(NSDictionary*)options
  89            downloadDelegate:(id<ICCameraDeviceDownloadDelegate>)downloadDelegate
  90         didDownloadSelector:(SEL)selector
  91                 contextInfo:(void*)contextInfo {
  92   base::FilePath saveDir(base::SysNSStringToUTF8(
  93       [[options objectForKey:ICDownloadsDirectoryURL] path]));
  94   std::string saveAsFilename =
  95       base::SysNSStringToUTF8([options objectForKey:ICSaveAsFilename]);
  96   // It appears that the ImageCapture library adds an extension to the requested
  97   // filename. Do that here to require a rename.
  98   saveAsFilename += ".jpg";
  99   base::FilePath toBeSaved = saveDir.Append(saveAsFilename);
 100   ASSERT_EQ(static_cast<int>(strlen(kTestFileContents)),
 101             base::WriteFile(toBeSaved, kTestFileContents,
 102                             strlen(kTestFileContents)));
 103
 104   NSMutableDictionary* returnOptions =
 105       [NSMutableDictionary dictionaryWithDictionary:options];
 106   [returnOptions setObject:base::SysUTF8ToNSString(saveAsFilename)
 107                     forKey:ICSavedFilename];
 108
 109   [static_cast<NSObject<ICCameraDeviceDownloadDelegate>*>(downloadDelegate)
 110    didDownloadFile:file
 111              error:nil
 112            options:returnOptions
 113        contextInfo:contextInfo];
 114 }
 115
 116 @end
 117
 118 @interface MockICCameraFolder : ICCameraFolder {
 119  @private
 120   base::scoped_nsobject<NSString> name_;
 121 }
 122
 123 - (id)initWithName:(NSString*)name;
 124
 125 @end
 126
 127 @implementation MockICCameraFolder
 128
 129 - (id)initWithName:(NSString*)name {
 130   if ((self = [super init])) {
 131     name_.reset([name retain]);
 132   }
 133   return self;
 134 }
 135
 136 - (NSString*)name {
 137   return name_;
 138 }
 139
 140 - (ICCameraFolder*)parentFolder {
 141   return nil;
 142 }
 143
 144 @end
 145
 146 @interface MockICCameraFile : ICCameraFile {
 147  @private
 148   base::scoped_nsobject<NSString> name_;
 149   base::scoped_nsobject<NSDate> date_;
 150   base::scoped_nsobject<MockICCameraFolder> parent_;
 151 }
 152
 153 - (id)init:(NSString*)name;
 154 - (void)setParent:(NSString*)parent;
 155
 156 @end
 157
 158 @implementation MockICCameraFile
 159
 160 - (id)init:(NSString*)name {
 161   if ((self = [super init])) {
 162     name_.reset([name retain]);
 163     date_.reset([[NSDate dateWithNaturalLanguageString:@"12/12/12"] retain]);
 164   }
 165   return self;
 166 }
 167
 168 - (void)setParent:(NSString*)parent {
 169   parent_.reset([[MockICCameraFolder alloc] initWithName:parent]);
 170 }
 171
 172 - (ICCameraFolder*)parentFolder {
 173   return parent_.get();
 174 }
 175
 176 - (NSString*)name {
 177   return name_;
 178 }
 179
 180 - (NSString*)UTI {
 181   return base::mac::CFToNSCast(kUTTypeImage);
 182 }
 183
 184 - (NSDate*)modificationDate {
 185   return date_.get();
 186 }
 187
 188 - (NSDate*)creationDate {
 189   return date_.get();
 190 }
 191
 192 - (off_t)fileSize {
 193   return 1000;
 194 }
 195
 196 @end
 197
 198 namespace storage_monitor {
 199
 200 class TestCameraListener
 201     : public ImageCaptureDeviceListener,
 202       public base::SupportsWeakPtr<TestCameraListener> {
 203  public:
 204   TestCameraListener()
 205       : completed_(false),
 206         removed_(false),
 207         last_error_(base::File::FILE_ERROR_INVALID_URL) {}
 208   ~TestCameraListener() override {}
 209
 210   void ItemAdded(const std::string& name,
 211                  const base::File::Info& info) override {
 212     items_.push_back(name);
 213   }
 214
 215   void NoMoreItems() override { completed_ = true; }
 216
 217   void DownloadedFile(const std::string& name,
 218                       base::File::Error error) override {
 219     EXPECT_TRUE(content::BrowserThread::CurrentlyOn(
 220         content::BrowserThread::UI));
 221     downloads_.push_back(name);
 222     last_error_ = error;
 223   }
 224
 225   void DeviceRemoved() override { removed_ = true; }
 226
 227   std::vector<std::string> items() const { return items_; }
 228   std::vector<std::string> downloads() const { return downloads_; }
 229   bool completed() const { return completed_; }
 230   bool removed() const { return removed_; }
 231   base::File::Error last_error() const { return last_error_; }
 232
 233  private:
 234   std::vector<std::string> items_;
 235   std::vector<std::string> downloads_;
 236   bool completed_;
 237   bool removed_;
 238   base::File::Error last_error_;
 239 };
 240
 241 class ImageCaptureDeviceManagerTest : public testing::Test {
 242  public:
 243   void SetUp() override { monitor_ = TestStorageMonitor::CreateAndInstall(); }
 244
 245   void TearDown() override { TestStorageMonitor::Destroy(); }
 246
 247   MockICCameraDevice* AttachDevice(ImageCaptureDeviceManager* manager) {
 248     // Ownership will be passed to the device browser delegate.
 249     base::scoped_nsobject<MockICCameraDevice> device(
 250         [[MockICCameraDevice alloc] init]);
 251     id<ICDeviceBrowserDelegate> delegate = manager->device_browser();
 252     [delegate deviceBrowser:nil didAddDevice:device moreComing:NO];
 253     return device.autorelease();
 254   }
 255
 256   void DetachDevice(ImageCaptureDeviceManager* manager,
 257                     ICCameraDevice* device) {
 258     id<ICDeviceBrowserDelegate> delegate = manager->device_browser();
 259     [delegate deviceBrowser:nil didRemoveDevice:device moreGoing:NO];
 260   }
 261
 262  protected:
 263   content::TestBrowserThreadBundle thread_bundle_;
 264   TestStorageMonitor* monitor_;
 265   TestCameraListener listener_;
 266 };
 267
 268 TEST_F(ImageCaptureDeviceManagerTest, TestAttachDetach) {
 269   ImageCaptureDeviceManager manager;
 270   manager.SetNotifications(monitor_->receiver());
 271   ICCameraDevice* device = AttachDevice(&manager);
 272   std::vector<StorageInfo> devices = monitor_->GetAllAvailableStorages();
 273
 274   ASSERT_EQ(1U, devices.size());
 275   EXPECT_EQ(std::string("ic:") + kDeviceId, devices[0].device_id());
 276
 277   DetachDevice(&manager, device);
 278   devices = monitor_->GetAllAvailableStorages();
 279   ASSERT_EQ(0U, devices.size());
 280 };
 281
 282 TEST_F(ImageCaptureDeviceManagerTest, OpenCamera) {
 283   ImageCaptureDeviceManager manager;
 284   manager.SetNotifications(monitor_->receiver());
 285   ICCameraDevice* device = AttachDevice(&manager);
 286
 287   EXPECT_FALSE(ImageCaptureDeviceManager::deviceForUUID(
 288       "nonexistent"));
 289
 290   base::scoped_nsobject<ImageCaptureDevice> camera(
 291       [ImageCaptureDeviceManager::deviceForUUID(kDeviceId) retain]);
 292
 293   [camera setListener:listener_.AsWeakPtr()];
 294   [camera open];
 295
 296   base::scoped_nsobject<MockICCameraFile> picture1(
 297       [[MockICCameraFile alloc] init:@"pic1"]);
 298   [camera cameraDevice:nil didAddItem:picture1];
 299   base::scoped_nsobject<MockICCameraFile> picture2(
 300       [[MockICCameraFile alloc] init:@"pic2"]);
 301   [camera cameraDevice:nil didAddItem:picture2];
 302   ASSERT_EQ(2U, listener_.items().size());
 303   EXPECT_EQ("pic1", listener_.items()[0]);
 304   EXPECT_EQ("pic2", listener_.items()[1]);
 305   EXPECT_FALSE(listener_.completed());
 306
 307   [camera deviceDidBecomeReadyWithCompleteContentCatalog:nil];
 308
 309   ASSERT_EQ(2U, listener_.items().size());
 310   EXPECT_TRUE(listener_.completed());
 311
 312   [camera close];
 313   DetachDevice(&manager, device);
 314   EXPECT_FALSE(ImageCaptureDeviceManager::deviceForUUID(kDeviceId));
 315 }
 316
 317 TEST_F(ImageCaptureDeviceManagerTest, RemoveCamera) {
 318   ImageCaptureDeviceManager manager;
 319   manager.SetNotifications(monitor_->receiver());
 320   ICCameraDevice* device = AttachDevice(&manager);
 321
 322   base::scoped_nsobject<ImageCaptureDevice> camera(
 323       [ImageCaptureDeviceManager::deviceForUUID(kDeviceId) retain]);
 324
 325   [camera setListener:listener_.AsWeakPtr()];
 326   [camera open];
 327
 328   [camera didRemoveDevice:device];
 329   EXPECT_TRUE(listener_.removed());
 330 }
 331
 332 TEST_F(ImageCaptureDeviceManagerTest, DownloadFile) {
 333   ImageCaptureDeviceManager manager;
 334   manager.SetNotifications(monitor_->receiver());
 335   MockICCameraDevice* device = AttachDevice(&manager);
 336
 337   base::scoped_nsobject<ImageCaptureDevice> camera(
 338       [ImageCaptureDeviceManager::deviceForUUID(kDeviceId) retain]);
 339
 340   [camera setListener:listener_.AsWeakPtr()];
 341   [camera open];
 342
 343   std::string kTestFileName("pic1");
 344
 345   base::scoped_nsobject<MockICCameraFile> picture1(
 346       [[MockICCameraFile alloc] init:base::SysUTF8ToNSString(kTestFileName)]);
 347   [device addMediaFile:picture1];
 348   [camera cameraDevice:nil didAddItem:picture1];
 349
 350   base::ScopedTempDir temp_dir;
 351   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 352
 353   EXPECT_EQ(0U, listener_.downloads().size());
 354
 355   // Test that a nonexistent file we ask to be downloaded will
 356   // return us a not-found error.
 357   base::FilePath temp_file = temp_dir.path().Append("tempfile");
 358   [camera downloadFile:std::string("nonexistent") localPath:temp_file];
 359   base::RunLoop().RunUntilIdle();
 360   ASSERT_EQ(1U, listener_.downloads().size());
 361   EXPECT_EQ("nonexistent", listener_.downloads()[0]);
 362   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, listener_.last_error());
 363
 364   // Test that an existing file we ask to be downloaded will end up in
 365   // the location we specify. The mock system will copy testing file
 366   // contents to a separate filename, mimicking the ImageCaptureCore
 367   // library behavior. Our code then renames the file onto the requested
 368   // destination.
 369   [camera downloadFile:kTestFileName localPath:temp_file];
 370   base::RunLoop().RunUntilIdle();
 371
 372   ASSERT_EQ(2U, listener_.downloads().size());
 373   EXPECT_EQ(kTestFileName, listener_.downloads()[1]);
 374   ASSERT_EQ(base::File::FILE_OK, listener_.last_error());
 375   char file_contents[5];
 376   ASSERT_EQ(4, base::ReadFile(temp_file, file_contents,
 377                               strlen(kTestFileContents)));
 378   EXPECT_EQ(kTestFileContents,
 379             std::string(file_contents, strlen(kTestFileContents)));
 380
 381   [camera didRemoveDevice:device];
 382 }
 383
 384 TEST_F(ImageCaptureDeviceManagerTest, TestSubdirectories) {
 385   ImageCaptureDeviceManager manager;
 386   manager.SetNotifications(monitor_->receiver());
 387   MockICCameraDevice* device = AttachDevice(&manager);
 388
 389   base::scoped_nsobject<ImageCaptureDevice> camera(
 390       [ImageCaptureDeviceManager::deviceForUUID(kDeviceId) retain]);
 391
 392   [camera setListener:listener_.AsWeakPtr()];
 393   [camera open];
 394
 395   std::string kTestFileName("pic1");
 396   base::scoped_nsobject<MockICCameraFile> picture1(
 397       [[MockICCameraFile alloc] init:base::SysUTF8ToNSString(kTestFileName)]);
 398   [picture1 setParent:base::SysUTF8ToNSString("dir")];
 399   [device addMediaFile:picture1];
 400   [camera cameraDevice:nil didAddItem:picture1];
 401
 402   base::ScopedTempDir temp_dir;
 403   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 404   base::FilePath temp_file = temp_dir.path().Append("tempfile");
 405
 406   [camera downloadFile:("dir/" + kTestFileName) localPath:temp_file];
 407   base::RunLoop().RunUntilIdle();
 408
 409   char file_contents[5];
 410   ASSERT_EQ(4, base::ReadFile(temp_file, file_contents,
 411                               strlen(kTestFileContents)));
 412   EXPECT_EQ(kTestFileContents,
 413             std::string(file_contents, strlen(kTestFileContents)));
 414
 415   [camera didRemoveDevice:device];
 416 }
 417
 418 }  // namespace storage_monitor