activerecord 2.0.5 → 2.1.0

data/lib/active_record/fixtures.rb

@@ -1,11 +1,14 @@
 require 'erb'
 require 'yaml'
 require 'csv'
+require 'active_support/test_case'
 
-module YAML #:nodoc:
-  class Omap #:nodoc:
-    def keys;   map { |k, v| k } end
-    def values; map { |k, v| v } end
+if RUBY_VERSION < '1.9'
+  module YAML #:nodoc:
+    class Omap #:nodoc:
+      def keys;   map { |k, v| k } end
+      def values; map { |k, v| v } end
+    end
   end
 end
 
@@ -29,9 +32,9 @@ end
 # in a non-verbose, human-readable format. It ships with Ruby 1.8.1+.
 #
 # Unlike single-file fixtures, YAML fixtures are stored in a single file per model, which are placed in the directory appointed
-# by <tt>Test::Unit::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
-# put your files in <your-rails-app>/test/fixtures/). The fixture file ends with the .yml file extension (Rails example:
-# "<your-rails-app>/test/fixtures/web_sites.yml"). The format of a YAML fixture file looks like this:
+# by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
+# put your files in <tt><your-rails-app>/test/fixtures/</tt>). The fixture file ends with the <tt>.yml</tt> file extension (Rails example:
+# <tt><your-rails-app>/test/fixtures/web_sites.yml</tt>). The format of a YAML fixture file looks like this:
 #
 #   rubyonrails:
 #     id: 1
@@ -64,7 +67,8 @@ end
 # = CSV fixtures
 #
 # Fixtures can also be kept in the Comma Separated Value format. Akin to YAML fixtures, CSV fixtures are stored
-# in a single file, but instead end with the .csv file extension (Rails example: "<your-rails-app>/test/fixtures/web_sites.csv")
+# in a single file, but instead end with the <tt>.csv</tt> file extension
+# (Rails example: <tt><your-rails-app>/test/fixtures/web_sites.csv</tt>).
 #
 # The format of this type of fixture file is much more compact than the others, but also a little harder to read by us
 # humans.  The first line of the CSV file is a comma-separated list of field names.  The rest of the file is then comprised
@@ -89,12 +93,12 @@ end
 #
 # This type of fixture was the original format for Active Record that has since been deprecated in favor of the YAML and CSV formats.
 # Fixtures for this format are created by placing text files in a sub-directory (with the name of the model) to the directory
-# appointed by <tt>Test::Unit::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
-# put your files in <your-rails-app>/test/fixtures/<your-model-name>/ -- like <your-rails-app>/test/fixtures/web_sites/ for the WebSite
-# model).
+# appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
+# put your files in <tt><your-rails-app>/test/fixtures/<your-model-name>/</tt> --
+# like <tt><your-rails-app>/test/fixtures/web_sites/</tt> for the WebSite model).
 #
 # Each text file placed in this directory represents a "record".  Usually these types of fixtures are named without
-# extensions, but if you are on a Windows machine, you might consider adding .txt as the extension.  Here's what the
+# extensions, but if you are on a Windows machine, you might consider adding <tt>.txt</tt> as the extension.  Here's what the
 # above example might look like:
 #
 #   web_sites/google
@@ -115,7 +119,7 @@ end
 #
 #   require 'web_site'
 #
-#   class WebSiteTest < Test::Unit::TestCase
+#   class WebSiteTest < ActiveSupport::TestCase
 #     def test_web_site_count
 #       assert_equal 2, WebSite.count
 #     end
@@ -125,7 +129,7 @@ end
 # easiest way to add fixtures to the database:
 #
 #   ...
-#   class WebSiteTest < Test::Unit::TestCase
+#   class WebSiteTest < ActiveSupport::TestCase
 #     fixtures :web_sites # add more by separating the symbols with commas
 #   ...
 #
@@ -135,20 +139,20 @@ end
 #
 # In addition to being available in the database, the fixtures are also loaded into a hash stored in an instance variable
 # of the test case.  It is named after the symbol... so, in our example, there would be a hash available called
