activerecord 1.4.0 → 1.5.0

data/lib/active_record/validations.rb

@@ -271,6 +271,39 @@ module ActiveRecord
           end
         end
       end
+
+      # Validates whether the associated object or objects are all themselves valid. Works with any kind of assocation.
+      #
+      #   class Book < ActiveRecord::Base
+      #     has_many :pages
+      #     belongs_to :library
+      #
+      #     validates_associated :pages, :library
+      #   end
+      #
+      # Warning: If, after the above definition, you then wrote:
+      #
+      #   class Page < ActiveRecord::Base
+      #     belongs_to :book
+      #
+      #     validates_associated :book
+      #   end
+      #
+      # this would specify a circular dependency and cause infinite recursion. The Rails team recommends against this practice.
+      #
+      # Configuration options:
+      # * <tt>on</tt> Specifies when this validation is active (default is :save, other options :create, :update)
+      def validates_associated(*attr_names)
+        configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save }
+        configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
+        
+        for attr_name in attr_names
+          class_eval(%(#{validation_method(configuration[:on])} %{
+            errors.add("#{attr_name}", "#{configuration[:message]}") unless
+              (#{attr_name}.is_a?(Array) ? #{attr_name} : [#{attr_name}]).inject(true){ |memo, record| memo and (record.nil? or record.valid?) }
+          }))
+        end
+      end
       
 
       private
@@ -293,7 +326,7 @@ module ActiveRecord
     # This is especially useful for boolean flags on existing records. The regular +update_attribute+ method
     # in Base is replaced with this when the validations module is mixed in, which it is by default.
     def update_attribute_with_validation_skipping(name, value)
-      @attributes[name] = value
+      self[name] = value
       save(false)
     end
 

data/lib/active_record/vendor/mysql411.rb

