public async Task SingleFile_FileAlreadyExist_With_Same_ByteSize()
{
var(fileHash, _) = await new FileHash(_iStorageFake).GetHashCodeAsync("/test.jpg");
var fakeQuery = new FakeIQuery(new List <FileIndexItem>
{
new FileIndexItem("/test.jpg")
{
FileHash = fileHash,
Size = _iStorageFake.Info("/test.jpg").Size, // < right byte size
Tags = "the tags should not be updated" // <= the tags in /test.jpg is nothing
}
});
var sync = new SyncSingleFile(new AppSettings(), fakeQuery,
_iStorageFake, new FakeIWebLogger());
var result = await sync.SingleFile("/test.jpg");
Assert.AreEqual(FileIndexItem.ExifStatus.OkAndSame, result.Status);
var fileIndexItem = fakeQuery.SingleItem("/test.jpg").FileIndexItem;
Assert.AreNotEqual(string.Empty, fileIndexItem.Tags);
Assert.AreEqual("the tags should not be updated", fileIndexItem.Tags);
}
public async Task SingleItem_DbItem_Updated_TriggerDelegate()
{
var item = new FileIndexItem("/test.jpg")
{
FileHash = "THIS_IS_THE_OLD_HASH",
Size = 99999999 // % % % that's not the right size % % %
};
var fakeQuery = new FakeIQuery(new List <FileIndexItem> {
item
});
var sync = new SyncSingleFile(new AppSettings(), fakeQuery,
_iStorageFake, new FakeIWebLogger());
var isCalled = false;
Task TestTask(List <FileIndexItem> _)
{
isCalled = true;
return(Task.CompletedTask);
}
await sync.SingleFile("/test.jpg", item, TestTask); // % % % % Enter item here % % % % %
Assert.IsTrue(isCalled);
}
public async Task SingleFile_FileAlreadyExist_WithSameFileHash_ShouldNotTrigger()
{
var(fileHash, _) = await new FileHash(_iStorageFake).GetHashCodeAsync("/test.jpg");
var fakeQuery = new FakeIQuery(new List <FileIndexItem>
{
new FileIndexItem("/test.jpg")
{
FileHash = fileHash
}
});
var sync = new SyncSingleFile(new AppSettings(), fakeQuery,
_iStorageFake, new FakeIWebLogger());
var isCalled = false;
Task TestTask(List <FileIndexItem> _)
{
isCalled = true;
return(Task.CompletedTask);
}
await sync.SingleFile("/test.jpg", TestTask);
Assert.IsFalse(isCalled);
}
private Tuple <IQuery, IServiceScopeFactory> CreateNewExampleData()
{
var services = new ServiceCollection();
var serviceProvider = services.BuildServiceProvider();
services.AddScoped(p => _appSettings);
var query = new FakeIQuery(new List <FileIndexItem>
{
new FileIndexItem("/folder_no_content/")
{
IsDirectory = true
},
new FileIndexItem("/folder_content")
{
IsDirectory = true
},
new FileIndexItem("/folder_content/test.jpg"),
new FileIndexItem("/folder_content/test2.jpg")
});
services.AddScoped <IQuery, FakeIQuery>(p => query);
var serviceScopeFactory = serviceProvider.GetRequiredService <IServiceScopeFactory>();
return(new Tuple <IQuery, IServiceScopeFactory>(query, serviceScopeFactory));
}
public void Delete_IsFileRemoved()
{
var storage = new FakeIStorage(new List <string> {
"/"
},
new List <string> {
"/test.jpg"
},
new List <byte[]> {
FakeCreateAn.CreateAnImage.Bytes
});
var selectorStorage = new FakeSelectorStorage(storage);
var fakeQuery =
new FakeIQuery(new List <FileIndexItem> {
new FileIndexItem("/test.jpg")
{
Tags = "!delete!"
}
});
var deleteItem = new DeleteItem(fakeQuery, new AppSettings(), selectorStorage);
var result = deleteItem.Delete("/test.jpg", true);
Assert.AreEqual(FileIndexItem.ExifStatus.Ok,
result.FirstOrDefault().Status);
Assert.IsNull(fakeQuery.GetObjectByFilePath("/test.jpg"));
Assert.IsFalse(storage.ExistFile("/test.jpg"));
}
public async Task AddParentFolder_ExistingFolder()
{
var storage = GetStorage();
var folderPath = "/exist2";
var query = new FakeIQuery(new List <FileIndexItem> {
new FileIndexItem("/exist2")
{
IsDirectory = true
}
});
var syncFolder = new SyncFolder(_appSettings, query, new FakeSelectorStorage(storage),
new ConsoleWrapper(), new FakeIWebLogger(), new FakeMemoryCache());
var result = await syncFolder.AddParentFolder(folderPath);
Assert.IsNotNull(query.GetObjectByFilePathAsync(folderPath));
Assert.AreEqual(folderPath, result.FilePath);
// should not add duplicate content
var allItems = await query.GetAllRecursiveAsync("/");
Assert.AreEqual(1, allItems.Count);
Assert.AreEqual(folderPath, allItems[0].FilePath);
Assert.AreEqual(FileIndexItem.ExifStatus.Ok, allItems[0].Status);
}
public async Task UpdateTransformations_ShouldNotUpdate_IndexOff()
{
var storage = new FakeIStorage(
new List <string> {
"/"
},
new List <string> {
"/test.jpg", "/test.xmp"
},
new List <byte[]> {
CreateAnPng.Bytes, CreateAnXmp.Bytes
});
var appSettings = new AppSettings();
var updateImportTransformations = new UpdateImportTransformations(new FakeIWebLogger(),
new FakeExifTool(storage, appSettings), new FakeSelectorStorage(storage), appSettings);
var query = new FakeIQuery();
await query.AddItemAsync(new FileIndexItem("/test.jpg"){ FileHash = "test" });
UpdateImportTransformations.QueryUpdateDelegate updateItemAsync = query.UpdateItemAsync;
await updateImportTransformations.UpdateTransformations(updateItemAsync,
new FileIndexItem("/test.jpg"){ ColorClass = ColorClassParser.Color.Typical }, 0,
false, false);
var updatedItem = await query.GetObjectByFilePathAsync("/test.jpg");
// Are NOT equal!
Assert.AreNotEqual(ColorClassParser.Color.Typical, updatedItem.ColorClass);
}
public async Task FileAlreadyExist_With_Changed_FileHash_MetaDataCheck()
{
var(fileHash, _) = await new FileHash(_iStorageFake)
.GetHashCodeAsync("/color_class_test.jpg");
var fakeQuery = new FakeIQuery(new List <FileIndexItem>
{
new FileIndexItem("/color_class_test.jpg")
{
FileHash = "THIS_IS_THE_OLD_HASH"
}
});
var sync = new SyncSingleFile(new AppSettings(), fakeQuery,
_iStorageFake, new FakeIWebLogger());
await sync.SingleFile("/color_class_test.jpg");
var fileIndexItem = fakeQuery.SingleItem("/color_class_test.jpg").FileIndexItem;
Assert.IsNotNull(fileIndexItem);
Assert.AreEqual(fileHash, fileIndexItem.FileHash);
Assert.AreEqual("Magland", fileIndexItem.LocationCity);
Assert.AreEqual(9, fileIndexItem.Aperture);
Assert.AreEqual(400, fileIndexItem.IsoSpeed);
Assert.AreEqual("tete de balacha, bergtop, mist, flaine", fileIndexItem.Tags);
Assert.AreEqual(ColorClassParser.Color.Winner, fileIndexItem.ColorClass);
}
public async Task SingleFile_ShouldAddToSidecarFieldWhenSidecarIsAdded()
{
// It should update the Sidecar field when a sidecar file is add to the directory
var storage = new FakeIStorage(new List <string> {
"/"
},
new List <string> {
"/test.dng", "/test.xmp"
}, new List <byte[]> {
CreateAnImageNoExif.Bytes,
new byte[0]
});
var(fileHash, _) = await new FileHash(storage).GetHashCodeAsync("/test.jpg");
var item = new FileIndexItem("/test.jpg")
{
FileHash = fileHash, // < right file hash
Size = _iStorageFake.Info("/test.jpg").Size, // < right byte size
};
var fakeQuery = new FakeIQuery(new List <FileIndexItem> {
item
});
var sync = new SyncSingleFile(new AppSettings {
Verbose = true
}, fakeQuery,
_iStorageFake, new FakeIWebLogger());
await sync.SingleFile("/test.xmp", item);
var fileIndexItem = fakeQuery.SingleItem("/test.jpg").FileIndexItem;
Assert.AreEqual(1, fileIndexItem.SidecarExtensionsList.Count);
Assert.AreEqual("xmp", fileIndexItem.SidecarExtensionsList.ToList()[0]);
}
public async Task SingleFile_FileAlreadyExist_WithSameFileHash()
{
var(fileHash, _) = await new FileHash(_iStorageFake).GetHashCodeAsync("/test.jpg");
var fakeQuery = new FakeIQuery(new List <FileIndexItem>
{
new FileIndexItem("/test.jpg")
{
FileHash = fileHash
}
});
var sync = new SyncSingleFile(new AppSettings(), fakeQuery,
_iStorageFake, new FakeIWebLogger());
var result = await sync.SingleFile("/test.jpg");
Assert.AreEqual(FileIndexItem.ExifStatus.OkAndSame, result.Status);
var count = (await fakeQuery.GetAllFilesAsync("/")).Count(p => p.FileName == "test.jpg");
Assert.AreEqual(1, count);
var detailView = fakeQuery.SingleItem("/test.jpg");
Assert.IsNotNull(detailView);
var fileIndexItem = detailView.FileIndexItem;
Assert.AreEqual("/test.jpg", fileIndexItem.FilePath);
}
public async Task AddParentCacheIfNotExist_IgnoreWhenCacheExists()
{
var fakeContent =
new List <FileIndexItem> {
new FileIndexItem("/test.jpg")
{
FileHash = "test1"
}
};
var fakeContentCache =
new List <FileIndexItem> {
new FileIndexItem("/test.jpg")
{
FileHash = "__old_key__"
}
};
var fakeQuery = new FakeIQuery(fakeContent, fakeContentCache);
var metaPreflight = new AddParentCacheIfNotExist(fakeQuery, new FakeIWebLogger());
await metaPreflight.AddParentCacheIfNotExistAsync(
fakeContent.Select(p => p.FilePath));
var(_, cacheGetParentFolder) = fakeQuery.CacheGetParentFolder("/");
Assert.AreEqual(1, cacheGetParentFolder.Count);
Assert.AreEqual("__old_key__", cacheGetParentFolder[0].FileHash);
}
public async Task ExportControllerTest__ThumbFalse_AddXmpFile_CreateListToExport()
{
var storage = new FakeIStorage(new List <string> {
"/"
}, new List <string>
{
_appSettings.DatabasePathToFilePath("/test.dng", false),
_appSettings.DatabasePathToFilePath("/test.xmp", false),
"/test.dng",
"/test.xmp"
});
var selectorStorage = new FakeSelectorStorage(storage);
var fileIndexResultsList = new List <FileIndexItem>
{
new FileIndexItem
{
FileName = "test.dng",
ParentDirectory = "/",
FileHash = "FileHash",
Status = FileIndexItem.ExifStatus.Ok
}
};
var fakeQuery = new FakeIQuery(fileIndexResultsList);
var export = new ExportService(fakeQuery, _appSettings, selectorStorage, new FakeIWebLogger());
var filePaths = await export.CreateListToExport(fileIndexResultsList, false);
Assert.AreEqual(true, filePaths[0].Contains("test.dng"));
Assert.AreEqual(true, filePaths[1].Contains("test.xmp"));
}
public void Delete_ChildDirectories()
{
var storage = new FakeIStorage(new List <string> {
"/test", "/", "/test/child", "/test/child/child"
},
new List <string> (),
new List <byte[]>());
var selectorStorage = new FakeSelectorStorage(storage);
var fakeQuery =
new FakeIQuery(new List <FileIndexItem> {
new FileIndexItem("/test")
{
IsDirectory = true, Tags = "!delete!"
},
new FileIndexItem("/test/child")
{
IsDirectory = true
},
new FileIndexItem("/test/child/child")
{
IsDirectory = true
},
});
var deleteItem = new DeleteItem(fakeQuery, new AppSettings(), selectorStorage);
var result = deleteItem.Delete("/test", false);
Assert.AreEqual(3, result.Count);
Assert.AreEqual("/test", result[0].FilePath);
Assert.AreEqual("/test/child", result[1].FilePath);
Assert.AreEqual("/test/child/child", result[2].FilePath);
}
public async Task Update_Write_GPX()
{
var changedFileIndexItemName = new Dictionary <string, List <string> > {
{
"/test.gpx", new List <string> {
"Tags"
}
}
};
await _iStorageFake.WriteStreamAsync(new MemoryStream(CreateAnGpx.Bytes), "/test.gpx");
var updateItem = new FileIndexItem("/test.gpx")
{
Tags = "test",
Status = FileIndexItem.ExifStatus.Ok
};
var query = new FakeIQuery();
await query.AddItemAsync(updateItem);
var fileIndexResultsList = new List <FileIndexItem> {
updateItem
};
var readMeta = new FakeReadMetaSubPathStorage();
var service = new MetaUpdateService(query, _exifTool,
new FakeSelectorStorage(_iStorageFake), new FakeMetaPreflight(),
new FakeIWebLogger(), readMeta);
await service.UpdateAsync(changedFileIndexItemName, fileIndexResultsList, updateItem, false, false, 0);
Assert.IsTrue(_iStorageFake.ExistFile("/.starsky.test.gpx.json"));
}
public void Delete_DirectoryWithChildItems_CollectionsOff()
{
var storage = new FakeIStorage(new List <string> {
"/test", "/"
},
new List <string> {
"/test/image.jpg", "/test/image.dng"
},
new List <byte[]> {
FakeCreateAn.CreateAnImage.Bytes,
FakeCreateAn.CreateAnImage.Bytes
});
var selectorStorage = new FakeSelectorStorage(storage);
var fakeQuery =
new FakeIQuery(new List <FileIndexItem> {
new FileIndexItem("/test")
{
IsDirectory = true, Tags = "!delete!"
}, new FileIndexItem("/test/image.jpg"),
new FileIndexItem("/test/image.dng")
});
var deleteItem = new DeleteItem(fakeQuery, new AppSettings(), selectorStorage);
var result = deleteItem.Delete("/test", false);
Assert.AreEqual(3, result.Count);
Assert.AreEqual("/test", result[0].FilePath);
Assert.AreEqual("/test/image.jpg", result[1].FilePath);
Assert.AreEqual("/test/image.dng", result[2].FilePath);
Assert.AreEqual(0, storage.GetAllFilesInDirectoryRecursive("/").Count());
Assert.AreEqual(0, fakeQuery.GetAllRecursive("/").Count);
}
public async Task SingleItem_DbItem_NoContent_NoItemInDb()
{
var(fileHash, _) = await new FileHash(_iStorageFake).GetHashCodeAsync("/test.jpg");
var item = new FileIndexItem("/test.jpg")
{
FileHash = "THIS_IS_THE_OLD_HASH",
Size = 99999999 // % % % that's not the right size % % %
};
var fakeQuery = new FakeIQuery(new List <FileIndexItem> {
item
});
var sync = new SyncSingleFile(new AppSettings(), fakeQuery,
_iStorageFake, new FakeIWebLogger());
var result = await sync.SingleFile("/test.jpg", null); // % % % % Null value here % % % % %
Assert.AreEqual(FileIndexItem.ExifStatus.Ok, result.Status);
var count = (await fakeQuery.GetAllFilesAsync("/")).Count(p => p.FileName == "test.jpg");
Assert.AreEqual(1, count);
var detailView = fakeQuery.SingleItem("/test.jpg");
Assert.IsNotNull(detailView);
var fileIndexItem = detailView.FileIndexItem;
Assert.AreEqual("/test.jpg", fileIndexItem.FilePath);
Assert.AreEqual(fileHash, fileIndexItem.FileHash);
}
public async Task SingleFile_DbItem_FileAlreadyExist_With_Same_ByteSize()
{
var(fileHash, _) = await new FileHash(_iStorageFake).GetHashCodeAsync("/test.jpg");
var item = new FileIndexItem("/test.jpg")
{
FileHash = fileHash,
Size = _iStorageFake.Info("/test.jpg").Size, // < right byte size
Tags = "the tags should not be updated" // <= the tags in /test.jpg is nothing
};
var fakeQuery = new FakeIQuery(new List <FileIndexItem> {
item
});
var sync = new SyncSingleFile(new AppSettings {
Verbose = true
}, fakeQuery,
_iStorageFake, new FakeIWebLogger());
await sync.SingleFile("/test.jpg", item); // % % % % Enter item here % % % % %
var fileIndexItem = fakeQuery.SingleItem("/test.jpg").FileIndexItem;
Assert.AreNotEqual(string.Empty, fileIndexItem.Tags);
Assert.AreEqual("the tags should not be updated", fileIndexItem.Tags);
}
public async Task UpdateTransformations_ShouldUpdate_Description_IndexModeOn()
{
var storage = new FakeIStorage(
new List <string> {
"/"
},
new List <string> {
"/test.jpg", "/test.xmp"
},
new List <byte[]> {
CreateAnPng.Bytes, CreateAnXmp.Bytes
});
var appSettings = new AppSettings();
var updateImportTransformations = new UpdateImportTransformations(new FakeIWebLogger(),
new FakeExifTool(storage, appSettings), new FakeSelectorStorage(storage), appSettings);
var query = new FakeIQuery();
await query.AddItemAsync(new FileIndexItem("/test.jpg"){ FileHash = "test" });
UpdateImportTransformations.QueryUpdateDelegate updateItemAsync = query.UpdateItemAsync;
await updateImportTransformations.UpdateTransformations(updateItemAsync,
new FileIndexItem("/test.jpg"){ Description = "test-ung" }, -1,
true, true);
var updatedItem = await query.GetObjectByFilePathAsync("/test.jpg");
Assert.AreEqual("test-ung", updatedItem.Description);
}
public void Delete_ReadOnly_Ignored()
{
var selectorStorage = new FakeSelectorStorage(new FakeIStorage(new List <string> {
"/"
},
new List <string> {
"/readonly/test.jpg"
}, new List <byte[]> {
FakeCreateAn.CreateAnImage.Bytes
}));
var fakeQuery =
new FakeIQuery(new List <FileIndexItem> {
new FileIndexItem("/readonly/test.jpg")
});
var deleteItem = new DeleteItem(fakeQuery, new AppSettings {
ReadOnlyFolders = new List <string> {
"/readonly"
}
}, selectorStorage);
var result = deleteItem.Delete("/readonly/test.jpg", true);
Assert.AreEqual(FileIndexItem.ExifStatus.ReadOnly,
result.FirstOrDefault().Status);
}
private Tuple <IQuery, IServiceScopeFactory> CreateNewExampleData(List <FileIndexItem> content)
{
// ReSharper disable once ConvertIfStatementToNullCoalescingAssignment
if (content == null)
{
content = new List <FileIndexItem>
{
new FileIndexItem("/folder_no_content/")
{
IsDirectory = true
},
new FileIndexItem("/folder_content")
{
IsDirectory = true
},
new FileIndexItem("/folder_content/test.jpg"),
new FileIndexItem("/folder_content/test2.jpg")
};
}
var services = new ServiceCollection();
var serviceProvider = services.BuildServiceProvider();
services.AddScoped(p => _appSettings);
var query = new FakeIQuery(content);
services.AddScoped <IQuery, FakeIQuery>(p => query);
var serviceScopeFactory = serviceProvider.GetRequiredService <IServiceScopeFactory>();
return(new Tuple <IQuery, IServiceScopeFactory>(query, serviceScopeFactory));
}
public async Task SingleFile_FileType_NotSupported()
{
var fakeQuery = new FakeIQuery(new List <FileIndexItem>());
var sync = new SyncSingleFile(new AppSettings(), fakeQuery,
_iStorageFake, new FakeIWebLogger());
var result = await sync.SingleFile("/non_exist.ext");
Assert.AreEqual(FileIndexItem.ExifStatus.OperationNotSupported, result.Status);
}
public async Task SingleFile_AddNewFile_StatusDeleted()
{
var fakeQuery = new FakeIQuery(new List <FileIndexItem>());
var sync = new SyncSingleFile(new AppSettings(), fakeQuery,
_iStorageFake, new FakeIWebLogger());
var result = await sync.SingleFile("/status_deleted.jpg");
Assert.AreEqual(FileIndexItem.ExifStatus.Deleted, result.Status);
}
public void Delete_NotFoundOnDisk_Ignore()
{
var selectorStorage = new FakeSelectorStorage(new FakeIStorage());
var fakeQuery =
new FakeIQuery(new List <FileIndexItem> {
new FileIndexItem("/exist-in-db.jpg")
});
var deleteItem = new DeleteItem(fakeQuery, new AppSettings(), selectorStorage);
var result = deleteItem.Delete("/exist-in-db.jpg", true);
Assert.AreEqual(FileIndexItem.ExifStatus.NotFoundSourceMissing,
result.FirstOrDefault().Status);
}
public async Task NonDuplicateItems()
{
var content = new List <FileIndexItem>
{
new FileIndexItem("/test.jpg"),
};
var query = new FakeIQuery(content);
await new Duplicate(query).RemoveDuplicateAsync(content);
var queryResult = await query.GetAllFilesAsync("/");
Assert.AreEqual(1, queryResult.Count);
}
public async Task SingleFile_AddNewFile_WithParentFolders()
{
var iStorageFake = new FakeIStorage(new List <string> {
"/level/deep/"
},
new List <string> {
"/level/deep/test.jpg"
},
new List <byte[]> {
CreateAnImageNoExif.Bytes
});
var fakeQuery = new FakeIQuery(new List <FileIndexItem>());
var sync = new SyncSingleFile(new AppSettings(), fakeQuery,
iStorageFake, new FakeIWebLogger());
await sync.SingleFile("/level/deep/test.jpg");
var detailView = fakeQuery.SingleItem("/level/deep/test.jpg");
// should add files to db
Assert.IsNotNull(detailView);
var fileIndexItem = detailView.FileIndexItem;
Assert.AreEqual("/level/deep/test.jpg", fileIndexItem.FilePath);
// should not duplicate add items
var count = (await fakeQuery.GetAllFilesAsync("/level/deep"))
.Count(p => p.FileName == "test.jpg");
Assert.AreEqual(1, count);
// should add parent items
// root folder
var rootFolder = fakeQuery.SingleItem("/")?.FileIndexItem;
Assert.IsNotNull(rootFolder);
Assert.AreEqual(true, rootFolder.IsDirectory);
// sub folder 'level folder
var levelFolder = fakeQuery.SingleItem("/level")?.FileIndexItem;
Assert.IsNotNull(levelFolder);
Assert.AreEqual(true, levelFolder.IsDirectory);
// sub folder 'level deep folder
var levelDeepFolder = fakeQuery.SingleItem("/level/deep")?.FileIndexItem;
Assert.IsNotNull(levelDeepFolder);
Assert.AreEqual(true, levelDeepFolder.IsDirectory);
}
public async Task UpdateService_Update_toDelete()
{
var query = new FakeIQuery();
await query.AddItemAsync(new FileIndexItem
{
Status = FileIndexItem.ExifStatus.Ok,
Tags = "",
FileName = "test_delete.jpg",
Description = "noChanges",
ParentDirectory = "/delete",
Id = 9
});
var item0 = query.GetObjectByFilePath("/delete/test_delete.jpg");
item0.Tags = "!delete!";
var changedFileIndexItemName = new Dictionary <string, List <string> >
{
{
"/delete/test_delete.jpg", new List <string>
{
nameof(FileIndexItem.Tags)
}
},
};
var fileIndexResultsList = new List <FileIndexItem>
{
item0
};
var readMeta = new FakeReadMetaSubPathStorage();
var service = new MetaUpdateService(query, _exifTool,
new FakeSelectorStorage(_iStorageFake), new FakeMetaPreflight(),
new FakeIWebLogger(), readMeta);
await service.UpdateAsync(changedFileIndexItemName, fileIndexResultsList, null, false, false, 0);
// Deleted status is done in the Preflight stage
Assert.AreEqual(FileIndexItem.ExifStatus.Ok, fileIndexResultsList[0].Status);
// db
Assert.AreEqual("!delete!", query.GetObjectByFilePath("/delete/test_delete.jpg").Tags);
Assert.AreEqual("noChanges", query.GetObjectByFilePath("/delete/test_delete.jpg").Description);
await query.RemoveItemAsync(item0);
}
public async Task ThumbnailCleanerTestAsync_Cleaner_WithDifferentSizes()
{
var fakeStorage = new FakeIStorage(new List <string> {
"/"
},
new List <string>
{
ThumbnailNameHelper.Combine("hash1234", ThumbnailSize.Large),
ThumbnailNameHelper.Combine("hash1234", ThumbnailSize.ExtraLarge),
ThumbnailNameHelper.Combine("hash1234", ThumbnailSize.TinyMeta),
ThumbnailNameHelper.Combine("exist", ThumbnailSize.TinyMeta),
ThumbnailNameHelper.Combine("exist", ThumbnailSize.ExtraLarge),
ThumbnailNameHelper.Combine("exist", ThumbnailSize.TinyMeta),
ThumbnailNameHelper.Combine("exist", ThumbnailSize.Large),
ThumbnailNameHelper.Combine("12234456677", ThumbnailSize.ExtraLarge),
});
var fakeQuery = new FakeIQuery(new List <FileIndexItem>
{
new FileIndexItem("/test.jpg")
{
FileHash = "exist"
}
});
var thumbnailCleaner = new ThumbnailCleaner(fakeStorage, fakeQuery,
new FakeIWebLogger());
await thumbnailCleaner.CleanAllUnusedFilesAsync(1);
Assert.IsTrue(fakeStorage.ExistFile(
ThumbnailNameHelper.Combine("exist", ThumbnailSize.TinyMeta)));
Assert.IsTrue(fakeStorage.ExistFile(
ThumbnailNameHelper.Combine("exist", ThumbnailSize.ExtraLarge)));
Assert.IsTrue(fakeStorage.ExistFile(
ThumbnailNameHelper.Combine("exist", ThumbnailSize.Large)));
Assert.IsTrue(fakeStorage.ExistFile(
ThumbnailNameHelper.Combine("exist", ThumbnailSize.TinyMeta)));
Assert.IsFalse(fakeStorage.ExistFile(
ThumbnailNameHelper.Combine("hash1234", ThumbnailSize.TinyMeta)));
Assert.IsFalse(fakeStorage.ExistFile(
ThumbnailNameHelper.Combine("hash1234", ThumbnailSize.ExtraLarge)));
Assert.IsFalse(fakeStorage.ExistFile(
ThumbnailNameHelper.Combine("hash1234", ThumbnailSize.Large)));
Assert.IsFalse(fakeStorage.ExistFile(
ThumbnailNameHelper.Combine("12234456677", ThumbnailSize.ExtraLarge)));
}
public async Task SingleItem_DbItem_Updated_StatusDeleted()
{
var item = new FileIndexItem("/status_deleted.jpg")
{
FileHash = "THIS_IS_THE_OLD_HASH",
Size = 99999999 // % % % that's not the right size % % %
};
var fakeQuery = new FakeIQuery(new List <FileIndexItem> {
item
});
var sync = new SyncSingleFile(new AppSettings(), fakeQuery,
_iStorageFake, new FakeIWebLogger());
var result = await sync.SingleFile("/status_deleted.jpg", item); // % % % % Enter item here % % % % %
Assert.AreEqual(FileIndexItem.ExifStatus.Deleted, result.Status);
}
public async Task AddParentFolder_NewFolders()
{
var storage = GetStorage();
var folderPath = "/should_add_root2";
storage.CreateDirectory(folderPath);
var query = new FakeIQuery();
var syncFolder = new SyncFolder(_appSettings, query, new FakeSelectorStorage(storage),
new ConsoleWrapper(), new FakeIWebLogger(), new FakeMemoryCache());
var result = await syncFolder.AddParentFolder(folderPath);
Assert.IsNotNull(query.GetObjectByFilePathAsync("/"));
Assert.IsNotNull(query.GetObjectByFilePathAsync(folderPath));
Assert.AreEqual(folderPath, result.FilePath);
Assert.AreEqual(FileIndexItem.ExifStatus.Ok, result.Status);
}
public async Task AddParentCacheIfNotExist_TriggerCacheSync()
{
var fakeContent =
new List <FileIndexItem> {
new FileIndexItem("/test.jpg")
};
var fakeQuery = new FakeIQuery(fakeContent);
var metaPreflight = new AddParentCacheIfNotExist(fakeQuery, new FakeIWebLogger());
await metaPreflight.AddParentCacheIfNotExistAsync(
fakeContent.Select(p => p.FilePath));
var(_, cacheGetParentFolder) = fakeQuery.CacheGetParentFolder("/");
Assert.AreEqual(1, cacheGetParentFolder.Count);
}