-# @web_sites.  This is where the "fixture name" comes into play.
+# <tt>@web_sites</tt>.  This is where the "fixture name" comes into play.
 #
-# On top of that, each record is automatically "found" (using Model.find(id)) and placed in the instance variable of its name.
-# So for the YAML fixtures, we'd get @rubyonrails and @google, which could be interrogated using regular Active Record semantics:
+# On top of that, each record is automatically "found" (using <tt>Model.find(id)</tt>) and placed in the instance variable of its name.
+# So for the YAML fixtures, we'd get <tt>@rubyonrails</tt> and <tt>@google</tt>, which could be interrogated using regular Active Record semantics:
 #
 #   # test if the object created from the fixture data has the same attributes as the data itself
 #   def test_find
 #     assert_equal @web_sites["rubyonrails"]["name"], @rubyonrails.name
 #   end
 #
-# As seen above, the data hash created from the YAML fixtures would have @web_sites["rubyonrails"]["url"] return
-# "http://www.rubyonrails.org" and @web_sites["google"]["name"] would return "Google". The same fixtures, but loaded
-# from a CSV fixture file, would be accessible via @web_sites["web_site_1"]["name"] == "Ruby on Rails" and have the individual
-# fixtures available as instance variables @web_site_1 and @web_site_2.
+# As seen above, the data hash created from the YAML fixtures would have <tt>@web_sites["rubyonrails"]["url"]</tt> return
+# "http://www.rubyonrails.org" and <tt>@web_sites["google"]["name"]</tt> would return "Google". The same fixtures, but loaded
+# from a CSV fixture file, would be accessible via <tt>@web_sites["web_site_1"]["name"] == "Ruby on Rails"</tt> and have the individual
+# fixtures available as instance variables <tt>@web_site_1</tt> and <tt>@web_site_2</tt>.
 #
 # If you do not wish to use instantiated fixtures (usually for performance reasons) there are two options.
 #
@@ -173,15 +177,15 @@ end
 # Some times you don't care about the content of the fixtures as much as you care about the volume. In these cases, you can
 # mix ERb in with your YAML or CSV fixtures to create a bunch of fixtures for load testing, like:
 #
-# <% for i in 1..1000 %>
-# fix_<%= i %>:
-#   id: <%= i %>
-#   name: guy_<%= 1 %>
-# <% end %>
+#   <% for i in 1..1000 %>
+#   fix_<%= i %>:
+#     id: <%= i %>
+#     name: guy_<%= 1 %>
+#   <% end %>
 #
 # This will create 1000 very simple YAML fixtures.
 #
-# Using ERb, you can also inject dynamic values into your fixtures with inserts like <%= Date.today.strftime("%Y-%m-%d") %>.
+# Using ERb, you can also inject dynamic values into your fixtures with inserts like <tt><%= Date.today.strftime("%Y-%m-%d") %></tt>.
 # 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.
@@ -191,23 +195,23 @@ end
 # 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
+#   class FooTest < ActiveSupport::TestCase
 #     self.use_transactional_fixtures = true
 #     self.use_instantiated_fixtures = false
-#   
+#
 #     fixtures :foos
-#   
+#
 #     def test_godzilla
 #       assert !Foo.find(:all).empty?
 #       Foo.destroy_all
 #       assert Foo.find(:all).empty?
 #     end
-#   
+#
 #     def test_godzilla_aftermath
 #       assert !Foo.find(:all).empty?
 #     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.
 #
@@ -254,7 +258,7 @@ end
 #   reginald: # generated id: 324201669
 #     name: Reginald the Pirate
 #
-# ActiveRecord looks at the fixture's model class, discovers the correct
+# Active Record looks at the fixture's model class, discovers the correct
 # primary key, and generates it right before inserting the fixture
 # into the database.
 #
@@ -264,7 +268,7 @@ end
 # == Label references for associations (belongs_to, has_one, has_many)
 #
 # Specifying foreign keys in fixtures can be very fragile, not to
-# mention difficult to read. Since ActiveRecord can figure out the ID of
+# mention difficult to read. Since Active Record can figure out the ID of
 # any fixture from its label, you can specify FK's by label instead of ID.
 #
 # === belongs_to
