activerecord 2.3.18 → 3.2.22

data/test/cases/schema_test_postgresql.rb

@@ -1,178 +0,0 @@
-require "cases/helper"
-
-class SchemaTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
-
-  SCHEMA_NAME = 'test_schema'
-  SCHEMA2_NAME = 'test_schema2'
-  TABLE_NAME = 'things'
-  CAPITALIZED_TABLE_NAME = 'Things'
-  INDEX_A_NAME = 'a_index_things_on_name'
-  INDEX_B_NAME = 'b_index_things_on_different_columns_in_each_schema'
-  INDEX_A_COLUMN = 'name'
-  INDEX_B_COLUMN_S1 = 'email'
-  INDEX_B_COLUMN_S2 = 'moment'
-  COLUMNS = [
-    'id integer',
-    'name character varying(50)',
-    'email character varying(50)',
-    'moment timestamp without time zone default now()'
-  ]
-
-  class Thing1 < ActiveRecord::Base
-    set_table_name "test_schema.things"
-  end
-
-  class Thing2 < ActiveRecord::Base
-    set_table_name "test_schema2.things"
-  end
-
-  class Thing3 < ActiveRecord::Base
-    set_table_name 'test_schema."things.table"'
-  end
-
-  class Thing4 < ActiveRecord::Base
-    set_table_name 'test_schema."Things"'
-  end
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
-    @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{TABLE_NAME}.table\" (#{COLUMNS.join(',')})"
-    @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{CAPITALIZED_TABLE_NAME}\" (#{COLUMNS.join(',')})"
-    @connection.execute "CREATE SCHEMA #{SCHEMA2_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
-    @connection.execute "CREATE INDEX #{INDEX_A_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_A_COLUMN});"
-    @connection.execute "CREATE INDEX #{INDEX_A_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_A_COLUMN});"
-    @connection.execute "CREATE INDEX #{INDEX_B_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_B_COLUMN_S1});"
-    @connection.execute "CREATE INDEX #{INDEX_B_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_B_COLUMN_S2});"
-  end
-
-  def teardown
-    @connection.execute "DROP SCHEMA #{SCHEMA2_NAME} CASCADE"
-    @connection.execute "DROP SCHEMA #{SCHEMA_NAME} CASCADE"
-  end
-
-  def test_with_schema_prefixed_table_name
-    assert_nothing_raised do
-      assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{TABLE_NAME}")
-    end
-  end
-
-  def test_with_schema_prefixed_capitalized_table_name
-    assert_nothing_raised do
-      assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{CAPITALIZED_TABLE_NAME}")
-    end
-  end
-
-  def test_with_schema_search_path
-    assert_nothing_raised do
-      with_schema_search_path(SCHEMA_NAME) do
-        assert_equal COLUMNS, columns(TABLE_NAME)
-      end
-    end
-  end
-
-
-  def test_proper_encoding_of_table_name
-    assert_equal '"table_name"', @connection.quote_table_name('table_name')
-    assert_equal '"table.name"', @connection.quote_table_name('"table.name"')
-    assert_equal '"schema_name"."table_name"', @connection.quote_table_name('schema_name.table_name')
-    assert_equal '"schema_name"."table.name"', @connection.quote_table_name('schema_name."table.name"')
-    assert_equal '"schema.name"."table_name"', @connection.quote_table_name('"schema.name".table_name')
-    assert_equal '"schema.name"."table.name"', @connection.quote_table_name('"schema.name"."table.name"')
-  end
-
-  def test_classes_with_qualified_schema_name
-    assert_equal 0, Thing1.count
-    assert_equal 0, Thing2.count
-    assert_equal 0, Thing3.count
-    assert_equal 0, Thing4.count
-
-    Thing1.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
-    assert_equal 1, Thing1.count
-    assert_equal 0, Thing2.count
-    assert_equal 0, Thing3.count
-    assert_equal 0, Thing4.count
-
-    Thing2.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
-    assert_equal 1, Thing1.count
-    assert_equal 1, Thing2.count
-    assert_equal 0, Thing3.count
-    assert_equal 0, Thing4.count
-
-    Thing3.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
-    assert_equal 1, Thing1.count
-    assert_equal 1, Thing2.count
-    assert_equal 1, Thing3.count
-    assert_equal 0, Thing4.count
-
-    Thing4.create(:id => 1, :name => "thing1", :email => "thing1@localhost", :moment => Time.now)
-    assert_equal 1, Thing1.count
-    assert_equal 1, Thing2.count
-    assert_equal 1, Thing3.count
-    assert_equal 1, Thing4.count
-  end
-
-  def test_raise_on_unquoted_schema_name
-    assert_raise(ActiveRecord::StatementInvalid) do
-      with_schema_search_path '$user,public'
-    end
-  end
-
-  def test_without_schema_search_path
-    assert_raise(ActiveRecord::StatementInvalid) { columns(TABLE_NAME) }
-  end
-
-  def test_ignore_nil_schema_search_path
-    assert_nothing_raised { with_schema_search_path nil }
-  end
-
-  def test_dump_indexes_for_schema_one
-    do_dump_index_tests_for_schema(SCHEMA_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S1)
-  end
-
-  def test_dump_indexes_for_schema_two
-    do_dump_index_tests_for_schema(SCHEMA2_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S2)
-  end
-
-  def test_with_uppercase_index_name
-    ActiveRecord::Base.connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
-    assert_nothing_raised { ActiveRecord::Base.connection.remove_index! "things", "#{SCHEMA_NAME}.things_Index"}
-
-    ActiveRecord::Base.connection.execute "CREATE INDEX \"things_Index\" ON #{SCHEMA_NAME}.things (name)"
-    ActiveRecord::Base.connection.schema_search_path = SCHEMA_NAME
-    assert_nothing_raised { ActiveRecord::Base.connection.remove_index! "things", "things_Index"}
-    ActiveRecord::Base.connection.schema_search_path = "public"
-  end
-
-  private
-    def columns(table_name)
-      @connection.send(:column_definitions, table_name).map do |name, type, default|
-        "#{name} #{type}" + (default ? " default #{default}" : '')
-      end
-    end
-
-    def with_schema_search_path(schema_search_path)
-      @connection.schema_search_path = schema_search_path
-      yield if block_given?
-    ensure
-      @connection.schema_search_path = "'$user', public"
-    end
-
-    def do_dump_index_tests_for_schema(this_schema_name, first_index_column_name, second_index_column_name)
-      with_schema_search_path(this_schema_name) do
-        indexes = @connection.indexes(TABLE_NAME).sort_by {|i| i.name}
-        assert_equal 2,indexes.size
-
-        do_dump_index_assertions_for_one_index(indexes[0], INDEX_A_NAME, first_index_column_name)
-        do_dump_index_assertions_for_one_index(indexes[1], INDEX_B_NAME, second_index_column_name)
-      end
-    end
-
-    def do_dump_index_assertions_for_one_index(this_index, this_index_name, this_index_column)
-      assert_equal TABLE_NAME, this_index.table
-      assert_equal 1, this_index.columns.size
-      assert_equal this_index_column, this_index.columns[0]
-      assert_equal this_index_name, this_index.name
-    end
-end

