Ticket #9981: foxy_fixtures.diff

activerecord/test/fixtures_test.rb

@@ -7 +7 @@
-require 'fixtures/joke'
-require 'fixtures/course'
-require 'fixtures/category'
+require 'fixtures/parrot'
+require 'fixtures/pirate'
+require 'fixtures/treasure'
-
-class FixturesTest < Test::Unit::TestCase
-  self.use_instantiated_fixtures = true
@@ -446 +449 @@
-    assert_equal 'Welcome to the weblog', posts(:welcome).title
-  end
-end
+
+class FoxyFixturesTest < Test::Unit::TestCase
+  fixtures :parrots, :parrots_pirates, :pirates, :treasures
+    
+  def test_identifies_strings
+    assert_equal(Fixtures.identify("foo"), Fixtures.identify("foo"))
+    assert_not_equal(Fixtures.identify("foo"), Fixtures.identify("FOO"))
+  end
+  
+  def test_identifies_symbols
+    assert_equal(Fixtures.identify(:foo), Fixtures.identify(:foo))
+  end
+  
+  TIMESTAMP_COLUMNS = %w(created_at created_on updated_at updated_on)
+  
+  def test_populates_timestamp_columns
+    TIMESTAMP_COLUMNS.each do |property|
+      assert_not_nil(parrots(:george).send(property), "should set #{property}")
+    end
+  end
+  
+  def test_populates_all_columns_with_the_same_time
+    last = nil
+    
+    TIMESTAMP_COLUMNS.each do |property|
+      current = parrots(:george).send(property)
+      last ||= current
+      
+      assert_equal(last, current)
+      last = current
+    end
+  end
+  
+  def test_only_populates_columns_that_exist
+    assert_not_nil(pirates(:blackbeard).created_on)
+    assert_not_nil(pirates(:blackbeard).updated_on)
+  end
+  
+  def test_preserves_existing_fixture_data
+    assert_equal(2.weeks.ago.to_date, pirates(:redbeard).created_on.to_date)
+    assert_equal(2.weeks.ago.to_date, pirates(:redbeard).updated_on.to_date)
+  end
+  
+  def test_generates_unique_ids
+    assert_not_nil(parrots(:george).id)
+    assert_not_equal(parrots(:george).id, parrots(:louis).id)
+  end
+  
+  def test_resolves_belongs_to_symbols
+    assert_equal(parrots(:george), pirates(:blackbeard).parrot)
+  end
+
+  def test_supports_join_tables
+    assert(pirates(:blackbeard).parrots.include?(parrots(:george)))
+    assert(pirates(:blackbeard).parrots.include?(parrots(:louis)))
+    assert(parrots(:george).pirates.include?(pirates(:blackbeard)))
+  end
+  
+  def test_supports_inline_habtm
+    assert(parrots(:george).treasures.include?(treasures(:diamond)))
+    assert(parrots(:george).treasures.include?(treasures(:sapphire)))
+    assert(!parrots(:george).treasures.include?(treasures(:ruby)))
+  end
+  
+  def test_supports_yaml_arrays
+    assert(parrots(:louis).treasures.include?(treasures(:diamond)))
+    assert(parrots(:louis).treasures.include?(treasures(:sapphire)))
+  end
+  
+  def test_strips_DEFAULTS_key
+    assert_raise(StandardError) { parrots(:DEFAULTS) }
+    
+    # this lets us do YAML defaults and not have an extra fixture entry
+    %w(sapphire ruby).each { |t| assert(parrots(:davey).treasures.include?(treasures(t))) }
+  end
+  
+  def test_supports_label_interpolation
+    assert_equal("frederick", parrots(:frederick).name)
+  end
+end

activerecord/test/fixtures/treasure.rb

@@ +1 @@
+class Treasure < ActiveRecord::Base
+  has_and_belongs_to_many :parrots
+end

activerecord/test/fixtures/treasures.yml

@@ +1 @@
+diamond:
+  name: $LABEL
+
+sapphire:
+  name: $LABEL
+
+ruby:
+  name: $LABEL

activerecord/test/fixtures/pirate.rb

@@ +1 @@
+class Pirate < ActiveRecord::Base
+  belongs_to :parrot
+  has_and_belongs_to_many :parrots
+end

activerecord/test/fixtures/pirates.yml

@@ +1 @@
+blackbeard:
+  catchphrase: "Yar."
+  parrot: george
+
+redbeard:
+  catchphrase: "Avast!"
+  parrot: louis
+  created_on: <%= 2.weeks.ago.to_s(:db) %>
+  updated_on: <%= 2.weeks.ago.to_s(:db) %>

activerecord/test/fixtures/parrots.yml

@@ +1 @@
+george:
+  name: "Curious George"
+  treasures: diamond, sapphire
+
+louis:
+  name: "King Louis"
+  treasures: [diamond, sapphire]
+
+frederick:
+  name: $LABEL
+
+DEFAULTS: &DEFAULTS
+  treasures: sapphire, ruby
+
+davey:
+  <<: *DEFAULTS

