ibm_db 3.0.4-x86-mingw32 → 3.0.5-x86-mingw32

data/test/cases/relation/mutation_test.rb

@@ -1,165 +1,165 @@
-require 'cases/helper'
-require 'models/post'
-
-module ActiveRecord
-  class RelationMutationTest < ActiveSupport::TestCase
-    class FakeKlass < Struct.new(:table_name, :name)
-      extend ActiveRecord::Delegation::DelegateCache
-      inherited self
-
-      def connection
-        Post.connection
-      end
-
-      def relation_delegate_class(klass)
-        self.class.relation_delegate_class(klass)
-      end
-
-      def attribute_alias?(name)
-        false
-      end
-
-      def sanitize_sql(sql)
-        sql
-      end
-    end
-
-    def relation
-      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table
-    end
-
-    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select]).each do |method|
-      test "##{method}!" do
-        assert relation.public_send("#{method}!", :foo).equal?(relation)
-        assert_equal [:foo], relation.public_send("#{method}_values")
-      end
-    end
-
-    test "#_select!" do
-      assert relation.public_send("_select!", :foo).equal?(relation)
-      assert_equal [:foo], relation.public_send("select_values")
-    end
-
-    test '#order!' do
-      assert relation.order!('name ASC').equal?(relation)
-      assert_equal ['name ASC'], relation.order_values
-    end
-
-    test '#order! with symbol prepends the table name' do
-      assert relation.order!(:name).equal?(relation)
-      node = relation.order_values.first
-      assert node.ascending?
-      assert_equal :name, node.expr.name
-      assert_equal "posts", node.expr.relation.name
-    end
-
-    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
-    end
-
-    test '#references!' do
-      assert relation.references!(:foo).equal?(relation)
-      assert relation.references_values.include?('foo')
-    end
-
-    test 'extending!' do
-      mod, mod2 = Module.new, Module.new
-
-      assert relation.extending!(mod).equal?(relation)
-      assert_equal [mod], relation.extending_values
-      assert relation.is_a?(mod)
-
-      relation.extending!(mod2)
-      assert_equal [mod, mod2], relation.extending_values
-    end
-
-    test 'extending! with empty args' do
-      relation.extending!
-      assert_equal [], relation.extending_values
-    end
-
-    (Relation::SINGLE_VALUE_METHODS - [:from, :lock, :reordering, :reverse_order, :create_with]).each do |method|
-      test "##{method}!" do
-        assert relation.public_send("#{method}!", :foo).equal?(relation)
-        assert_equal :foo, relation.public_send("#{method}_value")
-      end
-    end
-
-    test '#from!' do
-      assert relation.from!('foo').equal?(relation)
-      assert_equal ['foo', nil], relation.from_value
-    end
-
-    test '#lock!' do
-      assert relation.lock!('foo').equal?(relation)
-      assert_equal 'foo', relation.lock_value
-    end
-
-    test '#reorder!' do
-      order_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
-    end
-
-    test '#reorder! with symbol prepends the table name' do
-      assert relation.reorder!(:name).equal?(relation)
-      node = relation.order_values.first
-
-      assert node.ascending?
-      assert_equal :name, node.expr.name
-      assert_equal "posts", node.expr.relation.name
-    end
-
-    test 'reverse_order!' do
-      order_relation = Post.order('title ASC, comments_count DESC')
-
-      order_relation.reverse_order!
-
-      assert_equal 'title DESC', order_relation.order_values.first
-      assert_equal 'comments_count ASC', order_relation.order_values.last
-
-
-      order_relation.reverse_order!
-
-      assert_equal 'title ASC', order_relation.order_values.first
-      assert_equal 'comments_count DESC', order_relation.order_values.last
-    end
-
-    test 'create_with!' do
-      assert relation.create_with!(foo: 'bar').equal?(relation)
-      assert_equal({foo: 'bar'}, relation.create_with_value)
-    end
-
-    test 'test_merge!' do
-      assert relation.merge!(where: :foo).equal?(relation)
-      assert_equal [:foo], relation.where_values
-    end
-
-    test 'merge with a proc' do
-      assert_equal [:foo], relation.merge(-> { where(:foo) }).where_values
-    end
-
-    test 'none!' do
-      assert relation.none!.equal?(relation)
-      assert_equal [NullRelation], relation.extending_values
-      assert relation.is_a?(NullRelation)
-    end
-
-    test 'distinct!' do
-      relation.distinct! :foo
-      assert_equal :foo, relation.distinct_value
-      assert_equal :foo, relation.uniq_value # deprecated access
-    end
-
-    test 'uniq! was replaced by distinct!' do
-      relation.uniq! :foo
-      assert_equal :foo, relation.distinct_value
-      assert_equal :foo, relation.uniq_value # deprecated access
-    end
-  end
-end
+require 'cases/helper'
+require 'models/post'
+
+module ActiveRecord
+  class RelationMutationTest < ActiveSupport::TestCase
+    class FakeKlass < Struct.new(:table_name, :name)
+      extend ActiveRecord::Delegation::DelegateCache
+      inherited self
+
+      def connection
+        Post.connection
+      end
+
+      def relation_delegate_class(klass)
+        self.class.relation_delegate_class(klass)
+      end
+
+      def attribute_alias?(name)
+        false
+      end
+
+      def sanitize_sql(sql)
+        sql
+      end
+    end
+
+    def relation
+      @relation ||= Relation.new FakeKlass.new('posts'), Post.arel_table
+    end
+
+    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select]).each do |method|
+      test "##{method}!" do
+        assert relation.public_send("#{method}!", :foo).equal?(relation)
+        assert_equal [:foo], relation.public_send("#{method}_values")
+      end
+    end
+
+    test "#_select!" do
+      assert relation.public_send("_select!", :foo).equal?(relation)
+      assert_equal [:foo], relation.public_send("select_values")
+    end
+
+    test '#order!' do
+      assert relation.order!('name ASC').equal?(relation)
+      assert_equal ['name ASC'], relation.order_values
+    end
+
+    test '#order! with symbol prepends the table name' do
+      assert relation.order!(:name).equal?(relation)
+      node = relation.order_values.first
+      assert node.ascending?
+      assert_equal :name, node.expr.name
+      assert_equal "posts", node.expr.relation.name
+    end
+
+    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
+    end
+
+    test '#references!' do
+      assert relation.references!(:foo).equal?(relation)
+      assert relation.references_values.include?('foo')
+    end
+
+    test 'extending!' do
+      mod, mod2 = Module.new, Module.new
+
+      assert relation.extending!(mod).equal?(relation)
+      assert_equal [mod], relation.extending_values
+      assert relation.is_a?(mod)
+
+      relation.extending!(mod2)
+      assert_equal [mod, mod2], relation.extending_values
+    end
+
+    test 'extending! with empty args' do
+      relation.extending!
+      assert_equal [], relation.extending_values
+    end
+
+    (Relation::SINGLE_VALUE_METHODS - [:from, :lock, :reordering, :reverse_order, :create_with]).each do |method|
+      test "##{method}!" do
+        assert relation.public_send("#{method}!", :foo).equal?(relation)
+        assert_equal :foo, relation.public_send("#{method}_value")
+      end
+    end
+
+    test '#from!' do
+      assert relation.from!('foo').equal?(relation)
+      assert_equal ['foo', nil], relation.from_value
+    end
+
+    test '#lock!' do
+      assert relation.lock!('foo').equal?(relation)
+      assert_equal 'foo', relation.lock_value
+    end
+
+    test '#reorder!' do
+      order_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
+    end
+
+    test '#reorder! with symbol prepends the table name' do
+      assert relation.reorder!(:name).equal?(relation)
+      node = relation.order_values.first
+
+      assert node.ascending?
+      assert_equal :name, node.expr.name
+      assert_equal "posts", node.expr.relation.name
+    end
+
+    test 'reverse_order!' do
+      order_relation = Post.order('title ASC, comments_count DESC')
+
+      order_relation.reverse_order!
+
+      assert_equal 'title DESC', order_relation.order_values.first
+      assert_equal 'comments_count ASC', order_relation.order_values.last
+
+
+      order_relation.reverse_order!
+
+      assert_equal 'title ASC', order_relation.order_values.first
+      assert_equal 'comments_count DESC', order_relation.order_values.last
+    end
+
+    test 'create_with!' do
+      assert relation.create_with!(foo: 'bar').equal?(relation)
+      assert_equal({foo: 'bar'}, relation.create_with_value)
+    end
+
+    test 'test_merge!' do
+      assert relation.merge!(where: :foo).equal?(relation)
+      assert_equal [:foo], relation.where_values
+    end
+
+    test 'merge with a proc' do
+      assert_equal [:foo], relation.merge(-> { where(:foo) }).where_values
+    end
+
+    test 'none!' do
+      assert relation.none!.equal?(relation)
+      assert_equal [NullRelation], relation.extending_values
+      assert relation.is_a?(NullRelation)
+    end
+
+    test 'distinct!' do
+      relation.distinct! :foo
+      assert_equal :foo, relation.distinct_value
+      assert_equal :foo, relation.uniq_value # deprecated access
+    end
+
+    test 'uniq! was replaced by distinct!' do
+      relation.uniq! :foo
+      assert_equal :foo, relation.distinct_value
+      assert_equal :foo, relation.uniq_value # deprecated access
+    end
+  end
+end

