Testing and Examples

Relevant source files

• .claude/CLAUDE.md
• test/solid/process/dependencies/result_test.rb
• test/solid/process/result_test.rb

Purpose and Scope

This page provides an overview of testing strategies and example processes in the Solid::Process framework. It covers how the test suite is organized, the philosophy behind testing processes, and introduces the example processes used throughout the codebase as both tests and documentation.

For detailed testing patterns and best practices, see Testing Patterns and Best Practices. For in-depth walkthroughs of specific example processes, see Example Processes.

---

Testing Philosophy

Solid::Process adopts a test-first approach where processes return explicit Success or Failure results rather than raising exceptions. This design makes testing straightforward: invoke the process and assert on the result type, data, and predicates.

The framework's testing strategy emphasizes:

1. Result-based assertions - Test both success and failure paths by checking result types
2. Dependency injection for testability - Use .new(deps) to inject test doubles
3. Input validation as a gate - Test that invalid inputs return :invalid_input failures
4. Multi-version compatibility - Ensure processes work across Ruby 2.7-4.0 and Rails 6.0-8.1+

Testing vs Production Invocation

Pattern	Use Case	Example
.call(data)	Production usage, default dependencies	UserCreation.call(name: "John")
.new().call(data)	Explicit instantiation, default dependencies	UserCreation.new.call(name: "John")
.new(deps).call(data)	Testing with injected dependencies	UserCreation.new(repository: mock).call(name: "John")

Sources: test/solid/process/result_test.rb10-15 test/solid/process/dependencies/result_test.rb10-15

---

Test Suite Organization

The test suite follows a structured organization that separates framework tests from example process tests.

Directory Structure

Key Locations:

• test/solid/ - Framework component tests (Model, Input, Value, Process)
• test/solid/process/ - Process execution and result tests
• test/support/ - Shared fixtures including example processes

Test Support Files

Support files use numbered prefixes (e.g., 010_, 050_) to control load order. Lower numbers load first, ensuring dependencies are available.

File Pattern	Purpose
010_*.rb	Database models and schema setup
050_*.rb	Example processes without dependencies
051_*.rb	Example processes with dependencies or composition
052_*.rb	Complex multi-step example processes

Sources: .claude/CLAUDE.md84-86

---

Running Tests

Basic Test Commands

Multi-Version Testing

The framework tests across 8 Rails versions (6.0-8.1+edge) and 8 Ruby versions (2.7-4.0+head):

Rails Version	Ruby Versions	Command
6.0	2.7, 3.0	bundle exec appraisal rails-6-0 rake test
6.1	2.7, 3.0	bundle exec appraisal rails-6-1 rake test
7.0	3.0, 3.1, 3.2, 3.3	bundle exec appraisal rails-7-0 rake test
7.1	3.0, 3.1, 3.2, 3.3	bundle exec appraisal rails-7-1 rake test
7.2	3.1, 3.2, 3.3, 3.4	bundle exec appraisal rails-7-2 rake test
8.0	3.2, 3.3, 3.4	bundle exec appraisal rails-8-0 rake test
8.1	3.3, 3.4, 4.x	bundle exec appraisal rails-8-1 rake test
edge	head	bundle exec appraisal rails-edge rake test

For detailed information on the multi-version testing strategy, see Multi-Version Testing Strategy.

Sources: .claude/CLAUDE.md14-34 .claude/CLAUDE.md94-103

---

Common Testing Patterns

Testing Process Results

The most fundamental testing pattern asserts on result types and their data:

Testing Success Results

Testing Failure Results

Sources: test/solid/process/result_test.rb21-46 test/solid/process/result_test.rb48-70

Testing with Dependency Injection

Processes that declare dependencies using the deps DSL can have those dependencies injected for testing:

For comprehensive coverage of testing patterns including mocking, stubbing, and input testing, see Testing Patterns and Best Practices.

Sources: test/solid/process/dependencies/result_test.rb21-40 test/solid/process/dependencies/result_test.rb42-69

Input Flexibility in Tests

Tests can verify that processes accept both raw hash data and pre-instantiated Input objects:

This pattern ensures processes handle both invocation styles correctly.

Sources: test/solid/process/result_test.rb17-19

---

Example Processes

The codebase includes several example processes that demonstrate framework features and serve as both tests and documentation.

Example Process Architecture

Key Example Processes

Process	File	Demonstrates
UserCreationWithoutDeps	test/support/050_*	Basic process with input validation, no dependencies
UserCreationWithDeps	test/support/050_*	Dependency injection with repository pattern
User::Token::Creation	test/support/051_*	Namespaced process, token generation
Account::OwnerCreation	test/support/052_*	Process composition using Steps DSL

Example Testing Flow

Sources: test/solid/process/result_test.rb21-46 test/solid/process/result_test.rb48-70

UserCreationWithoutDeps

This process demonstrates the simplest pattern: input validation and database persistence without external dependencies.

Features Demonstrated:

• Input schema definition with type casting and validation
• Normalization (whitespace stripping, email downcasing)
• Direct ActiveRecord interaction
• Multiple result types (:user_created, :invalid_input, :email_already_taken)

Test Coverage:

• Success path with database assertion
• Input validation failures
• Business rule failures (email uniqueness)
• Input normalization behavior

Sources: test/solid/process/result_test.rb1-101

UserCreationWithDeps

This process demonstrates dependency injection for improved testability.

Features Demonstrated:

• deps DSL for declaring dependencies
• Repository pattern (injecting User model)
• Dependency validation
• Testing with mock/stub dependencies

Test Coverage:

• Invalid dependencies return :invalid_dependencies failure
• Valid injected dependencies work correctly
• Can inject Dependencies instance or individual attributes

Sources: test/solid/process/dependencies/result_test.rb1-111

User::Token::Creation

This namespaced process demonstrates token generation patterns.

Features Demonstrated:

• Nested module organization
• Token generation logic
• Association with parent model (User)

See Example Processes for detailed walkthrough.

Sources: .claude/CLAUDE.md86

Account::OwnerCreation

This complex process demonstrates composition using the Steps DSL.

Features Demonstrated:

• Process composition (calling other processes)
• Steps DSL (Given, and_then, Continue, and_expose)
• Coordinating multiple sub-processes
• Railway-oriented error handling

See Example Processes for detailed walkthrough.

Sources: .claude/CLAUDE.md86

---

Testing Strategies Summary

The testing approach in Solid::Process emphasizes:

1. Explicit result handling - All tests assert on Success or Failure results
2. Multi-path coverage - Test success, validation failures, and business rule failures
3. Dependency injection - Use .new(deps) to inject test doubles for isolation
4. Input validation - Verify both valid and invalid input scenarios
5. Multi-version compatibility - Ensure tests pass across Ruby and Rails versions

For hands-on testing guidance, see Testing Patterns and Best Practices. For detailed process examples, see Example Processes.

Sources: test/solid/process/result_test.rb1-101 test/solid/process/dependencies/result_test.rb1-111 .claude/CLAUDE.md1-118