activerecord 1.15.6 → 2.0.0

data/test/fixtures/parrot.rb

@@ -0,0 +1,13 @@
+class Parrot < ActiveRecord::Base
+  set_inheritance_column :parrot_sti_class
+  has_and_belongs_to_many :pirates
+  has_and_belongs_to_many :treasures
+  has_many :loots, :as => :looter
+end
+
+class LiveParrot < Parrot
+end
+
+class DeadParrot < Parrot
+  belongs_to :killer, :class_name => 'Pirate'
+end

data/test/fixtures/parrots.yml

@@ -0,0 +1,27 @@
+george:
+  name: "Curious George"
+  treasures: diamond, sapphire
+  parrot_sti_class: LiveParrot
+
+louis:
+  name: "King Louis"
+  treasures: [diamond, sapphire]
+  parrot_sti_class: LiveParrot
+
+frederick:
+  name: $LABEL
+  parrot_sti_class: LiveParrot
+
+polly:
+  id: 4
+  name: $LABEL
+  killer: blackbeard
+  treasures: sapphire, ruby
+  parrot_sti_class: DeadParrot
+
+DEFAULTS: &DEFAULTS
+  treasures: sapphire, ruby
+  parrot_sti_class: LiveParrot
+
+davey:
+  <<: *DEFAULTS

data/test/fixtures/parrots_pirates.yml

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

data/test/fixtures/pirate.rb

@@ -0,0 +1,5 @@
+class Pirate < ActiveRecord::Base
+  belongs_to :parrot
+  has_and_belongs_to_many :parrots
+  has_many :loots, :as => :looter
+end

data/test/fixtures/pirates.yml

@@ -0,0 +1,9 @@
+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) %>

data/test/fixtures/post.rb

@@ -16,6 +16,7 @@ class Post < ActiveRecord::Base
   has_one  :very_special_comment
   has_one  :very_special_comment_with_post, :class_name => "VerySpecialComment", :include => :post
   has_many :special_comments
+  has_many :nonexistant_comments, :class_name => 'Comment', :conditions => 'comments.id < 0'
 
   has_and_belongs_to_many :categories
   has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => 'category_id'

data/test/fixtures/project.rb

@@ -1,5 +1,6 @@
 class Project < ActiveRecord::Base
   has_and_belongs_to_many :developers, :uniq => true, :order => 'developers.name desc, developers.id desc'
+  has_and_belongs_to_many :selected_developers, :class_name => "Developer", :select => "developers.*", :uniq => true
   has_and_belongs_to_many :non_unique_developers, :order => 'developers.name desc, developers.id desc', :class_name => 'Developer'
   has_and_belongs_to_many :limited_developers, :class_name => "Developer", :limit => 1
   has_and_belongs_to_many :developers_named_david, :class_name => "Developer", :conditions => "name = 'David'", :uniq => true
@@ -7,8 +8,8 @@ class Project < ActiveRecord::Base
   has_and_belongs_to_many :salaried_developers, :class_name => "Developer", :conditions => "salary > 0"
   has_and_belongs_to_many :developers_with_finder_sql, :class_name => "Developer", :finder_sql => 'SELECT t.*, j.* FROM developers_projects j, developers t WHERE t.id = j.developer_id AND j.project_id = #{id}'
   has_and_belongs_to_many :developers_by_sql, :class_name => "Developer", :delete_sql => "DELETE FROM developers_projects WHERE project_id = \#{id} AND developer_id = \#{record.id}"
-  has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id}"},
-                            :after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id}"}, 
+  has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
+                            :after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
                             :before_remove => Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},
                             :after_remove => Proc.new {|o, r| o.developers_log << "after_removing#{r.id}"}
 

data/test/fixtures/reserved_words/distinct.yml

@@ -0,0 +1,5 @@
+distinct1:
+  id: 1
+
+distinct2:
+  id: 2

data/test/fixtures/reserved_words/distincts_selects.yml

@@ -0,0 +1,11 @@
+distincts_selects1:
+  distinct_id: 1
+  select_id: 1
+
+distincts_selects2:
+  distinct_id: 1
+  select_id: 2
+
+distincts_selects3:
+  distinct_id: 2
+  select_id: 3

data/test/fixtures/reserved_words/group.yml

@@ -0,0 +1,14 @@
+group1:
+  id: 1
+  select_id: 1
+  order: x
+
+group2:
+  id: 2
+  select_id: 2
+  order: y
+
+group3:
+  id: 3
+  select_id: 2
+  order: z