data/test/cases/relation/predicate_builder_test.rb

@@ -1,14 +1,14 @@
-require "cases/helper"
-require 'models/topic'
-
-module ActiveRecord
-  class PredicateBuilderTest < ActiveRecord::TestCase
-    def test_registering_new_handlers
-      PredicateBuilder.register_handler(Regexp, proc do |column, value|
-        Arel::Nodes::InfixOperation.new('~', column, Arel.sql(value.source))
-      end)
-
-      assert_match %r{["`]topics["`].["`]title["`] ~ rails}i, Topic.where(title: /rails/).to_sql
-    end
-  end
-end
+require "cases/helper"
+require 'models/topic'
+
+module ActiveRecord
+  class PredicateBuilderTest < ActiveRecord::TestCase
+    def test_registering_new_handlers
+      PredicateBuilder.register_handler(Regexp, proc do |column, value|
+        Arel::Nodes::InfixOperation.new('~', column, Arel.sql(value.source))
+      end)
+
+      assert_match %r{["`]topics["`].["`]title["`] ~ rails}i, Topic.where(title: /rails/).to_sql
+    end
+  end
+end

data/test/cases/relation/where_chain_test.rb

@@ -1,181 +1,181 @@
-require 'cases/helper'
-require 'models/post'
-require 'models/comment'
-
-module ActiveRecord
-  class WhereChainTest < ActiveRecord::TestCase
-    fixtures :posts
-
-    def setup
-      super
-      @name = 'title'
-    end
-
-    def test_not_eq
-      relation = Post.where.not(title: 'hello')
-
-      assert_equal 1, relation.where_values.length
-
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'hello', bind.last
-    end
-
-    def test_not_null
-      expected = Post.arel_table[@name].not_eq(nil)
-      relation = Post.where.not(title: nil)
-      assert_equal([expected], relation.where_values)
-    end
-
-    def test_not_with_nil
-      assert_raise ArgumentError do
-        Post.where.not(nil)
-      end
-    end
-
-    def test_not_in
-      expected = Post.arel_table[@name].not_in(%w[hello goodbye])
-      relation = Post.where.not(title: %w[hello goodbye])
-      assert_equal([expected], relation.where_values)
-    end
-
-    def test_association_not_eq
-      expected = Comment.arel_table[@name].not_eq('hello')
-      relation = Post.joins(:comments).where.not(comments: {title: 'hello'})
-      assert_equal(expected.to_sql, relation.where_values.first.to_sql)
-    end
-
-    def test_not_eq_with_preceding_where
-      relation = Post.where(title: 'hello').where.not(title: 'world')
-
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
-      assert_equal 'hello', bind.last
-
-      value = relation.where_values.last
-      bind  = relation.bind_values.last
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'world', bind.last
-    end
-
-    def test_not_eq_with_succeeding_where
-      relation = Post.where.not(title: 'hello').where(title: 'world')
-
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'hello', bind.last
-
-      value = relation.where_values.last
-      bind  = relation.bind_values.last
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
-      assert_equal 'world', bind.last
-    end
-
-    def test_not_eq_with_string_parameter
-      expected = Arel::Nodes::Not.new("title = 'hello'")
-      relation = Post.where.not("title = 'hello'")
-      assert_equal([expected], relation.where_values)
-    end
-
-    def test_not_eq_with_array_parameter
-      expected = Arel::Nodes::Not.new("title = 'hello'")
-      relation = Post.where.not(['title = ?', 'hello'])
-      assert_equal([expected], relation.where_values)
-    end
-
-    def test_chaining_multiple
-      relation = Post.where.not(author_id: [1, 2]).where.not(title: 'ruby on rails')
-
-      expected = Post.arel_table['author_id'].not_in([1, 2])
-      assert_equal(expected, relation.where_values[0])
-
-      value = relation.where_values[1]
-      bind  = relation.bind_values.first
-
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
-      assert_equal 'ruby on rails', bind.last
-    end
-
-    def test_rewhere_with_one_condition
-      relation = Post.where(title: 'hello').where(title: 'world').rewhere(title: 'alone')
-
-      assert_equal 1, relation.where_values.size
-      value = relation.where_values.first
-      bind = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
-      assert_equal 'alone', bind.last
-    end
-
-    def test_rewhere_with_multiple_overwriting_conditions
-      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone', body: 'again')
-
-      assert_equal 2, relation.where_values.size
-
-      value = relation.where_values.first
-      bind = relation.bind_values.first
-      assert_bound_ast value, Post.arel_table['title'], Arel::Nodes::Equality
-      assert_equal 'alone', bind.last
-
-      value = relation.where_values[1]
-      bind = relation.bind_values[1]
-      assert_bound_ast value, Post.arel_table['body'], Arel::Nodes::Equality
-      assert_equal 'again', bind.last
-    end
-
-    def assert_bound_ast value, table, type
-      assert_equal table, value.left
-      assert_kind_of type, value
-      assert_kind_of Arel::Nodes::BindParam, value.right
-    end
-
-    def test_rewhere_with_one_overwriting_condition_and_one_unrelated
-      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone')
-
-      assert_equal 2, relation.where_values.size
-
-      value = relation.where_values.first
-      bind  = relation.bind_values.first
-
-      assert_bound_ast value, Post.arel_table['body'], Arel::Nodes::Equality
-      assert_equal 'world', bind.last
-
-      value = relation.where_values.second
-      bind  = relation.bind_values.second
-
-      assert_bound_ast value, Post.arel_table['title'], Arel::Nodes::Equality
-      assert_equal 'alone', bind.last
-    end
-
-    def test_rewhere_with_range
-      relation = Post.where(comments_count: 1..3).rewhere(comments_count: 3..5)
-
-      assert_equal 1, relation.where_values.size
-      assert_equal Post.where(comments_count: 3..5), relation
-    end
-
-    def test_rewhere_with_infinite_upper_bound_range
-      relation = Post.where(comments_count: 1..Float::INFINITY).rewhere(comments_count: 3..5)
-
-      assert_equal 1, relation.where_values.size
-      assert_equal Post.where(comments_count: 3..5), relation
-    end
-
-    def test_rewhere_with_infinite_lower_bound_range
-      relation = Post.where(comments_count: -Float::INFINITY..1).rewhere(comments_count: 3..5)
-
-      assert_equal 1, relation.where_values.size
-      assert_equal Post.where(comments_count: 3..5), relation
-    end
-
-    def test_rewhere_with_infinite_range
-      relation = Post.where(comments_count: -Float::INFINITY..Float::INFINITY).rewhere(comments_count: 3..5)
-
-      assert_equal 1, relation.where_values.size
-      assert_equal Post.where(comments_count: 3..5), relation
-    end
-  end
-end
+require 'cases/helper'
+require 'models/post'
+require 'models/comment'
+
+module ActiveRecord
+  class WhereChainTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    def setup
+      super
+      @name = 'title'
+    end
+
+    def test_not_eq
+      relation = Post.where.not(title: 'hello')
+
+      assert_equal 1, relation.where_values.length
+
+      value = relation.where_values.first
+      bind  = relation.bind_values.first
+
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
+      assert_equal 'hello', bind.last
+    end
+
+    def test_not_null
+      expected = Post.arel_table[@name].not_eq(nil)
+      relation = Post.where.not(title: nil)
+      assert_equal([expected], relation.where_values)
+    end
+
+    def test_not_with_nil
+      assert_raise ArgumentError do
+        Post.where.not(nil)
+      end
+    end
+
+    def test_not_in
+      expected = Post.arel_table[@name].not_in(%w[hello goodbye])
+      relation = Post.where.not(title: %w[hello goodbye])
+      assert_equal([expected], relation.where_values)
+    end
+
+    def test_association_not_eq
+      expected = Comment.arel_table[@name].not_eq('hello')
+      relation = Post.joins(:comments).where.not(comments: {title: 'hello'})
+      assert_equal(expected.to_sql, relation.where_values.first.to_sql)
+    end
+
+    def test_not_eq_with_preceding_where
+      relation = Post.where(title: 'hello').where.not(title: 'world')
+
+      value = relation.where_values.first
+      bind  = relation.bind_values.first
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
+      assert_equal 'hello', bind.last
+
+      value = relation.where_values.last
+      bind  = relation.bind_values.last
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
+      assert_equal 'world', bind.last
+    end
+
+    def test_not_eq_with_succeeding_where
+      relation = Post.where.not(title: 'hello').where(title: 'world')
+
+      value = relation.where_values.first
+      bind  = relation.bind_values.first
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
+      assert_equal 'hello', bind.last
+
+      value = relation.where_values.last
+      bind  = relation.bind_values.last
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
+      assert_equal 'world', bind.last
+    end
+
+    def test_not_eq_with_string_parameter
+      expected = Arel::Nodes::Not.new("title = 'hello'")
+      relation = Post.where.not("title = 'hello'")
+      assert_equal([expected], relation.where_values)
+    end
+
+    def test_not_eq_with_array_parameter
+      expected = Arel::Nodes::Not.new("title = 'hello'")
+      relation = Post.where.not(['title = ?', 'hello'])
+      assert_equal([expected], relation.where_values)
+    end
+
+    def test_chaining_multiple
+      relation = Post.where.not(author_id: [1, 2]).where.not(title: 'ruby on rails')
+
+      expected = Post.arel_table['author_id'].not_in([1, 2])
+      assert_equal(expected, relation.where_values[0])
+
+      value = relation.where_values[1]
+      bind  = relation.bind_values.first
+
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::NotEqual
+      assert_equal 'ruby on rails', bind.last
+    end
+
+    def test_rewhere_with_one_condition
+      relation = Post.where(title: 'hello').where(title: 'world').rewhere(title: 'alone')
+
+      assert_equal 1, relation.where_values.size
+      value = relation.where_values.first
+      bind = relation.bind_values.first
+      assert_bound_ast value, Post.arel_table[@name], Arel::Nodes::Equality
+      assert_equal 'alone', bind.last
+    end
+
+    def test_rewhere_with_multiple_overwriting_conditions
+      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone', body: 'again')
+
+      assert_equal 2, relation.where_values.size
+
+      value = relation.where_values.first
+      bind = relation.bind_values.first
+      assert_bound_ast value, Post.arel_table['title'], Arel::Nodes::Equality
+      assert_equal 'alone', bind.last
+
+      value = relation.where_values[1]
+      bind = relation.bind_values[1]
+      assert_bound_ast value, Post.arel_table['body'], Arel::Nodes::Equality
+      assert_equal 'again', bind.last
+    end
+
+    def assert_bound_ast value, table, type
+      assert_equal table, value.left
+      assert_kind_of type, value
+      assert_kind_of Arel::Nodes::BindParam, value.right
+    end
+
+    def test_rewhere_with_one_overwriting_condition_and_one_unrelated
+      relation = Post.where(title: 'hello').where(body: 'world').rewhere(title: 'alone')
+
+      assert_equal 2, relation.where_values.size
+
+      value = relation.where_values.first
+      bind  = relation.bind_values.first
+
+      assert_bound_ast value, Post.arel_table['body'], Arel::Nodes::Equality
+      assert_equal 'world', bind.last
+
+      value = relation.where_values.second
+      bind  = relation.bind_values.second
+
+      assert_bound_ast value, Post.arel_table['title'], Arel::Nodes::Equality
+      assert_equal 'alone', bind.last
+    end
+
+    def test_rewhere_with_range
+      relation = Post.where(comments_count: 1..3).rewhere(comments_count: 3..5)
+
+      assert_equal 1, relation.where_values.size
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+
+    def test_rewhere_with_infinite_upper_bound_range
+      relation = Post.where(comments_count: 1..Float::INFINITY).rewhere(comments_count: 3..5)
+
+      assert_equal 1, relation.where_values.size
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+
+    def test_rewhere_with_infinite_lower_bound_range
+      relation = Post.where(comments_count: -Float::INFINITY..1).rewhere(comments_count: 3..5)
+
+      assert_equal 1, relation.where_values.size
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+
+    def test_rewhere_with_infinite_range
+      relation = Post.where(comments_count: -Float::INFINITY..Float::INFINITY).rewhere(comments_count: 3..5)
+
+      assert_equal 1, relation.where_values.size
+      assert_equal Post.where(comments_count: 3..5), relation
+    end
+  end
+end