ui/file_manager/gallery/js/gallery_item_unittest.js

   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 /**
   6  * Mock of ImageUtil.
   7  */
   8 var ImageUtil = {
   9   getMetricName: function() {},
  10   metrics: {
  11     recordEnum: function() {},
  12     recordInterval: function() {},
  13     startInterval: function() {}
  14   }
  15 };
  16
  17 /**
  18  * Mock of ImageEncoder. Since some test changes the behavior of ImageEncoder,
  19  * this is initialized in setUp().
  20  */
  21 var ImageEncoder;
  22
  23 /**
  24  * Load time data.
  25  */
  26 loadTimeData.data = {
  27   DRIVE_DIRECTORY_LABEL: '',
  28   DOWNLOADS_DIRECTORY_LABEL: ''
  29 };
  30
  31 function setUp() {
  32   ImageEncoder = {
  33     encodeMetadata: function() {},
  34     getBlob: function() {}
  35   };
  36 }
  37
  38 /**
  39  * Returns a mock of metadata model.
  40  * @private
  41  * @return {!MetadataModel}
  42  */
  43 function getMockMetadataModel() {
  44   return {
  45     get: function(entries, names) {
  46       return Promise.resolve([
  47         {size: 200}
  48       ]);
  49     },
  50     notifyEntriesChanged: function() {
  51     }
  52   };
  53 }
  54
  55 /**
  56  * Tests for GalleryItem#saveToFile.
  57  */
  58 function testSaveToFile(callback) {
  59   var fileSystem = new MockFileSystem('volumeId');
  60   fileSystem.populate(['/test.jpg']);
  61   var entry = fileSystem.entries['/test.jpg'];
  62   entry.createWriter = function(callback) {
  63     callback({
  64       write: function() {
  65         Promise.resolve().then(function() {
  66           this.onwriteend();
  67         }.bind(this));
  68       },
  69       truncate: function() {
  70         this.write();
  71       }
  72     });
  73   };
  74   var entryChanged = false;
  75   var metadataModel = getMockMetadataModel();
  76   metadataModel.notifyEntriesChanged = function() {
  77     entryChanged = true;
  78   };
  79
  80   var item = new Gallery.Item(
  81       entry,
  82       {isReadOnly: false},
  83       {size: 100},
  84       {},
  85       /* original */ true);
  86   assertEquals(100, item.getMetadataItem().size);
  87   assertFalse(entryChanged);
  88   reportPromise(
  89       new Promise(item.saveToFile.bind(
  90           item,
  91           {
  92             getLocationInfo: function() { return {}; },
  93             getVolumeInfo: function() { return {}; }
  94           },
  95           metadataModel,
  96           /* fallbackDir */ null,
  97           document.createElement('canvas'),
  98           true /* overwrite */)).then(function() {
  99             assertEquals(200, item.getMetadataItem().size);
 100             assertTrue(entryChanged);
 101           }), callback);
 102 }
 103
 104 /**
 105  * Tests for GalleryItem#saveToFile. In this test case, fileWriter.write fails
 106  * with an error.
 107  */
 108 function testSaveToFileWriteFailCase(callback) {
 109   var fileSystem = new MockFileSystem('volumeId');
 110   fileSystem.populate(['/test.jpg']);
 111   var entry = fileSystem.entries['/test.jpg'];
 112
 113   entry.createWriter = function(callback) {
 114     callback({
 115       write: function() {
 116         Promise.resolve().then(function() {
 117           this.onerror(new Error());
 118         }.bind(this));
 119       },
 120       truncate: function() {
 121         Promise.resolve().then(function() {
 122           this.onwriteend();
 123         }.bind(this));
 124       }
 125     });
 126   };
 127
 128   var item = new Gallery.Item(
 129       entry,
 130       {isReadOnly: false},
 131       {size: 100},
 132       {},
 133       /* original */ true);
 134   reportPromise(
 135       new Promise(item.saveToFile.bind(
 136           item,
 137           {
 138             getLocationInfo: function() { return {}; },
 139             getVolumeInfo: function() { return {}; }
 140           },
 141           getMockMetadataModel(),
 142           /* fallbackDir */ null,
 143           document.createElement('canvas'),
 144           true /* overwrite */)).then(function(result) {
 145             assertFalse(result);
 146           }), callback);
 147 }
 148
 149 /**
 150  * Tests for GalleryItem#saveToFile. In this test case, ImageEncoder.getBlob
 151  * fails with an error. This test case confirms that no write operation runs
 152  * when it fails to get a blob of new image.
 153  */
 154 function testSaveToFileGetBlobFailCase(callback) {
 155   ImageEncoder.getBlob = function() {
 156     throw new Error();
 157   };
 158
 159   var fileSystem = new MockFileSystem('volumeId');
 160   fileSystem.populate(['/test.jpg']);
 161   var entry = fileSystem.entries['/test.jpg'];
 162
 163   var writeOperationRun = false;
 164   entry.createWriter = function(callback) {
 165     callback({
 166       write: function() {
 167         Promise.resolve().then(function() {
 168           writeOperationRun = true;
 169           this.onwriteend();
 170         }.bind(this));
 171       },
 172       truncate: function() {
 173         Promise.resolve().then(function() {
 174           writeOperationRun = true;
 175           this.onwriteend();
 176         }.bind(this));
 177       }
 178     });
 179   };
 180
 181   var item = new Gallery.Item(
 182       entry,
 183       {isReadOnly: false},
 184       {size: 100},
 185       {},
 186       /* original */ true);
 187   reportPromise(
 188       new Promise(item.saveToFile.bind(
 189           item,
 190           {
 191             getLocationInfo: function() { return {}; },
 192             getVolumeInfo: function() { return {}; }
 193           },
 194           getMockMetadataModel(),
 195           /* fallbackDir */ null,
 196           document.createElement('canvas'),
 197           true /* overwrite*/)).then(function(result) {
 198             assertFalse(result);
 199             assertFalse(writeOperationRun);
 200           }), callback);
 201 }
 202
 203 function testSaveToFileRaw(callback) {
 204   var fileSystem = new MockFileSystem('volumeId');
 205   fileSystem.populate(['/test.arw']);
 206   fileSystem.entries['/'].getFile = function(name, options, success, error) {
 207     if (options.create) {
 208       assertEquals('test - Edited.jpg', name);
 209       fileSystem.populate(['/test - Edited.jpg']);
 210       var entry = fileSystem.entries['/test - Edited.jpg'];
 211       entry.createWriter = function(callback) {
 212         callback({
 213           write: function() {
 214             Promise.resolve().then(function() {
 215               this.onwriteend();
 216             }.bind(this));
 217           },
 218           truncate: function() {
 219             this.write();
 220           }
 221         });
 222       };
 223     }
 224     MockDirectoryEntry.prototype.getFile.apply(this, arguments);
 225   };
 226   var entryChanged = false;
 227   var metadataModel = getMockMetadataModel();
 228   metadataModel.notifyEntriesChanged = function() {
 229     entryChanged = true;
 230   };
 231
 232   var item = new Gallery.Item(
 233       fileSystem.entries['/test.arw'],
 234       {isReadOnly: false},
 235       {size: 100},
 236       {},
 237       /* original */ true);
 238   assertEquals(100, item.getMetadataItem().size);
 239   assertFalse(entryChanged);
 240   reportPromise(
 241       new Promise(item.saveToFile.bind(
 242           item,
 243           {
 244             getLocationInfo: function() { return {}; },
 245             getVolumeInfo: function() { return {}; }
 246           },
 247           metadataModel,
 248           /* fallbackDir */ null,
 249           document.createElement('canvas'),
 250           false /* not overwrite */)).then(function(success) {
 251             assertTrue(success);
 252             assertEquals(200, item.getMetadataItem().size);
 253             assertTrue(entryChanged);
 254             assertFalse(item.isOriginal());
 255           }), callback);
 256 }
 257
 258 function testIsWritableFile() {
 259   var downloads = new MockFileSystem('downloads');
 260   var removable = new MockFileSystem('removable');
 261   var mtp = new MockFileSystem('mtp');
 262
 263   var volumeTypes = {
 264     downloads: VolumeManagerCommon.VolumeType.DOWNLOADS,
 265     removable: VolumeManagerCommon.VolumeType.REMOVABLE,
 266     mtp: VolumeManagerCommon.VolumeType.MTP
 267   };
 268
 269   // Mock volume manager.
 270   var volumeManager = {
 271     getVolumeInfo: function(entry) {
 272       return {
 273         volumeType: volumeTypes[entry.filesystem.name]
 274       };
 275     }
 276   };
 277
 278   var getGalleryItem = function(path, fileSystem, isReadOnly) {
 279     return new Gallery.Item(new MockEntry(fileSystem, path),
 280         {isReadOnly: isReadOnly},
 281         {size: 100},
 282         {},
 283         true /* original */);
 284   };
 285
 286   // Jpeg file on downloads.
 287   assertTrue(getGalleryItem(
 288       '/test.jpg', downloads, false /* not read only */).
 289       isWritableFile(volumeManager));
 290
 291   // Png file on downloads.
 292   assertTrue(getGalleryItem(
 293       '/test.png', downloads, false /* not read only */).
 294       isWritableFile(volumeManager));
 295
 296   // Webp file on downloads.
 297   assertFalse(getGalleryItem(
 298       '/test.webp', downloads, false /* not read only */).
 299       isWritableFile(volumeManager));
 300
 301   // Jpeg file on non-writable volume.
 302   assertFalse(getGalleryItem(
 303       '/test.jpg', removable, true /* read only */).
 304       isWritableFile(volumeManager));
 305
 306   // Jpeg file on mtp volume.
 307   assertFalse(getGalleryItem(
 308       '/test.jpg', mtp, false /* not read only */).
 309       isWritableFile(volumeManager));
 310 };