aweXpect.Testably 0.15.0

aweXpect.Testably

Expectations for the file and time system from Testably.Abstractions.

File system

You can verify that a specific file or directory exists in the file system:

IFileSystem fileSystem = new MockFileSystem();
fileSystem.Directory.CreateDirectory("my/path");
fileSystem.File.WriteAllText("my-file.txt", "some content");

await That(fileSystem).HasDirectory("my/path");
await That(fileSystem).HasFile("my-file.txt");

File

For files, you can verify the file content:

IFileSystem fileSystem = new MockFileSystem();
fileSystem.File.WriteAllText("my-file.txt", "some content");

await That(fileSystem).HasFile("my-file.txt").WithContent("some content").IgnoringCase();
await That(fileSystem).HasFile("my-file.txt").WithContent().NotEqualTo("some unexpected content");

You can also verify the file content with regard to another file:

IFileSystem fileSystem = new MockFileSystem();
fileSystem.File.WriteAllText("my-file.txt", "some content");
fileSystem.File.WriteAllText("my-other-file.txt", "SOME CONTENT");
fileSystem.File.WriteAllText("my-third-file.txt", "some other content");

await That(fileSystem).HasFile("my-file.txt").WithContent().SameAs("my-other-file.txt").IgnoringCase();
await That(fileSystem).HasFile("my-file.txt").WithContent().NotSameAs("my-third-file.txt");

For files, you can verify the creation time, last access time and last write time:

IFileSystem fileSystem = new MockFileSystem();
fileSystem.File.WriteAllText("my-file.txt", "some content");

await That(sut).HasFile(path).WithCreationTime(DateTime.Now).Within(1.Second());
await That(sut).HasFile(path).WithLastAccessTime(DateTime.Now).Within(1.Second());
await That(sut).HasFile(path).LastWriteTime(DateTime.Now).Within(1.Second());

Directory

For directories, you can verify that they contain subdirectories:

IFileSystem fileSystem = new MockFileSystem();
fileSystem.Directory.CreateDirectory("foo/bar1");
fileSystem.Directory.CreateDirectory("foo/bar2/baz");

await That(fileSystem).HasDirectory("foo").WithDirectories(f => f.HasCount().EqualTo(2));

For directories, you can verify that they contain files:

IFileSystem fileSystem = new MockFileSystem();
fileSystem.Directory.CreateDirectory("foo/bar");
fileSystem.File.WriteAllText("foo/bar/my-file.txt", "some content");

await That(fileSystem).HasDirectory("foo/bar").WithFiles(f => f.All().ComplyWith(x => x.HasContent("SOME CONTENT").IgnoringCase()));

Drives

You can verify that a drive is registered on the file system. Drives are matched by name (case-insensitive) against IFileSystem.DriveInfo.GetDrives(); UNC drives (which do not appear in GetDrives()) are not supported by HasDrive:

MockFileSystem fileSystem = new(o => o.SimulatingOperatingSystem(SimulationMode.Windows));
fileSystem.WithDrive("D:", d => d.SetTotalSize(2048));

await That(fileSystem).HasDrive("D:\\");
await That(fileSystem).DoesNotHaveDrive("Z:\\");

HasDrive exposes a .Which property returning IThat<IDriveInfo>, so all IDriveInfo assertions can be chained directly:

await That(fileSystem).HasDrive("D:\\")
    .Which.HasTotalSize(2048).And.IsReady();

You can also assert directly on IDriveInfo instances:

IDriveInfo driveInfo = fileSystem.DriveInfo.New("D:");

await That(driveInfo).HasAvailableFreeSpace(2048);
await That(driveInfo).HasTotalSize(2048).And.HasTotalFreeSpace(2048);
await That(driveInfo).HasDriveFormat("NTFS");
await That(driveInfo).HasDriveType(System.IO.DriveType.Fixed);
await That(driveInfo).HasName(driveInfo.Name).And.HasVolumeLabel(driveInfo.VolumeLabel);
await That(driveInfo).IsReady();

