activerecord 1.0.0 → 2.0.0

data/test/migration_test_firebird.rb

@@ -0,0 +1,124 @@
+require 'abstract_unit'
+require 'fixtures/course'
+
+class FirebirdMigrationTest < Test::Unit::TestCase
+  self.use_transactional_fixtures = false
+
+  def setup
+    # using Course connection for tests -- need a db that doesn't already have a BOOLEAN domain
+    @connection = Course.connection
+    @fireruby_connection = @connection.instance_variable_get(:@connection)
+  end
+
+  def teardown
+    @connection.drop_table :foo rescue nil
+    @connection.execute("DROP DOMAIN D_BOOLEAN") rescue nil
+  end
+
+  def test_create_table_with_custom_sequence_name
+    assert_nothing_raised do
+      @connection.create_table(:foo, :sequence => 'foo_custom_seq') do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert sequence_exists?('foo_custom_seq')
+
+    assert_nothing_raised { @connection.drop_table(:foo, :sequence => 'foo_custom_seq') }
+    assert !sequence_exists?('foo_custom_seq')
+  ensure
+    FireRuby::Generator.new('foo_custom_seq', @fireruby_connection).drop rescue nil
+  end
+
+  def test_create_table_without_sequence
+    assert_nothing_raised do
+      @connection.create_table(:foo, :sequence => false) do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert_nothing_raised { @connection.drop_table :foo }
+
+    assert_nothing_raised do
+      @connection.create_table(:foo, :id => false) do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert_nothing_raised { @connection.drop_table :foo }
+  end
+
+  def test_create_table_with_boolean_column
+    assert !boolean_domain_exists?
+    assert_nothing_raised do
+      @connection.create_table :foo do |f|
+        f.column :bar, :string
+        f.column :baz, :boolean
+      end
+    end
+    assert boolean_domain_exists?
+  end
+
+  def test_add_boolean_column
+    assert !boolean_domain_exists?
+    @connection.create_table :foo do |f|
+      f.column :bar, :string
+    end
+
+    assert_nothing_raised { @connection.add_column :foo, :baz, :boolean }
+    assert boolean_domain_exists?
+    assert_equal :boolean, @connection.columns(:foo).find { |c| c.name == "baz" }.type
+  end
+
+  def test_change_column_to_boolean
+    assert !boolean_domain_exists?
+    # Manually create table with a SMALLINT column, which can be changed to a BOOLEAN
+    @connection.execute "CREATE TABLE foo (bar SMALLINT)"
+    assert_equal :integer, @connection.columns(:foo).find { |c| c.name == "bar" }.type
+
+    assert_nothing_raised { @connection.change_column :foo, :bar, :boolean }
+    assert boolean_domain_exists?
+    assert_equal :boolean, @connection.columns(:foo).find { |c| c.name == "bar" }.type
+  end
+
+  def test_rename_table_with_data_and_index
+    @connection.create_table :foo do |f|
+      f.column :baz, :string, :limit => 50
+    end
+    100.times { |i| @connection.execute "INSERT INTO foo VALUES (GEN_ID(foo_seq, 1), 'record #{i+1}')" }
+    @connection.add_index :foo, :baz
+
+    assert_nothing_raised { @connection.rename_table :foo, :bar }
+    assert !@connection.tables.include?("foo")
+    assert @connection.tables.include?("bar")
+    assert_equal "index_bar_on_baz", @connection.indexes("bar").first.name
+    assert_equal 100, FireRuby::Generator.new("bar_seq", @fireruby_connection).last
+    assert_equal 100, @connection.select_one("SELECT COUNT(*) FROM bar")["count"]
+  ensure
+    @connection.drop_table :bar rescue nil
+  end
+
+  def test_renaming_table_with_fk_constraint_raises_error
+    @connection.create_table :parent do |p|
+      p.column :name, :string
+    end
+    @connection.create_table :child do |c|
+      c.column :parent_id, :integer
+    end
+    @connection.execute "ALTER TABLE child ADD CONSTRAINT fk_child_parent FOREIGN KEY(parent_id) REFERENCES parent(id)"
+    assert_raise(ActiveRecord::ActiveRecordError) { @connection.rename_table :child, :descendant }
+  ensure
+    @connection.drop_table :child rescue nil
+    @connection.drop_table :descendant rescue nil
+    @connection.drop_table :parent rescue nil
+  end
+
+  private
+    def boolean_domain_exists?
+      !@connection.select_one("SELECT 1 FROM rdb$fields WHERE rdb$field_name = 'D_BOOLEAN'").nil?
+    end
+
+    def sequence_exists?(sequence_name)
+      FireRuby::Generator.exists?(sequence_name, @fireruby_connection)
+    end
+end

