Module: Synthra::RailsTestHelper

Defined in:
lib/synthra/rails_test_helper.rb

Overview

Rails Test Helper Integration

Provides seamless integration with Rails tests, allowing you to generate test data directly from ActiveRecord models or Synthra schemas.

Examples:

Setup in test_helper.rb

require 'synthra/rails_test_helper'
Synthra.configure_test_helper!

class ActiveSupport::TestCase
  include Synthra::RailsTestHelper
end

Usage in tests

class UserTest < ActiveSupport::TestCase
  test "validates email format" do
    user = generate_for_test(User)
    assert user.valid?
  end
end

Instance Method Summary collapse

Instance Method Details

#create_for_test(model, mode = :valid, **overrides) ⇒ Object

Generate and persist test data

Examples:

Create user in database

user = create_for_test(User)
assert user.persisted?

Parameters:

  • model (Class) —

    ActiveRecord model class

  • mode (Symbol) (defaults to: :valid) —

    generation mode

  • overrides (Hash) —

    field overrides

Returns:

  • (Object) —

    persisted model instance



67
68
69
70
71
 
# File 'lib/synthra/rails_test_helper.rb', line 67

def create_for_test(model, mode = :valid, **overrides)
  record = generate_for_test(model, mode, **overrides)
  record.save! if record.respond_to?(:save!)
  record
end

#create_many_for_test(model, count, mode = :valid, **overrides) ⇒ Array

Generate and persist multiple test records

Parameters:

  • model (Class) —

    ActiveRecord model

  • count (Integer) —

    number of records

  • mode (Symbol) (defaults to: :valid) —

    generation mode

  • overrides (Hash) —

    field overrides

Returns:

  • (Array) —

    array of persisted records



96
97
98
 
# File 'lib/synthra/rails_test_helper.rb', line 96

def create_many_for_test(model, count, mode = :valid, **overrides)
  count.times.map { create_for_test(model, mode, **overrides) }
end

#filter_attributes(model, data) ⇒ Object (private) 



119
120
121
122
123
124
 
# File 'lib/synthra/rails_test_helper.rb', line 119

def filter_attributes(model, data)
  return data unless defined?(ActiveRecord) && model < ActiveRecord::Base
  
  allowed = model.column_names
  data.select { |k, _| allowed.include?(k.to_s) }
end

#generate_for_test(model_or_schema, mode = :valid, **overrides) ⇒ Object

Generate test data for a model or schema

Examples:

Generate valid user

user = generate_for_test(User)

Generate with mode

user = generate_for_test(User, :invalid)

With overrides

user = generate_for_test(User, :valid, email: "test@example.com")

Parameters:

  • model_or_schema (Class, String, Schema) —

    ActiveRecord model, schema name, or Schema

  • mode (Symbol) (defaults to: :valid) —

    generation mode (:valid, :invalid, :edge, :random)

  • traits (Array<Symbol>) —

    traits to apply

  • overrides (Hash) —

    field overrides

Returns:

  • (Object) —

    generated model instance or hash



43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/synthra/rails_test_helper.rb', line 43

def generate_for_test(model_or_schema, mode = :valid, **overrides)
  schema = resolve_schema(model_or_schema)
  generation_mode = mode == :valid ? :random : mode
  
  data = schema.generate(mode: generation_mode, overrides: overrides)
  
  if model_or_schema.is_a?(Class) && defined?(ActiveRecord) && model_or_schema < ActiveRecord::Base
    model_or_schema.new(filter_attributes(model_or_schema, data))
  else
    data
  end
end

#generate_many_for_test(model_or_schema, count, mode = :valid, **overrides) ⇒ Array

Generate multiple test records

Examples:

Generate 10 users

users = generate_many_for_test(User, 10)

Parameters:

  • model_or_schema (Class, String, Schema) —

    model or schema

  • count (Integer) —

    number of records

  • mode (Symbol) (defaults to: :valid) —

    generation mode

  • overrides (Hash) —

    field overrides

Returns:

  • (Array) —

    array of generated records



84
85
86
 
# File 'lib/synthra/rails_test_helper.rb', line 84

def generate_many_for_test(model_or_schema, count, mode = :valid, **overrides)
  count.times.map { generate_for_test(model_or_schema, mode, **overrides) }
end

#resolve_schema(model_or_schema) ⇒ Object (private) 



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/synthra/rails_test_helper.rb', line 102

def resolve_schema(model_or_schema)
  case model_or_schema
  when Synthra::Schema
    model_or_schema
  when String, Symbol
    Synthra.parse(Synthra::SchemaInference.infer_dsl(model_or_schema.to_s))
  when Class
    if defined?(ActiveRecord) && model_or_schema < ActiveRecord::Base
      Synthra.parse(Synthra::SchemaInference.from_active_record(model_or_schema))
    else
      Synthra.parse(Synthra::SchemaInference.infer_dsl(model_or_schema.name))
    end
  else
    raise ArgumentError, "Unknown model/schema type: #{model_or_schema.class}"
  end
end