data/test/fixtures/reserved_words/select.yml

@@ -0,0 +1,8 @@
+select1:
+  id: 1
+
+select2:
+  id: 2
+
+select3:
+  id: 3

data/test/fixtures/reserved_words/values.yml

@@ -0,0 +1,7 @@
+values1:
+  id: 1
+  group_id: 2
+
+values2:
+  id: 2
+  group_id: 1

data/test/fixtures/ship.rb

@@ -0,0 +1,3 @@
+class Ship < ActiveRecord::Base
+  self.record_timestamps = false
+end

data/test/fixtures/ships.yml

@@ -0,0 +1,5 @@
+black_pearl:
+  name: "Black Pearl"
+interceptor:
+  id: 2
+  name: "Interceptor"

data/test/fixtures/tagging.rb

@@ -1,3 +1,7 @@
+# test that attr_readonly isn't called on the :taggable polymorphic association
+module Taggable
+end
+
 class Tagging < ActiveRecord::Base
   belongs_to :tag, :include => :tagging
   belongs_to :super_tag,   :class_name => 'Tag', :foreign_key => 'super_tag_id'

data/test/fixtures/taggings.yml

@@ -15,4 +15,11 @@ fake:
   id: 3
   tag_id: 1
   taggable_id: 1
-  taggable_type: FakeModel
+  taggable_type: FakeModel
+
+godfather:
+  id: 4
+  tag_id: 1
+  taggable_id: 1
+  taggable_type: Item
+  

data/test/fixtures/topic.rb

@@ -13,8 +13,14 @@ class Topic < ActiveRecord::Base
   def topic_id
     id
   end
+  
 
   protected
+    def approved=(val)
+      @custom_approved = val
+      write_attribute(:approved, val)
+    end
+
     def default_written_on
       self.written_on = Time.now unless attribute_present?("written_on")
     end
@@ -22,4 +28,10 @@ class Topic < ActiveRecord::Base
     def destroy_children
       self.class.delete_all "parent_id = #{id}"
     end
-end
+
+    def after_initialize
+      if self.new_record?
+        self.author_email_address = 'test@test.com'
+      end
+    end
+end

data/test/fixtures/treasure.rb

@@ -0,0 +1,4 @@
+class Treasure < ActiveRecord::Base
+  has_and_belongs_to_many :parrots
+  belongs_to :looter, :polymorphic => true
+end

data/test/fixtures/treasures.yml

@@ -0,0 +1,10 @@
+diamond:
+  name: $LABEL
+
+sapphire:
+  name: $LABEL
+  looter: redbeard (Pirate)
+
+ruby:
+  name: $LABEL
+  looter: louis (Parrot)

data/test/fixtures_test.rb

@@ -1,5 +1,8 @@
 require 'abstract_unit'
+require 'fixtures/post'
+require 'fixtures/binary'
 require 'fixtures/topic'
+require 'fixtures/computer'
 require 'fixtures/developer'
 require 'fixtures/company'
 require 'fixtures/task'
@@ -7,6 +10,11 @@ require 'fixtures/reply'
 require 'fixtures/joke'
 require 'fixtures/course'
 require 'fixtures/category'
+require 'fixtures/parrot'
+require 'fixtures/pirate'
+require 'fixtures/treasure'
+require 'fixtures/matey'
+require 'fixtures/ship'
 
 class FixturesTest < Test::Unit::TestCase
   self.use_instantiated_fixtures = true
@@ -49,15 +57,18 @@ class FixturesTest < Test::Unit::TestCase
 
   def test_inserts
     topics = create_fixtures("topics")
-    firstRow = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'David'")
-    assert_equal("The First Topic", firstRow["title"])
+    first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'David'")
+    assert_equal("The First Topic", first_row["title"])
 
-    secondRow = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'Mary'")
-    assert_nil(secondRow["author_email_address"])
+    second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'Mary'")
+    assert_nil(second_row["author_email_address"])
   end
 
   if ActiveRecord::Base.connection.supports_migrations?
     def test_inserts_with_pre_and_suffix
+      # Reset cache to make finds on the new table work
+      Fixtures.reset_cache
+
       ActiveRecord::Base.connection.create_table :prefix_topics_suffix do |t|
         t.column :title, :string
         t.column :author_name, :string
@@ -82,15 +93,15 @@ class FixturesTest < Test::Unit::TestCase
 
       topics = create_fixtures("topics")
 