data/test/mixin_test.rb

@@ -0,0 +1,95 @@
+require 'abstract_unit'
+
+class Mixin < ActiveRecord::Base
+end
+
+# Let us control what Time.now returns for the TouchTest suite
+class Time
+  @@forced_now_time = nil
+  cattr_accessor :forced_now_time
+  
+  class << self
+    def now_with_forcing
+      if @@forced_now_time
+        @@forced_now_time
+      else
+        now_without_forcing
+      end
+    end
+    alias_method_chain :now, :forcing
+  end
+end
+
+
+class TouchTest < Test::Unit::TestCase
+  fixtures :mixins
+  
+  def setup
+    Time.forced_now_time = Time.now
+  end
+  
+  def teardown
+    Time.forced_now_time = nil
+  end
+
+  def test_time_mocking
+    five_minutes_ago = 5.minutes.ago
+    Time.forced_now_time = five_minutes_ago
+    assert_equal five_minutes_ago, Time.now
+    
+    Time.forced_now_time = nil
+    assert_not_equal five_minutes_ago, Time.now
+  end
+
+  def test_update
+    stamped = Mixin.new
+
+    assert_nil stamped.updated_at
+    assert_nil stamped.created_at
+    stamped.save
+    assert_equal Time.now, stamped.updated_at
+    assert_equal Time.now, stamped.created_at
+  end
+
+  def test_create
+    obj = Mixin.create
+    assert_equal Time.now, obj.updated_at
+    assert_equal Time.now, obj.created_at
+  end
+
+  def test_many_updates
+    stamped = Mixin.new
+
+    assert_nil stamped.updated_at
+    assert_nil stamped.created_at
+    stamped.save
+    assert_equal Time.now, stamped.created_at
+    assert_equal Time.now, stamped.updated_at
+
+    old_updated_at = stamped.updated_at
+
+    Time.forced_now_time = 5.minutes.from_now
+    stamped.save
+
+    assert_equal Time.now, stamped.updated_at
+    assert_equal old_updated_at, stamped.created_at
+  end
+
+  def test_create_turned_off
+    Mixin.record_timestamps = false
+
+    mixin = Mixin.new
+
+    assert_nil mixin.updated_at
+    mixin.save
+    assert_nil mixin.updated_at
+
+  # Make sure Mixin.record_timestamps gets reset, even if this test fails,
+  # so that other tests do not fail because Mixin.record_timestamps == false
+  rescue Exception => e
+    raise e
+  ensure
+    Mixin.record_timestamps = true
+  end
+
+end

data/test/modules_test.rb

@@ -1,21 +1,34 @@
 require 'abstract_unit'
-# require File.dirname(__FILE__) + '/../dev-utils/eval_debugger'
 require 'fixtures/company_in_module'
 
 class ModulesTest < Test::Unit::TestCase
-  def setup
-    create_fixtures "accounts"
-    create_fixtures "companies"
-  end
+  fixtures :accounts, :companies, :projects, :developers
 
   def test_module_spanning_associations
-    assert MyApplication::Business::Firm.find_first.has_clients?, "Firm should have clients"
-    firm = MyApplication::Business::Firm.find_first
+    firm = MyApplication::Business::Firm.find(:first)
+    assert !firm.clients.empty?, "Firm should have clients"
     assert_nil firm.class.table_name.match('::'), "Firm shouldn't have the module appear in its table name"
-    assert_equal 2, firm.clients_count, "Firm should have two clients"
+  end
+
+  def test_module_spanning_has_and_belongs_to_many_associations
+    project = MyApplication::Business::Project.find(:first)
+    project.developers << MyApplication::Business::Developer.create("name" => "John")
+    assert "John", project.developers.last.name
   end
   
   def test_associations_spanning_cross_modules
-    assert MyApplication::Billing::Account.find(1).has_firm?, "37signals account should be able to backtrack"
+    account = MyApplication::Billing::Account.find(:first, :order => 'id')
+    assert_kind_of MyApplication::Business::Firm, account.firm
+    assert_kind_of MyApplication::Billing::Firm, account.qualified_billing_firm
+    assert_kind_of MyApplication::Billing::Firm, account.unqualified_billing_firm
+    assert_kind_of MyApplication::Billing::Nested::Firm, account.nested_qualified_billing_firm
+    assert_kind_of MyApplication::Billing::Nested::Firm, account.nested_unqualified_billing_firm
   end
