public async Task TestFileSimilar()
{
// arrange
await using var app = await DefaultPhotoFolder.Initialize(_output, new Dictionary <string, string>
{
{ "2010/05.09 - Flora Wanderung/flora_sonyalpha_compressed.jpg", "flora_sonyalpha_compressed.jpg" },
{ "2010/05.09 - Flora Wanderung/flora_sonyalpha.jpg", "flora_sonyalpha.jpg" }
});
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
var worker = app.Container.Resolve <ICheckIndexWorker>();
// act
var response = await worker.Execute(new CheckIndexRequest(photoDirectory));
// assert
var issue = Assert.Single(response.Issues);
var similarFileIssue = Assert.IsType <SimilarFilesIssue>(issue);
Assert.Single(similarFileIssue.RelevantFiles);
Assert.Equal(similarFileIssue.RelevantFiles.Concat(issue.File.Yield()).Select(x => x.RelativeFilename).OrderBy(x => x),
new[] { "2010/05.09 - Flora Wanderung/flora_sonyalpha_compressed.jpg", "2010/05.09 - Flora Wanderung/flora_sonyalpha.jpg" }.OrderBy(x => x));
}
public async Task TestSimilarFile()
{
// arrange
await using var app = await DefaultPhotoFolder.Initialize(_output, DefaultPhotoFolder.CleanFileBase);
const string newFilePath = "D:\\Camera\\flora.jpg";
app.AddResourceFile(newFilePath, "flora_sonyalpha_compressed.jpg");
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
var worker = app.Container.Resolve <IImportFilesWorker>();
// act
var response = await worker.Execute(new ImportFilesRequest(new[] { newFilePath }, photoDirectory));
// assert
Assert.Equal(2, response.Issues.Count);
Assert.Single(response.Issues.OfType <InvalidFileLocationIssue>());
var similarFileIssue = Assert.Single(response.Issues.OfType <SimilarFilesIssue>());
Assert.Null(similarFileIssue.File.RelativeFilename);
Assert.Equal("D:/Camera/flora.jpg", similarFileIssue.File.Filename);
var similarFile = Assert.Single(similarFileIssue.RelevantFiles);
Assert.Equal("2010/05.09/flora_sonyalpha.jpg", similarFile.RelativeFilename);
}
public async Task <ApplicationContext> TestFileMoved()
{
await using var app = await DefaultPhotoFolder.Initialize(_output, DefaultPhotoFolder.DefaultFileBase);
var photoFolderPath = DefaultPhotoFolder.PhotoFolderPath;
var newDirectory = Path.Combine(photoFolderPath, "2019\\18");
app.MockFileSystem.Directory.CreateDirectory(newDirectory);
app.MockFileSystem.File.Move(Path.Combine(photoFolderPath, "egypt_sonyz3.jpg"), Path.Combine(photoFolderPath, newDirectory, "egypt_sonyz3.jpg"));
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(photoFolderPath);
var worker = app.Container.Resolve <ISynchronizeIndexWorker>();
var response = await worker.Execute(new SynchronizeIndexRequest(photoDirectory));
Assert.Collection(response.Operations.OrderBy(x => x.TargetFilename), x =>
{
Assert.Equal("egypt_sonyz3.jpg", x.SourceFilename);
Assert.Equal("2019/18/egypt_sonyz3.jpg", x.TargetFilename);
Assert.Equal(FileOperationType.Moved, x.Type);
});
return(app);
}
public async Task TestImportNewFile()
{
// arrange
await using var app = await DefaultPhotoFolder.Initialize(_output, DefaultPhotoFolder.CleanFileBase);
const string newFilePath = "D:\\Camera\\lando.jpg";
app.AddResourceFile(newFilePath, "lando_sonyalpha.jpg");
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
var worker = app.Container.Resolve <IImportFilesWorker>();
// act
var response = await worker.Execute(new ImportFilesRequest(new[] { newFilePath }, photoDirectory));
// assert
var issue = Assert.Single(response.Issues);
var locationIssue = Assert.IsType <InvalidFileLocationIssue>(issue);
Assert.Null(locationIssue.File.RelativeFilename);
Assert.Equal("D:/Camera/lando.jpg", locationIssue.File.Filename);
Assert.Equal("lando.jpg", locationIssue.CorrectFilename);
Assert.Equal("2018/01.20", Assert.Single(locationIssue.Suggestions).Directory);
Assert.Empty(locationIssue.RelevantFiles);
}
public async Task TestDuplicateFile()
{
// arrange
await using var app = await DefaultPhotoFolder.Initialize(_output, DefaultPhotoFolder.CleanFileBase);
const string newFilePath = "D:\\Camera\\hanszimmer_htcu11.jpg";
app.AddResourceFile(newFilePath, "hanszimmer_htcu11.jpg");
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
var worker = app.Container.Resolve <IImportFilesWorker>();
// act
var response = await worker.Execute(new ImportFilesRequest(new[] { newFilePath }, photoDirectory));
// assert
Assert.Equal(2, response.Issues.Count);
Assert.Single(response.Issues.OfType <InvalidFileLocationIssue>());
var duplicateFileIssue = Assert.Single(response.Issues.OfType <DuplicateFilesIssue>());
Assert.Null(duplicateFileIssue.File.RelativeFilename);
Assert.Equal("D:/Camera/hanszimmer_htcu11.jpg", duplicateFileIssue.File.Filename);
var duplicateFile = Assert.Single(duplicateFileIssue.RelevantFiles);
Assert.Equal("2019/03.30/hanszimmer_htcu11.jpg", duplicateFile.RelativeFilename);
}
public async Task TestFileWithInvalidLocationSuggestExistingFolders()
{
// arrange
const string file = "hanszimmer_htcu11.jpg";
const string correctFolder = "2019/03.30";
const string correctLocation = "2019/03.30/hanszimmer_htcu11.jpg";
var existingFolder = $"{correctFolder} - Hans Zimmer";
await using var app = await DefaultPhotoFolder.Initialize(_output, new Dictionary <string, string>
{
{ $"test/{file}", file },
{ $"{existingFolder}/test.jpg", "egypt_sonyz3.jpg" }
});
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
var worker = app.Container.Resolve <ICheckIndexWorker>();
// act
var response = await worker.Execute(new CheckIndexRequest(photoDirectory));
// assert
var issue = Assert.Single(response.Issues.OfType <InvalidFileLocationIssue>().Where(x => x.CorrectFilename == file));
Assert.Collection(issue.Suggestions.OrderByDescending(x => x.Filename), x => Assert.Equal(correctLocation, x.Filename),
x => Assert.Equal(existingFolder, x.Directory));
}
public async Task TestSynchronizeExistingDatabase()
{
await using var app = await DefaultPhotoFolder.Initialize(_output, DefaultPhotoFolder.DefaultFileBase);
var photoFolderPath = DefaultPhotoFolder.PhotoFolderPath;
app.MockFileSystem.RemoveFile(Path.Combine(photoFolderPath, "egypt_sonyz3.jpg"));
app.MockFileSystem.RemoveFile(Path.Combine(photoFolderPath, "flora_sonyalpha.jpg"));
app.MockFileSystem.AddFileFromEmbeddedResource(Path.Combine(photoFolderPath, "flora_sonyalpha.jpg"), Assembly.GetExecutingAssembly(),
"PhotoFolder.Application.IntegrationTests.Resources.flora_sonyalpha_compressed.jpg");
app.MockFileSystem.AddFileFromEmbeddedResource(Path.Combine(photoFolderPath, "lando_sonyalpha.jpg"), Assembly.GetExecutingAssembly(),
"PhotoFolder.Application.IntegrationTests.Resources.lando_sonyalpha.jpg");
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(photoFolderPath);
var worker = app.Container.Resolve <ISynchronizeIndexWorker>();
var response = await worker.Execute(new SynchronizeIndexRequest(photoDirectory));
Assert.Collection(response.Operations.OrderBy(x => x.TargetFilename), x =>
{
Assert.Equal("egypt_sonyz3.jpg", x.TargetFilename);
Assert.Equal(FileOperationType.Removed, x.Type);
}, x =>
{
Assert.Equal("flora_sonyalpha.jpg", x.TargetFilename);
Assert.Equal(FileOperationType.Changed, x.Type);
}, x =>
{
Assert.Equal("lando_sonyalpha.jpg", x.TargetFilename);
Assert.Equal(FileOperationType.New, x.Type);
});
}
public async Task TestFileWithInvalidLocation()
{
// arrange
const string file = "hanszimmer_htcu11.jpg";
const string correctLocation = "2019/03.30/hanszimmer_htcu11.jpg";
await using var app = await DefaultPhotoFolder.Initialize(_output, new Dictionary <string, string> { { $"test/{file}", file } });
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
var worker = app.Container.Resolve <ICheckIndexWorker>();
// act
var response = await worker.Execute(new CheckIndexRequest(photoDirectory));
// assert
var issue = Assert.Single(response.Issues);
var invalidLocation = Assert.IsType <InvalidFileLocationIssue>(issue);
Assert.Equal(file, invalidLocation.CorrectFilename);
var suggestion = Assert.Single(invalidLocation.Suggestions);
Assert.Equal(correctLocation, suggestion.Filename);
}
public async Task TestCreateDatabaseAndSynchronizeDuplicates()
{
await using var _ = await DefaultPhotoFolder.Initialize(_output, new Dictionary <string, string>
{
{ "egypt_sonyz3.jpg", "egypt_sonyz3.jpg" }, { "asd/asd.jpg", "egypt_sonyz3.jpg" }
});
}
public async Task TestSynchronizeWithoutChanges()
{
await using var app = await DefaultPhotoFolder.Initialize(_output, DefaultPhotoFolder.DefaultFileBase);
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
var worker = app.Container.Resolve <ISynchronizeIndexWorker>();
var response = await worker.Execute(new SynchronizeIndexRequest(photoDirectory));
Assert.Empty(response.Operations);
}
public async Task TestAddDuplicateNonPhotoFile()
{
await using var app = await DefaultPhotoFolder.Initialize(_output, new Dictionary <string, string> { { "2019/23/test.jpg", "textfile.txt" } });
var photoFolderPath = DefaultPhotoFolder.PhotoFolderPath;
app.MockFileSystem.AddFileFromEmbeddedResource(Path.Combine(photoFolderPath, "textfile.jpg"), Assembly.GetExecutingAssembly(),
"PhotoFolder.Application.IntegrationTests.Resources.textfile.txt");
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(photoFolderPath);
var worker = app.Container.Resolve <ISynchronizeIndexWorker>();
var response = await worker.Execute(new SynchronizeIndexRequest(photoDirectory));
}
public async Task TestCheckFiles()
{
// arrange
await using var app = await DefaultPhotoFolder.Initialize(_output, DefaultPhotoFolder.CleanFileBase);
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
var worker = app.Container.Resolve <ICheckIndexWorker>();
// act
var response = await worker.Execute(new CheckIndexRequest(photoDirectory));
// assert
Assert.Empty(response.Issues);
}
public async Task TestNonPhotoFileHasPhotoPropertiesNull()
{
await using var app = await DefaultPhotoFolder.Initialize(_output, new Dictionary <string, string> { { "2019/23/test.jpg", "textfile.txt" } });
var photoFolderPath = DefaultPhotoFolder.PhotoFolderPath;
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(photoFolderPath);
await using var context = photoDirectory.GetDataContext();
var files = await context.FileRepository.GetAll();
var file = files.Single();
Assert.Null(file.PhotoProperties);
}
public async Task TestFormerlyDeletedFile()
{
// arrange
var beginTime = DateTimeOffset.UtcNow;
await using var app = await DefaultPhotoFolder.Initialize(_output, DefaultPhotoFolder.CleanFileBase);
var entryToDelete = "2019/03.30/hanszimmer_htcu11.jpg";
app.MockFileSystem.File.Delete(Path.Combine(DefaultPhotoFolder.PhotoFolderPath, entryToDelete));
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
var synchronizeWorker = app.Container.Resolve <ISynchronizeIndexWorker>();
var syncResult = await synchronizeWorker.Execute(new SynchronizeIndexRequest(photoDirectory));
var op = Assert.Single(syncResult.Operations);
Assert.Equal(FileOperationType.Removed, op.Type);
// the file should now be stored as a formerly deleted file
Assert.NotEmpty(photoDirectory.MemoryManager.DirectoryMemory.DeletedFiles);
const string formerlyDeletedFilePath = "C:/hanszimmer.jpg";
app.AddResourceFile(formerlyDeletedFilePath, "hanszimmer_htcu11.jpg");
var worker = app.Container.Resolve <IImportFilesWorker>();
// act
var response = await worker.Execute(new ImportFilesRequest(new[] { formerlyDeletedFilePath }, photoDirectory));
// assert
Assert.Equal(2, response.Issues.Count);
Assert.Single(response.Issues.OfType <InvalidFileLocationIssue>());
var formerlyDeletedIssue = Assert.Single(response.Issues.OfType <FormerlyDeletedIssue>());
Assert.True(formerlyDeletedIssue.DeletedFileInfo.DeletedAt > beginTime, "The deleted at property was set to current time");
Assert.Equal(entryToDelete, formerlyDeletedIssue.DeletedFileInfo.RelativeFilename);
Assert.Equal(formerlyDeletedFilePath, formerlyDeletedIssue.File.Filename);
}
public async Task TestFormerlyDeletedFilesAreNotShown()
{
// arrange
await using var app = await DefaultPhotoFolder.Initialize(_output, DefaultPhotoFolder.CleanFileBase);
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
app.MockFileSystem.File.Delete(Path.Combine(DefaultPhotoFolder.PhotoFolderPath, "2015/10.25/egypt_sonyz3.jpg"));
var synchronizeWorker = app.Container.Resolve <ISynchronizeIndexWorker>();
var syncResult = await synchronizeWorker.Execute(new SynchronizeIndexRequest(photoDirectory));
var op = Assert.Single(syncResult.Operations);
Assert.Equal(FileOperationType.Removed, op.Type);
Assert.NotEmpty(photoDirectory.MemoryManager.DirectoryMemory.DeletedFiles);
app.AddResourceFile(Path.Combine(DefaultPhotoFolder.PhotoFolderPath, "test.jpg"), "egypt_sonyz3.jpg");
synchronizeWorker = app.Container.Resolve <ISynchronizeIndexWorker>();
syncResult = await synchronizeWorker.Execute(new SynchronizeIndexRequest(photoDirectory));
op = Assert.Single(syncResult.Operations);
Assert.Equal(FileOperationType.New, op.Type);
var worker = app.Container.Resolve <ICheckIndexWorker>();
// act
var response = await worker.Execute(new CheckIndexRequest(photoDirectory));
// assert
var issue = Assert.Single(response.Issues);
Assert.IsType <InvalidFileLocationIssue>(issue);
Assert.Empty(photoDirectory.MemoryManager.DirectoryMemory.DeletedFiles);
}
public async Task TestFileDuplicate()
{
// arrange
await using var app = await DefaultPhotoFolder.Initialize(_output, new Dictionary <string, string>
{
{ "cats/lando/lando.jpg", "lando_sonyalpha.jpg" },
{ "2018/01.20/lando_sonyalpha.jpg", "lando_sonyalpha.jpg" }
});
var loader = app.Container.Resolve <IPhotoDirectoryLoader>();
var photoDirectory = await loader.Load(DefaultPhotoFolder.PhotoFolderPath);
var worker = app.Container.Resolve <ICheckIndexWorker>();
// act
var response = await worker.Execute(new CheckIndexRequest(photoDirectory));
// assert
var issue = Assert.Single(response.Issues.OfType <DuplicateFilesIssue>());
Assert.Single(issue.RelevantFiles);
Assert.Equal(issue.RelevantFiles.Concat(issue.File.Yield()).Select(x => x.RelativeFilename).OrderBy(x => x),
new[] { "cats/lando/lando.jpg", "2018/01.20/lando_sonyalpha.jpg" }.OrderBy(x => x));
}
public async Task TestCreateDatabaseAndSynchronize()
{
await using var _ = await DefaultPhotoFolder.Initialize(_output, DefaultPhotoFolder.DefaultFileBase);
}
public async Task TestSynchronizeNonPhotoFile()
{
await using var _ = await DefaultPhotoFolder.Initialize(_output, new Dictionary <string, string> { { "2019/23/test.jpg", "textfile.txt" } });
}
