@@ -138,16 +138,46 @@
# This is however a feature to be used with some caution. The point of fixtures are that they're stable units of predictable
# sample data. If you feel that you need to inject dynamic values, then perhaps you should reexamine whether your application
# is properly testable. Hence, dynamic values in fixtures are to be considered a code smell.
#
# = Transactional fixtures
#
# TestCases can use begin+rollback to isolate their changes to the database instead of having to delete+insert for every test case.
# They can also turn off auto-instantiation of fixture data since the feature is costly and often unused.
#
# class FooTest < Test::Unit::TestCase
# self.use_transactional_fixtures = true
# self.use_instantiated_fixtures = false
#
# fixtures :foos
#
# def test_godzilla
# assert !Foo.find_all.emtpy?
# Foo.destroy_all
# assert Foo.find_all.emtpy?
# end
#
# def test_godzilla_aftermath
# assert !Foo.find_all.emtpy?
# end
# end
#
# If you preload your test database with all fixture data (probably in the Rakefile task) and use transactional fixtures,
# then you may omit all fixtures declarations in your test cases since all the data's already there and every case rolls back its changes.
#
# When *not* to use transactional fixtures:
# 1. You're testing whether a transaction works correctly. Nested transactions don't commit until all parent transactions commit,
# particularly, the fixtures transaction which is begun in setup and rolled back in teardown. Thus, you won't be able to verify
# the results of your transaction until Active Record supports nested transactions or savepoints (in progress.)
# 2. Your database does not support transactions. Every Active Record database supports transactions except MySQL MyISAM.
# Use InnoDB, MaxDB, or NDB instead.
class Fixtures < Hash
DEFAULT_FILTER_RE = /\. ya?ml$/
def self.instantiate_fixtures (object , fixtures_directory , * table_names )
[ create_fixtures(fixtures_directory, * table_names) ].flatten.each_with_index do |fixtures , idx |
object.instance_variable_set " @#{ table_names[idx] } "
fixtures.each do |name , fixture |
if model = fixture.find
object.instance_variable_set " @#{ name } "
end
def self.instantiate_fixtures (object , table_name , fixtures )
object.instance_variable_set " @#{ table_name } "
fixtures.each do |name , fixture |
if model = fixture.find
object.instance_variable_set " @#{ name } "
end
end
end
@@ -322,51 +352,100 @@ def read_fixture_file(fixture_file_path)
end
end
module Test # :nodoc:
module Unit # :nodoc:
module Test # :nodoc:
module Unit # :nodoc:
class TestCase # :nodoc:
include ClassInheritableAttributes
cattr_accessor :fixture_path
cattr_accessor :fixture_table_names
class_inheritable_accessor :fixture_table_names
class_inheritable_accessor :use_transactional_fixtures
class_inheritable_accessor :use_instantiated_fixtures
self .fixture_table_names = []
self .use_transactional_fixtures = false
self .use_instantiated_fixtures = true
def self.fixtures (* table_names )
require_fixture_classes( table_names)
write_inheritable_attribute( " fixture_table_names " , table_names)
self .fixture_table_names = table_names.flatten
require_fixture_classes
end
def self.require_fixture_classes ( table_names )
table_names .each do |table_name |
def self.require_fixture_classes
fixture_table_names .each do |table_name |
begin
require ( Inflector .singularize(table_name.to_s) )
require Inflector .singularize(table_name.to_s)
rescue LoadError
# Let's hope the developer is included it himself
# Let's hope the developer has included it himself
end
end
end
def setup
instantiate_fixtures(* fixture_table_names) if fixture_table_names
def setup_with_fixtures
# Load fixtures once and begin transaction.
if use_transactional_fixtures
load_fixtures unless @already_loaded_fixtures
@already_loaded_fixtures = true
ActiveRecord ::Base .lock_mutex
ActiveRecord ::Base .connection.begin_db_transaction
# Load fixtures for every test.
else
load_fixtures
end
# Instantiate fixtures for every test if requested.
instantiate_fixtures if use_instantiated_fixtures
end
alias_method :setup , :setup_with_fixtures
def teardown_with_fixtures
# Rollback changes.
if use_transactional_fixtures
ActiveRecord ::Base .connection.rollback_db_transaction
ActiveRecord ::Base .unlock_mutex
end
end
def self.method_added (method_symbol )
if method_symbol == :setup && ! method_defined?(:setup_without_fixtures )
alias_method :setup_without_fixtures , :setup
define_method(:setup ) do
instantiate_fixtures(* fixture_table_names) if fixture_table_names
setup_without_fixtures
alias_method :teardown , :teardown_with_fixtures
def self.method_added (method )
case method.to_s
when ' setup'
unless method_defined?(:setup_without_fixtures )
alias_method :setup_without_fixtures , :setup
define_method(:setup ) do
setup_with_fixtures
setup_without_fixtures
end
end
when ' teardown'
unless method_defined?(:teardown_without_fixtures )
alias_method :teardown_without_fixtures , :teardown
define_method(:teardown ) do
teardown_without_fixtures
teardown_with_fixtures
end
end
end
end
private
def instantiate_fixtures (* table_names )
Fixtures .instantiate_fixtures(self , fixture_path, * table_names)
def load_fixtures
@loaded_fixtures = {}
fixture_table_names.each do |table_name |
@loaded_fixtures [table_name] = Fixtures .create_fixtures(fixture_path, table_name)
end
end
def fixture_table_names
self .class.read_inheritable_attribute(" fixture_table_names"
def instantiate_fixtures
raise RuntimeError , ' Load fixtures before instantiating them.' if @loaded_fixtures .nil?
@loaded_fixtures .each do |table_name , fixtures |
Fixtures .instantiate_fixtures(self , table_name, fixtures)
end
end
end
end
end
0 comments on commit
903ef71