@@ -301,15 +305,15 @@ end
 #     name: George the Monkey
 #     pirate: reginald
 #
-# Pow! All is made clear. ActiveRecord reflects on the fixture's model class,
+# Pow! All is made clear. Active Record reflects on the fixture's model class,
 # finds all the +belongs_to+ associations, and allows you to specify
 # a target *label* for the *association* (monkey: george) rather than
-# a target *id* for the *FK* (monkey_id: 1).
+# a target *id* for the *FK* (<tt>monkey_id: 1</tt>).
 #
 # ==== Polymorphic belongs_to
 #
 # Supporting polymorphic relationships is a little bit more complicated, since
-# ActiveRecord needs to know what type your association is pointing at. Something
+# Active Record needs to know what type your association is pointing at. Something
 # like this should look familiar:
 #
 #   ### in fruit.rb
@@ -329,7 +333,7 @@ end
 #   apple:
 #     eater: george (Monkey)
 #
-# Just provide the polymorphic target type and ActiveRecord will take care of the rest.
+# Just provide the polymorphic target type and Active Record will take care of the rest.
 #
 # === has_and_belongs_to_many
 #
@@ -392,15 +396,15 @@ end
 #
 # Zap! No more fruits_monkeys.yml file. We've specified the list of fruits
 # on George's fixture, but we could've just as easily specified a list
-# of monkeys on each fruit. As with +belongs_to+, ActiveRecord reflects on
+# of monkeys on each fruit. As with +belongs_to+, Active Record reflects on
 # the fixture's model class and discovers the +has_and_belongs_to_many+
 # associations.
 #
 # == Autofilled timestamp columns
 #
-# If your table/model specifies any of ActiveRecord's
-# standard timestamp columns (created_at, created_on, updated_at, updated_on),
-# they will automatically be set to Time.now.
+# If your table/model specifies any of Active Record's
+# standard timestamp columns (+created_at+, +created_on+, +updated_at+, +updated_on+),
+# they will automatically be set to <tt>Time.now</tt>.
 #
 # If you've set specific values, they'll be left alone.
 #
@@ -423,7 +427,7 @@ end
 # == Support for YAML defaults
 #
 # You probably already know how to use YAML to set and reuse defaults in
-# your +database.yml+ file,. You can use the same technique in your fixtures:
+# your <tt>database.yml</tt> file. You can use the same technique in your fixtures:
 #
 #   DEFAULTS: &DEFAULTS
 #     created_on: <%= 3.weeks.ago.to_s(:db) %>
@@ -466,8 +470,8 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
     fixtures.size > 1 ? fixtures : fixtures.first
   end
 
-  def self.cache_fixtures(connection, fixtures)
-    cache_for_connection(connection).update(fixtures.index_by { |f| f.table_name })
+  def self.cache_fixtures(connection, fixtures_map)
+    cache_for_connection(connection).update(fixtures_map)
   end
 
   def self.instantiate_fixtures(object, table_name, fixtures, load_instances = true)
@@ -523,7 +527,7 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
             end
           end
 
-          cache_fixtures(connection, fixtures)
+          cache_fixtures(connection, fixtures_map)
         end
       end
     end
@@ -558,7 +562,11 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
     now = now.to_s(:db)
 
     # allow a standard key to be used for doing defaults in YAML
-    delete(assoc("DEFAULTS"))
+    if is_a?(Hash)
+      delete('DEFAULTS')
+    else
+      delete(assoc('DEFAULTS'))
+    end
 
     # track any join tables we need to insert later
     habtm_fixtures = Hash.new do |h, habtm|
@@ -684,14 +692,6 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
         read_yaml_fixture_files
       elsif File.file?(csv_file_path)
         read_csv_fixture_files
-      else
-        # Standard fixtures
-        Dir.entries(@fixture_path).each do |file|
-          path = File.join(@fixture_path, file)
-          if File.file?(path) and file !~ @file_filter
-            self[file] = Fixture.new(path, model_class)
-          end
-        end
       end
     end
 
@@ -712,7 +712,8 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
           end
 
         yaml_value.each do |fixture|