@@ -0,0 +1,305 @@
+#
+# mysq411.rb - 0.1 - Matt Mower <self@mattmower.com>
+#
+# The native Ruby MySQL client (mysql.rb) by Tomita Masahiro does not (yet) handle the new MySQL
+# protocol introduced in MySQL 4.1.1. This protocol introduces a new authentication scheme as
+# well as modifications to the client/server exchanges themselves.
+#
+# mysql411.rb modifies the Mysql class to add MySQL 4.1.x support.  It modifies the connection
+# algorithm to detect a 4.1.1 server and respond with the new authentication scheme, otherwise using
+# the original one.  Similarly for the changes to packet structures and field definitions, etc...
+#
+# It redefines serveral methods which behave differently depending upon the server context. The
+# way I have implemented this is to alias the old method, create a new alternative method, and redefine
+# the original method as a selector which calls the appropriate method based upon the server version.
+# There may have been a neater way to do this.
+#
+# In general I've tried not to change the original code any more than necessary, i.e. even where I
+# redefine a method I have made the smallest number of changes possible, rather than rewriting from
+# scratch.
+#
+# *Caveat Lector* This code passes all current ActiveRecord unit tests however this is no guarantee that
+# full & correct MySQL 4.1 support has been achieved.
+# 
+
+require 'digest/sha1'
+
+#
+# Extend the Mysql class to work with MySQL 4.1.1+ servers.  After version
+# 4.1.1 the password hashing function (and some other connection details) have
+# changed rendering the previous Mysql class unable to connect:
+#
+#
+
+class Mysql
+  CLIENT_PROTOCOL_41 = 512
+  CLIENT_SECURE_CONNECTION = 32768
+  
+  def real_connect( host=nil, user=nil, passwd=nil, db=nil, port=nil, socket=nil, flag=nil )
+    @server_status = SERVER_STATUS_AUTOCOMMIT
+    
+    if( host == nil || host == "localhost" ) && defined? UNIXSocket
+      unix_socket = socket || ENV["MYSQL_UNIX_PORT"] || MYSQL_UNIX_ADDR
+      sock = UNIXSocket::new( unix_socket )
+      @host_info = Error::err( Error::CR_LOCALHOST_CONNECTION )
+      @unix_socket = unix_socket
+    else      
+      sock = TCPSocket::new(host, port||ENV["MYSQL_TCP_PORT"]||(Socket::getservbyname("mysql","tcp") rescue MYSQL_PORT))
+      @host_info = sprintf Error::err(Error::CR_TCP_CONNECTION), host
+    end
+    
+    @host = host ? host.dup : nil
+    sock.setsockopt Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true
+    @net = Net::new sock
+    
+    a = read
+    
+    @protocol_version = a.slice!(0)
+    @server_version, a = a.split(/\0/,2)
+
+    # Store the version number components for speedy comparison
+    version, ostag = @server_version.split( /-/, 2 )
+    @major_ver, @minor_ver, @revision_num = version.split( /\./ ).map { |v| v.to_i }
+    
+    @thread_id, @scramble_buff = a.slice!(0,13).unpack("La8")
+    if a.size >= 2 then
+      @server_capabilities, = a.slice!(0,2).unpack("v")
+    end
+    if a.size >= 16 then
+      @server_language, @server_status = a.unpack("cv")
+    end
+    
+    # Set the flags we'll send back to the server
+    flag = 0 if flag == nil
+    flag |= @client_flag | CLIENT_CAPABILITIES
+    flag |= CLIENT_CONNECT_WITH_DB if db
+    
+    if version_meets_minimum?( 4, 1, 1 )
+      # In 4.1.1+ the seed comes in two parts which must be combined
+      a.slice!( 0, 16 )
+      seed_part_2 = a.slice!( 0, 12 );      
+      @scramble_buff << seed_part_2
+      
+      flag |= CLIENT_FOUND_ROWS
+      flag |= CLIENT_PROTOCOL_41
+      flag |= CLIENT_SECURE_CONNECTION if @server_capabilities & CLIENT_SECURE_CONNECTION;
+      
+      if db && @server_capabilities & CLIENT_CONNECT_WITH_DB != 0
+        @db = db.dup
+      end
+      
+      scrambled_password = scramble411( passwd, @scramble_buff, @protocol_version==9 )
+      data = make_client_auth_packet_41( flag, user, scrambled_password, db )
+    else
+      scrambled_password = scramble( passwd, @scramble_buff, @protocol_version == 9 )
+      data = Net::int2str(flag)+Net::int3str(@max_allowed_packet)+(user||"")+"\0"+scrambled_password
+      if db and @server_capabilities & CLIENT_CONNECT_WITH_DB != 0 then
+        data << "\0"+db
+        @db = db.dup
+      end
+    end
+    
+    write data
+    read
+    self
+  end
+  alias :connect :real_connect
+  
+  # Pack the authentication information into depending upon whether an initial database has
+  # been specified
+  def make_client_auth_packet_41( flag, user, password, db )
+    if db && @server_capabilities & CLIENT_CONNECT_WITH_DB != 0
+      template = "VVcx23a#{user.size+1}cA#{password.size}a#{db.size+1}"
+    else
+      template = "VVcx23a#{user.size+1}cA#{password.size}x"
+    end
+    
+    [ flag, @max_allowed_packet, @server_language, user, password.size, password, db ].pack( template )
+  end
+  
+  def version_meets_minimum?( major, minor, revision )
+    @major_ver >= major && @minor_ver >= minor && @revision_num >= revision
+  end
+  
+  # SERVER:  public_seed=create_random_string()
+  #          send(public_seed)
+  #
+  # CLIENT:  recv(public_seed)
+  #          hash_stage1=sha1("password")
+  #          hash_stage2=sha1(hash_stage1)
+  #          reply=xor(hash_stage1, sha1(public_seed,hash_stage2)
+  #
+  #          #this three steps are done in scramble()
+  #
+  #          send(reply)
+  #
+  #
+  # SERVER:  recv(reply)
+  #          hash_stage1=xor(reply, sha1(public_seed,hash_stage2))
+  #          candidate_hash2=sha1(hash_stage1)
+  #          check(candidate_hash2==hash_stage2)
+  def scramble411( password, seed, old_ver )
+    raise "old version password is not implemented" if old_ver
+    
+    #    print "Seed Bytes = "
+    #    seed.each_byte { |b| print "0x#{b.to_s( 16 )}, " }
+    #    puts
+    
+    stage1 = Digest::SHA1.digest( password )
+    stage2 = Digest::SHA1.digest( stage1 )
+    
+    dgst = Digest::SHA1.new
+    dgst << seed
+    dgst << stage2
+    stage3 = dgst.digest
+    
+    #    stage1.zip( stage3 ).map { |a, b| (a ^ b).chr }.join
+    scrambled = ( 0 ... stage3.size ).map { |i| stage3[i] ^ stage1[i] }
+    scrambled = scrambled.map { |x| x.chr }
+    scrambled.join
+  end
+  
+  def change_user(user="", passwd="", db="")
+    scrambled_password = version_meets_minimum?( 4, 1, 1 ) ? scramble411( passwd, @scramble_buff, @protocol_version==9 ) : scramble( passwd, @scramble_buff, @protocol_version==9 )
+    data = user+"\0"+scrambled_password+"\0"+db
+    command COM_CHANGE_USER, data
+    @user = user
+    @passwd = passwd
+    @db = db
+  end
+  
+  #
+  # The 4.1 protocol changed the length of the END packet
+  #
+  alias_method :old_read_one_row, :read_one_row
+
+  def read_one_row( field_count )
+    if version_meets_minimum?( 4, 1, 1 )
+      read_one_row_41( field_count )
+    else
+      old_read_one_row( field_count )
+    end
+  end
+
+  def read_one_row_41( field_count )
+    data = read
+    return if data[0] == 254 and data.length < 9
+    rec = []
+    field_count.times do
+      len = get_length data
+      if len == nil then
+	rec << len
+      else
+	rec << data.slice!(0,len)
+      end
+    end
+    rec
+  end
+  
+  #
+  # The 4.1 protocol changed the length of the END packet
+  #
+  alias_method :old_skip_result, :skip_result
+  
+  def skip_result
+    if version_meets_minimum?( 4, 1, 1 )
+      skip_result_41
+    else
+      old_skip_result
+    end
+  end
+  
+  def skip_result_41()
+    if @status == :STATUS_USE_RESULT then
+      loop do
+	data = read
+	break if data[0] == 254 and data.length == 1
+      end
+      @status = :STATUS_READY
+    end
+  end
+  
+  # The field description structure is changed for the 4.1 protocol passing
+  # more data and a different packing form.  NOTE: The 4.1 protocol now passes
+  # back a "catalog" name for each field which is a new feature.  Since AR has
+  # nowhere to put it I'm throwing it away.  Possibly this is not the best
+  # idea?
+  #
+  alias_method :old_unpack_fields, :unpack_fields
+  
+  def unpack_fields( data, long_flag_protocol )
+    if version_meets_minimum?( 4, 1, 1 )
+      unpack_fields_41( data, long_flag_protocol )
+    else
+      old_unpack_fields( data, long_flag_protocol )
+    end
+  end
+  
+  def unpack_fields_41( data, long_flag_protocol )
+    ret = []
+    
+    data.each do |f|
+      catalog_name = f[0]
+      database_name = f[1]
+      table_name_alias = f[2]
+      table_name = f[3]
+      column_name_alias = f[4]
+      column_name = f[5]
+      
+      charset = f[6][0] + f[6][1]*256
+      length = f[6][2] + f[6][3]*256 + f[6][4]*256*256 + f[6][5]*256*256*256
+      type = f[6][6]
+      flags = f[6][7] + f[6][8]*256
+      decimals = f[6][9]
+      def_value = f[7]
+      max_length = 0
+      
+      ret << Field::new(table_name, table_name, column_name, length, type, flags, decimals, def_value, max_length)
+    end
+    ret
+  end
+
+  # In this instance the read_query_result method in mysql is bound to read 5 field parameters which
+  # is expanded to 7 in the 4.1 protocol.  So in this case we redefine this entire method in order
+  # to write "read_rows 7" instead of "read_rows 5"!
+  #
+  alias_method :old_read_query_result, :read_query_result
+  
+  def read_query_result
+    if version_meets_minimum?( 4, 1, 1 )
+      read_query_result_41
+    else
+      old_read_query_result
+    end
+  end
+  
+  def read_query_result_41
+    data = read
+    @field_count = get_length(data)
+    if @field_count == nil then		# LOAD DATA LOCAL INFILE
+      File::open(data) do |f|
+	write f.read
+      end
+      write ""		# mark EOF
+      data = read
+      @field_count = get_length(data)
+    end
+    if @field_count == 0 then
+      @affected_rows = get_length(data, true)
+      @insert_id = get_length(data, true)
+      if @server_capabilities & CLIENT_TRANSACTIONS != 0 then
+	a = data.slice!(0,2)
+	@server_status = a[0]+a[1]*256
+      end
+      if data.size > 0 and get_length(data) then
+	@info = data
+      end
+    else
+      @extra_info = get_length(data, true)
+      fields = read_rows 7
+      @fields = unpack_fields(fields, @server_capabilities & CLIENT_LONG_FLAG != 0)
+      @status = :STATUS_GET_RESULT
+    end
+    self
+  end
+end