activerecord/test/fixtures/db_definitions/schema.rb

@@ -295 +295 @@
-    t.column :city, :string, :null => false
-    t.column :type, :string
-  end
+  
+  create_table :parrots, :force => true do |t|
+    t.column :name, :string
+    t.column :created_at, :datetime
+    t.column :created_on, :datetime
+    t.column :updated_at, :datetime
+    t.column :updated_on, :datetime
+  end
+  
+  create_table :pirates, :force => true do |t|
+    t.column :catchphrase, :string
+    t.column :parrot_id, :integer
+    t.column :created_on, :datetime
+    t.column :updated_on, :datetime
+  end
+  
+  create_table :parrots_pirates, :id => false, :force => true do |t|
+    t.column :parrot_id, :integer
+    t.column :pirate_id, :integer
+  end
+  
+  create_table :treasures, :force => true do |t|
+    t.column :name, :string
+  end
+  
+  create_table :parrots_treasures, :id => false, :force => true do |t|
+    t.column :parrot_id, :integer
+    t.column :treasure_id, :integer
+  end
-end

activerecord/test/fixtures/parrots_pirates.yml

@@ +1 @@
+george_blackbeard:
+  parrot_id: <%= Fixtures.identify(:george) %>
+  pirate_id: <%= Fixtures.identify(:blackbeard) %>
+
+louis_blackbeard:
+  parrot_id: <%= Fixtures.identify(:louis) %>
+  pirate_id: <%= Fixtures.identify(:blackbeard) %>

activerecord/test/fixtures/parrot.rb

@@ +1 @@
+class Parrot < ActiveRecord::Base
+  has_and_belongs_to_many :pirates
+  has_and_belongs_to_many :treasures
+end

activerecord/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -70 +70 @@
-        name
-      end
-
+      # REFERENTIAL INTEGRITY ====================================
+
+      # Override to turn off referential integrity while executing +&block+
+      def disable_referential_integrity(&block)
+        yield
+      end          
+
-      # CONNECTION MANAGEMENT ====================================
-
-      # Is this connection active and ready to perform queries?

activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -364 +364 @@
-        end
-      end
-
+      # REFERENTIAL INTEGRITY ====================================
-
+      def disable_referential_integrity(&block) #:nodoc:
+        execute(tables.collect { |name| "ALTER TABLE #{name} DISABLE TRIGGER ALL" }.join(";"))
+      
+        begin
+          yield
+        ensure
+          execute(tables.collect { |name| "ALTER TABLE #{name} ENABLE TRIGGER ALL" }.join(";"))
+        end
+      end          
+
-      # DATABASE STATEMENTS ======================================
-
-      # Executes a SELECT query and returns an array of rows. Each row is an

activerecord/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -224 +224 @@
-        "0"
-      end
-
+      # REFERENTIAL INTEGRITY ====================================
-
+      def disable_referential_integrity(&block) #:nodoc:
+        old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
+
+        begin
+          update("SET FOREIGN_KEY_CHECKS = 0")
+          yield
+        ensure
+          update("SET FOREIGN_KEY_CHECKS = #{old}")              
+        end
+      end          
+
-      # CONNECTION MANAGEMENT ====================================
-
-      def active?

activerecord/lib/active_record/fixtures.rb