IFileInfo / IDirectoryInfo as subjects

You can also assert directly on IFileInfo and IDirectoryInfo instances:

IFileInfo fileInfo = fileSystem.FileInfo.New("my-file.txt");
await That(fileInfo).HasLength(12).And.HasContent("some content");
await That(fileInfo).HasName("my-file.txt").And.HasExtension(".txt");
await That(fileInfo).Exists();

IDirectoryInfo dirInfo = fileSystem.DirectoryInfo.New("foo");
await That(dirInfo).IsNotEmpty();
await That(dirInfo).HasFile("bar/my-file.txt");
await That(dirInfo).HasDirectory("bar").Which.HasFile("my-file.txt");

Bridging from the file-system chain via .Which

HasFile, HasDirectory and HasDrive expose a .Which property that returns the IThat<IFileInfo> / IThat<IDirectoryInfo> / IThat<IDriveInfo> for the resolved entry, so the same assertions light up in both places:

await That(fileSystem).HasFile("my-file.txt").Which.HasLength(12).And.HasContent("some content");
await That(fileSystem).HasDirectory("logs").Which.IsEmpty();
await That(fileSystem).HasDrive("D:\\").Which.IsReady().And.HasDriveFormat("NTFS");

IFileVersionInfo

IFileVersionInfo instances obtained via MockFileSystem.FileVersionInfo.GetVersionInfo can be asserted directly. The configured values come from MockFileSystem.WithFileVersionInfo(glob, builder):

MockFileSystem fileSystem = new();
fileSystem.WithFileVersionInfo("*.dll", v => v
    .SetCompanyName("Acme")
    .SetProductName("Anvil")
    .SetFileVersion("1.2.3.4")
    .SetIsDebug(true));
fileSystem.File.WriteAllText("Acme.dll", "");

IFileVersionInfo info = fileSystem.FileVersionInfo.GetVersionInfo("Acme.dll");

await That(info).HasCompanyName("Acme").And.HasProductName("Anvil");
await That(info).HasFileVersion("1.2.3.4");
await That(info).IsDebug().And.IsNotPreRelease();

The following common fields have dedicated assertions: HasCompanyName, HasProductName, HasFileDescription, HasFileVersion, HasProductVersion, HasOriginalFilename, HasLanguage, plus the bool pairs IsDebug / IsNotDebug, IsPreRelease / IsNotPreRelease, IsPatched / IsNotPatched. For the remaining properties (e.g. Comments, LegalCopyright, FileMajorPart), assert on them directly via await That(info.LegalCopyright).IsEqualTo("…").

Notifications

A MockFileSystem raises notifications when files or directories change. Run the code under test, then assert against the notifications it produced:

MockFileSystem fileSystem = new();
fileSystem.File.WriteAllText("my-file.txt", "some content");

await That(fileSystem).TriggeredNotification();
await That(fileSystem).TriggeredNotification(c => c.Name == "my-file.txt");

.Within(timeout) (default 30 s) lets the assertion wait for asynchronous notifications — if a matching notification already fired the assertion completes synchronously, otherwise it waits up to the timeout for a late arrival:

_ = Task.Run(() => fileSystem.File.WriteAllText("foo.txt", "x"));
await That(fileSystem).TriggeredNotification().Within(100.Milliseconds());

DidNotTriggerNotification mirrors the same shapes and short-circuits as soon as a matching notification is observed:

await That(fileSystem).DidNotTriggerNotification().Within(100.Milliseconds());
await That(fileSystem).DidNotTriggerNotification(c => c.Name == "secret.txt");

TriggeredNotification accepts a Quantifier (AtLeast, AtMost, Exactly, Between, Never, Once) so you can assert how often the notification fires:

fileSystem.File.WriteAllText("a.txt", "x");
fileSystem.File.WriteAllText("b.txt", "y");

