ibm_db 3.0.5-x86-mingw32 → 5.0.5-x86-mingw32

data/test/cases/readonly_test.rb

@@ -7,9 +7,10 @@ require 'models/computer'
 require 'models/project'
 require 'models/reader'
 require 'models/person'
+require 'models/ship'
 
 class ReadOnlyTest < ActiveRecord::TestCase
-  fixtures :authors, :posts, :comments, :developers, :projects, :developers_projects, :people, :readers, :author_addresses
+  fixtures :authors, :posts, :comments, :developers, :projects, :developers_projects, :people, :readers
 
   def test_cant_save_readonly_record
     dev = Developer.find(1)

data/test/cases/reflection_test.rb

@@ -24,6 +24,7 @@ require 'models/department'
 require 'models/cake_designer'
 require 'models/drink_designer'
 require 'models/mocktail_designer'
+require 'models/recipe'
 
 class ReflectionTest < ActiveRecord::TestCase
   include ActiveRecord::Reflection
@@ -51,13 +52,13 @@ class ReflectionTest < ActiveRecord::TestCase
   end
 
   def test_columns_are_returned_in_the_order_they_were_declared
-    column_names = Topic.columns.map { |column| column.name }
+    column_names = Topic.columns.map(&:name)
     assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content important approved replies_count unique_replies_count parent_id parent_title type group created_at updated_at), column_names
   end
 
   def test_content_columns
     content_columns        = Topic.content_columns
-    content_column_names   = content_columns.map {|column| column.name}
+    content_column_names   = content_columns.map(&:name)
     assert_equal 13, content_columns.length
     assert_equal %w(title author_name author_email_address written_on bonus_time last_read content important group approved parent_title created_at updated_at).sort, content_column_names.sort
   end
@@ -81,10 +82,21 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_equal :integer, @first.column_for_attribute("id").type
   end
 
-  def test_non_existent_columns_return_nil
-    assert_deprecated do
-      assert_nil @first.column_for_attribute("attribute_that_doesnt_exist")
-    end
+  def test_non_existent_columns_return_null_object
+    column = @first.column_for_attribute("attribute_that_doesnt_exist")
+    assert_instance_of ActiveRecord::ConnectionAdapters::NullColumn, column
+    assert_equal "attribute_that_doesnt_exist", column.name
+    assert_equal nil, column.sql_type
+    assert_equal nil, column.type
+  end
+
+  def test_non_existent_types_are_identity_types
+    type = @first.type_for_attribute("attribute_that_doesnt_exist")
+    object = Object.new
+
+    assert_equal object, type.deserialize(object)
+    assert_equal object, type.cast(object)
+    assert_equal object, type.serialize(object)
   end
 
   def test_reflection_klass_for_nested_class_name
@@ -272,9 +284,26 @@ class ReflectionTest < ActiveRecord::TestCase
     @hotel.mocktail_designers << MocktailDesigner.create!
 
     assert_equal 1, @hotel.mocktail_designers.size
+    assert_equal 1, @hotel.mocktail_designers.count
     assert_equal 1, @hotel.chef_lists.size
   end
 
+  def test_scope_chain_of_polymorphic_association_does_not_leak_into_other_hmt_associations
+    hotel = Hotel.create!
+    department = hotel.departments.create!
+    drink = department.chefs.create!(employable: DrinkDesigner.create!)
+    Recipe.create!(chef_id: drink.id, hotel_id: hotel.id)
+
+    expected_sql = capture_sql { hotel.recipes.to_a }
+
+    Hotel.reflect_on_association(:recipes).clear_association_scope_cache
+    hotel.reload
+    hotel.drink_designers.to_a
+    loaded_sql = capture_sql { hotel.recipes.to_a }
+
+    assert_equal expected_sql, loaded_sql
+  end
+
   def test_nested?
     assert !Author.reflect_on_association(:comments).nested?
     assert Author.reflect_on_association(:tags).nested?