-          fixture.each do |name, data|
+          raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{fixture}" unless fixture.respond_to?(:each)
+	  fixture.each do |name, data|
             unless data
               raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{name} (nil)"
             end
@@ -730,7 +731,7 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
       reader.each do |row|
         data = {}
         row.each_with_index { |cell, j| data[header[j].to_s.strip] = cell.to_s.strip }
-        self["#{Inflector::underscore(@class_name)}_#{i+=1}"] = Fixture.new(data, model_class)
+        self["#{@class_name.to_s.underscore}_#{i+=1}"] = Fixture.new(data, model_class)
       end
     end
 
@@ -769,15 +770,7 @@ class Fixture #:nodoc:
   attr_reader :model_class
 
   def initialize(fixture, model_class)
-    case fixture
-      when Hash, YAML::Omap
-        @fixture = fixture
-      when String
-        @fixture = read_fixture_file(fixture)
-      else
-        raise ArgumentError, "Bad fixture argument #{fixture.inspect} during creation of #{class_name} fixture"
-    end
-
+    @fixture = fixture
     @model_class = model_class.is_a?(Class) ? model_class : model_class.constantize rescue nil
   end
 
@@ -817,30 +810,14 @@ class Fixture #:nodoc:
       raise FixtureClassNotFound, "No class attached to find."
     end
   end
-
-  private
-    def read_fixture_file(fixture_file_path)
-      IO.readlines(fixture_file_path).inject({}) do |fixture, line|
-        # Mercifully skip empty lines.
-        next if line =~ /^\s*$/
-
-        # Use the same regular expression for attributes as Active Record.
-        unless md = /^\s*([a-zA-Z][-_\w]*)\s*=>\s*(.+)\s*$/.match(line)
-          raise FormatError, "#{fixture_file_path}: fixture format error at '#{line}'.  Expecting 'key => value'."
-        end
-        key, value = md.captures
-
-        # Disallow duplicate keys to catch typos.
-        raise FormatError, "#{fixture_file_path}: duplicate '#{key}' in fixture." if fixture[key]
-        fixture[key] = value.strip
-        fixture
-      end
-    end
 end
 
 module Test #:nodoc:
   module Unit #:nodoc:
     class TestCase #:nodoc:
+      setup :setup_fixtures
+      teardown :teardown_fixtures
+
       superclass_delegating_accessor :fixture_path
       superclass_delegating_accessor :fixture_table_names
       superclass_delegating_accessor :fixture_class_names
@@ -856,67 +833,78 @@ module Test #:nodoc:
       @@already_loaded_fixtures = {}
       self.fixture_class_names = {}
 
-      def self.set_fixture_class(class_names = {})
-        self.fixture_class_names = self.fixture_class_names.merge(class_names)
-      end
+      class << self
+        def set_fixture_class(class_names = {})
+          self.fixture_class_names = self.fixture_class_names.merge(class_names)
+        end
 
-      def self.fixtures(*table_names)
-        if table_names.first == :all
-          table_names = Dir["#{fixture_path}/*.yml"] + Dir["#{fixture_path}/*.csv"]
-          table_names.map! { |f| File.basename(f).split('.')[0..-2].join('.') }
-        else
-          table_names = table_names.flatten.map { |n| n.to_s }
+        def fixtures(*table_names)
+          if table_names.first == :all
+            table_names = Dir["#{fixture_path}/*.yml"] + Dir["#{fixture_path}/*.csv"]
+            table_names.map! { |f| File.basename(f).split('.')[0..-2].join('.') }
+          else
+            table_names = table_names.flatten.map { |n| n.to_s }
+          end
+
+          self.fixture_table_names |= table_names
+          require_fixture_classes(table_names)
+          setup_fixture_accessors(table_names)
         end
 
-        self.fixture_table_names |= table_names
-        require_fixture_classes(table_names)
-        setup_fixture_accessors(table_names)
-      end
+        def try_to_load_dependency(file_name)
+          require_dependency file_name
+        rescue LoadError => e
+          # Let's hope the developer has included it himself
 