data/test/cases/serialization_test.rb

@@ -1,47 +0,0 @@
-require "cases/helper"
-require 'models/contact'
-
-class SerializationTest < ActiveRecord::TestCase
-  FORMATS = [ :xml, :json ]
-
-  def setup
-    @contact_attributes = {
-      :name        => 'aaron stack',
-      :age         => 25,
-      :avatar      => 'binarydata',
-      :created_at  => Time.utc(2006, 8, 1),
-      :awesome     => false,
-      :preferences => { :gem => '<strong>ruby</strong>' }
-    }
-
-    @contact = Contact.new(@contact_attributes)
-  end
-
-  def test_serialize_should_be_reversible
-    for format in FORMATS
-      @serialized = Contact.new.send("to_#{format}")
-      contact = Contact.new.send("from_#{format}", @serialized)
-
-      assert_equal @contact_attributes.keys.collect(&:to_s).sort, contact.attributes.keys.collect(&:to_s).sort, "For #{format}"
-    end
-  end
-
-  def test_serialize_should_allow_attribute_only_filtering
-    for format in FORMATS
-      @serialized = Contact.new(@contact_attributes).send("to_#{format}", :only => [ :age, :name ])
-      contact = Contact.new.send("from_#{format}", @serialized)
-      assert_equal @contact_attributes[:name], contact.name, "For #{format}"
-      assert_nil contact.avatar, "For #{format}"
-    end
-  end
-
-  def test_serialize_should_allow_attribute_except_filtering
-    for format in FORMATS
-      @serialized = Contact.new(@contact_attributes).send("to_#{format}", :except => [ :age, :name ])
-      contact = Contact.new.send("from_#{format}", @serialized)
-      assert_nil contact.name, "For #{format}"
-      assert_nil contact.age, "For #{format}"
-      assert_equal @contact_attributes[:awesome], contact.awesome, "For #{format}"
-    end
-  end
-end