@@ -296,6 +325,15 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_equal "custom_primary_key", Author.reflect_on_association(:tags_with_primary_key).association_primary_key.to_s # nested
   end
 
+  def test_association_primary_key_type
+    # Normal Association
+    assert_equal :integer, Author.reflect_on_association(:posts).association_primary_key_type.type
+    assert_equal :string,  Author.reflect_on_association(:essay).association_primary_key_type.type
+
+    # Through Association
+    assert_equal :string, Author.reflect_on_association(:essay_category).association_primary_key_type.type
+  end
+
   def test_association_primary_key_raises_when_missing_primary_key
     reflection = ActiveRecord::Reflection.create(:has_many, :edge, nil, {}, Author)
     assert_raises(ActiveRecord::UnknownPrimaryKey) { reflection.association_primary_key }
@@ -374,12 +412,14 @@ class ReflectionTest < ActiveRecord::TestCase
     product = Struct.new(:table_name, :pluralize_table_names).new('products', true)
 
     reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, {}, product)
-    reflection.stubs(:klass).returns(category)
-    assert_equal 'categories_products', reflection.join_table
+    reflection.stub(:klass, category) do
+      assert_equal 'categories_products', reflection.join_table
+    end
 
     reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, {}, category)
-    reflection.stubs(:klass).returns(product)
-    assert_equal 'categories_products', reflection.join_table
+    reflection.stub(:klass, product) do
+      assert_equal 'categories_products', reflection.join_table
+    end
   end
 
   def test_join_table_with_common_prefix
@@ -387,12 +427,14 @@ class ReflectionTest < ActiveRecord::TestCase
     product = Struct.new(:table_name, :pluralize_table_names).new('catalog_products', true)
 
     reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, {}, product)
-    reflection.stubs(:klass).returns(category)
-    assert_equal 'catalog_categories_products', reflection.join_table
+    reflection.stub(:klass, category) do
+      assert_equal 'catalog_categories_products', reflection.join_table
+    end
 
     reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, {}, category)
-    reflection.stubs(:klass).returns(product)
-    assert_equal 'catalog_categories_products', reflection.join_table
+    reflection.stub(:klass, product) do
+      assert_equal 'catalog_categories_products', reflection.join_table
+    end
   end
 
   def test_join_table_with_different_prefix
@@ -400,12 +442,14 @@ class ReflectionTest < ActiveRecord::TestCase
     page = Struct.new(:table_name, :pluralize_table_names).new('content_pages', true)
 
     reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, {}, page)
-    reflection.stubs(:klass).returns(category)
-    assert_equal 'catalog_categories_content_pages', reflection.join_table
+    reflection.stub(:klass, category) do
+      assert_equal 'catalog_categories_content_pages', reflection.join_table
+    end
 
     reflection = ActiveRecord::Reflection.create(:has_many, :pages, nil, {}, category)
-    reflection.stubs(:klass).returns(page)
-    assert_equal 'catalog_categories_content_pages', reflection.join_table
+    reflection.stub(:klass, page) do
+      assert_equal 'catalog_categories_content_pages', reflection.join_table
+    end
   end
 
   def test_join_table_can_be_overridden
@@ -413,12 +457,14 @@ class ReflectionTest < ActiveRecord::TestCase
     product = Struct.new(:table_name, :pluralize_table_names).new('products', true)
 
     reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, { :join_table => 'product_categories' }, product)
-    reflection.stubs(:klass).returns(category)
-    assert_equal 'product_categories', reflection.join_table
+    reflection.stub(:klass, category) do
+      assert_equal 'product_categories', reflection.join_table
+    end
 
     reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, { :join_table => 'product_categories' }, category)
-    reflection.stubs(:klass).returns(product)
-    assert_equal 'product_categories', reflection.join_table
+    reflection.stub(:klass, product) do
+      assert_equal 'product_categories', reflection.join_table
+    end
   end
 
   def test_includes_accepts_symbols

