CommandLineUtils VS xUnit

The library doesn't support that format, here you can see that MultipleValues means for example "-o value1 -o value2" Options Support options with multiple values · Issue #311 · natemcmaster/CommandLineUtils · GitHub

You could roll your own with some command-line argument processing. You could write that yourself and use reflection, or for an example from a library I've used, example.

I want to test how my tools generated files and folders in the destination with different arguments passed to the program. However, in my old code, I put all the logic of working with arguments in the static int main( string[] args) function. I could not use Interface and Dependency injection to mock the CLI tools because CommandLineUtils does not have an interface library. Luckily, I found this guidance from the owner of CommandLineUtils, and he advised that "Split the command-line argument parser and application execution into separate class structures" to test various options programmatically. It is a great suggestion, and I rewrote my program by adding class CommandLineOptions and adding logic to class Generator to make it works with CommandLineOptions. I can kill two birds with one stone by this change: code refactoring and writing better tests. Another problem I had was my folder structure. Before, I put the project's sln file, .git file , and src files in the root of the folder. However, when I added a new test project for Shinny-SSG, I had it outside my git folder, and it would be impossible to commit the change and put it in my remote repository. To resolve this, I had to change my folder structure to this:

Thanks to https://github.com/natemcmaster/CommandLineUtils for supplying a lot of the command structures. If you're interested in creating your own dotnet tool, this is highly recommended.

Several well-known NuGet packages such as xUnit.net, FluentAssertions, StyleCop, Entity Framework Core, and others include by default a significant number of Roslyn analyzers. They help you adhere to the conventions and best practices of these libraries.

Most of my rules apply to document types, so let's build some tests for document types. We start by creating a new test class and a new test function and getting a list of all document types. This test is created using xUnit and FluentAssertions:

xUnit -> https://xunit.net/

.NET / xUnit / NUnit / MSTest

This library extends the traditional assertions provided by frameworks like MSTest, NUnit, or XUnit by offering a more extensive set of extension methods. Fluent Assertions supports a wide range of types like collections, strings, and objects and even allows for more advanced assertions like throwing exceptions.

You can verify the functionality of this validator by writing the following tests (using xUnit):

The git repo has other runners. AssemblyRunner appears to be the best fit for an already compiled tests project, but there is a runner that can be wrapped into an MSBuild task for example.

At this point you're going to see a familiar screen asking you to select a project. Here we're looking for a test project. By default, Visual Studio gives you access to 3 different testing frameworks based on your choice of project. These are MSTest, XUnit and NUnit. Ultimately, all 3 of these testing accomplish the same thing, and I've worked with all of them at various points in my career. The difference is mainly in exact syntax and documentation. Although, it's generally considered that MSTest is a little "older" than NUnit or XUnit, so I tend to see it less now. For the purposes of this demo, I'm going to go with NUnit:

xUnit unit tests tool

Use a testing framework: Utilize a testing framework like NUnit, xUnit, or MSTest to create, organize, and run your tests. These frameworks provide a consistent way to write tests, generate test reports, and integrate with continuous integration tools.