data/test/cases/sp_test_mysql.rb

@@ -1,16 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-require 'models/minimalistic'
-
-class StoredProcedureTest < ActiveRecord::TestCase
-  fixtures :topics
-
-  # Test that MySQL allows multiple results for stored procedures
-  if Mysql.const_defined?(:CLIENT_MULTI_RESULTS)
-    def test_multi_results_from_find_by_sql
-      topics = Topic.find_by_sql 'CALL topics();'
-      assert_equal 1, topics.size
-      assert ActiveRecord::Base.connection.active?, "Bad connection use by 'MysqlAdapter.select'"
-    end
-  end
-end

data/test/cases/synonym_test_oracle.rb

@@ -1,17 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-require 'models/subject'
-
-# confirm that synonyms work just like tables; in this case
-# the "subjects" table in Oracle (defined in oci.sql) is just
-# a synonym to the "topics" table
-
-class TestOracleSynonym < ActiveRecord::TestCase
-
-  def test_oracle_synonym
-    topic = Topic.new
-    subject = Subject.new
-    assert_equal(topic.attributes, subject.attributes)
-  end
-
-end

data/test/cases/timestamp_test.rb

@@ -1,75 +0,0 @@
-require 'cases/helper'
-require 'models/developer'
-require 'models/owner'
-require 'models/pet'
-
-class TimestampTest < ActiveRecord::TestCase
-  fixtures :developers, :owners, :pets
-
-  def setup
-    @developer = Developer.first
-    @previously_updated_at = @developer.updated_at
-  end
-
-  def test_saving_a_changed_record_updates_its_timestamp
-    @developer.name = "Jack Bauer"
-    @developer.save!
-    
-    assert @previously_updated_at != @developer.updated_at
-  end
-  
-  def test_saving_a_unchanged_record_doesnt_update_its_timestamp
-    @developer.save!
-    
-    assert @previously_updated_at == @developer.updated_at
-  end
-  
-  def test_touching_a_record_updates_its_timestamp
-    @developer.touch
-    
-    assert @previously_updated_at != @developer.updated_at
-  end
-  
-  def test_touching_a_different_attribute
-    previously_created_at = @developer.created_at
-    @developer.touch(:created_at)
-
-    assert previously_created_at != @developer.created_at
-  end
-  
-  def test_saving_a_record_with_a_belongs_to_that_specifies_touching_the_parent_should_update_the_parent_updated_at
-    pet   = Pet.first
-    owner = pet.owner
-    previously_owner_updated_at = owner.updated_at
-    
-    pet.name = "Fluffy the Third"
-    pet.save
-    
-    assert previously_owner_updated_at != pet.owner.updated_at
-  end
-
-  def test_destroying_a_record_with_a_belongs_to_that_specifies_touching_the_parent_should_update_the_parent_updated_at
-    pet   = Pet.first
-    owner = pet.owner
-    previously_owner_updated_at = owner.updated_at
-    
-    pet.destroy
-    
-    assert previously_owner_updated_at != pet.owner.updated_at
-  end
-  
-  def test_saving_a_record_with_a_belongs_to_that_specifies_touching_a_specific_attribute_the_parent_should_update_that_attribute
-    Pet.belongs_to :owner, :touch => :happy_at
-
-    pet   = Pet.first
-    owner = pet.owner
-    previously_owner_happy_at = owner.happy_at
-    
-    pet.name = "Fluffy the Third"
-    pet.save
-    
-    assert previously_owner_happy_at != pet.owner.happy_at
-  ensure
-    Pet.belongs_to :owner, :touch => true
-  end
-end