data/test/cases/relation/delegation_test.rb

@@ -27,12 +27,13 @@ module ActiveRecord
 
   module DelegationWhitelistBlacklistTests
     ARRAY_DELEGATES = [
-      :+, :-, :|, :&, :[],
+      :+, :-, :|, :&, :[], :shuffle,
       :all?, :collect, :compact, :detect, :each, :each_cons, :each_with_index,
       :exclude?, :find_all, :flat_map, :group_by, :include?, :length,
       :map, :none?, :one?, :partition, :reject, :reverse,
       :sample, :second, :sort, :sort_by, :third,
-      :to_ary, :to_set, :to_xml, :to_yaml, :join
+      :to_ary, :to_set, :to_xml, :to_yaml, :join,
+      :in_groups, :in_groups_of, :to_sentence, :to_formatted_s
     ]
 
     ARRAY_DELEGATES.each do |method|
@@ -40,12 +41,6 @@ module ActiveRecord
         assert_respond_to target, method
       end
     end
-
-    ActiveRecord::Delegation::BLACKLISTED_ARRAY_METHODS.each do |method|
-      define_method "test_#{method}_is_not_delegated_to_Array" do
-        assert_raises(NoMethodError) { call_method(target, method) }
-      end
-    end
   end
 
   class DelegationAssociationTest < DelegationTest

data/test/cases/relation/merging_test.rb

@@ -8,7 +8,7 @@ require 'models/project'
 require 'models/rating'
 
 class RelationMergingTest < ActiveRecord::TestCase
-  fixtures :developers, :comments, :authors, :posts, :author_addresses
+  fixtures :developers, :comments, :authors, :posts
 
   def test_relation_merging
     devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order('id ASC').where("id < 3"))
@@ -82,26 +82,15 @@ class RelationMergingTest < ActiveRecord::TestCase
     left  = Post.where(title: "omg").where(comments_count: 1)
     right = Post.where(title: "wtf").where(title: "bbq")
 
-    expected = [left.bind_values[1]] + right.bind_values
+    expected = [left.bound_attributes[1]] + right.bound_attributes
     merged   = left.merge(right)
 
-    assert_equal expected, merged.bind_values
+    assert_equal expected, merged.bound_attributes
     assert !merged.to_sql.include?("omg")
     assert merged.to_sql.include?("wtf")
     assert merged.to_sql.include?("bbq")
   end
 
-  def test_merging_keeps_lhs_bind_parameters
-    column = Post.columns_hash['id']
-    binds = [[column, 20]]
-
-    right  = Post.where(id: 20)
-    left   = Post.where(id: 10)
-
-    merged = left.merge(right)
-    assert_equal binds, merged.bind_values
-  end
-
   def test_merging_reorders_bind_params
     post  = Post.first
     right = Post.where(id: 1)
@@ -115,6 +104,13 @@ class RelationMergingTest < ActiveRecord::TestCase
     post = PostThatLoadsCommentsInAnAfterSaveHook.create!(title: "First Post", body: "Blah blah blah.")
     assert_equal "First comment!", post.comments.where(body: "First comment!").first_or_create.body
   end
+
+  def test_merging_with_from_clause
+    relation = Post.all
+    assert relation.from_clause.empty?
+    relation = relation.merge(Post.from("posts"))
+    refute relation.from_clause.empty?
+  end
 end
 
 class MergingDifferentRelationsTest < ActiveRecord::TestCase

data/test/cases/relation/mutation_test.rb

@@ -22,13 +22,21 @@ module ActiveRecord
       def sanitize_sql(sql)
         sql
       end
+
+      def sanitize_sql_for_order(sql)
+        sql
+      end
+
+      def arel_attribute(name, table)
+        table[name]
+      end
     end
 
     def relation
-      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table
+      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table, Post.predicate_builder
     end
 
