public async Task ShouldGiveMultipleResultsBack()
{
await _query.AddItemAsync(
new FileIndexItem("/recursive_test/image0.jpg"));
await _query.AddItemAsync(
new FileIndexItem("/recursive_test/sub/image1.jpg"));
await _query.AddItemAsync(
new FileIndexItem("/recursive_test/image2.jpg"));
await _query.AddItemAsync(
new FileIndexItem("/recursive_test/image3.jpg"));
var result = await _query.GetAllRecursiveAsync(new List <string>
{
"/recursive_test/"
});
Assert.AreEqual("/recursive_test/image0.jpg", result[0].FilePath);
Assert.AreEqual("/recursive_test/image2.jpg", result[1].FilePath);
Assert.AreEqual("/recursive_test/image3.jpg", result[2].FilePath);
Assert.AreEqual("/recursive_test/sub/image1.jpg", result[3].FilePath);
await _query.RemoveItemAsync(result[0]);
await _query.RemoveItemAsync(result[1]);
await _query.RemoveItemAsync(result[2]);
await _query.RemoveItemAsync(result[3]);
}
public async Task UploadToFolder_DefaultFlow_ShouldNotOverWriteDatabase()
{
var controller = new UploadController(_import, _appSettings,
new FakeSelectorStorage(_iStorage), _query,
new FakeIRealtimeConnectionsService(), new FakeIWebLogger(),
new FakeIMetaExifThumbnailService())
{
ControllerContext = RequestWithFile(),
};
var toPlaceSubPath = "/duplicate_upload/yes01.jpg";
var toPlaceFolder = "/duplicate_upload";
// add to db
await _query.AddItemAsync(new FileIndexItem(toPlaceSubPath));
_iStorage.CreateDirectory(toPlaceFolder);
controller.ControllerContext.HttpContext.Request.Headers["to"] = toPlaceSubPath; //Set header
var actionResult = await controller.UploadToFolder() as JsonResult;
if (actionResult == null)
{
throw new ArgumentNullException(nameof(actionResult),
"actionResult should not be null");
}
var list = actionResult.Value as List <ImportIndexItem>;
if (list == null)
{
throw new ArgumentNullException(nameof(list),
"result should not be null");
}
Assert.AreEqual(ImportStatus.Ok, list[0].Status);
var fileSystemResult = _iStorage.ExistFile(toPlaceSubPath);
Assert.IsTrue(fileSystemResult);
var getAllFiles = await _query.GetAllFilesAsync(toPlaceFolder);
// Should not duplicate
Assert.AreEqual(1, getAllFiles.Count);
var queryResult = _query.SingleItem(toPlaceSubPath);
Assert.AreEqual("Sony", queryResult.FileIndexItem.Make);
await _query.RemoveItemAsync(queryResult.FileIndexItem);
}
public async Task DownloadPhotoCorrupt()
{
// Arrange
var selectorStorage = new FakeSelectorStorage(ArrangeStorage());
var item = await _query.AddItemAsync(new FileIndexItem
{
FileName = "corrupt.jpg",
ParentDirectory = "/",
FileHash = "hash"
});
// Act
var controller = new DownloadPhotoController(_query, selectorStorage, new FakeIWebLogger())
{
ControllerContext = { HttpContext = new DefaultHttpContext() }
};
var actionResult = await controller.DownloadPhoto("/corrupt.jpg") as JsonResult;
Assert.AreNotEqual(null, actionResult);
Assert.AreEqual(500, controller.Response.StatusCode);
await _query.RemoveItemAsync(item);
}
internal async Task CompareFolderListAndFixMissingFolders(List <string> subPaths, List <FileIndexItem> folderList)
{
if (subPaths.Count == folderList.Count)
{
return;
}
foreach (var path in subPaths.Where(path => folderList.All(p => p.FilePath != path) &&
_subPathStorage.ExistFolder(path) && !_syncIgnoreCheck.Filter(path)))
{
await _query.AddItemAsync(new FileIndexItem(path)
{
IsDirectory = true,
AddToDatabase = DateTime.UtcNow,
ColorClass = ColorClassParser.Color.None
});
}
}
public async Task UpdateService_Update_NoChangedFileIndexItemName_AndHasChanged()
{
var databaseItem = await _query.AddItemAsync(new FileIndexItem
{
Status = FileIndexItem.ExifStatus.Ok,
Tags = "databaseItem",
FileName = "test.jpg",
ParentDirectory = "/",
IsDirectory = false
});
var fileIndexResultsList = new List <FileIndexItem>
{
new FileIndexItem
{
Status = FileIndexItem.ExifStatus.Ok,
Tags = "initial tags (from database)",
FileName = "test.jpg",
ParentDirectory = "/",
Description = "keep",
IsDirectory = false
}
};
var toUpdateItem = new FileIndexItem
{
Status = FileIndexItem.ExifStatus.Ok,
Tags = "databaseItem",
FileName = "test.jpg",
ParentDirectory = "/",
IsDirectory = false
};
var readMeta = new ReadMetaSubPathStorage(
new FakeSelectorStorage(_iStorageFake), _appSettings,
_memoryCache);
var service = new MetaUpdateService(_query, _exifTool,
new FakeSelectorStorage(_iStorageFake), new FakeMetaPreflight(),
new FakeIWebLogger(), readMeta);
await service.UpdateAsync(null, fileIndexResultsList,
toUpdateItem, false, false, 0);
// Second one is null
// check for item (Referenced)
Assert.AreEqual("databaseItem", toUpdateItem.Tags);
// db
Assert.AreEqual("databaseItem", _query.SingleItem("/test.jpg").FileIndexItem.Tags);
_query.RemoveItem(databaseItem);
}
public async Task Thumbnail_CorruptImage_NoContentResult_Test()
{
// Arrange
var storage = ArrangeStorage();
var plainTextStream = new PlainTextFileHelper().StringToStream("CorruptImage");
await storage.WriteStreamAsync(plainTextStream, ThumbnailNameHelper.Combine(
"hash-corrupt-image", ThumbnailSize.ExtraLarge));
await _query.AddItemAsync(new FileIndexItem("/test2.jpg"){ FileHash = "hash-corrupt-image" });
// Act
var controller = new ThumbnailController(_query, new FakeSelectorStorage(storage));
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var actionResult = controller.Thumbnail("hash-corrupt-image",
false, true) as NoContentResult;
Assert.AreEqual(204, actionResult.StatusCode);
// remove files + database item
await _query.RemoveItemAsync(await _query.GetObjectByFilePathAsync("/test2.jpg"));
}
public async Task ExportControllerTest__ThumbTrue_CreateListToExport()
{
var selectorStorage = _serviceProvider.GetRequiredService <ISelectorStorage>();
var export = new ExportService(_query, _appSettings, selectorStorage, new FakeIWebLogger());
var item = new FileIndexItem
{
FileName = "testFile.jpg",
ParentDirectory = "/",
FileHash = _createAnImage.FileName,
Status = FileIndexItem.ExifStatus.Ok
};
await _query.AddItemAsync(item);
var fileIndexResultsList = new List <FileIndexItem> {
item
};
var filePaths = await export.CreateListToExport(fileIndexResultsList, true);
Assert.AreEqual(true, filePaths.FirstOrDefault().Contains(item.FileHash));
}
/// <summary>
/// Create an new item in the database
/// </summary>
/// <param name="statusItem">contains the status</param>
/// <param name="subPath">relative path</param>
/// <returns>database item</returns>
private async Task <FileIndexItem> NewItem(FileIndexItem statusItem, string subPath)
{
// Add a new Item
var dbItem = await _newItem.NewFileItem(statusItem);
// When not OK do not Add (fileHash issues)
if (dbItem.Status != FileIndexItem.ExifStatus.Ok)
{
return(dbItem);
}
await _query.AddItemAsync(dbItem);
await _query.AddParentItemsAsync(subPath);
AddDeleteStatus(dbItem);
return(dbItem);
}
/// <summary>
/// Perform database updates
/// </summary>
/// <param name="metaDataItem">to update to</param>
/// <returns>updated item</returns>
private async Task <FileIndexItem> SyncItem(FileIndexItem metaDataItem)
{
var itemFromDatabase = await _query.GetObjectByFilePathAsync(metaDataItem.FilePath);
if (itemFromDatabase == null)
{
AddOrRemoveXmpSidecarFileToDatabase(metaDataItem);
await _query.AddItemAsync(metaDataItem);
return(metaDataItem);
}
FileIndexCompareHelper.Compare(itemFromDatabase, metaDataItem);
AddOrRemoveXmpSidecarFileToDatabase(metaDataItem);
await _query.UpdateItemAsync(itemFromDatabase);
return(itemFromDatabase);
}
private async Task CreateNewDatabaseDirectory(string parentPath)
{
if (AddedParentDirectories.Contains(parentPath) ||
_query.SingleItem(parentPath) != null)
{
return;
}
var item = new FileIndexItem(PathHelper.RemoveLatestSlash(parentPath))
{
AddToDatabase = DateTime.UtcNow,
IsDirectory = true,
ColorClass = ColorClassParser.Color.None
};
await _query.AddItemAsync(item);
AddedParentDirectories.Add(parentPath);
}
public async Task <IActionResult> Mkdir(string f)
{
var inputFilePaths = PathHelper.SplitInputFilePaths(f).ToList();
var syncResultsList = new List <SyncViewModel>();
foreach (var subPath in inputFilePaths.Select(PathHelper.RemoveLatestSlash))
{
var toAddStatus = new SyncViewModel
{
FilePath = subPath,
Status = FileIndexItem.ExifStatus.Ok
};
if (_iStorage.ExistFolder(subPath))
{
toAddStatus.Status = FileIndexItem.ExifStatus.OperationNotSupported;
syncResultsList.Add(toAddStatus);
continue;
}
await _query.AddItemAsync(new FileIndexItem(subPath)
{
IsDirectory = true
});
// add to fs
_iStorage.CreateDirectory(subPath);
syncResultsList.Add(toAddStatus);
}
// When all items are not found
if (syncResultsList.All(p => p.Status != FileIndexItem.ExifStatus.Ok))
{
Response.StatusCode = 409; // A conflict, Directory already exist
}
await SyncMessageToSocket(syncResultsList, ApiNotificationType.Mkdir);
return(Json(syncResultsList));
}
public async Task Replace_AllDataIncluded_WithFakeExifTool()
{
var item = await _query.AddItemAsync(new FileIndexItem
{
FileName = "test09.jpg",
ParentDirectory = "/",
Tags = "7test"
});
var selectorStorage = new FakeSelectorStorage(new FakeIStorage(new List <string> {
"/"
},
new List <string> {
"/test09.jpg"
}));
var metaReplaceService = new MetaReplaceService(_query, _appSettings, selectorStorage, new FakeIWebLogger());
var controller = new MetaReplaceController(metaReplaceService, _bgTaskQueue,
new FakeIRealtimeConnectionsService(), new FakeIWebLogger(), NewScopeFactory());
var jsonResult = await controller.Replace("/test09.jpg", "Tags", "test",
string.Empty) as JsonResult;
if (jsonResult == null)
{
throw new NullReferenceException(nameof(jsonResult));
}
var fileModel = jsonResult.Value as List <FileIndexItem>;
if (fileModel == null)
{
throw new NullReferenceException(nameof(fileModel));
}
Assert.AreNotEqual(null, fileModel.FirstOrDefault()?.Tags);
Assert.AreEqual("7", fileModel.FirstOrDefault()?.Tags);
await _query.RemoveItemAsync(item);
}
public async Task Update_SourceImageMissingOnDisk_WithFakeExifTool()
{
await _query.AddItemAsync(new FileIndexItem
{
FileName = "ApiController_Update_SourceImageMissingOnDisk_WithFakeExifTool.jpg",
ParentDirectory = "/",
FileHash = "ApiController_Update_SourceImageMissingOnDisk_WithFakeExifTool"
});
var selectorStorage = new FakeSelectorStorage(new StorageSubPathFilesystem(_appSettings, new FakeIWebLogger()));
var metaPreflight = new MetaPreflight(_query,
_appSettings, selectorStorage, new FakeIWebLogger());
var metaUpdateService = new MetaUpdateService(_query, _exifTool,
selectorStorage, new FakeMetaPreflight(),
new FakeIWebLogger(), new FakeReadMetaSubPathStorage());
var controller = new MetaUpdateController(metaPreflight, metaUpdateService, _bgTaskQueue,
new FakeIWebLogger(), NewScopeFactory())
{
ControllerContext = { HttpContext = new DefaultHttpContext() }
};
// Not Found --> 404
var testElement = new FileIndexItem();
var notFoundResult = await controller.UpdateAsync(testElement, "/ApiController_Update_SourceImageMissingOnDisk_WithFakeExifTool.jpg",
false, false) as NotFoundObjectResult;
if (notFoundResult == null)
{
throw new NullReferenceException(nameof(notFoundResult));
}
Assert.AreEqual(404, notFoundResult.StatusCode);
await _query.RemoveItemAsync(_query.SingleItem("/ApiController_Update_SourceImageMissingOnDisk_WithFakeExifTool.jpg").FileIndexItem);
}
public async Task ExistingItem()
{
await _query.AddItemAsync(new FileIndexItem(_createAnImage.DbPath)
{
Size = 9998,
FileHash = "INKV4BSQ54PIAIS5XUFAKBUW5Y"
});
var stopWatch = new Stopwatch();
stopWatch.Start();
var sync = new Synchronize(_appSettings, _query, new FakeSelectorStorage(_iStorage), new FakeIWebLogger(), _memoryCache);
var result = await sync.Sync("/");
stopWatch.Stop();
var ts = stopWatch.Elapsed;
var elapsedTime = $"{ts.Hours:00}:{ts.Minutes:00}:{ts.Seconds:00}.{ts.Milliseconds / 10:00}";
Console.WriteLine("RunTime " + elapsedTime);
Assert.IsNotNull(result);
}
public async Task Folder_InDbButNotOnDisk()
{
await _query.AddItemAsync(new FileIndexItem("/Folder_InDbButNotOnDisk/test.jpg"));
await _query.AddItemAsync(new FileIndexItem("/Folder_InDbButNotOnDisk/test2.jpg"));
var storage = new FakeIStorage();
var syncFolder = new SyncFolder(_appSettings, _query, new FakeSelectorStorage(storage),
new ConsoleWrapper(), new FakeIWebLogger(), new FakeMemoryCache());
var result = await syncFolder.Folder("/Folder_InDbButNotOnDisk");
Assert.AreEqual("/Folder_InDbButNotOnDisk/test.jpg", result[0].FilePath);
Assert.AreEqual("/Folder_InDbButNotOnDisk/test2.jpg", result[1].FilePath);
Assert.AreEqual(FileIndexItem.ExifStatus.NotFoundSourceMissing, result[0].Status);
Assert.AreEqual(FileIndexItem.ExifStatus.NotFoundSourceMissing, result[1].Status);
Assert.AreEqual(null,
_query.SingleItem("/Folder_InDbButNotOnDisk/test.jpg"));
Assert.AreEqual(null,
_query.SingleItem("/Folder_InDbButNotOnDisk/test2.jpg"));
}
public async Task Folder_FileSizeIsChanged()
{
var subPath = "/change/test_change.jpg";
await _query.AddItemAsync(new FileIndexItem(subPath)
{
Size = 123456
});
var storage = GetStorage();
await storage.WriteStreamAsync(new MemoryStream(FakeCreateAn.CreateAnImage.Bytes),
subPath);
var syncFolder = new SyncFolder(_appSettings, _query, new FakeSelectorStorage(storage),
new ConsoleWrapper(), new FakeIWebLogger(), new FakeMemoryCache());
var result = await syncFolder.Folder("/change");
Assert.AreEqual(subPath, result[0].FilePath);
Assert.AreEqual(FileIndexItem.ExifStatus.Ok, result[0].Status);
Assert.IsTrue(result[0].Size != 123456);
Assert.IsFalse(string.IsNullOrWhiteSpace(result[0].Tags));
}