data/rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'activerecord'
-PKG_VERSION   = '1.4.0' + PKG_BUILD
+PKG_VERSION   = '1.5.0' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 PKG_FILES = FileList[
@@ -17,7 +17,7 @@ PKG_FILES = FileList[
 
 
 desc "Default Task"
-task :default => [ :test_ruby_mysql, :test_mysql_ruby, :test_sqlite, :test_postgresql ]
+task :default => [ :test_ruby_mysql, :test_mysql_ruby, :test_sqlite, :test_sqlite3, :test_postgresql ]
 
 # Run the unit tests
 
@@ -45,6 +45,12 @@ Rake::TestTask.new("test_sqlite") { |t|
   t.verbose = true
 }
 
+Rake::TestTask.new("test_sqlite3") { |t|
+  t.libs << "test" << "test/connections/native_sqlite3"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+}
+
 Rake::TestTask.new("test_sqlserver") { |t|
   t.libs << "test" << "test/connections/native_sqlserver"
   t.pattern = 'test/*_test.rb'
@@ -99,6 +105,9 @@ spec = Gem::Specification.new do |s|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
   end
   s.files.delete "test/fixtures/fixture_database.sqlite"
+  s.files.delete "test/fixtures/fixture_database_2.sqlite"
+  s.files.delete "test/fixtures/fixture_database.sqlite3"
+  s.files.delete "test/fixtures/fixture_database_2.sqlite3"
   s.require_path = 'lib'
   s.autorequire = 'active_record'
 

data/test/abstract_unit.rb

@@ -1,5 +1,4 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
-# $:.unshift(File.dirname(__FILE__) + '/fixtures')
 
 require 'test/unit'
 require 'active_record'
@@ -18,4 +17,4 @@ class Test::Unit::TestCase #:nodoc:
   end
 end
 
-Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"

data/test/associations_test.rb

@@ -5,6 +5,7 @@ require 'fixtures/project'
 require 'fixtures/company'
 require 'fixtures/topic'
 require 'fixtures/reply'
+require 'fixtures/computer'
 
 # Can't declare new classes in test case methods, so tests before that
 bad_collection_keys = false
@@ -18,19 +19,19 @@ raise "ActiveRecord should have barked on bad collection keys" unless bad_collec
 
 class AssociationsTest < Test::Unit::TestCase
   def setup
-    create_fixtures "accounts", "companies", "developers", "projects", "developers_projects"  
+    create_fixtures "accounts", "companies", "developers", "projects", "developers_projects", "computers"
     @signals37 = Firm.find(1)
   end
   
   def test_force_reload
-    firm = Firm.new
+    firm = Firm.new("name" => "A New Firm, Inc")
     firm.save
     firm.clients.each {|c|} # forcing to load all clients
     assert firm.clients.empty?, "New firm shouldn't have client objects"
     assert !firm.has_clients?, "New firm shouldn't have clients"
     assert_equal 0, firm.clients.size, "New firm should have 0 clients"
 
-    client = Client.new("firm_id" => firm.id)
+    client = Client.new("name" => "TheClient.com", "firm_id" => firm.id)
     client.save
 
     assert firm.clients.empty?, "New firm should have cached no client objects"
@@ -71,12 +72,6 @@ class HasOneAssociationsTest < Test::Unit::TestCase
   def test_has_one
     assert_equal @signals37.account, Account.find(1)
     assert_equal Account.find(1).credit_limit, @signals37.account.credit_limit
-    assert @signals37.has_account?, "37signals should have an account"
-    assert Account.find(1).firm?(@signals37), "37signals account should be able to backtrack"
-    assert Account.find(1).has_firm?, "37signals account should be able to backtrack"
-
-    assert !Account.find(2).has_firm?, "Unknown isn't linked"
-    assert !Account.find(2).firm?(@signals37), "Unknown isn't linked"
   end
 
   def test_type_mismatch
@@ -99,43 +94,105 @@ class HasOneAssociationsTest < Test::Unit::TestCase
     assert_nil Account.find(old_account_id).firm_id
   end
 
+  def test_dependence
+    firm = Firm.find(1)
+    assert !firm.account.nil?
+    firm.destroy
+    assert_equal 1, Account.find_all.length
+  end
+
   def test_build
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.save
-    
-    account = firm.build_account("credit_limit" => 1000)
+
+    account = firm.account.build("credit_limit" => 1000)
+    assert_equal account, firm.account
     assert account.save
     assert_equal account, firm.account
   end
 
+  def test_build_before_child_saved
+    firm = Firm.find(1)
+
+    account = firm.account.build("credit_limit" => 1000)
+    assert_equal account, firm.account
+    assert account.new_record?
+    assert firm.save
+    assert_equal account, firm.account
+    assert !account.new_record?
+  end
+
+  def test_build_before_either_saved
+    firm = Firm.new("name" => "GlobalMegaCorp")
+
+    account = firm.account.build("credit_limit" => 1000)
+    assert_equal account, firm.account
+    assert account.new_record?
+    assert firm.save
+    assert_equal account, firm.account
+    assert !account.new_record?
+  end
+
   def test_failing_build_association
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.save
     
-    account = firm.build_account
+    account = firm.account.build
+    assert_equal account, firm.account
     assert !account.save
+    assert_equal account, firm.account
     assert_equal "can't be empty", account.errors.on("credit_limit")
   end
 
   def test_create
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.save
-    assert_equal firm.create_account("credit_limit" => 1000), firm.account
+    assert_equal firm.account.create("credit_limit" => 1000), firm.account
   end
-  
-  def test_dependence
-    firm = Firm.find(1)
-    assert !firm.account.nil?
-    firm.destroy
-    assert_equal 1, Account.find_all.length
+
+  def test_create_before_save
+    firm = Firm.new("name" => "GlobalMegaCorp")
+    assert_equal firm.account.create("credit_limit" => 1000), firm.account
   end
 
   def test_dependence_with_missing_association
     Account.destroy_all
-    firm = Firm.find(1)    
-    assert !firm.has_account?
+    firm = Firm.find(1)
+    assert firm.account.nil?
     firm.destroy
   end
+
+  def test_assignment_before_parent_saved
+    firm = Firm.new("name" => "GlobalMegaCorp")
+    firm.account = a = Account.find(1)
+    assert firm.new_record?
+    assert_equal a, firm.account
+    assert firm.save
+    assert_equal a, firm.account
+    assert_equal a, firm.account(true)
+  end
+
+  def test_assignment_before_child_saved
+    firm = Firm.find(1)
+    firm.account = a = Account.new("credit_limit" => 1000)
+    assert !a.new_record?
+    assert_equal a, firm.account
+    assert_equal a, firm.account
+    assert_equal a, firm.account(true)
+  end
+
+  def test_assignment_before_either_saved
+    firm = Firm.new("name" => "GlobalMegaCorp")
+    firm.account = a = Account.new("credit_limit" => 1000)
+    assert firm.new_record?
+    assert a.new_record?
+    assert_equal a, firm.account
+    assert firm.save
+    assert !firm.new_record?
+    assert !a.new_record?
+    assert_equal a, firm.account
+    assert_equal a, firm.account(true)
+  end
 end
 
 
@@ -256,16 +313,72 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert_equal 3, @signals37.clients_of_firm(true).size
   end
 
+  def test_adding_before_save
+    no_of_firms = Firm.count
+    no_of_clients = Client.count
+    new_firm = Firm.new("name" => "A New Firm, Inc")
+    new_firm.clients_of_firm.push Client.new("name" => "Natural Company")
+    new_firm.clients_of_firm << (c = Client.new("name" => "Apple"))
+    assert new_firm.new_record?
+    assert c.new_record?
+    assert_equal 2, new_firm.clients_of_firm.size
+    assert_equal no_of_firms, Firm.count      # Firm was not saved to database.
+    assert_equal no_of_clients, Client.count  # Clients were not saved to database.
+    assert new_firm.save
+    assert !new_firm.new_record?
+    assert !c.new_record?
+    assert_equal new_firm, c.firm
+    assert_equal no_of_firms+1, Firm.count      # Firm was saved to database.
+    assert_equal no_of_clients+2, Client.count  # Clients were saved to database.
+    assert_equal 2, new_firm.clients_of_firm.size
+    assert_equal 2, new_firm.clients_of_firm(true).size
+  end
+
+  def test_invalid_adding
+    firm = Firm.find(1)
+    assert !(firm.clients_of_firm << c = Client.new)
+    assert c.new_record?
+    assert !firm.save
+    assert c.new_record?
+  end
+
+  def test_invalid_adding_before_save
+    no_of_firms = Firm.count
+    no_of_clients = Client.count
+    new_firm = Firm.new("name" => "A New Firm, Inc")
+    new_firm.clients_of_firm.concat([c = Client.new, Client.new("name" => "Apple")])
+    assert c.new_record?
+    assert !c.valid?
+    assert new_firm.valid?
+    assert !new_firm.save
+    assert c.new_record?
+    assert new_firm.new_record?
+  end
+
   def test_build
     new_client = @signals37.clients_of_firm.build("name" => "Another Client")
     assert_equal "Another Client", new_client.name
-    assert new_client.save
+    assert new_client.new_record?
+    assert_equal new_client, @signals37.clients_of_firm.last
+    assert @signals37.save
+    assert !new_client.new_record?
     assert_equal 2, @signals37.clients_of_firm(true).size
   end
+
+  def test_invalid_build
+    new_client = @signals37.clients_of_firm.build
+    assert new_client.new_record?
+    assert !new_client.valid?
+    assert_equal new_client, @signals37.clients_of_firm.last
+    assert !@signals37.save
+    assert new_client.new_record?
+    assert_equal 1, @signals37.clients_of_firm(true).size
+  end
   
   def test_create
     force_signal37_to_load_all_clients_of_firm
     new_client = @signals37.clients_of_firm.create("name" => "Another Client")
+    assert !new_client.new_record?
     assert_equal new_client, @signals37.clients_of_firm.last
     assert_equal new_client, @signals37.clients_of_firm(true).last
   end
@@ -277,6 +390,14 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert_equal 0, @signals37.clients_of_firm(true).size
   end
 
+  def test_deleting_before_save
+    new_firm = Firm.new("name" => "A New Firm, Inc.")
+    new_client = new_firm.clients_of_firm.build("name" => "Another Client")
+    assert_equal 1, new_firm.clients_of_firm.size
+    new_firm.clients_of_firm.delete(new_client)
+    assert_equal 0, new_firm.clients_of_firm.size
+  end
+
   def test_deleting_a_collection
     force_signal37_to_load_all_clients_of_firm
     @signals37.clients_of_firm.create("name" => "Another Client")
@@ -366,8 +487,10 @@ class HasManyAssociationsTest < Test::Unit::TestCase
 end
 
 class BelongsToAssociationsTest < Test::Unit::TestCase
+  fixtures :accounts, :companies, :developers, :projects, :topics
+  
   def setup
-    create_fixtures "accounts", "companies", "developers", "projects", "developers_projects", "topics"
+    create_fixtures "developers_projects"
     @signals37 = Firm.find(1)
   end
 
@@ -418,6 +541,62 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply deleted"
   end
 
+  def test_assignment_before_parent_saved
+    client = Client.find_first
+    apple = Firm.new("name" => "Apple")
+    client.firm = apple
+    assert_equal apple, client.firm
+    assert apple.new_record?
+    assert client.save
+    assert apple.save
+    assert !apple.new_record?
+    assert_equal apple, client.firm
+    assert_equal apple, client.firm(true)
+  end
+
+  def test_assignment_before_child_saved
+    final_cut = Client.new("name" => "Final Cut")
+    firm = Firm.find(1)
+    final_cut.firm = firm
+    assert final_cut.new_record?
+    assert final_cut.save
+    assert !final_cut.new_record?
+    assert !firm.new_record?
+    assert_equal firm, final_cut.firm
+    assert_equal firm, final_cut.firm(true)
+  end
+
+  def test_assignment_before_either_saved
+    final_cut = Client.new("name" => "Final Cut")
+    apple = Firm.new("name" => "Apple")
+    final_cut.firm = apple
+    assert final_cut.new_record?
+    assert apple.new_record?
+    assert final_cut.save
+    assert !final_cut.new_record?
+    assert !apple.new_record?
+    assert_equal apple, final_cut.firm
+    assert_equal apple, final_cut.firm(true)
+  end
+
+  def test_new_record_with_foreign_key_but_no_object
+    c = Client.new("firm_id" => 1)
+    assert_equal @first_firm, c.firm_with_basic_id
+  end
+
+  def test_forgetting_the_load_when_foreign_key_enters_late
+    c = Client.new
+    assert_nil c.firm_with_basic_id
+
+    c.firm_id = 1
+    assert_equal @first_firm, c.firm_with_basic_id
+  end
+
+  def test_field_name_same_as_foreign_key
+    computer = Computer.find 1
+    assert_not_nil computer.developer, ":foreign key == attribute didn't lock up"
+  end
+
   def xtest_counter_cache
     apple = Firm.create("name" => "Apple")
     final_cut = apple.clients.create("name" => "Final Cut")
@@ -508,6 +687,38 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     assert_equal 2, aridridel.projects.size
     assert_equal 2, aridridel.projects(true).size
   end
+
+  def test_habtm_adding_before_save
+    no_of_devels = Developer.count
+    no_of_projects = Project.count
+    aridridel = Developer.new("name" => "Aridridel")
+    aridridel.projects.concat([Project.find(1), p = Project.new("name" => "Projekt")])
+    assert aridridel.new_record?
+    assert p.new_record?
+    assert aridridel.save
+    assert !aridridel.new_record?
+    assert_equal no_of_devels+1, Developer.count
+    assert_equal no_of_projects+1, Project.count
+    assert_equal 2, aridridel.projects.size
+    assert_equal 2, aridridel.projects(true).size
+  end
+
+  def test_build
+    devel = Developer.find(1)
+    proj = devel.projects.build("name" => "Projekt")
+    assert_equal devel.projects.last, proj
+    assert proj.new_record?
+    devel.save
+    assert !proj.new_record?
+    assert_equal devel.projects.last, proj
+  end
+  
+  def test_create
+    devel = Developer.find(1)
+    proj = devel.projects.create("name" => "Projekt")
+    assert_equal devel.projects.last, proj
+    assert !proj.new_record?
+  end
   
   def test_uniq_after_the_fact
     @developers["jamis"].find.projects << @projects["active_record"].find