-end
+  
+  def test_find_account_and_include_company
+    account = MyApplication::Billing::Account.find(1, :include => :firm)
+    assert_kind_of MyApplication::Business::Firm, account.instance_variable_get('@firm')
+    assert_kind_of MyApplication::Business::Firm, account.firm
+  end
+  
+end

data/test/multiple_db_test.rb

@@ -1,8 +1,12 @@
 require 'abstract_unit'
-require 'fixtures/course'
 require 'fixtures/entrant'
 
+# So we can test whether Course.connection survives a reload.
+require_dependency 'fixtures/course'
+
 class MultipleDbTest < Test::Unit::TestCase
+  self.use_transactional_fixtures = false
+
   def setup
     @courses  = create_fixtures("courses") { Course.retrieve_connection }
     @entrants = create_fixtures("entrants")
@@ -35,12 +39,22 @@ class MultipleDbTest < Test::Unit::TestCase
 
   def test_associations
     c1 = Course.find(1)
-    assert_equal 2, c1.entrants_count
+    assert_equal 2, c1.entrants.count
     e1 = Entrant.find(1)
     assert_equal e1.course.id, c1.id
     c2 = Course.find(2)
-    assert_equal 1, c2.entrants_count
+    assert_equal 1, c2.entrants.count
     e3 = Entrant.find(3)
     assert_equal e3.course.id, c2.id
   end
+
+  def test_course_connection_should_survive_dependency_reload
+    assert Course.connection
+
+    Dependencies.clear
+    Object.send(:remove_const, :Course)
+    require_dependency 'fixtures/course'
+
+    assert Course.connection
+  end
 end

data/test/pk_test.rb

@@ -1,57 +1,101 @@
-require 'abstract_unit'
+require "#{File.dirname(__FILE__)}/abstract_unit"
 require 'fixtures/topic'
+require 'fixtures/reply'
 require 'fixtures/subscriber'
 require 'fixtures/movie'
+require 'fixtures/keyboard'
+require 'fixtures/mixed_case_monkey'
 
 class PrimaryKeysTest < Test::Unit::TestCase
-  def setup
-    @topics      = create_fixtures "topics"
-    @subscribers = create_fixtures "subscribers"
-    @movies      = create_fixtures "movies"
-  end
+  fixtures :topics, :subscribers, :movies, :mixed_case_monkeys
 
   def test_integer_key
     topic = Topic.find(1)
-    assert_equal(@topics["first"]["author_name"], topic.author_name)
+    assert_equal(topics(:first).author_name, topic.author_name)
     topic = Topic.find(2)
-    assert_equal(@topics["second"]["author_name"], topic.author_name)
+    assert_equal(topics(:second).author_name, topic.author_name)
 
     topic = Topic.new
     topic.title = "New Topic"
-    topic.save
+    assert_equal(nil, topic.id)
+    assert_nothing_raised { topic.save! }
     id = topic.id
 
     topicReloaded = Topic.find(id)
     assert_equal("New Topic", topicReloaded.title)
   end
 
+  def test_customized_primary_key_auto_assigns_on_save
+    Keyboard.delete_all
+    keyboard = Keyboard.new(:name => 'HHKB')
+    assert_nothing_raised { keyboard.save! }
+    assert_equal keyboard.id, Keyboard.find_by_name('HHKB').id
+  end
+
+  def test_customized_primary_key_can_be_get_before_saving
+    keyboard = Keyboard.new
+    assert_nil keyboard.id
+    assert_nothing_raised { assert_nil keyboard.key_number }
+  end
+
+  def test_customized_string_primary_key_settable_before_save
+    subscriber = Subscriber.new
+    assert_nothing_raised { subscriber.id = 'webster123' }
+    assert_equal 'webster123', subscriber.id
+    assert_equal 'webster123', subscriber.nick
+  end
+
   def test_string_key
