public MetaUpdateControllerTest()
{
var provider = new ServiceCollection()
.AddMemoryCache()
.BuildServiceProvider();
var memoryCache = provider.GetService <IMemoryCache>();
var builderDb = new DbContextOptionsBuilder <ApplicationDbContext>();
builderDb.UseInMemoryDatabase("test1234");
var options = builderDb.Options;
var context = new ApplicationDbContext(options);
_query = new Query(context, new AppSettings(), null, new FakeIWebLogger(), memoryCache);
// Inject Fake ExifTool; dependency injection
var services = new ServiceCollection();
// Fake the readMeta output
services.AddSingleton <IReadMeta, FakeReadMeta>();
// Inject Config helper
services.AddSingleton <IConfiguration>(new ConfigurationBuilder().Build());
// random config
_createAnImage = new CreateAnImage();
var dict = new Dictionary <string, string>
{
{ "App:StorageFolder", _createAnImage.BasePath },
{ "App:ThumbnailTempFolder", _createAnImage.BasePath },
{ "App:Verbose", "true" }
};
// Start using dependency injection
var builder = new ConfigurationBuilder();
// Add random config to dependency injection
builder.AddInMemoryCollection(dict);
// build config
var configuration = builder.Build();
// inject config as object to a service
services.ConfigurePoCo <AppSettings>(configuration.GetSection("App"));
// Add Background services
services.AddSingleton <IHostedService, UpdateBackgroundQueuedHostedService>();
services.AddSingleton <IUpdateBackgroundTaskQueue, UpdateBackgroundTaskQueue>();
// build the service
var serviceProvider = services.BuildServiceProvider();
// get the service
_appSettings = serviceProvider.GetRequiredService <AppSettings>();
// inject fake exifTool
_exifTool = new FakeExifTool(_iStorage, _appSettings);
// get the background helper
_bgTaskQueue = serviceProvider.GetRequiredService <IUpdateBackgroundTaskQueue>();
_iStorage = new StorageSubPathFilesystem(_appSettings, new FakeIWebLogger());
}
public void ImportIndexItemParse_OverWriteStructureFeature_Test()
{
var createAnImageNoExif = new CreateAnImageNoExif();
var createAnImage = new CreateAnImage();
_appSettings.Structure = null;
// Go to the default structure setting
_appSettings.StorageFolder = createAnImage.BasePath;
// Use a strange structure setting to overwrite
var input = new ImportIndexItem(_appSettings)
{
SourceFullFilePath = createAnImageNoExif.FullFilePathWithDate,
Structure = "/HHmmss_yyyyMMdd.ext"
};
input.ParseDateTimeFromFileName();
DateTime.TryParseExact(
"20120101_123300",
"yyyyMMdd_HHmmss",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out var answerDateTime);
// Check if those overwrite is accepted
Assert.AreEqual(answerDateTime, input.DateTime);
new StorageHostFullPathFilesystem().FileDelete(createAnImageNoExif.FullFilePathWithDate);
}
public SingleFileIntegrationTest()
{
var provider = new ServiceCollection()
.AddMemoryCache();
_createAnImage = new CreateAnImage();
_appSettings = new AppSettings {
DatabaseType = AppSettings.DatabaseTypeList.InMemoryDatabase,
StorageFolder = _createAnImage.BasePath,
Verbose = true
};
provider.AddSingleton(_appSettings);
new SetupDatabaseTypes(_appSettings, provider).BuilderDb();
provider.AddScoped <IQuery, Query>();
provider.AddScoped <IWebLogger, FakeIWebLogger>();
var serviceProvider = provider.BuildServiceProvider();
_iStorage = new StorageSubPathFilesystem(_appSettings, new FakeIWebLogger());
_scopeFactory = serviceProvider.GetRequiredService <IServiceScopeFactory>();
_memoryCache = serviceProvider.GetRequiredService <IMemoryCache>();
_query = serviceProvider.GetRequiredService <IQuery>();
}
public FileStreamingHelperTest()
{
// Add a dependency injection feature
var services = new ServiceCollection();
// Inject Config helper
services.AddSingleton <IConfiguration>(new ConfigurationBuilder().Build());
// random config
var newImage = new CreateAnImage();
var dict = new Dictionary <string, string>
{
{ "App:StorageFolder", newImage.BasePath },
{ "App:ThumbnailTempFolder", newImage.BasePath },
{ "App:Verbose", "true" }
};
// Start using dependency injection
var builder = new ConfigurationBuilder();
// Add random config to dependency injection
builder.AddInMemoryCollection(dict);
// build config
var configuration = builder.Build();
// inject config as object to a service
services.ConfigurePoCo <AppSettings>(configuration.GetSection("App"));
// build the service
var serviceProvider = services.BuildServiceProvider();
// get the service
_appSettings = serviceProvider.GetRequiredService <AppSettings>();
}
public StorageFilesystemTest()
{
_newImage = new CreateAnImage();
var appSettings = new AppSettings {
StorageFolder = _newImage.BasePath
};
_storage = new StorageSubPathFilesystem(appSettings, new FakeIWebLogger());
}
public void FileCopy_source_notFound()
{
var createNewImage = new CreateAnImage();
_thumbnailStorage.FileCopy("not_found", "StorageThumbnailFilesystemTest_FileCopy2");
var path2 = Path.Combine(createNewImage.BasePath, "StorageThumbnailFilesystemTest_FileCopy2.jpg");
Assert.IsFalse(File.Exists(path2));
}
public StorageThumbnailFilesystemTest()
{
var createNewImage = new CreateAnImage();
var appSettings = new AppSettings {
ThumbnailTempFolder = createNewImage.BasePath
};
_thumbnailStorage = new StorageThumbnailFilesystem(appSettings, new FakeIWebLogger());
_fileNameWithoutExtension = FilenamesHelper.GetFileNameWithoutExtension(createNewImage.FileName);
}
public void FileHash_StringArray_CreateAnImage_Test()
{
var createAnImage = new CreateAnImage();
var iStorage = new StorageSubPathFilesystem(new AppSettings {
StorageFolder = createAnImage.BasePath
}, new FakeIWebLogger());
var fileHashCode = new FileHash(iStorage).GetHashCode(new [] { createAnImage.DbPath });
Assert.IsTrue(fileHashCode[0].Value);
Assert.AreEqual(26, fileHashCode[0].Key.Length);
}
public void StarskyGeoCli_HelpTest()
{
var newImage = new CreateAnImage();
var args = new List <string> {
"-h", "-v", "-c", "test", "-d", "InMemoryDatabase",
"-b", newImage.BasePath, "--thumbnailtempfolder",
newImage.BasePath, "-e", newImage.FullFilePath
}.ToArray();
Program.Main(args);
Assert.IsNotNull(args);
}
public async Task ResizeThumbnailToStream__HostDependency__JPEG_Test()
{
var newImage = new CreateAnImage();
var iStorage = new StorageHostFullPathFilesystem();
// string subPath, int width, string outputHash = null,bool removeExif = false,ExtensionRolesHelper.ImageFormat
// imageFormat = ExtensionRolesHelper.ImageFormat.jpg
var thumb = await new Thumbnail(iStorage,
iStorage, new FakeIWebLogger()).ResizeThumbnailFromSourceImage(
newImage.FullFilePath, 1, null, true);
Assert.AreEqual(true, thumb.Item1.CanRead);
}
public async Task ThumbnailCleanerTestAsync_Cleaner()
{
var createAnImage = new CreateAnImage();
var existFullDir = createAnImage.BasePath + Path.DirectorySeparatorChar + "thumb";
if (!Directory.Exists(existFullDir))
{
Directory.CreateDirectory(existFullDir);
}
if (!File.Exists(Path.Join(existFullDir, "EXIST.jpg")))
{
File.Copy(createAnImage.FullFilePath,
Path.Join(existFullDir, "EXIST.jpg"));
}
if (!File.Exists(Path.Join(existFullDir, "DELETE.jpg")))
{
File.Copy(createAnImage.FullFilePath,
Path.Join(existFullDir, "DELETE.jpg"));
}
await _query.AddItemAsync(new FileIndexItem
{
FileHash = "EXIST",
FileName = "exst2"
});
var appSettings = new AppSettings
{
ThumbnailTempFolder = existFullDir,
Verbose = true
};
var thumbnailStorage = new StorageThumbnailFilesystem(appSettings, new FakeIWebLogger());
var thumbnailCleaner = new ThumbnailCleaner(thumbnailStorage, _query, new FakeIWebLogger());
// there are now two files inside this dir
var allThumbnailFilesBefore = thumbnailStorage.GetAllFilesInDirectory("/");
Assert.AreEqual(2, allThumbnailFilesBefore.Count());
await thumbnailCleaner.CleanAllUnusedFilesAsync();
// DELETE.jpg is removed > is missing in database
var allThumbnailFilesAfter = thumbnailStorage.GetAllFilesInDirectory("/");
Assert.AreEqual(1, allThumbnailFilesAfter.Count());
new StorageHostFullPathFilesystem().FolderDelete(existFullDir);
}
public async Task Update_ChangedFileIndexItemNameContent()
{
var createAnImage = new CreateAnImage();
InsertSearchData();
var serviceScopeFactory = NewScopeFactory();
var fakeIMetaUpdateService = _serviceProvider.GetService <IMetaUpdateService>() as
FakeIMetaUpdateService;
Assert.IsNotNull(fakeIMetaUpdateService);
fakeIMetaUpdateService.ChangedFileIndexItemNameContent =
new List <Dictionary <string, List <string> > >();
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, new FakeIUpdateBackgroundTaskQueue(),
new FakeIWebLogger(), serviceScopeFactory)
{
ControllerContext = { HttpContext = new DefaultHttpContext() }
};
var input = new FileIndexItem
{
Tags = "test"
};
var jsonResult = await controller.UpdateAsync(input,
createAnImage.DbPath, false, false) as JsonResult;
if (jsonResult == null)
{
Console.WriteLine("json should not be null");
throw new NullReferenceException(nameof(jsonResult));
}
Assert.IsNotNull(fakeIMetaUpdateService);
Assert.AreEqual(1, fakeIMetaUpdateService.ChangedFileIndexItemNameContent.Count);
var actual = JsonSerializer.Serialize(
fakeIMetaUpdateService.ChangedFileIndexItemNameContent[0],
DefaultJsonSerializer.CamelCase);
var expected = "{\"" + createAnImage.DbPath + "\":[\"tags\"]}";
Assert.AreEqual(expected, actual);
}
public async Task WriteStreamAsync()
{
var createNewImage = new CreateAnImage();
await _thumbnailStorage.WriteStreamAsync(new MemoryStream(CreateAnImage.Bytes),
"StorageThumbnailFilesystemTest_WriteStreamAsync");
var readStream = _thumbnailStorage.ReadStream("StorageThumbnailFilesystemTest_WriteStreamAsync");
Assert.AreEqual(CreateAnImage.Bytes.Length, readStream.Length);
await readStream.DisposeAsync();
File.Delete(Path.Combine(createNewImage.BasePath, "StorageThumbnailFilesystemTest_WriteStreamAsync.jpg"));
}
public void WriteStream()
{
var createNewImage = new CreateAnImage();
_thumbnailStorage.WriteStream(new MemoryStream(CreateAnImage.Bytes),
"StorageThumbnailFilesystemTest_WriteStream");
var readStream = _thumbnailStorage.ReadStream("StorageThumbnailFilesystemTest_WriteStream");
Assert.AreEqual(CreateAnImage.Bytes.Length, readStream.Length);
readStream.Dispose();
File.Delete(Path.Combine(createNewImage.BasePath, "StorageThumbnailFilesystemTest_FileMove.jpg"));
}
public List <FileIndexItem> ReadExifAndXmpFromFileAddFilePathHash(List <string> subPathArray,
List <string> fileHashes = null)
{
var createAnImage = new CreateAnImage();
return(new List <FileIndexItem>
{
new FileIndexItem
{
Status = FileIndexItem.ExifStatus.Ok,
FileName = createAnImage.FileName
}
});
}
public void FileMove()
{
var createNewImage = new CreateAnImage();
_thumbnailStorage.FileMove(_fileNameWithoutExtension, "StorageThumbnailFilesystemTest_FileMove");
var path = Path.Combine(createNewImage.BasePath, _fileNameWithoutExtension + ".jpg");
Assert.IsFalse(File.Exists(path));
var path2 = Path.Combine(createNewImage.BasePath, "StorageThumbnailFilesystemTest_FileMove.jpg");
Assert.IsTrue(File.Exists(path2));
File.Delete(Path.Combine(createNewImage.BasePath, "StorageThumbnailFilesystemTest_FileMove.jpg"));
new CreateAnImage();
}
public async Task Replace_ChangedFileIndexItemNameContent()
{
var createAnImage = new CreateAnImage();
InsertSearchData();
var serviceScopeFactory = NewScopeFactory();
var fakeIMetaUpdateService = _serviceProvider.GetService <IMetaUpdateService>() as
FakeIMetaUpdateService;
Assert.IsNotNull(fakeIMetaUpdateService);
fakeIMetaUpdateService.ChangedFileIndexItemNameContent =
new List <Dictionary <string, List <string> > >();
var metaReplaceService = new FakeIMetaReplaceService(new List <FileIndexItem>
{
new FileIndexItem(createAnImage.DbPath)
{
Tags = "a",
Status = FileIndexItem.ExifStatus.Ok
}
});
var controller = new MetaReplaceController(metaReplaceService, new FakeIUpdateBackgroundTaskQueue(),
new FakeIRealtimeConnectionsService(), new FakeIWebLogger(), serviceScopeFactory);
var jsonResult = await controller.Replace(createAnImage.DbPath, "tags", "a", "b") as JsonResult;
if (jsonResult == null)
{
Console.WriteLine("json should not be null");
throw new NullReferenceException(nameof(jsonResult));
}
Assert.IsNotNull(fakeIMetaUpdateService);
Assert.AreEqual(1, fakeIMetaUpdateService.ChangedFileIndexItemNameContent.Count);
var actual = JsonSerializer.Serialize(
fakeIMetaUpdateService.ChangedFileIndexItemNameContent[0],
DefaultJsonSerializer.CamelCase);
var expected = "{\"" + createAnImage.DbPath + "\":[\"tags\"]}";
Assert.AreEqual(expected, actual);
}
public RenameServiceTest()
{
var provider = new ServiceCollection()
.AddMemoryCache()
.BuildServiceProvider();
var memoryCache = provider.GetService <IMemoryCache>();
var builder = new DbContextOptionsBuilder <ApplicationDbContext>();
builder.UseInMemoryDatabase(nameof(RenameServiceTest));
var options = builder.Options;
var context = new ApplicationDbContext(options);
_newImage = new CreateAnImage();
_appSettings = new AppSettings
{
StorageFolder = PathHelper.AddBackslash(_newImage.BasePath),
ThumbnailTempFolder = _newImage.BasePath
};
_query = new Query(context, _appSettings, null,
new FakeIWebLogger(), memoryCache);
if (_query.GetAllFiles("/").All(p => p.FileName != _newImage.FileName))
{
_query.AddItem(new FileIndexItem
{
FileName = _newImage.FileName,
ParentDirectory = "/",
AddToDatabase = DateTime.UtcNow,
});
}
var iStorage = new StorageSubPathFilesystem(_appSettings, new FakeIWebLogger());
var readMeta = new ReadMeta(iStorage, _appSettings, memoryCache);
_iStorageSubPath = new StorageSubPathFilesystem(_appSettings, new FakeIWebLogger());
var services = new ServiceCollection();
var selectorStorage = new FakeSelectorStorage(iStorage);
//_sync = new Synchronize(_appSettings, _query, selectorStorage, new FakeIWebLogger());
}
public async Task FileStreamingHelperTest_FileStreamingHelper_StreamFile_imagejpeg()
{
var createAnImage = new CreateAnImage();
FileStream requestBody = new FileStream(createAnImage.FullFilePath, FileMode.Open);
_appSettings.TempFolder = createAnImage.BasePath;
var streamSelector = new FakeSelectorStorage(new StorageHostFullPathFilesystem());
var formValueProvider = await FileStreamingHelper.StreamFile("image/jpeg",
requestBody, _appSettings, streamSelector);
Assert.AreNotEqual(null, formValueProvider.ToString());
await requestBody.DisposeAsync();
// Clean
streamSelector.Get(SelectorStorage.StorageServices.HostFilesystem)
.FileDelete(formValueProvider.FirstOrDefault());
}
public void SyncServiceRenameListItemsToDbStyleTest()
{
var appSettings = new AppSettings();
var newImage = new CreateAnImage();
_appSettings.StorageFolder = newImage.BasePath; // needs to have an / or \ at the end
var inputList = new List <string> {
Path.DirectorySeparatorChar.ToString()
};
var expectedOutputList = new List <string> {
"/"
};
var output = appSettings.RenameListItemsToDbStyle(inputList);
// list of files names that are starting with a filename (and not an / or \ )
CollectionAssert.AreEqual(expectedOutputList, output);
}
public async Task Update_AllDataIncluded_WithFakeExifTool()
{
var createAnImage = new CreateAnImage();
InsertSearchData();
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());
var input = new FileIndexItem
{
Tags = "test"
};
var jsonResult = await controller.UpdateAsync(input, createAnImage.DbPath, false,
false) as JsonResult;
if (jsonResult == null)
{
Console.WriteLine("json should not be null");
throw new NullReferenceException(nameof(jsonResult));
}
var fileModel = jsonResult.Value as List <FileIndexItem>;
//you could not test because exiftool is an external dependency
if (fileModel == null)
{
throw new NullReferenceException(nameof(fileModel));
}
Assert.AreNotEqual(null, fileModel.FirstOrDefault()?.Tags);
}
public UploadControllerTest()
{
var provider = new ServiceCollection()
.AddMemoryCache()
.BuildServiceProvider();
_memoryCache = provider.GetService <IMemoryCache>();
var builderDb = new DbContextOptionsBuilder <ApplicationDbContext>();
builderDb.UseInMemoryDatabase(nameof(ExportControllerTest));
var options = builderDb.Options;
var context = new ApplicationDbContext(options);
var scopeFactory = provider.GetService <IServiceScopeFactory>();
var services = new ServiceCollection();
// Fake the readMeta output
services.AddSingleton <IReadMeta, FakeReadMeta>();
// Inject Config helper
services.AddSingleton <IConfiguration>(new ConfigurationBuilder().Build());
// random config
var createAnImage = new CreateAnImage();
_appSettings = new AppSettings {
TempFolder = createAnImage.BasePath
};
_query = new Query(context, _appSettings, scopeFactory, new FakeIWebLogger(), _memoryCache);
_iStorage = new FakeIStorage(new List <string> {
"/", "/test"
},
new List <string> {
createAnImage.DbPath
},
new List <byte[]> {
CreateAnImage.Bytes
});
var readMeta = new ReadMeta(_iStorage, _appSettings);
var selectorStorage = new FakeSelectorStorage(_iStorage);
_import = new Import(selectorStorage, _appSettings, new FakeIImportQuery(),
new FakeExifTool(_iStorage, _appSettings), _query, new ConsoleWrapper(),
new FakeIMetaExifThumbnailService(), new FakeIWebLogger(), _memoryCache);
// Start using dependency injection
var builder = new ConfigurationBuilder();
// Add random config to dependency injection
// build config
var configuration = builder.Build();
// inject config as object to a service
// Add Background services
services.AddSingleton <IHostedService, UpdateBackgroundQueuedHostedService>();
services.AddSingleton <IUpdateBackgroundTaskQueue, UpdateBackgroundTaskQueue>();
// build the service
var serviceProvider = services.BuildServiceProvider();
// get the service
serviceProvider.GetRequiredService <IServiceScopeFactory>();
}
