progala2/buildenator

A test data builders source generator for .net 5 and later.

Buildenator

A test data builders source generator for .net 5 and later.

A simple usage example

The following code:

using Buildenator.Abstraction;
using Buildenator.Abstraction.AutoFixture;
using SampleProject;

namespace SampleTestProject.Builders
{
    [MakeBuilder(typeof(DomainEntity))]
    [AutoFixtureConfiguration()]
    public partial class DomainEntityBuilder
    {
    }
}

Will generate something very close to this source code:

using System;
using System.Linq;
using Buildenator.Abstraction.Helpers;
using SampleProject;
using AutoFixture;


namespace SampleTestProject.Builders
{
    public partial class DomainEntityBuilder
    {
        private readonly Fixture _fixture = new Fixture();

        public DomainEntityBuilder()
        {

        }

        private Nullbox<int>? _propertyIntGetter;
        private Nullbox<string>? _propertyStringGetter;


        public DomainEntityBuilder WithPropertyIntGetter(int value)
        {
            _propertyIntGetter = new Nullbox<int>(value);
            return this;
        }


        public DomainEntityBuilder WithPropertyStringGetter(string value)
        {
            _propertyStringGetter = new Nullbox<string>(value);
            return this;
        }

        public DomainEntity Build()
        {
            return new DomainEntity((_propertyIntGetter.HasValue ? _propertyIntGetter.Value : new Nullbox<int>(_fixture.Create<int>())).Object, (_propertyStringGetter.HasValue ? _propertyStringGetter.Value : new Nullbox<string>(_fixture.Create<string>())).Object)
            {

            };
        }

        public static DomainEntityBuilder DomainEntity => new DomainEntityBuilder();

        public System.Collections.Generic.IEnumerable<DomainEntity> BuildMany(int count = 3)
        {
            return Enumerable.Range(0, count).Select(_ => Build());
        }

        public static DomainEntity BuildDefault(int _propertyIntGetter = default(int), string _propertyStringGetter = default(string))
        {
            return new DomainEntity(_propertyIntGetter, _propertyStringGetter)
            {

            };
        }

    }
}

Check Buildenator.IntegrationTests for more examples.

Feel free to contribute!

buildenator's Issues

Global configuration attribute

Give possibility to configure builders generation for all the builders in a project

Create by one method with default parameters

object Rule(paramType param = null, ...)
{
new object(param, ...);
}

Generating the "With" methods basing on settable properties

Generating the "With" methods basing on settable properties.

Regression:
Detecting any constructor parameters that are settable, to not generate duplicate "With" methods.

Handling generic classes

If class inherits some other class, construct builder(s) the same way?

Mimic virtual fields etc.
[TODO]

Make all-fields-default method

Create a static method that will allow to quickly build an object by this method parameters.

Migrate to sdk 6

Sophisticated domain subentities creation methods

The golden sample

the source generator should have possibility to generate as follows:
Source:

public class Aggregate
{
     public Entity Entity  { get; set; }
     public IEnumerable<Entity> Entities  { get; set; }
}

public class Entity
{
    /*    */
}

[MakeBuilder(typeof(Aggregate), <NewOption?>)]
[<NewAttribute?>]
public partial class AggregateBuilder
{
}

Output:

public partial class AggregateBuilder
{
     private Entity _entity;
     public AggregateBuilder WithEntity(Func<EntityBuilder, EntityBuilder> configureEntity)
     {
            _entity = configureEntity(new EntityBuilder());
            return this;
     }
     private IEnumerable<Entity> _entities;
     public AggregateBuilder WithEntities(params Func<EntityBuilder, EntityBuilder>[] configureEntities)
     {
            _entities = configureEntities.Select(x => x(new EntityBuilder()));
            return this;
     }
}

Detecting entities to generate methods

Namespace rule

To prevent generating wrongly builders for build-in types, or types from external libraries, the buildenator will detect subentities by the same root namespace of the parent entity.

e.x.
this is correct:

NameSpaceRoot.Aggregate
NameSpaceRoot.SubNamespace.Entity

this is not correct:

NameSpaceRoot.Aggregate
SubNamespace.Entity

Filtering out value types

By default if the subentity has only one not sophisticated property/contr. parameter, it will be treated as a value type, so default methods will be created.

Configurability