-    subscriber = Subscriber.find(@subscribers["first"]["nick"])
-    assert_equal(@subscribers["first"]["name"], subscriber.name)
-    subscriber = Subscriber.find(@subscribers["second"]["nick"])
-    assert_equal(@subscribers["second"]["name"], subscriber.name)
+    subscriber = Subscriber.find(subscribers(:first).nick)
+    assert_equal(subscribers(:first).name, subscriber.name)
+    subscriber = Subscriber.find(subscribers(:second).nick)
+    assert_equal(subscribers(:second).name, subscriber.name)
 
     subscriber = Subscriber.new
     subscriber.id = "jdoe"
+    assert_equal("jdoe", subscriber.id)
     subscriber.name = "John Doe"
-    subscriber.save
+    assert_nothing_raised { subscriber.save! }
+    assert_equal("jdoe", subscriber.id)
 
     subscriberReloaded = Subscriber.find("jdoe")
     assert_equal("John Doe", subscriberReloaded.name)
   end
 
   def test_find_with_more_than_one_string_key
-    assert_equal 2, Subscriber.find(@subscribers["first"]["nick"], @subscribers["second"]["nick"]).length
+    assert_equal 2, Subscriber.find(subscribers(:first).nick, subscribers(:second).nick).length
   end
   
   def test_primary_key_prefix
     ActiveRecord::Base.primary_key_prefix_type = :table_name
+    Topic.reset_primary_key
     assert_equal "topicid", Topic.primary_key
 
     ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
+    Topic.reset_primary_key
     assert_equal "topic_id", Topic.primary_key
 
     ActiveRecord::Base.primary_key_prefix_type = nil
+    Topic.reset_primary_key
     assert_equal "id", Topic.primary_key
   end
+  
+  def test_delete_should_quote_pkey
+    assert_nothing_raised { MixedCaseMonkey.delete(1) }
+  end
+  def test_update_counters_should_quote_pkey_and_quote_counter_columns
+    assert_nothing_raised { MixedCaseMonkey.update_counters(1, :fleaCount => 99) }
+  end
+  def test_find_with_one_id_should_quote_pkey
+    assert_nothing_raised { MixedCaseMonkey.find(1) }
+  end
+  def test_find_with_multiple_ids_should_quote_pkey
+    assert_nothing_raised { MixedCaseMonkey.find([1,2]) }
+  end
+  def test_instance_update_should_quote_pkey
+    assert_nothing_raised { MixedCaseMonkey.find(1).save }
+  end
+  def test_instance_destroy_should_quote_pkey
+    assert_nothing_raised { MixedCaseMonkey.find(1).destroy }
+  end
 end

data/test/query_cache_test.rb

@@ -0,0 +1,104 @@
+require 'abstract_unit'
+require 'fixtures/topic'
+require 'fixtures/reply'
+require 'fixtures/task'
+require 'fixtures/course'
+
+
+class QueryCacheTest < Test::Unit::TestCase
+  fixtures :tasks, :topics
+
+  def test_find_queries
+    assert_queries(2) { Task.find(1); Task.find(1) }
+  end
+
+  def test_find_queries_with_cache
+    Task.cache do
+      assert_queries(1) { Task.find(1); Task.find(1) }
+    end
+  end
+
+  def test_count_queries_with_cache
+    Task.cache do
+      assert_queries(1) { Task.count; Task.count }
+    end
+  end
+
+  def test_query_cache_dups_results_correctly
+    Task.cache do
+      now  = Time.now.utc
+      task = Task.find 1
+      assert_not_equal now, task.starting
+      task.starting = now
+      task.reload
+      assert_not_equal now, task.starting
+    end
+  end
+
+  def test_cache_is_flat
+    Task.cache do
+      Topic.columns # don't count this query
+      assert_queries(1) { Topic.find(1); Topic.find(1); }
+    end
+
+    ActiveRecord::Base.cache do
+      assert_queries(1) { Task.find(1); Task.find(1) }
+    end
+  end
+
+  def test_cache_does_not_wrap_string_results_in_arrays
+    Task.cache do
+      assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
+    end
+  end
+end
+
+uses_mocha 'QueryCacheExpiryTest' do
+
+class QueryCacheExpiryTest < Test::Unit::TestCase
+  fixtures :tasks
+
+  def test_find
+    Task.connection.expects(:clear_query_cache).times(1)
+
+    assert !Task.connection.query_cache_enabled
+    Task.cache do
+      assert Task.connection.query_cache_enabled
+      Task.find(1)
+
+      Task.uncached do
+        assert !Task.connection.query_cache_enabled
+        Task.find(1)
+      end
+
+      assert Task.connection.query_cache_enabled
+    end
+    assert !Task.connection.query_cache_enabled
+  end
+
+  def test_update
+    Task.connection.expects(:clear_query_cache).times(2)
+
+    Task.cache do
+      Task.find(1).save!
+    end
+  end
+
+  def test_destroy
+    Task.connection.expects(:clear_query_cache).times(2)
+
+    Task.cache do
+      Task.find(1).destroy
+    end
+  end
+
+  def test_insert
+    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
+
+    Task.cache do
+      Task.create!
+    end
+  end
+end
+
+end