@@ -215 +215 @@
-#      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.
+#
+# = Advanced YAML Fixtures
+# 
+# YAML fixtures that don't specify an ID get some extra features:
+#
+# * Stable, autogenerated ID's
+# * Label references for associations (belongs_to, has_one, has_many)
+# * HABTM associations as inline lists
+# * Autofilled timestamp columns
+# * Fixture label interpolation
+# * Support for YAML defaults
+# 
+# == Stable, autogenerated ID's
+# 
+# Here, have a monkey fixture:
+# 
+#   george:
+#     id: 1
+#     name: George the Monkey
+# 
+#   reginald:
+#     id: 2
+#     name: Reginald the Pirate
+# 
+# Each of these fixtures has two unique identifiers: one for the database
+# and one for the humans. Why don't we generate the primary key instead?
+# Hashing each fixture's label yields a consistent ID:
+# 
+#   george: # generated id: 503576764
+#     name: George the Monkey
+# 
+#   reginald: # generated id: 324201669
+#     name: Reginald the Pirate
+#     
+# ActiveRecord looks at the fixture's model class, discovers the correct
+# primary key, and generates it right before inserting the fixture
+# into the database.
+# 
+# The generated ID for a given label is constant, so we can discover
+# any fixture's ID without loading anything, as long as we know the label.
+# 
+# == 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
+# and fixture from its label, you can specify FK's by label instead of ID.
+# 
+# === belongs_to
+# 
+# Let's break out some more monkeys and pirates.
+# 
+#   ### in pirates.yml
+#   
+#   reginald:
+#     id: 1
+#     name: Reginald the Pirate
+#     monkey_id: 1
+#   
+#   ### in monkeys.yml
+#   
+#   george:
+#     id: 1
+#     name: George the Monkey
+#     pirate_id: 1
+# 
+# Add a few more monkeys and pirates and break this into multiple files,
+# and it gets pretty hard to keep track of what's going on. Let's
+# use labels instead of ID's:
+# 
+#   ### in pirates.yml
+# 
+#   reginald:
+#     name: Reginald the Pirate
+#     monkey: george
+# 
+#   ### in monkeys.yml
+# 
+#   george:
+#     name: George the Monkey
+#     pirate: reginald
+# 
+# Pow! All is made clear. ActiveRecord 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).
+# 
+# === has_and_belongs_to_many
+# 
+# Time to give our monkey some fruit.
+# 
+#   ### in monkeys.yml
+#   
+#   george:
+#     id: 1
+#     name: George the Monkey
+#     pirate_id: 1
+# 
+#   ### in fruits.yml
+#   
+#   apple:
+#     id: 1
+#     name: apple
+# 
+#   orange:
+#     id: 2
+#     name: orange
+# 
+#   grape:
+#     id: 3
+#     name: grape
+#   
+#   ### in fruits_monkeys.yml
+#   
+#   apple_george:
+#     fruit_id: 1
+#     monkey_id: 1
+# 
+#   orange_george:
+#     fruit_id: 2
+#     monkey_id: 1
+# 
+#   grape_george:
+#     fruit_id: 3
+#     monkey_id: 1
+# 
+# Let's make the HABTM fixture go away.
+# 
+#   ### in monkeys.yml
+# 
+#   george:
+#     name: George the Monkey
+#     pirate: reginald
+#     fruits: apple, orange, grape
+# 
+#   ### in fruits.yml
+# 
+#   apple:
+#     name: apple
+# 
+#   orange:
+#     name: orange
+# 
+#   grape:
+#     name: grape
+# 
+# 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
+# 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 you've set specific values, they'll be left alone.
+# 
+# == Fixture label interpolation
+#
+# The label of the current fixture is always available as a column value:
+# 
+#   geeksomnia:
+#     name: Geeksomnia's Account
+#     subdomain: $LABEL
+# 
+# Also, sometimes (like when porting older join table fixtures) you'll need
+# to be able to get ahold of the identifier for a given label. ERB
+# to the rescue:
+# 
+#   george_reginald:
+#     monkey_id: <%= Fixtures.identify(:reginald) %>
+#     pirate_id: <%= Fixtures.identify(:george) %>
+#
+# == 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:
+# 
+#   DEFAULTS: &DEFAULTS
+#     created_on: <%= 3.weeks.ago.to_s(:db) %>
+#     
+#   first:
+#     name: Smurf
+#     <<: *DEFAULTS
+# 
+#   second:
+#     name: Fraggle
+#     <<: *DEFAULTS
+# 
+# Any fixture labeled "DEFAULTS" is safely ignored.
+
-class Fixtures < YAML::Omap
-  DEFAULT_FILTER_RE = /\.ya?ml$/
-
@@ -279 +472 @@
-
-    unless table_names_to_fetch.empty?
-      ActiveRecord::Base.silence do
-
+
+
-
-
-
-
+  
+  
+  
-
-
+  
-
-
-
-
+  
+  
+  
-
-
-
-
-
+
+
+
+
+
-            end
-          end
+
+          cache_fixtures(connection, fixtures)
-        end
-
-        cache_fixtures(connection, fixtures)
-      end
-    end
-    cached_fixtures(connection, table_names)
-  end
+  
+  # Returns a consistent identifier for +label+. This will always
+  # be a positive integer, and will always be the same for a given
+  # label, assuming the same OS, platform, and version of Ruby.
+  def self.identify(label)
+    label.to_s.hash.abs
+  end
-
-  attr_reader :table_name
-
@@ -322 +524 @@
-  end
-
-  def insert_fixtures
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-      @connection.insert_fixture(fixture, @table_name)
-    end
+    
+    # insert any HABTM join tables we discovered
+    habtm_fixtures.values.each do |fixture|
+      fixture.delete_existing_fixtures
+      fixture.insert_fixtures
+    end
-  end
-
-  private
+    class HabtmFixtures < ::Fixtures #:nodoc:
+      def read_fixture_files; end
+    end
+
+    def model_class
+      @model_class ||= @class_name.is_a?(Class) ?
+        @class_name : @class_name.constantize rescue nil
+    end
+  
+    def primary_key_name
+      @primary_key_name ||= model_class && model_class.primary_key
+    end
+
+    def timestamp_column_names
+      @timestamp_column_names ||= %w(created_at created_on updated_at updated_on).select do |name|
+        column_names.include?(name)
+      end
+    end
+
+    def column_names
+      @column_names ||= @connection.columns(@table_name).collect(&:name)
+    end
+  
-    def read_fixture_files
-      if File.file?(yaml_file_path)
-        read_yaml_fixture_files