Generic.DummyGenerator.Tool 1.0.2

Dummy Generator

In integration tests, the data objects that need to be provided to the test method are often complex and nested. According to IOSP, we separate data from integration and operation and have the following requirements for our data classes:

• Data contains only data, no methods
• Data objects are immutable
• Data objects are fully initialized after the constructor call

In C#, we now find these requirements implemented as a language feature with the record concept: The primary constructor forces us to set all parameters, which helps us meet our requirements, and we do not deviate from this.

In tests, however, we must always call the constructor, both for incoming parameters and for the expected object, in every test, even if some values do not interest us. When data objects change, all places in tests must be adjusted: production efficiency decreases.

The Dummy Generator provides a remedy by following the principle of dummy factory methods. This allows for the effortless creation of always suitable test objects that do not break when data structures change. The Dummy Generator performs the following:

• There is a (static) class "Dummies".
• In this class, there is a method for each data type, named after the data type for which it should create an object.
• The method contains a default parameter for each property defined by the type (either a meaningful primitive value or null). Only direct properties can be controlled via parameters.
• Parameters that are potentially set to null are initialized in the implementation (using other dummy methods if necessary).

The default values should be plausible for the "happy path" but do not necessarily have to be internally consistent.

using static Dummies;
​
...

[Test]
public void QueryShouldMatchExpected()
{
    var request = Request();

    var actual = ProductionCode.Query(request);
​
    var expected = Response(complexType2: ResponseComplexType2(9422));
​
    actual.Should().BeEquivalentTo(expected);
}
​
...

Usage

Once the tool is installed you can start it using this command:

dummygenerator

1. It will ask for the assembly where your data classes (preferably C# records) are located.
2. The namespace will be extracted using the assembly provided, but can be changed in the next step (leave blank if you are fine with the default).
3. The dummygenerator crawls the assembly and displays all types by namespaces in a tree view
   • If it finds any records, these will be selected by default.
   • Use the arrow keys ⬆️ and ⬇️ to navigate through namespaces and types
   • Use the space bar to change selection
4. Once you are happy with the selection, hit enter
5. The dummygenerator will create a dummy class and display its content in the console
6. Use the arrow keys ⬆️ and ⬇️ to select your next command, if needed. You can also copy the code from the console if your OS allows to do so.
7. Commands are as follows:
   • LoadAssembly
     Starts the process all over
   • SetRecordsAsDefaults
     No matter what your previous selection was, all (and only) C# records are selected
   • ChooseTypes
     Allows to select types of the loaded assembly (and also generates a new dummy class)
   • SetNamespace
     Changes the namespace of the generated dummy class (and also re-generate it)
   • CopyToClipboard
     Copy the dummy class content into the clipboard.
   • SaveToFile
     Will save the dummy class content into a file by the name provided (defaults to assembly directory + Dummies.cs)
   • Exit
     Exits the tool