public async Task WriteDisabled_WriteAllBytesAsync_ShouldNotWriteToFile()
{
const string relativePath = "file";
var path = Path.Combine(_testDir, relativePath);
// randomize content
var content = new byte[512];
new Random().NextBytes(content);
// create the provider and disable write
var provider = new ProtectedAppDataFileProvider(_testDir);
provider.DisableWrite();
// call WriteAllBytesAsync and make sure file is not created
await provider.WriteAllBytesAsync(relativePath, content, default);
Assert.False(File.Exists(path));
// create an empty file
File.Create(path).Dispose();
// call WriteAllBytesAsync and make sure file nothing is written
await provider.WriteAllBytesAsync(relativePath, content, default);
Assert.True(string.IsNullOrEmpty(File.ReadAllText(path)));
}
public void WriteDisabled_GetFilesInDirectory_ShouldReturnEmpty(int depth, int fileCount)
{
// Get the directory that will contain all the files
var relativePath = GetDirectoryPathForDepth(depth);
var containerDir = Path.Combine(_testDir, relativePath);
Directory.CreateDirectory(containerDir);
// Get the 'relativeFileNames' list that contains all the relative path of the files
var relativeFileNames = Enumerable.Range(0, fileCount).Select(i => Path.Combine(relativePath, i.ToString())).ToArray();
foreach (var relativeFileName in relativeFileNames)
{
File.Open(Path.Combine(_testDir, relativeFileName), FileMode.Create).Dispose();
}
// Disable writes and call 'GetFilesInDirectory'
var provider = new ProtectedAppDataFileProvider(_testDir);
provider.DisableWrite();
var files = provider.GetFilesInDirectory(relativePath);
// assert
Assert.Empty(files);
}
public void WriteEnabled_CreateDirectory_ShouldCreateDirectory(string relativePath)
{
var provider = new ProtectedAppDataFileProvider(_testDir);
provider.CreateDirectory(relativePath);
Assert.True(Directory.Exists(Path.Combine(_testDir, relativePath)));
}
public void DisableWrite_ReturnWriteDisabled()
{
var provider = new ProtectedAppDataFileProvider(_testDir);
Assert.True(provider.IsWriteEnabled);
provider.DisableWrite();
Assert.False(provider.IsWriteEnabled);
}
public void WriteDisabled_CreateDirectory_ShouldNotCreateDirectory()
{
const string relativePath = "dir";
var provider = new ProtectedAppDataFileProvider(_testDir);
provider.DisableWrite();
provider.CreateDirectory(relativePath);
Assert.False(Directory.Exists(Path.Combine(_testDir, relativePath)));
}
public void WriteEnabled_WriteAllText_ShouldWriteToFile()
{
const string relativePath = "file.txt";
const string content = "file content";
var path = Path.Combine(_testDir, relativePath);
var provider = new ProtectedAppDataFileProvider(_testDir);
provider.WriteAllText(relativePath, content, Encoding.UTF8);
var readContent = File.ReadAllText(path);
Assert.Equal(content, readContent);
}
public void WriteEnabled_OpenStream_ShouldWriteToFile()
{
const string relativePath = "file.txt";
const string content = "file content";
var provider = new ProtectedAppDataFileProvider(_testDir);
using (var stream = provider.OpenFile(relativePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None))
{
WriteContentToStream(stream, content);
}
var readContent = File.ReadAllText(Path.Combine(_testDir, relativePath));
Assert.Equal(content, readContent);
}
public void WriteEnabled_ReadAllText_ShouldReturnText(int depth)
{
// setup
var fileText = Guid.NewGuid().ToString();
var containerDir = GetDirectoryPathForDepth(depth);
Directory.CreateDirectory(Path.Combine(_testDir, containerDir));
var filePath = Path.Combine(containerDir, "file");
File.WriteAllText(Path.Combine(_testDir, filePath), fileText);
// call
var provider = new ProtectedAppDataFileProvider(_testDir);
var readText = provider.ReadAllText(filePath);
// assert
Assert.Equal(fileText, readText);
}
public void DeleteFile_ShouldDeleteOnlyIfWriteEnabled(bool writeEnabled)
{
// setup: create the file
var fileName = "file";
File.Open(Path.Combine(_testDir, fileName), FileMode.Create).Dispose();
// call 'DeleteFile'
var provider = new ProtectedAppDataFileProvider(_testDir);
if (!writeEnabled)
{
provider.DisableWrite();
}
provider.DeleteFile(fileName);
// assert
Assert.Equal(!writeEnabled, File.Exists(Path.Combine(_testDir, fileName)));
}
public void WriteEnabled_ReadAllText_ShouldThrowException(int depth)
{
// setup
var fileText = Guid.NewGuid().ToString();
var containerDir = GetDirectoryPathForDepth(depth);
Directory.CreateDirectory(Path.Combine(_testDir, containerDir));
var filePath = Path.Combine(containerDir, "file");
File.WriteAllText(Path.Combine(_testDir, filePath), fileText);
// call
var provider = new ProtectedAppDataFileProvider(_testDir);
provider.DisableWrite();
// assert
Assert.Throws <FileNotFoundException>(() => provider.ReadAllText(filePath));
}
public void WriteEnabled_FileExists_ShouldReturnFileExistence(int depth, bool fileActuallyExists)
{
// Setup
var containerDir = GetDirectoryPathForDepth(depth);
Directory.CreateDirectory(Path.Combine(_testDir, containerDir));
var filePath = Path.Combine(containerDir, "file");
if (fileActuallyExists)
{
File.Open(Path.Combine(_testDir, filePath), FileMode.Create).Dispose();
}
// Call
var provider = new ProtectedAppDataFileProvider(_testDir);
// Assert
Assert.Equal(fileActuallyExists, provider.FileExists(filePath));
}
public async Task PersistentQueue_PushAndGet(int batchCount)
{
var dataDir = Path.Combine(AppContext.BaseDirectory, Guid.NewGuid().ToString());
var queueDir = Path.Combine(dataDir, _queueDirName);
Directory.CreateDirectory(queueDir);
var fileProvider = new ProtectedAppDataFileProvider(dataDir);
try
{
var secondary = new FilePersistentQueue <List <int> >(100, queueDir, new IntegerListSerializer(), fileProvider, NullLogger.Instance);
var q = new AsyncBatchQueue <int>(1000,
new long[] { batchCount },
new Func <int, long>[] { s => 1 }, secondary);
await q.PushSecondaryAsync(Enumerable.Range(0, batchCount + 1).ToList());
var output = new List <int>();
var getTask = q.GetNextBatchAsync(output, 10 * 1000).AsTask();
Assert.True(getTask.Wait(1000));
Assert.Equal(batchCount, output.Count);
if (batchCount == 0)
{
return;
}
// second call should return the last item
output.Clear();
await q.GetNextBatchAsync(output, 100);
Assert.Single(output);
}
finally
{
if (Directory.Exists(dataDir))
{
Directory.Delete(dataDir, true);
}
}
}
public async Task PersistentQueue_PullBothQueues()
{
var dataDir = Path.Combine(AppContext.BaseDirectory, Guid.NewGuid().ToString());
var queueDir = Path.Combine(dataDir, _queueDirName);
Directory.CreateDirectory(queueDir);
var fileProvider = new ProtectedAppDataFileProvider(dataDir);
try
{
var secondary = new FilePersistentQueue <List <int> >(10, queueDir, new IntegerListSerializer(), fileProvider, NullLogger.Instance);
var q = new AsyncBatchQueue <int>(500,
new long[] { 500 },
new Func <int, long>[] { s => 1 }, secondary);
await q.PushSecondaryAsync(Enumerable.Range(0, 500).ToList());
for (var i = 500; i < 1000; i++)
{
await q.PushAsync(i);
}
// pull 3 times
var output = new List <int>();
await q.GetNextBatchAsync(output, 1000);
await q.GetNextBatchAsync(output, 1000);
await q.GetNextBatchAsync(output, 1000);
Assert.Equal(1000, output.Distinct().Count());
}
finally
{
if (Directory.Exists(dataDir))
{
Directory.Delete(dataDir, true);
}
}
}
public void WriteDisabled_WriteAllText_ShouldNotWriteToFile()
{
const string relativePath = "file.txt";
const string content = "file content";
var path = Path.Combine(_testDir, relativePath);
// create the provider and disable write
var provider = new ProtectedAppDataFileProvider(_testDir);
provider.DisableWrite();
// call WriteAllText and make sure file is not created
provider.WriteAllText(relativePath, content, Encoding.UTF8);
Assert.False(File.Exists(path));
// create an empty file
File.Create(path).Dispose();
// call WriteAllText and make sure file nothing is written
provider.WriteAllText(relativePath, content, Encoding.UTF8);
Assert.True(string.IsNullOrEmpty(File.ReadAllText(path)));
}
public void WriteEnabled_GetFilesInDirectory_ShouldReturnDirectories(int depth, int fileCount)
{
// Get the directory that will contain all the files
var relativePath = GetDirectoryPathForDepth(depth);
var containerDir = Path.Combine(_testDir, relativePath);
Directory.CreateDirectory(containerDir);
// Get the 'relativeFileNames' list that contains all the relative path of the files
var relativeFileNames = Enumerable.Range(0, fileCount).Select(i => Path.Combine(relativePath, i.ToString())).ToArray();
foreach (var relativeFileName in relativeFileNames)
{
File.Open(Path.Combine(_testDir, relativeFileName), FileMode.Create).Dispose();
}
// Call 'GetFilesInDirectory'
var provider = new ProtectedAppDataFileProvider(_testDir);
var files = provider.GetFilesInDirectory(relativePath).OrderBy(f => int.Parse(Path.GetFileName(f))).ToList();
// Assert that returned list is the same as 'relativeFileNames'
Assert.Equal(relativeFileNames, files);
}
public void WriteDisabledWhileStreamOpen_ShouldNotWrite()
{
const string relativePath = "file.txt";
const string content = "file content";
var path = Path.Combine(_testDir, relativePath);
var provider = new ProtectedAppDataFileProvider(_testDir);
// open the file stream
using var stream = provider.OpenFile(relativePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
// write something
WriteContentToStream(stream, content);
// disable write while the stream is still open
provider.DisableWrite();
// write more content
WriteContentToStream(stream, "more content");
// assert that the new content is not written
var readContent = File.ReadAllText(Path.Combine(_testDir, relativePath));
Assert.Equal(content, readContent);
}
public async Task PersistentQueue_ConcurrentRead(int readerCount, int itemCount)
{
var dataDir = Path.Combine(AppContext.BaseDirectory, Guid.NewGuid().ToString());
var queueDir = Path.Combine(dataDir, _queueDirName);
Directory.CreateDirectory(queueDir);
var fileProvider = new ProtectedAppDataFileProvider(dataDir);
try
{
var secondary = new FilePersistentQueue <List <int> >(100000, queueDir, new IntegerListSerializer(), fileProvider, NullLogger.Instance);
using var cts = new CancellationTokenSource();
using var semaphore = new SemaphoreSlim(0, readerCount);
var results = new List <int>();
var q = new AsyncBatchQueue <int>(10000,
new long[] { 100 },
new Func <int, long>[] { s => 1 }, secondary);
async Task readerTask()
{
var output = new List <int>();
await semaphore.WaitAsync();
// we're trying to test that the readers will 'eventually' read all the items, so we do several pulls here
await q.GetNextBatchAsync(output, 500);
await q.GetNextBatchAsync(output, 500);
await q.GetNextBatchAsync(output, 500);
await Task.Delay(100);
lock (results)
{
results.AddRange(output);
}
};
var readers = new Task[readerCount];
for (var i = 0; i < readerCount; i++)
{
readers[i] = readerTask();
}
for (var i = 0; i < itemCount; i++)
{
if (i % 2 == 0)
{
await q.PushAsync(i);
}
else
{
await q.PushSecondaryAsync(new List <int> {
i
});
}
}
semaphore.Release(readerCount);
await Task.WhenAll(readers);
_output.WriteLine(results.Count.ToString());
_output.WriteLine(q.EstimateSize().ToString());
_output.WriteLine(q.EstimateSecondaryQueueSize().ToString());
Assert.Equal(itemCount, results.Distinct().Count());
}
finally
{
if (Directory.Exists(dataDir))
{
Directory.Delete(dataDir, true);
}
}
}