SeedFactory - a toolkit for test data generation

This is great. I’ve tried a bunch of factory approaches, but this one feels quite well executed and seems to cover the needs I generally have quite well. I also really like that it makes it impossible to insert data in a way the codebase wouldn’t.

That seems like super reasonable approach to factories. I already like that, however it feels a little bit macro heavy.

Actually, command resolver can use whatever code you need. So, you can use something that differs from the actual implementation, like a simplified version of it. But the fact that it is placed in a single centralized place makes it very maintainable.

When I read your comment for the first time, I was surprised why do you think so, as there is only 1 macro – produce/1. Completely forgot that DSL for schema definition is built on macros That’s because the heavy lifting is done by spark (@zachdaniel thank you for the library, support and quick bug fixing!)

I tried to describe the schema using simple structures in my initial implementation. But eventually, current implementation won.

SeedFactory v0.6.0 has been released

SeedFactory v0.7.0 Released

A big release with many internal changes

Same trait from multiple commands

The same trait can now be defined with different commands. This enables schemas that mirror real business logic where the same state can be reached through different paths:

command :create_user do
  # ... creates user with status: :pending
  produce :user
end

command :activate_user do
  param :user, entity: :user, with_traits: [:pending]
  # ... updates user to status: :active
  update :user
end

command :create_active_user do
  # ... creates user with status: :active directly
  produce :user
end

# :active can be reached via transition...
trait :active, :user do
  from :pending
  exec :activate_user
end

# ...or directly
trait :active, :user do
  exec :create_active_user
end

# Unique marker for the direct path
trait :pending_skipped, :user do
  exec :create_active_user
end

Usage:

# SeedFactory picks the first declared command by default
produce(ctx, user: [:active])

# Force a specific path using a trait unique to that command
produce(ctx, user: [:active, :pending_skipped])

When multiple commands can produce the same trait, SeedFactory automatically picks one based on which commands can satisfy their dependencies without duplicating existing entities.

Compile-time validations

Schemas are now validated more thoroughly at compile time with helpful “did you mean?” suggestions in error messages.

Documentation

README now includes an “Advanced features” section covering pre_exec/pre_produce, args_match/generate_args, and trail tracking.

SeedFactory v0.8.0 Released!

This release is focused on developer experience: better error reporting, improved documentation, and fewer dependencies.

Structured error reporting

When a command fails, you now get SeedFactory.ExecError with a visual execution plan showing what succeeded, what failed, and what was still pending:

** (SeedFactory.ExecError) unable to execute :create_user command: :email_already_taken

Execution plan:
  ✔ :create_company
  ✔ :create_office
  ✖ :create_user
  · :activate_user
  · :create_profile

Current traits:
  %{company: [], office: [:main]}

Execution history

Every produce/exec call is now recorded in meta, providing a full audit trail of how a context was built. Combined with a compact inspect format, it’s easy to see what happened:

#execution[produce(user: [:admin, :active]): create_company → create_user → activate_user]
#execution[produce(order: [:pending]): create_order]

Performance

Replaced libgraph dependency with an inline topological sort, optimized compile-time trait indexing, and fixed quadratic list accumulation — fewer dependencies and faster compilation.

SeedFactory v0.9.0 Released!

This release has a new dependency planner. It searches for a complete plan and backtracks when a choice doesn’t work out, including deciding the order in which commands run.

I also added test generators that exercise thousands of schemas and command sequences, plus tests that compare the planner’s results with all possible execution orders on small schemas. This helped cover a lot more combinations and fix quite a few bugs along the way.

Never got to tell you: I love the declarative approach of that library and would love to try it when I get the time. Every time I checked it (as you announce versions), I liked it.

Thanks, glad you like it! I like this approach too

I’m currently migrating some old tests from ex_machina to seed_factory before refactoring, and Claude reports that the tests end up with 20–25% fewer lines of code on average. But, of course, new tests aren’t byte-to-byte identical to the old ones, they’re improved a bit