• UseSubentityBuilders[True/False]: whether using subentity builders [False by default]
  • Should have possibility to set up a global config

Detecting List/Array/Enumerables types

For better usage of fixtures (e.g. using CreateMany instead of Create)

Better nullable detecting

To get rid of any warnings that could be produced.

Possibility to Mock interfaces

Consider it as a breaking change, as interfaces should be mocked by default in my opinion.

Add a partial method to generated builder class for post build steps

It would be great if the generated builder class included something like the following:

partial void PostBuild(<<type>> buildResult);

the developer could then implement this method to do additional work to the result before it is returned. The Build method would need to call this before it returns a result.

Improve Readme file and first good use

Add possibility to select a strategy about how to deal with multiple constructors

Issue:
When a class has more than one constructor, which one should be chosen to construct the object?

Solution:

• Constructor selection strategies
• By default, constructor with the longest numbers of parameters will be taken.

Ability to include name of property for autofixture generation

I'm trying to integrate Buildenator + AutoBogus into a project, and I've hit an issue.

Currently when generating the properties I can only see the type of the property by overriding the additionalConfiguration string and using {0} for the type.

It would be useful if the name of the property was also included in this template (with {1} for example) so as to provide extra customisation depending on the property name.

Thanks

Introduce strict mode for nullable reference types

If the nullable context is enabled and null is passed to a notnullable parameter throw an exception.

Add diagnostics to better inform user about wrong usage.

GeneratorExecutionContext .ReportDiagnostic

Generated files should be marked as auto-generated to avoid Code Analysis errors

I just added a builder to my test project and ended up with hundreds of code analysis errors.

The generated code should include a header to say that it's generated. Here's an example:

// ------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a source generator named Vogen (https://github.com/SteveDunn/Vogen)
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------

Duplicate usings can appear in generated code.

Fix it.

Refactor fixture configuration to decouple from autofixture

Make it in the same fashion as the mocking configuration

Add possibility to select a strategy for random data generation.

As the title says.

Additionally it would be good to add possibility to opt-out of default random data initialization, so all the properties would have default values instead.

Remove default constructor from builder

It would be great to remove the default constructor from the generated builder so that the partial class can define one of its own so that it could initialize any of the fields that are generated.

Generating subentites builders

The golden sample

the source generator should have possibility to generate as follows:
Source:

public class Aggregate
{
     public Entity Entity  { get; set; }
}

public class Entity
{
    /*    */
}


[MakeBuilder(typeof(Aggregate), <NewOption?>)]
[<NewAttribute?>]
public partial class AggregateBuilder
{
}

Output:

public partial class AggregateBuilder
{
     /*    */
}

public partial class EntityBuilder
{
    /*   */
}

Detecting entities to generate builders

Namespace rule

To prevent generating wrongly builders for build-in types, or types from external libraries, the buildenator will detect subentities by the same root namespace of the parent entity.

e.x.
this is correct:

NameSpaceRoot.Aggregate
NameSpaceRoot.SubNamespace.Entity

this is not correct:

NameSpaceRoot.Aggregate
SubNamespace.Entity

Filtering out value types

By default if the subentity has only one not sophisticated property/contr. parameter, it will be treated as a value type, so no additional builders will be created.

Configurability

• GenereteSubentitiesBuilders[True/False]: whether generating subentities builders [False by default]
  • Should have possibility to set up a global config

Known problems and challenges

• How to easilly detect whether the entity is simple or not?
• Secondly, what about reference loop, i.e. one entity having the second one and vice versa?
  • It should be one directional, and it means it'd require to remember what are parent entities and pass them to children.
• A user should have a possibility to override the subentities builder in a partial class. Probably it'd require an additional marker

For the future

• A thing to improve in the next iterations - loosen namespace rules, i.e. detect by the number of identifiers taken into the account.
  For example, if the AR has its namespace A.B.C.D, and we set up the number of identifiers to 2, then the generator will generate builders for each entity that has its namespace in the A.B scope.

Ability to set not accessible properties by the reflection

As the title says.
Sometimes some properties are set only by some methods of the object. For some scenarios it would be useful to set it manually instead of calling some logic around.

Acceptance Criteria:

• Disabled by default
• Two modes if the "with" method is not used
  • Default: do nothing on creation
  • generate some value from the given fixture

Fix nuget packaging