-      firstRow = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'David'")
-      assert_equal("The First Topic", firstRow["title"])
+      first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'David'")
+      assert_equal("The First Topic", first_row["title"])
 
-      secondRow = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'Mary'")
-      assert_nil(secondRow["author_email_address"])        
+      second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'Mary'")
+      assert_nil(second_row["author_email_address"])
     ensure
       # Restore prefix/suffix to its previous values
-      ActiveRecord::Base.table_name_prefix = old_prefix 
-      ActiveRecord::Base.table_name_suffix = old_suffix 
+      ActiveRecord::Base.table_name_prefix = old_prefix
+      ActiveRecord::Base.table_name_suffix = old_suffix
 
       ActiveRecord::Base.connection.drop_table :prefix_topics_suffix rescue nil
     end
@@ -187,7 +198,7 @@ class FixturesTest < Test::Unit::TestCase
 
   def test_binary_in_fixtures
     assert_equal 1, @binaries.size
-    data = File.read(BINARY_FIXTURE_PATH).freeze
+    data = File.open(BINARY_FIXTURE_PATH, "rb").read.freeze
     assert_equal data, @flowers.data
   end
 end
@@ -199,6 +210,7 @@ if Account.connection.respond_to?(:reset_pk_sequence!)
 
     def setup
       @instances = [Account.new(:credit_limit => 50), Company.new(:name => 'RoR Consulting')]
+      Fixtures.reset_cache # make sure tables get reinitialized
     end
 
     def test_resets_to_min_pk_with_specified_pk_and_sequence
@@ -223,7 +235,7 @@ if Account.connection.respond_to?(:reset_pk_sequence!)
       end
     end
 
-    def test_create_fixtures_resets_sequences
+    def test_create_fixtures_resets_sequences_when_not_cached
       @instances.each do |instance|
         max_id = create_fixtures(instance.class.table_name).inject(0) do |max_id, (name, fixture)|
           fixture_id = fixture['id'].to_i
@@ -238,7 +250,6 @@ if Account.connection.respond_to?(:reset_pk_sequence!)
   end
 end
 
-
 class FixturesWithoutInstantiationTest < Test::Unit::TestCase
   self.use_instantiated_fixtures = false
   fixtures :topics, :developers, :accounts
@@ -259,8 +270,20 @@ class FixturesWithoutInstantiationTest < Test::Unit::TestCase
     assert_equal "Jamis", developers(:jamis).name
     assert_equal 50, accounts(:signals37).credit_limit
   end
-end
 
+  def test_accessor_methods_with_multiple_args
+    assert_equal 2, topics(:first, :second).size
+    assert_raise(StandardError) { topics([:first, :second]) }
+  end
+
+  uses_mocha 'reloading_fixtures_through_accessor_methods' do
+    def test_reloading_fixtures_through_accessor_methods
+      assert_equal "The First Topic", topics(:first).title
+      @loaded_fixtures['topics']['first'].expects(:find).returns(stub(:title => "Fresh Topic!"))
+      assert_equal "Fresh Topic!", topics(:first, true).title
+    end
+  end
+end
 
 class FixturesWithoutInstanceInstantiationTest < Test::Unit::TestCase
   self.use_instantiated_fixtures = true
@@ -276,7 +299,6 @@ class FixturesWithoutInstanceInstantiationTest < Test::Unit::TestCase
   end
 end
 
-
 class TransactionalFixturesTest < Test::Unit::TestCase
   self.use_instantiated_fixtures = true
   self.use_transactional_fixtures = true
@@ -293,7 +315,6 @@ class TransactionalFixturesTest < Test::Unit::TestCase
   end
 end
 
-
 class MultipleFixturesTest < Test::Unit::TestCase
   fixtures :topics
   fixtures :developers, :accounts
@@ -303,7 +324,6 @@ class MultipleFixturesTest < Test::Unit::TestCase
   end
 end
 
-
 class OverlappingFixturesTest < Test::Unit::TestCase
   fixtures :topics, :developers
   fixtures :developers, :accounts
@@ -313,7 +333,6 @@ class OverlappingFixturesTest < Test::Unit::TestCase
   end
 end
 
-
 class ForeignKeyFixturesTest < Test::Unit::TestCase
   fixtures :fk_test_has_pk, :fk_test_has_fk
 
@@ -333,7 +352,7 @@ end
 class SetTableNameFixturesTest < Test::Unit::TestCase
   set_fixture_class :funny_jokes => 'Joke'
   fixtures :funny_jokes
-  
+
   def test_table_method
     assert_kind_of Joke, funny_jokes(:a_joke)
   end
