activerecord 2.3.18 → 3.2.22

data/test/cases/migration_test_firebird.rb

@@ -1,124 +0,0 @@
-require "cases/helper"
-require 'models/course'
-
-class FirebirdMigrationTest < ActiveRecord::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/cases/mixin_test.rb

@@ -1,96 +0,0 @@
-require "cases/helper"
-
-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 < ActiveRecord::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.lft_will_change!
-    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/cases/modules_test.rb

@@ -1,109 +0,0 @@
-require "cases/helper"
-require 'models/company_in_module'
-
-class ModulesTest < ActiveRecord::TestCase
-  fixtures :accounts, :companies, :projects, :developers
-
-  def setup
-    # need to make sure Object::Firm and Object::Client are not defined,
-    # so that constantize will not be able to cheat when having to load namespaced classes
-    @undefined_consts = {}
-
-    [:Firm, :Client].each do |const|
-      @undefined_consts.merge! const => Object.send(:remove_const, const) if Object.const_defined?(const)
-    end
-  end
-
-  def teardown
-    # reinstate the constants that we undefined in the setup
-    @undefined_consts.each do |constant, value|
-      Object.send :const_set, constant, value unless value.nil?
-    end
-  end
-
-  def test_module_spanning_associations
-    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"
-  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
-    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
-
-  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
-
-  def test_table_name
-    assert_equal 'accounts', MyApplication::Billing::Account.table_name, 'table_name for ActiveRecord model in module'
-    assert_equal 'companies', MyApplication::Business::Client.table_name, 'table_name for ActiveRecord model subclass'
-    assert_equal 'company_contacts', MyApplication::Business::Client::Contact.table_name, 'table_name for ActiveRecord model enclosed by another ActiveRecord model'
-  end
-
-  def test_assign_ids
-    firm = MyApplication::Business::Firm.first
-
-    assert_nothing_raised NameError, "Should be able to resolve all class constants via reflection" do
-      firm.client_ids = [MyApplication::Business::Client.first.id]
-    end
-  end
-
-  # need to add an eager loading condition to force the eager loading model into
-  # the old join model, to test that. See http://dev.rubyonrails.org/ticket/9640
-  def test_eager_loading_in_modules
-    clients = []
-
-    assert_nothing_raised NameError, "Should be able to resolve all class constants via reflection" do
-      clients << MyApplication::Business::Client.find(3, :include => {:firm => :account}, :conditions => 'accounts.id IS NOT NULL')
-      clients << MyApplication::Business::Client.find(3, :include => {:firm => :account})
-    end
-
-    clients.each do |client|
-      assert_no_queries do
-        assert_not_nil(client.firm.account)
-      end
-    end
-  end
-
-  def test_module_table_name_prefix
-    assert_equal 'prefixed_companies', MyApplication::Business::Prefixed::Company.table_name, 'inferred table_name for ActiveRecord model in module with table_name_prefix'
-    assert_equal 'prefixed_companies', MyApplication::Business::Prefixed::Nested::Company.table_name, 'table_name for ActiveRecord model in nested module with a parent table_name_prefix'
-    assert_equal 'companies', MyApplication::Business::Prefixed::Firm.table_name, 'explicit table_name for ActiveRecord model in module with table_name_prefix should not be prefixed'
-  end
-
-  def test_module_table_name_prefix_with_global_prefix
-    classes = [ MyApplication::Business::Company,
-                MyApplication::Business::Firm,
-                MyApplication::Business::Client,
-                MyApplication::Business::Client::Contact,
-                MyApplication::Business::Developer,
-                MyApplication::Business::Project,
-                MyApplication::Business::Prefixed::Company,
-                MyApplication::Business::Prefixed::Nested::Company,
-                MyApplication::Billing::Account ]
-
-    ActiveRecord::Base.table_name_prefix = 'global_'
-    classes.each(&:reset_table_name)
-    assert_equal 'global_companies', MyApplication::Business::Company.table_name, 'inferred table_name for ActiveRecord model in module without table_name_prefix'
-    assert_equal 'prefixed_companies', MyApplication::Business::Prefixed::Company.table_name, 'inferred table_name for ActiveRecord model in module with table_name_prefix'
-    assert_equal 'prefixed_companies', MyApplication::Business::Prefixed::Nested::Company.table_name, 'table_name for ActiveRecord model in nested module with a parent table_name_prefix'
-    assert_equal 'companies', MyApplication::Business::Prefixed::Firm.table_name, 'explicit table_name for ActiveRecord model in module with table_name_prefix should not be prefixed'
-  ensure
-    ActiveRecord::Base.table_name_prefix = ''
-    classes.each(&:reset_table_name)
-  end
-end

data/test/cases/multiple_db_test.rb

@@ -1,85 +0,0 @@
-require "cases/helper"
-require 'models/entrant'
-
-# So we can test whether Course.connection survives a reload.
-require_dependency 'models/course'
-
-class MultipleDbTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
-
-  def setup
-    @courses  = create_fixtures("courses") { Course.retrieve_connection }
-    @entrants = create_fixtures("entrants")
-  end
-
-  def test_connected
-    assert_not_nil Entrant.connection
-    assert_not_nil Course.connection
-  end
-
-  def test_proper_connection
-    assert_not_equal(Entrant.connection, Course.connection)
-    assert_equal(Entrant.connection, Entrant.retrieve_connection)
-    assert_equal(Course.connection, Course.retrieve_connection)
-    assert_equal(ActiveRecord::Base.connection, Entrant.connection)
-  end
-
-  def test_find
-    c1 = Course.find(1)
-    assert_equal "Ruby Development", c1.name
-    c2 = Course.find(2)
-    assert_equal "Java Development", c2.name
-    e1 = Entrant.find(1)
-    assert_equal "Ruby Developer", e1.name
-    e2 = Entrant.find(2)
-    assert_equal "Ruby Guru", e2.name
-    e3 = Entrant.find(3)
-    assert_equal "Java Lover", e3.name
-  end
-
-  def test_associations
-    c1 = Course.find(1)
-    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
-    e3 = Entrant.find(3)
-    assert_equal e3.course.id, c2.id
-  end
-
-  def test_course_connection_should_survive_dependency_reload
-    assert Course.connection
-
-    ActiveSupport::Dependencies.clear
-    Object.send(:remove_const, :Course)
-    require_dependency 'models/course'
-
-    assert Course.connection
-  end
-
-  def test_transactions_across_databases
-    c1 = Course.find(1)
-    e1 = Entrant.find(1)
-
-    begin
-      Course.transaction do
-        Entrant.transaction do
-          c1.name = "Typo"
-          e1.name = "Typo"
-          c1.save
-          e1.save
-          raise "No I messed up."
-        end
-      end
-    rescue
-      # Yup caught it
-    end
-
-    assert_equal "Typo", c1.name
-    assert_equal "Typo", e1.name
-
-    assert_equal "Ruby Development", Course.find(1).name
-    assert_equal "Ruby Developer", Entrant.find(1).name
-  end
-end