chrome/browser/media_galleries/mac/mtp_device_delegate_impl_mac_unittest.mm

   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 #import <Foundation/Foundation.h>
   6 #import <ImageCaptureCore/ImageCaptureCore.h>
   7
   8 #include "base/files/file.h"
   9 #include "base/files/file_util.h"
  10 #include "base/files/scoped_temp_dir.h"
  11 #include "base/mac/cocoa_protocols.h"
  12 #include "base/mac/foundation_util.h"
  13 #include "base/mac/scoped_nsobject.h"
  14 #include "base/mac/sdk_forward_declarations.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/run_loop.h"
  17 #include "base/strings/sys_string_conversions.h"
  18 #include "base/synchronization/waitable_event.h"
  19 #include "base/test/sequenced_worker_pool_owner.h"
  20 #include "base/threading/sequenced_worker_pool.h"
  21 #include "chrome/browser/media_galleries/mac/mtp_device_delegate_impl_mac.h"
  22 #include "components/storage_monitor/image_capture_device_manager.h"
  23 #include "components/storage_monitor/test_storage_monitor.h"
  24 #include "content/public/browser/browser_thread.h"
  25 #include "content/public/test/test_browser_thread.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27
  28 namespace {
  29
  30 const char kDeviceId[] = "id";
  31 const char kDevicePath[] = "/ic:id";
  32 const char kTestFileContents[] = "test";
  33
  34 }  // namespace
  35
  36 @interface MockMTPICCameraDevice : ICCameraDevice {
  37  @private
  38   base::scoped_nsobject<NSMutableArray> allMediaFiles_;
  39 }
  40
  41 - (void)addMediaFile:(ICCameraFile*)file;
  42
  43 @end
  44
  45 @implementation MockMTPICCameraDevice
  46
  47 - (NSString*)mountPoint {
  48   return @"mountPoint";
  49 }
  50
  51 - (NSString*)name {
  52   return @"name";
  53 }
  54
  55 - (NSString*)UUIDString {
  56   return base::SysUTF8ToNSString(kDeviceId);
  57 }
  58
  59 - (ICDeviceType)type {
  60   return ICDeviceTypeCamera;
  61 }
  62
  63 - (void)requestOpenSession {
  64 }
  65
  66 - (void)requestCloseSession {
  67 }
  68
  69 - (NSArray*)mediaFiles {
  70   return allMediaFiles_;
  71 }
  72
  73 - (void)addMediaFile:(ICCameraFile*)file {
  74   if (!allMediaFiles_.get())
  75     allMediaFiles_.reset([[NSMutableArray alloc] init]);
  76   [allMediaFiles_ addObject:file];
  77 }
  78
  79 - (void)requestDownloadFile:(ICCameraFile*)file
  80                     options:(NSDictionary*)options
  81            downloadDelegate:(id<ICCameraDeviceDownloadDelegate>)downloadDelegate
  82         didDownloadSelector:(SEL)selector
  83                 contextInfo:(void*)contextInfo {
  84   base::FilePath saveDir(base::SysNSStringToUTF8(
  85       [[options objectForKey:ICDownloadsDirectoryURL] path]));
  86   std::string saveAsFilename =
  87       base::SysNSStringToUTF8([options objectForKey:ICSaveAsFilename]);
  88   // It appears that the ImageCapture library adds an extension to the requested
  89   // filename. Do that here to require a rename.
  90   saveAsFilename += ".jpg";
  91   base::FilePath toBeSaved = saveDir.Append(saveAsFilename);
  92   ASSERT_EQ(static_cast<int>(strlen(kTestFileContents)),
  93             base::WriteFile(toBeSaved, kTestFileContents,
  94                             strlen(kTestFileContents)));
  95
  96   NSMutableDictionary* returnOptions =
  97       [NSMutableDictionary dictionaryWithDictionary:options];
  98   [returnOptions setObject:base::SysUTF8ToNSString(saveAsFilename)
  99                     forKey:ICSavedFilename];
 100
 101   [static_cast<NSObject<ICCameraDeviceDownloadDelegate>*>(downloadDelegate)
 102    didDownloadFile:file
 103              error:nil
 104            options:returnOptions
 105        contextInfo:contextInfo];
 106 }
 107
 108 @end
 109
 110 @interface MockMTPICCameraFile : ICCameraFile {
 111  @private
 112   base::scoped_nsobject<NSString> name_;
 113   base::scoped_nsobject<NSDate> date_;
 114 }
 115
 116 - (id)init:(NSString*)name;
 117
 118 @end
 119
 120 @implementation MockMTPICCameraFile
 121
 122 - (id)init:(NSString*)name {
 123   if ((self = [super init])) {
 124     name_.reset([name retain]);
 125     date_.reset([[NSDate dateWithNaturalLanguageString:@"12/12/12"] retain]);
 126   }
 127   return self;
 128 }
 129
 130 - (NSString*)name {
 131   return name_.get();
 132 }
 133
 134 - (NSString*)UTI {
 135   return base::mac::CFToNSCast(kUTTypeImage);
 136 }
 137
 138 - (NSDate*)modificationDate {
 139   return date_.get();
 140 }
 141
 142 - (NSDate*)creationDate {
 143   return date_.get();
 144 }
 145
 146 - (off_t)fileSize {
 147   return 1000;
 148 }
 149
 150 @end
 151
 152 class MTPDeviceDelegateImplMacTest : public testing::Test {
 153  public:
 154   MTPDeviceDelegateImplMacTest() : camera_(NULL), delegate_(NULL) {}
 155
 156   virtual void SetUp() OVERRIDE {
 157     ui_thread_.reset(new content::TestBrowserThread(
 158         content::BrowserThread::UI, &message_loop_));
 159     file_thread_.reset(new content::TestBrowserThread(
 160         content::BrowserThread::FILE, &message_loop_));
 161     io_thread_.reset(new content::TestBrowserThread(
 162         content::BrowserThread::IO));
 163     ASSERT_TRUE(io_thread_->Start());
 164
 165     storage_monitor::TestStorageMonitor* monitor =
 166         storage_monitor::TestStorageMonitor::CreateAndInstall();
 167     manager_.SetNotifications(monitor->receiver());
 168
 169     camera_ = [MockMTPICCameraDevice alloc];
 170     id<ICDeviceBrowserDelegate> delegate = manager_.device_browser();
 171     [delegate deviceBrowser:nil didAddDevice:camera_ moreComing:NO];
 172
 173     delegate_ = new MTPDeviceDelegateImplMac(kDeviceId, kDevicePath);
 174   }
 175
 176   virtual void TearDown() OVERRIDE {
 177     id<ICDeviceBrowserDelegate> delegate = manager_.device_browser();
 178     [delegate deviceBrowser:nil didRemoveDevice:camera_ moreGoing:NO];
 179
 180     delegate_->CancelPendingTasksAndDeleteDelegate();
 181
 182     storage_monitor::TestStorageMonitor::Destroy();
 183
 184     io_thread_->Stop();
 185   }
 186
 187   void OnError(base::WaitableEvent* event, base::File::Error error) {
 188     error_ = error;
 189     event->Signal();
 190   }
 191
 192   void OverlappedOnError(base::WaitableEvent* event,
 193                          base::File::Error error) {
 194     overlapped_error_ = error;
 195     event->Signal();
 196   }
 197
 198   void OnFileInfo(base::WaitableEvent* event,
 199                   const base::File::Info& info) {
 200     error_ = base::File::FILE_OK;
 201     info_ = info;
 202     event->Signal();
 203   }
 204
 205   void OnReadDir(base::WaitableEvent* event,
 206                  const storage::AsyncFileUtil::EntryList& files,
 207                  bool has_more) {
 208     error_ = base::File::FILE_OK;
 209     ASSERT_FALSE(has_more);
 210     file_list_ = files;
 211     event->Signal();
 212   }
 213
 214   void OverlappedOnReadDir(base::WaitableEvent* event,
 215                            const storage::AsyncFileUtil::EntryList& files,
 216                            bool has_more) {
 217     overlapped_error_ = base::File::FILE_OK;
 218     ASSERT_FALSE(has_more);
 219     overlapped_file_list_ = files;
 220     event->Signal();
 221   }
 222
 223   void OnDownload(base::WaitableEvent* event,
 224                   const base::File::Info& file_info,
 225                   const base::FilePath& local_path) {
 226     error_ = base::File::FILE_OK;
 227     event->Signal();
 228   }
 229
 230   base::File::Error GetFileInfo(const base::FilePath& path,
 231                                 base::File::Info* info) {
 232     base::WaitableEvent wait(true, false);
 233     delegate_->GetFileInfo(
 234       path,
 235       base::Bind(&MTPDeviceDelegateImplMacTest::OnFileInfo,
 236                  base::Unretained(this),
 237                  &wait),
 238       base::Bind(&MTPDeviceDelegateImplMacTest::OnError,
 239                  base::Unretained(this),
 240                  &wait));
 241     base::RunLoop loop;
 242     loop.RunUntilIdle();
 243     EXPECT_TRUE(wait.IsSignaled());
 244     *info = info_;
 245     return error_;
 246   }
 247
 248   base::File::Error ReadDir(const base::FilePath& path) {
 249     base::WaitableEvent wait(true, false);
 250     delegate_->ReadDirectory(
 251         path,
 252         base::Bind(&MTPDeviceDelegateImplMacTest::OnReadDir,
 253                    base::Unretained(this),
 254                    &wait),
 255         base::Bind(&MTPDeviceDelegateImplMacTest::OnError,
 256                    base::Unretained(this),
 257                    &wait));
 258     base::RunLoop loop;
 259     loop.RunUntilIdle();
 260     wait.Wait();
 261     return error_;
 262   }
 263
 264   base::File::Error DownloadFile(
 265       const base::FilePath& path,
 266       const base::FilePath& local_path) {
 267     base::WaitableEvent wait(true, false);
 268     delegate_->CreateSnapshotFile(
 269         path, local_path,
 270         base::Bind(&MTPDeviceDelegateImplMacTest::OnDownload,
 271                    base::Unretained(this),
 272                    &wait),
 273         base::Bind(&MTPDeviceDelegateImplMacTest::OnError,
 274                    base::Unretained(this),
 275                    &wait));
 276     base::RunLoop loop;
 277     loop.RunUntilIdle();
 278     wait.Wait();
 279     return error_;
 280   }
 281
 282  protected:
 283   base::MessageLoopForUI message_loop_;
 284   // Note: threads must be made in this order: UI > FILE > IO
 285   scoped_ptr<content::TestBrowserThread> ui_thread_;
 286   scoped_ptr<content::TestBrowserThread> file_thread_;
 287   scoped_ptr<content::TestBrowserThread> io_thread_;
 288   base::ScopedTempDir temp_dir_;
 289   storage_monitor::ImageCaptureDeviceManager manager_;
 290   MockMTPICCameraDevice* camera_;
 291
 292   // This object needs special deletion inside the above |task_runner_|.
 293   MTPDeviceDelegateImplMac* delegate_;
 294
 295   base::File::Error error_;
 296   base::File::Info info_;
 297   storage::AsyncFileUtil::EntryList file_list_;
 298
 299   base::File::Error overlapped_error_;
 300   storage::AsyncFileUtil::EntryList overlapped_file_list_;
 301
 302  private:
 303   DISALLOW_COPY_AND_ASSIGN(MTPDeviceDelegateImplMacTest);
 304 };
 305
 306 TEST_F(MTPDeviceDelegateImplMacTest, TestGetRootFileInfo) {
 307   base::File::Info info;
 308   // Making a fresh delegate should have a single file entry for the synthetic
 309   // root directory, with the name equal to the device id string.
 310   EXPECT_EQ(base::File::FILE_OK,
 311             GetFileInfo(base::FilePath(kDevicePath), &info));
 312   EXPECT_TRUE(info.is_directory);
 313   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
 314             GetFileInfo(base::FilePath("/nonexistent"), &info));
 315
 316   // Signal the delegate that no files are coming.
 317   delegate_->NoMoreItems();
 318
 319   EXPECT_EQ(base::File::FILE_OK, ReadDir(base::FilePath(kDevicePath)));
 320   EXPECT_EQ(0U, file_list_.size());
 321 }
 322
 323 TEST_F(MTPDeviceDelegateImplMacTest, TestOverlappedReadDir) {
 324   base::Time time1 = base::Time::Now();
 325   base::File::Info info1;
 326   info1.size = 1;
 327   info1.is_directory = false;
 328   info1.is_symbolic_link = false;
 329   info1.last_modified = time1;
 330   info1.last_accessed = time1;
 331   info1.creation_time = time1;
 332   delegate_->ItemAdded("name1", info1);
 333
 334   base::WaitableEvent wait(true, false);
 335
 336   delegate_->ReadDirectory(
 337       base::FilePath(kDevicePath),
 338       base::Bind(&MTPDeviceDelegateImplMacTest::OnReadDir,
 339                  base::Unretained(this),
 340                  &wait),
 341       base::Bind(&MTPDeviceDelegateImplMacTest::OnError,
 342                  base::Unretained(this),
 343                  &wait));
 344
 345   delegate_->ReadDirectory(
 346       base::FilePath(kDevicePath),
 347       base::Bind(&MTPDeviceDelegateImplMacTest::OverlappedOnReadDir,
 348                  base::Unretained(this),
 349                  &wait),
 350       base::Bind(&MTPDeviceDelegateImplMacTest::OverlappedOnError,
 351                  base::Unretained(this),
 352                  &wait));
 353
 354
 355   // Signal the delegate that no files are coming.
 356   delegate_->NoMoreItems();
 357
 358   base::RunLoop loop;
 359   loop.RunUntilIdle();
 360   wait.Wait();
 361
 362   EXPECT_EQ(base::File::FILE_OK, error_);
 363   EXPECT_EQ(1U, file_list_.size());
 364   EXPECT_EQ(base::File::FILE_OK, overlapped_error_);
 365   EXPECT_EQ(1U, overlapped_file_list_.size());
 366 }
 367
 368 TEST_F(MTPDeviceDelegateImplMacTest, TestGetFileInfo) {
 369   base::Time time1 = base::Time::Now();
 370   base::File::Info info1;
 371   info1.size = 1;
 372   info1.is_directory = false;
 373   info1.is_symbolic_link = false;
 374   info1.last_modified = time1;
 375   info1.last_accessed = time1;
 376   info1.creation_time = time1;
 377   delegate_->ItemAdded("name1", info1);
 378
 379   base::File::Info info;
 380   EXPECT_EQ(base::File::FILE_OK,
 381             GetFileInfo(base::FilePath("/ic:id/name1"), &info));
 382   EXPECT_EQ(info1.size, info.size);
 383   EXPECT_EQ(info1.is_directory, info.is_directory);
 384   EXPECT_EQ(info1.last_modified, info.last_modified);
 385   EXPECT_EQ(info1.last_accessed, info.last_accessed);
 386   EXPECT_EQ(info1.creation_time, info.creation_time);
 387
 388   info1.size = 2;
 389   delegate_->ItemAdded("name2", info1);
 390   delegate_->NoMoreItems();
 391
 392   EXPECT_EQ(base::File::FILE_OK,
 393             GetFileInfo(base::FilePath("/ic:id/name2"), &info));
 394   EXPECT_EQ(info1.size, info.size);
 395
 396   EXPECT_EQ(base::File::FILE_OK, ReadDir(base::FilePath(kDevicePath)));
 397
 398   ASSERT_EQ(2U, file_list_.size());
 399   EXPECT_EQ(time1, file_list_[0].last_modified_time);
 400   EXPECT_FALSE(file_list_[0].is_directory);
 401   EXPECT_EQ("name1", file_list_[0].name);
 402
 403   EXPECT_EQ(time1, file_list_[1].last_modified_time);
 404   EXPECT_FALSE(file_list_[1].is_directory);
 405   EXPECT_EQ("name2", file_list_[1].name);
 406 }
 407
 408 TEST_F(MTPDeviceDelegateImplMacTest, TestDirectoriesAndSorting) {
 409   base::Time time1 = base::Time::Now();
 410   base::File::Info info1;
 411   info1.size = 1;
 412   info1.is_directory = false;
 413   info1.is_symbolic_link = false;
 414   info1.last_modified = time1;
 415   info1.last_accessed = time1;
 416   info1.creation_time = time1;
 417   delegate_->ItemAdded("name2", info1);
 418
 419   info1.is_directory = true;
 420   delegate_->ItemAdded("dir2", info1);
 421   delegate_->ItemAdded("dir1", info1);
 422
 423   info1.is_directory = false;
 424   delegate_->ItemAdded("name1", info1);
 425   delegate_->NoMoreItems();
 426
 427   EXPECT_EQ(base::File::FILE_OK, ReadDir(base::FilePath(kDevicePath)));
 428
 429   ASSERT_EQ(4U, file_list_.size());
 430   EXPECT_EQ("dir1", file_list_[0].name);
 431   EXPECT_EQ("dir2", file_list_[1].name);
 432   EXPECT_EQ(time1, file_list_[2].last_modified_time);
 433   EXPECT_FALSE(file_list_[2].is_directory);
 434   EXPECT_EQ("name1", file_list_[2].name);
 435
 436   EXPECT_EQ(time1, file_list_[3].last_modified_time);
 437   EXPECT_FALSE(file_list_[3].is_directory);
 438   EXPECT_EQ("name2", file_list_[3].name);
 439 }
 440
 441 TEST_F(MTPDeviceDelegateImplMacTest, SubDirectories) {
 442   base::Time time1 = base::Time::Now();
 443   base::File::Info info1;
 444   info1.size = 0;
 445   info1.is_directory = true;
 446   info1.is_symbolic_link = false;
 447   info1.last_modified = time1;
 448   info1.last_accessed = time1;
 449   info1.creation_time = time1;
 450   delegate_->ItemAdded("dir1", info1);
 451
 452   info1.size = 1;
 453   info1.is_directory = false;
 454   info1.is_symbolic_link = false;
 455   info1.last_modified = time1;
 456   info1.last_accessed = time1;
 457   info1.creation_time = time1;
 458   delegate_->ItemAdded("dir1/name1", info1);
 459
 460   info1.is_directory = true;
 461   info1.size = 0;
 462   delegate_->ItemAdded("dir2", info1);
 463
 464   info1.is_directory = false;
 465   info1.size = 1;
 466   delegate_->ItemAdded("dir2/name2", info1);
 467
 468   info1.is_directory = true;
 469   info1.size = 0;
 470   delegate_->ItemAdded("dir2/subdir", info1);
 471
 472   info1.is_directory = false;
 473   info1.size = 1;
 474   delegate_->ItemAdded("dir2/subdir/name3", info1);
 475   delegate_->ItemAdded("name4", info1);
 476
 477   delegate_->NoMoreItems();
 478
 479   EXPECT_EQ(base::File::FILE_OK, ReadDir(base::FilePath(kDevicePath)));
 480   ASSERT_EQ(3U, file_list_.size());
 481   EXPECT_TRUE(file_list_[0].is_directory);
 482   EXPECT_EQ("dir1", file_list_[0].name);
 483   EXPECT_TRUE(file_list_[1].is_directory);
 484   EXPECT_EQ("dir2", file_list_[1].name);
 485   EXPECT_FALSE(file_list_[2].is_directory);
 486   EXPECT_EQ("name4", file_list_[2].name);
 487
 488   EXPECT_EQ(base::File::FILE_OK,
 489             ReadDir(base::FilePath(kDevicePath).Append("dir1")));
 490   ASSERT_EQ(1U, file_list_.size());
 491   EXPECT_FALSE(file_list_[0].is_directory);
 492   EXPECT_EQ("name1", file_list_[0].name);
 493
 494   EXPECT_EQ(base::File::FILE_OK,
 495             ReadDir(base::FilePath(kDevicePath).Append("dir2")));
 496   ASSERT_EQ(2U, file_list_.size());
 497   EXPECT_FALSE(file_list_[0].is_directory);
 498   EXPECT_EQ("name2", file_list_[0].name);
 499   EXPECT_TRUE(file_list_[1].is_directory);
 500   EXPECT_EQ("subdir", file_list_[1].name);
 501
 502   EXPECT_EQ(base::File::FILE_OK,
 503             ReadDir(base::FilePath(kDevicePath)
 504                     .Append("dir2").Append("subdir")));
 505   ASSERT_EQ(1U, file_list_.size());
 506   EXPECT_FALSE(file_list_[0].is_directory);
 507   EXPECT_EQ("name3", file_list_[0].name);
 508
 509   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
 510             ReadDir(base::FilePath(kDevicePath)
 511                     .Append("dir2").Append("subdir").Append("subdir")));
 512   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
 513             ReadDir(base::FilePath(kDevicePath)
 514                     .Append("dir3").Append("subdir")));
 515   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
 516             ReadDir(base::FilePath(kDevicePath).Append("dir3")));
 517 }
 518
 519 TEST_F(MTPDeviceDelegateImplMacTest, TestDownload) {
 520   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 521   base::Time t1 = base::Time::Now();
 522   base::File::Info info;
 523   info.size = 4;
 524   info.is_directory = false;
 525   info.is_symbolic_link = false;
 526   info.last_modified = t1;
 527   info.last_accessed = t1;
 528   info.creation_time = t1;
 529   std::string kTestFileName("filename");
 530   base::scoped_nsobject<MockMTPICCameraFile> picture1(
 531       [[MockMTPICCameraFile alloc]
 532           init:base::SysUTF8ToNSString(kTestFileName)]);
 533   [camera_ addMediaFile:picture1];
 534   delegate_->ItemAdded(kTestFileName, info);
 535   delegate_->NoMoreItems();
 536
 537   EXPECT_EQ(base::File::FILE_OK, ReadDir(base::FilePath(kDevicePath)));
 538   ASSERT_EQ(1U, file_list_.size());
 539   ASSERT_EQ("filename", file_list_[0].name);
 540
 541   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND,
 542             DownloadFile(base::FilePath("/ic:id/nonexist"),
 543                          temp_dir_.path().Append("target")));
 544
 545   EXPECT_EQ(base::File::FILE_OK,
 546             DownloadFile(base::FilePath("/ic:id/filename"),
 547                          temp_dir_.path().Append("target")));
 548   std::string contents;
 549   EXPECT_TRUE(base::ReadFileToString(temp_dir_.path().Append("target"),
 550                                      &contents));
 551   EXPECT_EQ(kTestFileContents, contents);
 552 }