@@ -342,7 +361,7 @@ end
 class CustomConnectionFixturesTest < Test::Unit::TestCase
   set_fixture_class :courses => Course
   fixtures :courses
-  
+
   def test_connection
     assert_kind_of Course, courses(:ruby)
     assert_equal Course.connection, courses(:ruby).connection
@@ -368,17 +387,15 @@ class CheckEscapedYamlFixturesTest < Test::Unit::TestCase
   end
 end
 
-class DevelopersProject; end;
-
+class DevelopersProject; end
 class ManyToManyFixturesWithClassDefined < Test::Unit::TestCase
   fixtures :developers_projects
-  
+
   def test_this_should_run_cleanly
     assert true
   end
 end
 
-
 class FixturesBrokenRollbackTest < Test::Unit::TestCase
   def blank_setup; end
   alias_method :ar_setup_with_fixtures, :setup_with_fixtures
@@ -403,3 +420,167 @@ class FixturesBrokenRollbackTest < Test::Unit::TestCase
       raise 'argh'
     end
 end
+
+class LoadAllFixturesTest < Test::Unit::TestCase
+  self.fixture_path= File.join(File.dirname(__FILE__), '/fixtures/all')
+  fixtures :all
+
+  def test_all_there
+    assert_equal %w(developers people tasks), fixture_table_names.sort
+  end
+end
+
+class FasterFixturesTest < Test::Unit::TestCase
+  fixtures :categories, :authors
+
+  def load_extra_fixture(name)
+    fixture = create_fixtures(name)
+    assert fixture.is_a?(Fixtures)
+    @loaded_fixtures[fixture.table_name] = fixture
+  end
+
+  def test_cache
+    assert Fixtures.fixture_is_cached?(ActiveRecord::Base.connection, 'categories')
+    assert Fixtures.fixture_is_cached?(ActiveRecord::Base.connection, 'authors')
+
+    assert_no_queries do
+      create_fixtures('categories')
+      create_fixtures('authors')
+    end
+
+    load_extra_fixture('posts')
+    assert Fixtures.fixture_is_cached?(ActiveRecord::Base.connection, 'posts')
+    self.class.setup_fixture_accessors('posts')
+    assert_equal 'Welcome to the weblog', posts(:welcome).title
+  end
+end
+
+class FoxyFixturesTest < Test::Unit::TestCase
+  fixtures :parrots, :parrots_pirates, :pirates, :treasures, :mateys, :ships, :computers, :developers
+
+  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_does_not_populate_timestamp_columns_if_model_has_set_record_timestamps_to_false
+    TIMESTAMP_COLUMNS.each do |property|
+      assert_nil(ships(:black_pearl).send(property), "should not 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_automatically_sets_primary_key
+    assert_not_nil(ships(:black_pearl))
+  end
+
+  def test_preserves_existing_primary_key
+    assert_equal(2, ships(:interceptor).id)
+  end
+
+  def test_resolves_belongs_to_symbols
+    assert_equal(parrots(:george), pirates(:blackbeard).parrot)
+  end
+
+  def test_ignores_belongs_to_symbols_if_association_and_foreign_key_are_named_the_same
+    assert_equal(developers(:david), computers(:workstation).developer)
+  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_inline_habtm_with_specified_id
+    assert(parrots(:polly).treasures.include?(treasures(:ruby)))
+    assert(parrots(:polly).treasures.include?(treasures(:sapphire)))
+    assert(!parrots(:polly).treasures.include?(treasures(:diamond)))
+  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
+
+  def test_supports_polymorphic_belongs_to
+    assert_equal(pirates(:redbeard), treasures(:sapphire).looter)
+    assert_equal(parrots(:louis), treasures(:ruby).looter)
+  end
+
+  def test_only_generates_a_pk_if_necessary
+    m = Matey.find(:first)
+    m.pirate = pirates(:blackbeard)
+    m.target = pirates(:redbeard)
+  end
+
+  def test_supports_sti
+    assert_kind_of DeadParrot, parrots(:polly)
+    assert_equal pirates(:blackbeard), parrots(:polly).killer
+  end
+end
+
+class ActiveSupportSubclassWithFixturesTest < ActiveSupport::TestCase
+  fixtures :parrots
+
+  # This seemingly useless assertion catches a bug that caused the fixtures
+  # setup code call nil[]
+  def test_foo
+    assert_equal parrots(:louis), Parrot.find_by_name("King Louis")
+  end
+end