AutoBogus

Configuration in AutoBogus is hierarchical. Settings cascade from most general to most specific. If a setting is not defined at a lower level, the library falls back to the level above:

1. Global: Scoped as the default configuration across all generate requests (AutoFaker.Configure).
2. Faker: Scoped to all requests made by a specific AutoFaker instance (AutoFaker.Create).
3. Generate: Scoped to a single specific generate request (faker.Generate<T>()).

The AutoFaker class provides non-generic methods to generate type instances. You can use it statically for quick generation or create an instance for reusable configuration.

Static Usage: Best for one-off generation without custom configuration.

Instance Usage: Best when you want to reuse a specific configuration across multiple calls.

AutoFaker.Generate<int>();
AutoFaker.Generate<Person>();

// Instance usage
var faker = AutoFaker.Create();
faker.Generate<int>();
faker.Generate<Person>();

The AutoBogus.Conventions package allows you to generate values based on property names and types. For example, a string property named Email will automatically use Faker.Internet.Email().

To use conventions, call .WithConventions() in your configuration. You can further customize individual generators within the convention configuration.

AutoFaker.Configure(builder =>
{
  builder.WithConventions(config =>
  {
    config.FirstName.Enabled = false;      // Disable a specific generator
    config.LastName.AlwaysGenerate = true; // Force generation
    config.Email.Aliases("AnotherEmail");  // Map specific names to a generator
  });
});

AutoBogus is available via NuGet. Depending on your needs, you can install the core library or specialized packages for mocking frameworks:

• AutoBogus: Core auto-generation capabilities.
• AutoBogus.Conventions: Adds name-based and type-based generation rules (e.g., properties named Email automatically use Bogus email generators).
• AutoBogus.FakeItEasy: Binder for FakeItEasy to handle interfaces and abstract classes.
• AutoBogus.Moq: Binder for Moq to handle interfaces and abstract classes.
• AutoBogus.NSubstitute: Binder for NSubstitute to handle interfaces and abstract classes.

dotnet add package AutoBogus

AutoBogus can automatically generate DataTable objects populated with fake data. It supports two modes of generation:

1. Untyped DataTables: If you request a standard System.Data.DataTable, the generator creates a table with a random number of columns (between 3 and 10) using randomized system types.
2. Typed DataTables: If you use a custom class inheriting from TypedTableBase<T>, AutoBogus identifies the specific row type (T) and generates a populated instance of that typed table.

When generating rows, AutoBogus respects ForeignKeyConstraint relationships. It attempts to pick valid related rows from the referenced tables to maintain referential integrity. If a foreign key involves unique columns, AutoBogus will ensure it selects distinct rows to avoid constraint violations.

The AutoBogus.Templating package provides the GenerateWithTemplate() extension method. This allows you to define complex data sets using a text-based notation (similar to a CSV or table format) which is then parsed into objects.

{
  public int Id { get; set; }
  public string FirstName { get; set; }
  public string LastName { get; set; }
  public string Status { get; set; }
}

var persons = new AutoFaker<Person>().GenerateWithTemplate(@"
  Id | FirstName | LastName
  0  | John      | Smith
  1  | Jane      | Jones
  2  | Bob       | Clark
");

You can control how many rows are generated for a DataTable using the DataTableRowCount configuration option.

• If DataTableRowCount is provided in your configuration, AutoBogus will use that value.
• If it is not specified, AutoBogus defaults to a random number of rows between 1 and 20.
• Note on Constraints: If a table has a foreign key constraint on a unique column, and the related table does not have enough rows to satisfy your requested DataTableRowCount, AutoBogus will throw an ArgumentException to prevent invalid data generation.