SimpleFluentTester 0.1.0

<div align="center">

Simple Fluent Tester <br> 😼

Simple and user-friendly C# testing tool.

</div>

What is it for?

Let's say you are solving algorithmic problems on a platform like LeetCode or conducting intermediate testing for a complex algorithm.

Would you start writing your own wrappers? This will take some time that could be spent more productively.

Would you use a testing framework? That's a good option, but it requires writing a lot of unnecessary infrastructure code.

Based on my personal experience, I have created a library that allows you to set up the entire testing environment in just a minute!

Instruction

Use your preferred IDE or CLI to install the NuGet package SimpleFluentTester. You can also find the NuGet package at this link.

I assume that you have a very complex function to cover with test cases, but let's say we have a very simple one of some sort:

 int Adder(int number1, int number2)
 {
     return number1 + number2;
 }

Let's start writing test cases for it!

TestSuite.Sequential
     // Here we specify the method we want to test.
    .UseOperation(Adder) 
     // Then we add 2 valid tests and one invalid test.
    .Expect(2).WithInput(1, 1) 
    .Expect(-2).WithInput(-1, -1)
    .Expect(-3).WithInput(-1, -1)
    .Run() 
    .Report();

And the output of this code will indicate that one out of the three test cases has not passed:

05:10:31.455 fail: SimpleFluentTester.Reporter.DefaultTestRunReporter[0]
      Executing tests for target method [Int32 Adder(Int32, Int32)]
      Total tests: 3
      Tests to execute: 3
      
      Test case [3] not passed
        Inputs: '-1', '-1'
        Expected: '-3'
        Output: '-2'
        Elapsed: 0,00050ms
      
      1/3 tests haven't passed!
      Failed test cases: 3
      Elapsed total: 0,16400ms; Avg: 0,05467ms; Max: 0,11000ms [Number 2]

Furthermore, for debugging purposes, for the next run it would be most convenient to select only the unsuccessful test cases:

TestSuite.Sequential
    .UseOperation(Adder) 
    .Expect(2).WithInput(1, 1) 
    .Expect(-2).WithInput(-1, -1)
    .Expect(-3).WithInput(-1, -1)
     // You should not comment on your test cases; just specify the iteration you want to test, every other iteration will be ignored.
    .Run(3) 
    .Report();

Also, you can write your custom reporter that will generate a report in the format you need:

TestSuite.Sequential
    .UseOperation<int>(CustomMethods.Adder) 
    .WithCustomReporterFactory<CustomReporterFactory>() 
    .Expect(2).WithInput(1, 1) 
    .Run()
    .Report();

If your project contains multiple test suites simultaneously, and you wish to debug only one of them, you don't need to comment out the code; simply follow these steps:

TestSuite.Sequential.Ignore // <- add Ignore here and this test run will be fully ignored.
    .UseOperation<int>(CustomMethods.Adder) 
    .Expect(2).WithInput(1, 1) 
    .Run()
    .Report();

If you use non-standard object types in your function, you can define how the TestSuite should compare them yourself.

TestSuite.Sequential
    // Return type of your testable method could be specified with a provided comparer.
    .WithExpectedReturnType<CustomValue>((x, y) => x.Value == y.Value)
    .UseOperation((CustomValue a, CustomValue b) => a.Value + b.Value)
    .Expect(CustomValue.FromInt(2)).WithInput(CustomValue.FromInt(1), CustomValue.FromInt(1))
    .Run()
    .Report();

If you have any questions, you can find all these examples in this project or ask me directly via email!

License

Released under MIT by @EvgenyHalzov.

• You can freely modify and reuse.
• The original license must be included with copies of this software.
• Please link back to this repo if you use a significant portion the source code.