data/test/readonly_test.rb

@@ -0,0 +1,107 @@
+require 'abstract_unit'
+require 'fixtures/post'
+require 'fixtures/comment'
+require 'fixtures/developer'
+require 'fixtures/project'
+require 'fixtures/reader'
+require 'fixtures/person'
+
+# Dummy class methods to test implicit association scoping.
+def Comment.foo() find :first end
+def Project.foo() find :first end
+
+
+class ReadOnlyTest < Test::Unit::TestCase
+  fixtures :posts, :comments, :developers, :projects, :developers_projects
+
+  def test_cant_save_readonly_record
+    dev = Developer.find(1)
+    assert !dev.readonly?
+
+    dev.readonly!
+    assert dev.readonly?
+
+    assert_nothing_raised do
+      dev.name = 'Luscious forbidden fruit.'
+      assert !dev.save
+      dev.name = 'Forbidden.'
+    end
+    assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save  }
+    assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save! }
+  end
+
+
+  def test_find_with_readonly_option
+    Developer.find(:all).each { |d| assert !d.readonly? }
+    Developer.find(:all, :readonly => false).each { |d| assert !d.readonly? }
+    Developer.find(:all, :readonly => true).each { |d| assert d.readonly? }
+  end
+
+
+  def test_find_with_joins_option_implies_readonly
+    # Blank joins don't count.
+    Developer.find(:all, :joins => '  ').each { |d| assert !d.readonly? }
+    Developer.find(:all, :joins => '  ', :readonly => false).each { |d| assert !d.readonly? }
+
+    # Others do.
+    Developer.find(:all, :joins => ', projects').each { |d| assert d.readonly? }
+    Developer.find(:all, :joins => ', projects', :readonly => false).each { |d| assert !d.readonly? }
+  end
+
+
+  def test_habtm_find_readonly
+    dev = Developer.find(1)
+    assert !dev.projects.empty?
+    assert dev.projects.all?(&:readonly?)
+    assert dev.projects.find(:all).all?(&:readonly?)
+    assert dev.projects.find(:all, :readonly => true).all?(&:readonly?)
+  end
+
+  def test_has_many_find_readonly
+    post = Post.find(1)
+    assert !post.comments.empty?
+    assert !post.comments.any?(&:readonly?)
+    assert !post.comments.find(:all).any?(&:readonly?)
+    assert post.comments.find(:all, :readonly => true).all?(&:readonly?)
+  end
+
+  def test_has_many_with_through_is_not_implicitly_marked_readonly
+    assert people = Post.find(1).people
+    assert !people.any?(&:readonly?)
+  end
+
+  def test_readonly_scoping
+    Post.with_scope(:find => { :conditions => '1=1' }) do 
+      assert !Post.find(1).readonly?
+      assert Post.find(1, :readonly => true).readonly?
+      assert !Post.find(1, :readonly => false).readonly?
+    end
+
+    Post.with_scope(:find => { :joins => '   ' }) do 
+      assert !Post.find(1).readonly?
+      assert Post.find(1, :readonly => true).readonly?
+      assert !Post.find(1, :readonly => false).readonly?
+    end
+
+    # Oracle barfs on this because the join includes unqualified and
+    # conflicting column names
+    unless current_adapter?(:OracleAdapter)
+      Post.with_scope(:find => { :joins => ', developers' }) do 
+        assert Post.find(1).readonly?
+        assert Post.find(1, :readonly => true).readonly?
+        assert !Post.find(1, :readonly => false).readonly?
+      end
+    end
+
+    Post.with_scope(:find => { :readonly => true }) do
+      assert Post.find(1).readonly?
+      assert Post.find(1, :readonly => true).readonly?
+      assert !Post.find(1, :readonly => false).readonly?
+    end
+  end
+
+  def test_association_collection_method_missing_scoping_not_readonly
+    assert !Developer.find(1).projects.foo.readonly?
+    assert !Post.find(1).comments.foo.readonly?
+  end
+end