await That(fileSystem).TriggeredNotification(c => c.ChangeType == WatcherChangeTypes.Created)
    .Exactly(2.Times());

Both TriggeredNotification and DidNotTriggerNotification expose .Which(c => …), which applies inner expectations from ChangeDescriptionExtensions as an additional per-notification filter — only changes that satisfy them count:

fileSystem.File.WriteAllText("a.txt", "x");

await That(fileSystem)
    .TriggeredNotification()
    .Which(c => c.HasName("a.txt").And.HasChangeType(WatcherChangeTypes.Created))
    .Exactly(1.Times());

Replay of historical notifications relies on the MockFileSystem notification history. Disable it via new MockFileSystem(o => o.WithoutNotificationHistory()) only if you don't use these assertions — they throw against a history-disabled file system.

Watcher events

An individual IFileSystemWatcher can also be the subject. The watcher must come from a MockFileSystem, and EnableRaisingEvents must be true for any event to be observed:

MockFileSystem fileSystem = new();
using IFileSystemWatcher watcher = fileSystem.FileSystemWatcher.New("/");
watcher.EnableRaisingEvents = true;
fileSystem.File.WriteAllText("my-file.txt", "some content");

await That(watcher).Triggered();
await That(watcher).Triggered(c => c.Name == "my-file.txt");

Only events that originate from this specific watcher count — events fired on other watchers of the same MockFileSystem are ignored.

.Within(timeout) (default 30 s) lets the assertion wait for asynchronous events:

_ = Task.Run(() => fileSystem.File.WriteAllText("foo.txt", "x"));
await That(watcher).Triggered().Within(100.Milliseconds());

DidNotTrigger mirrors the same shapes and short-circuits as soon as a matching event is observed:

await That(watcher).DidNotTrigger().Within(100.Milliseconds());
await That(watcher).DidNotTrigger(c => c.Name == "secret.txt");

Both Triggered and DidNotTrigger accept either a synchronous Func<WatcherChangeDescription, bool> predicate or a .Which(c => …) callback that composes inner expectations from ChangeDescriptionExtensions:

await That(watcher)
    .Triggered()
    .Which(c => c.HasName("my-file.txt").And.HasChangeType(WatcherChangeTypes.Created))
    .Exactly(1.Times());

ChangeDescription as a subject

Individual ChangeDescription instances can be asserted directly. The HasChangeType, HasFileSystemType and HasNotifyFilters assertions use flag containment (so a LastWrite | FileName change satisfies HasNotifyFilters(NotifyFilters.LastWrite)); the empty / default value is rejected with an ArgumentException to avoid silent passes.

await That(change).HasChangeType(WatcherChangeTypes.Created);
await That(change).DoesNotHaveChangeType(WatcherChangeTypes.Deleted);

await That(change).HasFileSystemType(FileSystemTypes.File);
await That(change).HasNotifyFilters(NotifyFilters.LastWrite);

await That(change).HasName("my-file.txt").And.HasPath("/abs/my-file.txt");
await That(renamedChange).HasOldName("old.txt").And.HasOldPath("/abs/old.txt");

Time system

Timers

A MockTimeSystem exposes timers as ITimerMock. You can assert how often the timer callback was executed without blocking the test thread:

MockTimeSystem timeSystem = new();
ITimerMock timer = (ITimerMock)timeSystem.Timer.New(
    _ => { }, null, TimeSpan.Zero, TimeSpan.FromMilliseconds(10));

await That(timer).Executed(3.Times()).Within(5.Seconds());

Executed() accepts a Quantifier (AtLeast, AtMost, Exactly, Between, …) and exposes .Within(timeout) for asynchronous execution. The assertion polls ITimerMock.ExecutionCount until the quantifier is satisfied or the timeout expires — 30 seconds by default.

await That(timer).Executed().AtLeast(2.Times()).Within(100.Milliseconds());