-      def self.require_fixture_classes(table_names = nil)
-        (table_names || fixture_table_names).each do |table_name|
-          file_name = table_name.to_s
-          file_name = file_name.singularize if ActiveRecord::Base.pluralize_table_names
-          begin
-            require_dependency file_name
-          rescue LoadError
-            # Let's hope the developer has included it himself
+          # Let's warn in case this is a subdependency, otherwise
+          # subdependency error messages are totally cryptic
+          if ActiveRecord::Base.logger
+            ActiveRecord::Base.logger.warn("Unable to load #{file_name}, underlying cause #{e.message} \n\n #{e.backtrace.join("\n")}")
           end
         end
-      end
 
-      def self.setup_fixture_accessors(table_names = nil)
-        (table_names || fixture_table_names).each do |table_name|
-          table_name = table_name.to_s.tr('.', '_')
+        def require_fixture_classes(table_names = nil)
+          (table_names || fixture_table_names).each do |table_name|
+            file_name = table_name.to_s
+            file_name = file_name.singularize if ActiveRecord::Base.pluralize_table_names
+            try_to_load_dependency(file_name)
+          end
+        end
+
+        def setup_fixture_accessors(table_names = nil)
+          table_names = [table_names] if table_names && !table_names.respond_to?(:each)
+          (table_names || fixture_table_names).each do |table_name|
+            table_name = table_name.to_s.tr('.', '_')
 
-          define_method(table_name) do |*fixtures|
-            force_reload = fixtures.pop if fixtures.last == true || fixtures.last == :reload
+            define_method(table_name) do |*fixtures|
+              force_reload = fixtures.pop if fixtures.last == true || fixtures.last == :reload
 
-            @fixture_cache[table_name] ||= {}
+              @fixture_cache[table_name] ||= {}
 
-            instances = fixtures.map do |fixture|
-              @fixture_cache[table_name].delete(fixture) if force_reload
+              instances = fixtures.map do |fixture|
+                @fixture_cache[table_name].delete(fixture) if force_reload
 
-              if @loaded_fixtures[table_name][fixture.to_s]
-                @fixture_cache[table_name][fixture] ||= @loaded_fixtures[table_name][fixture.to_s].find
-              else
-                raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+                if @loaded_fixtures[table_name][fixture.to_s]
+                  @fixture_cache[table_name][fixture] ||= @loaded_fixtures[table_name][fixture.to_s].find
+                else
+                  raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+                end
               end
-            end
 
-            instances.size == 1 ? instances.first : instances
+              instances.size == 1 ? instances.first : instances
+            end
           end
         end
-      end
 
-      def self.uses_transaction(*methods)
-        @uses_transaction = [] unless defined?(@uses_transaction)
-        @uses_transaction.concat methods.map(&:to_s)
-      end
+        def uses_transaction(*methods)
+          @uses_transaction = [] unless defined?(@uses_transaction)
+          @uses_transaction.concat methods.map(&:to_s)
+        end
 
-      def self.uses_transaction?(method)
-        @uses_transaction = [] unless defined?(@uses_transaction)
-        @uses_transaction.include?(method.to_s)
+        def uses_transaction?(method)
+          @uses_transaction = [] unless defined?(@uses_transaction)
+          @uses_transaction.include?(method.to_s)
+        end
       end
 
       def use_transactional_fixtures?
@@ -924,8 +912,8 @@ module Test #:nodoc:
           !self.class.uses_transaction?(method_name)
       end
 
-      def setup_with_fixtures
-        return unless defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
+      def setup_fixtures
+        return unless defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
 
         if pre_loaded_fixtures && !use_transactional_fixtures
           raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures'
@@ -953,10 +941,9 @@ module Test #:nodoc:
         # Instantiate fixtures for every test if requested.
         instantiate_fixtures if use_instantiated_fixtures
       end
-      alias_method :setup, :setup_with_fixtures
 
-      def teardown_with_fixtures
-        return unless defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
+      def teardown_fixtures
+        return unless defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
 
         unless use_transactional_fixtures?
           Fixtures.reset_cache
@@ -969,28 +956,6 @@ module Test #:nodoc:
         end
         ActiveRecord::Base.verify_active_connections!
       end
-      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 load_fixtures