-    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select]).each do |method|
+    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select, :left_joins]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal [:foo], relation.public_send("#{method}_values")
@@ -55,9 +63,10 @@ module ActiveRecord
 
     test '#order! on non-string does not attempt regexp match for references' do
       obj = Object.new
-      obj.expects(:=~).never
-      assert relation.order!(obj)
-      assert_equal [obj], relation.order_values
+      assert_not_called(obj, :=~) do
+        assert relation.order!(obj)
+        assert_equal [obj], relation.order_values
+      end
     end
 
     test '#references!' do
@@ -81,7 +90,7 @@ module ActiveRecord
       assert_equal [], relation.extending_values
     end
 
-    (Relation::SINGLE_VALUE_METHODS - [:from, :lock, :reordering, :reverse_order, :create_with]).each do |method|
+    (Relation::SINGLE_VALUE_METHODS - [:lock, :reordering, :reverse_order, :create_with, :uniq]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal :foo, relation.public_send("#{method}_value")
@@ -90,7 +99,7 @@ module ActiveRecord
 
     test '#from!' do
       assert relation.from!('foo').equal?(relation)
-      assert_equal ['foo', nil], relation.from_value
+      assert_equal 'foo', relation.from_clause.value
     end
 
     test '#lock!' do
@@ -99,11 +108,11 @@ module ActiveRecord
     end
 
     test '#reorder!' do
-      order_relation = self.relation.order('foo')
+      @relation = self.relation.order('foo')
 
-      assert order_relation.reorder!('bar').equal?(order_relation)
-      assert_equal ['bar'], order_relation.order_values
-      assert order_relation.reordering_value
+      assert relation.reorder!('bar').equal?(relation)
+      assert_equal ['bar'], relation.order_values
+      assert relation.reordering_value
     end
 
     test '#reorder! with symbol prepends the table name' do
@@ -116,18 +125,18 @@ module ActiveRecord
     end
 
     test 'reverse_order!' do
-      order_relation = Post.order('title ASC, comments_count DESC')
+      @relation = Post.order('title ASC, comments_count DESC')
 
-      order_relation.reverse_order!
+      relation.reverse_order!
 
-      assert_equal 'title DESC', order_relation.order_values.first
-      assert_equal 'comments_count ASC', order_relation.order_values.last
+      assert_equal 'title DESC', relation.order_values.first
+      assert_equal 'comments_count ASC', relation.order_values.last
 
 
-      order_relation.reverse_order!
+      relation.reverse_order!
 
-      assert_equal 'title ASC', order_relation.order_values.first
-      assert_equal 'comments_count DESC', order_relation.order_values.last
+      assert_equal 'title ASC', relation.order_values.first
+      assert_equal 'comments_count DESC', relation.order_values.last
     end
 
     test 'create_with!' do
@@ -136,12 +145,12 @@ module ActiveRecord
     end
 
     test 'test_merge!' do
-      assert relation.merge!(where: :foo).equal?(relation)
-      assert_equal [:foo], relation.where_values
+      assert relation.merge!(select: :foo).equal?(relation)
+      assert_equal [:foo], relation.select_values
     end
 
     test 'merge with a proc' do
-      assert_equal [:foo], relation.merge(-> { where(:foo) }).where_values
+      assert_equal [:foo], relation.merge(-> { select(:foo) }).select_values
     end
 
     test 'none!' do
@@ -153,13 +162,22 @@ module ActiveRecord
     test 'distinct!' do
       relation.distinct! :foo
       assert_equal :foo, relation.distinct_value
-      assert_equal :foo, relation.uniq_value # deprecated access
+
+      assert_deprecated do
+        assert_equal :foo, relation.uniq_value # deprecated access
+      end
     end
 
     test 'uniq! was replaced by distinct!' do
-      relation.uniq! :foo
+      assert_deprecated(/use distinct! instead/) do
+        relation.uniq! :foo
+      end
+
+      assert_deprecated(/use distinct_value instead/) do
+        assert_equal :foo, relation.uniq_value # deprecated access
+      end
+
       assert_equal :foo, relation.distinct_value
-      assert_equal :foo, relation.uniq_value # deprecated access
     end
   end
 end

data/test/cases/relation/or_test.rb

@@ -0,0 +1,92 @@
+require "cases/helper"
+require 'models/post'
+
+module ActiveRecord
+  class OrTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    def test_or_with_relation
+      expected = Post.where('id = 1 or id = 2').to_a
+      assert_equal expected, Post.where('id = 1').or(Post.where('id = 2')).to_a
+    end
+
+    def test_or_identity
+      expected = Post.where('id = 1').to_a
+      assert_equal expected, Post.where('id = 1').or(Post.where('id = 1')).to_a
+    end
+
+    def test_or_with_null_left
+      expected = Post.where('id = 1').to_a
+      assert_equal expected, Post.none.or(Post.where('id = 1')).to_a
+    end
+
+    def test_or_with_null_right
+      expected = Post.where('id = 1').to_a
+      assert_equal expected, Post.where('id = 1').or(Post.none).to_a
+    end
+
+    def test_or_with_bind_params
+      assert_equal Post.find([1, 2]), Post.where(id: 1).or(Post.where(id: 2)).to_a
+    end
+
+    def test_or_with_null_both
+      expected = Post.none.to_a
+      assert_equal expected, Post.none.or(Post.none).to_a
+    end
+
+    def test_or_without_left_where
+      expected = Post.all
+      assert_equal expected, Post.or(Post.where('id = 1')).to_a
+    end
+
+    def test_or_without_right_where
+      expected = Post.all
+      assert_equal expected, Post.where('id = 1').or(Post.all).to_a
+    end
+
+    def test_or_preserves_other_querying_methods
+      expected = Post.where('id = 1 or id = 2 or id = 3').order('body asc').to_a
+      partial = Post.order('body asc')
+      assert_equal expected, partial.where('id = 1').or(partial.where(:id => [2, 3])).to_a
+      assert_equal expected, Post.order('body asc').where('id = 1').or(Post.order('body asc').where(:id => [2, 3])).to_a
+    end
+
+    def test_or_with_incompatible_relations
+      error = assert_raises ArgumentError do
+        Post.order('body asc').where('id = 1').or(Post.order('id desc').where(:id => [2, 3])).to_a
+      end
+
+      assert_equal "Relation passed to #or must be structurally compatible. Incompatible values: [:order]", error.message
+    end
+
+    def test_or_when_grouping
+      groups = Post.where('id < 10').group('body').select('body, COUNT(*) AS c')
+      expected = groups.having("COUNT(*) > 1 OR body like 'Such%'").to_a.map {|o| [o.body, o.c] }
+      assert_equal expected, groups.having('COUNT(*) > 1').or(groups.having("body like 'Such%'")).to_a.map {|o| [o.body, o.c] }
+    end
+
+    def test_or_with_named_scope
+      expected = Post.where("id = 1 or body LIKE '\%a\%'").to_a
+      assert_equal expected, Post.where('id = 1').or(Post.containing_the_letter_a)
+    end
+
+    def test_or_inside_named_scope
+      expected = Post.where("body LIKE '\%a\%' OR title LIKE ?", "%'%").order('id DESC').to_a
+      assert_equal expected, Post.order(id: :desc).typographically_interesting
+    end
+
+    def test_or_on_loaded_relation
+      expected = Post.where('id = 1 or id = 2').to_a
+      p = Post.where('id = 1')
+      p.load
+      assert_equal p.loaded?, true
+      assert_equal expected, p.or(Post.where('id = 2')).to_a
+    end
+
+    def test_or_with_non_relation_object_raises_error
+      assert_raises ArgumentError do
+        Post.where(id: [1, 2, 3]).or(title: 'Rails')
+      end
+    end
+  end
+end