private async Task TestDirectoryIsWriteable(IDirectoryInfo directory)
{
const string fileName = "TestFile.ext";
Assert.NotNull(directory);
var file = await directory.CreateFileAsync(fileName);
Assert.NotNull(file);
var content = Encoding.UTF8.GetBytes("Some data");
using (var stream = await file.OpenAsync(System.IO.FileAccess.ReadWrite))
{
await stream.WriteAsync(content, 0, content.Length);
await stream.FlushAsync();
}
using (var stream = await file.OpenAsync(System.IO.FileAccess.Read))
{
Assert.Equal(content.Length, stream.Length);
}
await file.DeleteAsync();
var files = await directory.EnumerateFilesAsync();
Assert.DoesNotContain(files, d => d.Name == fileName);
}
public async Task <IFileInfo> CreateFileAsync(string name, Stream stream, long length, CancellationToken ct)
{
if (FileSystem.EncryptFileName)
{
name = EncryptName(name);
}
using (var aes = CreateAes(FileSystem.Version))
{
using (var headerStream = new MemoryStream())
{
var aesHeader = new AesHeader(FileSystem.Version, aes.IV);
aesHeader.Write(headerStream);
headerStream.Seek(0, SeekOrigin.Begin);
var key = FileSystem.ComputeKey(aes.IV, FileSystem.Version);
ICryptoTransform encryptor = CreateTransform(aes, key, aes.IV, AesMode.Encrypt);
using (var cryptoStream = new CryptoStream(stream, encryptor, CryptoStreamMode.Read))
using (var concat = new StreamEnumerator(new Stream[] { headerStream, cryptoStream }, true))
{
var fileInfo = await _directoryInfo.CreateFileAsync(name, concat, length, ct).ConfigureAwait(false);
return(new AesFileInfo(FileSystem, fileInfo));
}
}
}
}
protected override async Task <Stream> OpenFileStreamAsyncInternal(string path, FileAccess accessType)
{
if (!path.StartsWith(HandledScheme))
{
return(null);
}
var contents = await GetContents();
path = path.Substring(HandledScheme.Length).ToLowerInvariant();
contents.TryGetValue(path, out var file);
if (accessType == FileAccess.Read && file == null)
{
return(null);
}
if (file == null)
{
file = await RootFolder.CreateFileAsync(path);
Contents.Add(GenerateSchemaName(file), file);
}
var output = await file.OpenAsync(accessType);
return(output);
}
public static async Task <IFileInfo> CopyFileAsync(this IDirectoryInfo directory, IFileInfo file, string fileName, CancellationToken ct)
{
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
if (file == null)
{
throw new ArgumentNullException(nameof(file));
}
using var inputStream = await file.OpenReadAsync(ct).ConfigureAwait(false);
return(await directory.CreateFileAsync(fileName, inputStream, file.Length, ct).ConfigureAwait(false));
}
public static async Task <IFileInfo> CreateFileAsync(this IDirectoryInfo parent, string name, byte[] content, CancellationToken ct)
{
if (parent == null)
{
throw new ArgumentNullException(nameof(parent));
}
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
using MemoryStream ms = new MemoryStream(content);
return(await parent.CreateFileAsync(name, ms, ms.Length, ct).ConfigureAwait(false));
}
public void AddItem(string path, byte[] content = null)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
bool isDirectory = path.EndsWith("/") || path.EndsWith("\\");
var parts = path.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);
IDirectoryInfo di = _root;
for (int index = 0; index < parts.Length; index++)
{
var part = parts[index];
if (!isDirectory && index == parts.Length - 1)
{
di.CreateFileAsync(part, content ?? Array.Empty <byte>(), CancellationToken.None).Wait();
}
else
{
di = di.CreateDirectoryAsync(part, CancellationToken.None).Result;
}
}
}
public async Task CreateFileWorks()
{
var fileName = "one.ext";
var fileOne = await TestRootFolder.CreateFileAsync(fileName);
var files = await TestRootFolder.EnumerateFilesAsync();
var items = await TestRootFolder.EnumerateItemsAsync();
Assert.Collection(files, d => Assert.Equal(fileOne, d));
Assert.Single(items);
var item = await TestRootFolder.GetFileAsync(fileName);
Assert.NotNull(item);
item = await TestRootFolder.GetFileAsync("notExistent");
Assert.Null(item);
}
