public Task GetNotifications(int number, bool recursive)
{
using var helper = new HelperTest();
using var watcher = new Watcher();
watcher.Add(new Request(helper.Folder, recursive));
var added = 0;
watcher.OnAddedAsync += (ft, t) =>
{
++added;
return(Task.CompletedTask);
};
// start
watcher.Start();
for (var i = 0; i < number; ++i)
{
helper.AddFile();
}
// wait a bit
_ = SpinWait.SpinUntil(() =>
{
return(number == added);
}, number * 1000);
watcher.Stop();
// stop
Assert.AreEqual(number, added);
return(Task.CompletedTask);
}
public async Task TestSimpleAddFilesNotification(int numberToAdd, bool recursive)
{
using var helper = new HelperTest();
// the number of files we will be adding
var numberAdded = 0;
// first we need to create the watcher
using (var watcher = new Watcher())
{
watcher.Add(new Request(helper.Folder, recursive));
watcher.OnAddedAsync += (fse, token) =>
{
TestContext.Out.WriteLine("Message to write to log");
if (fse.IsFile)
{
++numberAdded;
}
return(Task.CompletedTask);
};
watcher.Start();
for (var i = 0; i < numberToAdd; ++i)
{
// create an empty file
helper.AddFile();
await Task.Yield();
}
// give a bit of time
_ = SpinWait.SpinUntil(() => numberAdded >= numberToAdd, numberToAdd * 1000);
}
Assert.AreEqual(numberToAdd, numberAdded);
}
public void IfWeHaveNoFoldersToWatchThenStartReturnsFalse()
{
using var helper = new HelperTest();
using var watcher = new Watcher();
// start the watcher, we return false as we have not folders.
Assert.IsFalse(watcher.Start());
// stop it.
watcher.Stop();
}
public void GetNotificationsMultipleWatchers(int number, bool recursive)
{
using var helper = new HelperTest();
using var watcher1 = new Watcher();
watcher1.Add(new Request(helper.Folder, recursive, new Rates(500)));
using var watcher2 = new Watcher();
watcher2.Add(new Request(helper.Folder, recursive, new Rates(500)));
var added1 = 0;
var added2 = 0;
watcher1.OnAddedAsync += (ft, t) =>
{
Interlocked.Increment(ref added1);
return(Task.CompletedTask);
};
watcher2.OnAddedAsync += (ft, t) =>
{
Interlocked.Increment(ref added2);
return(Task.CompletedTask);
};
// start
watcher1.Start();
watcher2.Start();
TestContext.Out.WriteLine("Waiting for watchers!");
//we then need to wait a bit for all the workers to have started.
var timeout = number * 1000;
Assert.IsTrue(SpinWait.SpinUntil(() => watcher1.Ready() && watcher2.Ready(), timeout));
TestContext.Out.WriteLine("All watchers ready!");
for (var i = 0; i < number; ++i)
{
helper.AddFile();
}
// wait a bit
SpinWait.SpinUntil(() => number == added1 && number == added2, timeout);
watcher1.Stop();
watcher2.Stop();
// stop
Assert.AreEqual(number, added1);
Assert.AreEqual(number, added2);
}
public void StartedWatcherWithNoFolderIsAlwaysReady()
{
using var helper = new HelperTest();
using var watcher = new Watcher();
// start the watcher
watcher.Start();
// nothing was added, but we are ready
Assert.IsTrue(watcher.Ready());
// stop it.
watcher.Stop();
}
public async Task RemoveAddedDelegateBeforeStop(int number, bool recursive)
{
var added = 0;
Task fn(IFileSystemEvent ft, CancellationToken token)
{
++added;
return(Task.CompletedTask);
};
using var helper = new HelperTest();
using var watcher = new Watcher();
watcher.Add(new Request(helper.Folder, recursive));
watcher.Start();
watcher.OnAddedAsync += fn;
for (var i = 0; i < number; ++i)
{
helper.AddFile();
}
// wait a bit
var stopWatch = new Stopwatch();
stopWatch.Start();
_ = SpinWait.SpinUntil(() =>
{
return(number == added);
}, number * 1000);
stopWatch.Stop();
// check that they all added.
Assert.AreEqual(number, added);
// stop watching
watcher.OnAddedAsync -= fn;
// add some more
for (var i = 0; i < number; ++i)
{
helper.AddFile();
}
await Task.Delay((int)stopWatch.ElapsedMilliseconds).ConfigureAwait(false);
Assert.AreEqual(number, added);
watcher.Stop();
}
public async Task DeleteWatchedFolder(bool recursive)
{
using var helper = new HelperTest();
// create a folder will be actually watch
var folder = helper.AddFolder();
await Task.Delay(100).ConfigureAwait(false);
// start watching it.
using var watcher = new Watcher();
watcher.Add(new Request(folder, recursive));
watcher.Start();
// try and delete it
Assert.DoesNotThrow(() => Directory.Delete(folder, true));
watcher.Stop();
}
public async Task TestSimpleAddFilesNotification(int numberToAdd, bool recursive)
{
using var helper = new HelperTest();
// the number of files we will be adding
var numberAdded = 0;
// first we need to create the watcher
using (var watcher = new Watcher())
{
watcher.Add(new Request(helper.Folder, recursive));
watcher.OnAddedAsync += (fse, token) =>
{
TestContext.Out.WriteLine($"Adding {(fse.IsFile?"File":"Folder")}");
if (fse.IsFile)
{
Interlocked.Increment(ref numberAdded);
}
return(Task.CompletedTask);
};
watcher.Start();
//we then need to wait a bit for all the workers to have started.
TestContext.Out.WriteLine("Waiting for watchers!");
//we then need to wait a bit for all the workers to have started.
var timeout = (numberToAdd <= 2 ? 3 : numberToAdd) * 1000;
Assert.IsTrue(SpinWait.SpinUntil(() => watcher.Ready(), timeout));
TestContext.Out.WriteLine("All watchers ready!");
for (var i = 0; i < numberToAdd; ++i)
{
// create an empty file
helper.AddFile();
await Task.Yield();
}
// give a bit of time
SpinWait.SpinUntil(() => numberAdded >= numberToAdd, timeout);
}
Assert.AreEqual(numberToAdd, numberAdded);
}
public void RemoveAddedDelegateBeforeStop(int number, bool recursive)
{
var added = 0;
Task Fn(IFileSystemEvent ft, CancellationToken token)
{
Interlocked.Increment(ref added);
return(Task.CompletedTask);
}
using var helper = new HelperTest();
using var watcher = new Watcher();
watcher.Add(new Request(helper.Folder, recursive, new Rates(50)));
watcher.Start();
SpinWait.SpinUntil(() => watcher.Ready());
watcher.OnAddedAsync += Fn;
for (var i = 0; i < number; ++i)
{
helper.AddFile();
}
// wait a bit
Assert.IsTrue(SpinWait.SpinUntil(() => number == added, number * 1000));
// check that they all added.
Assert.AreEqual(number, added);
// stop watching
watcher.OnAddedAsync -= Fn;
// add some more
for (var i = 0; i < number; ++i)
{
helper.AddFile();
}
Assert.AreEqual(number, added);
watcher.Stop();
}
public async Task DeleteWatchedFolder(bool recursive)
{
using var helper = new HelperTest();
// create a folder will be actually watch
var folder = helper.AddFolder();
await Task.Delay(100).ConfigureAwait(false);
// start watching it.
using var watcher = new Watcher();
watcher.Add(new Request(folder, recursive));
watcher.Start();
//we then need to wait a bit for all the workers to have started.
SpinWait.SpinUntil(() => watcher.Ready());
// try and delete it
Assert.DoesNotThrow(() => Directory.Delete(folder, true));
watcher.Stop();
}
public async Task StartWatcherBeforeAddingAnything(bool recursive)
{
using var helper = new HelperTest();
using var watcher = new Watcher();
// start the watcher
watcher.Start();
// the number of files we actually added
var numberAdded = 0;
const int numberToAdd = 10;
var timeout = (numberToAdd <= 2 ? 3 : numberToAdd) * 1000;
Assert.IsTrue(SpinWait.SpinUntil(() => watcher.Ready(), timeout));
// and then add the folder we are after
watcher.Add(new Request(helper.Folder, recursive));
// then wait
Assert.IsTrue(SpinWait.SpinUntil(() => watcher.Ready(), timeout));
watcher.OnAddedAsync += (fse, token) =>
{
Interlocked.Increment(ref numberAdded);
return(Task.CompletedTask);
};
TestContext.Out.WriteLine("All watchers ready!");
for (var i = 0; i < numberToAdd; ++i)
{
// create an empty file
helper.AddFile();
await Task.Yield();
}
// give a bit of time
SpinWait.SpinUntil(() => numberAdded >= numberToAdd, timeout);
}
