ibm_db 5.1.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/type/adapter_specific_registry_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -74,7 +76,6 @@ module ActiveRecord
     end
 
     test "construct args are passed to the type" do
-      type = Struct.new(:args)
       registry = Type::AdapterSpecificRegistry.new
       registry.register(:foo, type)
 
@@ -115,7 +116,6 @@ module ActiveRecord
 
     test "registering adapter specific modifiers" do
       decoration = Struct.new(:value)
-      type = Struct.new(:args)
       registry = Type::AdapterSpecificRegistry.new
       registry.register(:foo, type)
       registry.add_modifier({ array: true }, decoration, adapter: :postgresql)
@@ -129,5 +129,17 @@ module ActiveRecord
         registry.lookup(:foo, array: true, adapter: :sqlite3)
       )
     end
+
+    TYPE = Class.new do
+      attr_reader :args
+
+      def initialize(args = nil)
+        @args = args
+      end
+
+      def ==(other) self.args == other.args end
+    end
+
+    private def type; TYPE end
   end
 end

data/test/cases/type/date_time_test.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/task"
 
 module ActiveRecord
   module Type
-    class IntegerTest < ActiveRecord::TestCase
+    class DateTimeTest < ActiveRecord::TestCase
       def test_datetime_seconds_precision_applied_to_timestamp
-        skip "This test is invalid if subsecond precision isn't supported" unless subsecond_precision_supported?
+        skip "This test is invalid if subsecond precision isn't supported" unless supports_datetime_with_precision?
         p = Task.create!(starting: ::Time.now)
         assert_equal p.starting.usec, p.reload.starting.usec
       end

data/test/cases/type/integer_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/company"
 
@@ -6,13 +8,13 @@ module ActiveRecord
     class IntegerTest < ActiveRecord::TestCase
       test "casting ActiveRecord models" do
         type = Type::Integer.new
-        firm = Firm.create(:name => 'Apple')
+        firm = Firm.create(name: "Apple")
         assert_nil type.cast(firm)
       end
 
       test "values which are out of range can be re-assigned" do
         klass = Class.new(ActiveRecord::Base) do
-          self.table_name = 'posts'
+          self.table_name = "posts"
           attribute :foo, :integer
         end
         model = klass.new

data/test/cases/type/string_test.rb

@@ -1,22 +1,24 @@
-require 'cases/helper'
+# frozen_string_literal: true
+
+require "cases/helper"
 
 module ActiveRecord
   class StringTypeTest < ActiveRecord::TestCase
     test "string mutations are detected" do
       klass = Class.new(Base)
-      klass.table_name = 'authors'
+      klass.table_name = "authors"
 
-      author = klass.create!(name: 'Sean')
-      assert_not author.changed?
+      author = klass.create!(name: "Sean")
+      assert_not_predicate author, :changed?
 
-      author.name << ' Griffin'
-      assert author.name_changed?
+      author.name << " Griffin"
+      assert_predicate author, :name_changed?
 
       author.save!
       author.reload
 
-      assert_equal 'Sean Griffin', author.name
-      assert_not author.changed?
+      assert_equal "Sean Griffin", author.name
+      assert_not_predicate author, :changed?
     end
   end
 end

data/test/cases/type/time_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+
+module ActiveRecord
+  module Type
+    class TimeTest < ActiveRecord::TestCase
+      def test_default_year_is_correct
+        expected_time = ::Time.utc(2000, 1, 1, 10, 30, 0)
+        topic = Topic.new(bonus_time: { 4 => 10, 5 => 30 })
+
+        assert_equal expected_time, topic.bonus_time
+        assert_instance_of ::Time, topic.bonus_time
+
+        topic.save!
+
+        assert_equal expected_time, topic.bonus_time
+        assert_instance_of ::Time, topic.bonus_time
+
+        topic.reload
+
+        assert_equal expected_time, topic.bonus_time
+        assert_instance_of ::Time, topic.bonus_time
+      end
+    end
+  end
+end

data/test/cases/type/type_map_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -15,7 +17,7 @@ module ActiveRecord
 
         mapping.register_type(/boolean/i, boolean)
 
-        assert_equal mapping.lookup('boolean'), boolean
+        assert_equal mapping.lookup("boolean"), boolean
       end
 
       def test_overriding_registered_types
@@ -26,26 +28,26 @@ module ActiveRecord
         mapping.register_type(/time/i, time)
         mapping.register_type(/time/i, timestamp)
 
-        assert_equal mapping.lookup('time'), timestamp
+        assert_equal mapping.lookup("time"), timestamp
       end
 
       def test_fuzzy_lookup
-        string = String.new
+        string = +""
         mapping = TypeMap.new
 
         mapping.register_type(/varchar/i, string)
 
-        assert_equal mapping.lookup('varchar(20)'), string
+        assert_equal mapping.lookup("varchar(20)"), string
       end
 
       def test_aliasing_types
-        string = String.new
+        string = +""
         mapping = TypeMap.new
 
         mapping.register_type(/string/i, string)
-        mapping.alias_type(/varchar/i, 'string')
+        mapping.alias_type(/varchar/i, "string")
 
-        assert_equal mapping.lookup('varchar'), string
+        assert_equal mapping.lookup("varchar"), string
       end
 
       def test_changing_type_changes_aliases
@@ -54,37 +56,37 @@ module ActiveRecord
         mapping = TypeMap.new
 
         mapping.register_type(/timestamp/i, time)
-        mapping.alias_type(/datetime/i, 'timestamp')
+        mapping.alias_type(/datetime/i, "timestamp")
         mapping.register_type(/timestamp/i, timestamp)
 
-        assert_equal mapping.lookup('datetime'), timestamp
+        assert_equal mapping.lookup("datetime"), timestamp
       end
 
       def test_aliases_keep_metadata
         mapping = TypeMap.new
 
         mapping.register_type(/decimal/i) { |sql_type| sql_type }
-        mapping.alias_type(/number/i, 'decimal')
+        mapping.alias_type(/number/i, "decimal")
 
-        assert_equal mapping.lookup('number(20)'), 'decimal(20)'
-        assert_equal mapping.lookup('number'), 'decimal'
+        assert_equal mapping.lookup("number(20)"), "decimal(20)"
+        assert_equal mapping.lookup("number"), "decimal"
       end
 
       def test_register_proc
-        string = String.new
+        string = +""
         binary = Binary.new
         mapping = TypeMap.new
 
         mapping.register_type(/varchar/i) do |type|
-          if type.include?('(')
+          if type.include?("(")
             string
           else
             binary
           end
         end
 
-        assert_equal mapping.lookup('varchar(20)'), string
-        assert_equal mapping.lookup('varchar'), binary
+        assert_equal mapping.lookup("varchar(20)"), string
+        assert_equal mapping.lookup("varchar"), binary
       end
 
       def test_additional_lookup_args
@@ -92,16 +94,16 @@ module ActiveRecord
 
         mapping.register_type(/varchar/i) do |type, limit|
           if limit > 255
-            'text'
+            "text"
           else
-            'string'
+            "string"
           end
         end
-        mapping.alias_type(/string/i, 'varchar')
+        mapping.alias_type(/string/i, "varchar")
 
-        assert_equal mapping.lookup('varchar', 200), 'string'
-        assert_equal mapping.lookup('varchar', 400), 'text'
-        assert_equal mapping.lookup('string', 400), 'text'
+        assert_equal mapping.lookup("varchar", 200), "string"
+        assert_equal mapping.lookup("varchar", 400), "text"
+        assert_equal mapping.lookup("string", 400), "text"
       end
 
       def test_requires_value_or_block
@@ -115,13 +117,13 @@ module ActiveRecord
       def test_lookup_non_strings
         mapping = HashLookupTypeMap.new
 
-        mapping.register_type(1, 'string')
-        mapping.register_type(2, 'int')
+        mapping.register_type(1, "string")
+        mapping.register_type(2, "int")
         mapping.alias_type(3, 1)
 
-        assert_equal mapping.lookup(1), 'string'
-        assert_equal mapping.lookup(2), 'int'
-        assert_equal mapping.lookup(3), 'string'
+        assert_equal mapping.lookup(1), "string"
+        assert_equal mapping.lookup(2), "int"
+        assert_equal mapping.lookup(3), "string"
         assert_kind_of Type::Value, mapping.lookup(4)
       end
 
@@ -174,4 +176,3 @@ module ActiveRecord
     end
   end
 end
-

data/test/cases/type/unsigned_integer_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module Type
+    class UnsignedIntegerTest < ActiveRecord::TestCase
+      test "unsigned int max value is in range" do
+        assert_equal(4294967295, UnsignedInteger.new.serialize(4294967295))
+      end
+
+      test "minus value is out of range" do
+        assert_raises(ActiveModel::RangeError) do
+          UnsignedInteger.new.serialize(-1)
+        end
+      end
+    end
+  end
+end

data/test/cases/type_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class TypeTest < ActiveRecord::TestCase

data/test/cases/types_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -9,7 +11,7 @@ module ActiveRecord
           raise
         end
         klass = Class.new(ActiveRecord::Base) do
-          self.table_name = 'posts'
+          self.table_name = "posts"
           attribute :foo, type_which_cannot_go_to_the_database
         end
         model = klass.new

data/test/cases/unconnected_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class TestRecord < ActiveRecord::Base
@@ -9,6 +11,9 @@ class TestUnconnectedAdapter < ActiveRecord::TestCase
   def setup
     @underlying = ActiveRecord::Base.connection
     @specification = ActiveRecord::Base.remove_connection
+
+    # Clear out connection info from other pids (like a fork parent) too
+    ActiveRecord::ConnectionAdapters::PoolConfig.discard_pools!
   end
 
   teardown do
@@ -27,7 +32,15 @@ class TestUnconnectedAdapter < ActiveRecord::TestCase
     end
   end
 
+  def test_error_message_when_connection_not_established
+    error = assert_raise(ActiveRecord::ConnectionNotEstablished) do
+      TestRecord.find(1)
+    end
+
+    assert_equal "No connection pool for 'ActiveRecord::Base' found.", error.message
+  end
+
   def test_underlying_adapter_no_longer_active
-    assert !@underlying.active?, "Removed adapter should no longer be active"
+    assert_not @underlying.active?, "Removed adapter should no longer be active"
   end
 end

data/test/cases/unsafe_raw_sql_test.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+require "models/comment"
+
+class UnsafeRawSqlTest < ActiveRecord::TestCase
+  fixtures :posts, :comments
+
+  test "order: allows string column name" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids = Post.order("title").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows symbol column name" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids = Post.order(:title).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows downcase symbol direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids = Post.order(title: :asc).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows upcase symbol direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("ASC")).pluck(:id)
+
+    ids = Post.order(title: :ASC).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows string direction" do
+    ids_expected = Post.order(Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids = Post.order(title: "asc").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows multiple columns" do
+    ids_expected = Post.order(Arel.sql("author_id"), Arel.sql("title")).pluck(:id)
+
+    ids = Post.order(:author_id, :title).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows mixed" do
+    ids_expected = Post.order(Arel.sql("author_id"), Arel.sql("title") => Arel.sql("asc")).pluck(:id)
+
+    ids = Post.order(:author_id, title: :asc).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows table and column names" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    ids = Post.order("posts.title").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows quoted table and column names" do
+    ids_expected = Post.order(Arel.sql("title")).pluck(:id)
+
+    quoted_title = Post.connection.quote_table_name("posts.title")
+    ids = Post.order(quoted_title).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows column name and direction in string" do
+    ids_expected = Post.order(Arel.sql("title desc")).pluck(:id)
+
+    ids = Post.order("title desc").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows table name, column name and direction in string" do
+    ids_expected = Post.order(Arel.sql("title desc")).pluck(:id)
+
+    ids = Post.order("posts.title desc").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows NULLS FIRST and NULLS LAST too" do
+    raise "precondition failed" if Post.count < 2
+
+    # Ensure there are NULL and non-NULL post types.
+    Post.first.update_column(:type, nil)
+    Post.last.update_column(:type, "Programming")
+
+    ["asc", "desc", ""].each do |direction|
+      %w(first last).each do |position|
+        ids_expected = Post.order(Arel.sql("type::text #{direction} nulls #{position}")).pluck(:id)
+
+        ids = Post.order("type::text #{direction} nulls #{position}").pluck(:id)
+
+        assert_equal ids_expected, ids
+      end
+    end
+  end if current_adapter?(:PostgreSQLAdapter)
+
+  test "order: disallows invalid column name" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order("REPLACE(title, 'misc', 'zzzz') asc").pluck(:id)
+    end
+  end
+
+  test "order: disallows invalid direction" do
+    assert_raises(ArgumentError) do
+      Post.order(title: :foo).pluck(:id)
+    end
+  end
+
+  test "order: disallows invalid column with direction" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order("REPLACE(title, 'misc', 'zzzz')" => :asc).pluck(:id)
+    end
+  end
+
+  test "order: always allows Arel" do
+    titles = Post.order(Arel.sql("length(title)")).pluck(:title)
+
+    assert_not_empty titles
+  end
+
+  test "order: allows Arel.sql with binds" do
+    ids_expected = Post.order(Arel.sql("REPLACE(title, 'misc', 'zzzz'), id")).pluck(:id)
+
+    ids = Post.order([Arel.sql("REPLACE(title, ?, ?), id"), "misc", "zzzz"]).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: disallows invalid bind statement" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order(["REPLACE(title, ?, ?), id", "misc", "zzzz"]).pluck(:id)
+    end
+  end
+
+  test "order: disallows invalid Array arguments" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order(["author_id", "REPLACE(title, 'misc', 'zzzz')"]).pluck(:id)
+    end
+  end
+
+  test "order: allows valid Array arguments" do
+    ids_expected = Post.order(Arel.sql("author_id, length(title)")).pluck(:id)
+
+    ids = Post.order(["author_id", "length(title)"]).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: logs deprecation warning for unrecognized column" do
+    e = assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.order("REPLACE(title, 'misc', 'zzzz')")
+    end
+
+    assert_match(/Query method called with non-attribute argument\(s\):/, e.message)
+  end
+
+  test "pluck: allows string column name" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck("title")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows string column name with function and alias" do
+    titles_expected = Post.pluck(Arel.sql("UPPER(title)"))
+
+    titles = Post.pluck("UPPER(title) AS title")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows symbol column name" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck(:title)
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows multiple column names" do
+    values_expected = Post.pluck(Arel.sql("title"), Arel.sql("id"))
+
+    values = Post.pluck(:title, :id)
+
+    assert_equal values_expected, values
+  end
+
+  test "pluck: allows column names with includes" do
+    values_expected = Post.includes(:comments).pluck(Arel.sql("title"), Arel.sql("id"))
+
+    values = Post.includes(:comments).pluck(:title, :id)
+
+    assert_equal values_expected, values
+  end
+
+  test "pluck: allows auto-generated attributes" do
+    values_expected = Post.pluck(Arel.sql("tags_count"))
+
+    values = Post.pluck(:tags_count)
+
+    assert_equal values_expected, values
+  end
+
+  test "pluck: allows table and column names" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck("posts.title")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows quoted table and column names" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    quoted_title = Post.connection.quote_table_name("posts.title")
+    titles = Post.pluck(quoted_title)
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: disallows invalid column name" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.pluck("REPLACE(title, 'misc', 'zzzz')")
+    end
+  end
+
+  test "pluck: disallows invalid column name amongst valid names" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.pluck(:title, "REPLACE(title, 'misc', 'zzzz')")
+    end
+  end
+
+  test "pluck: disallows invalid column names with includes" do
+    assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.includes(:comments).pluck(:title, "REPLACE(title, 'misc', 'zzzz')")
+    end
+  end
+
+  test "pluck: always allows Arel" do
+    excepted_values = Post.includes(:comments).pluck(:title).map { |title| [title, title.size] }
+    values = Post.includes(:comments).pluck(:title, Arel.sql("length(title)"))
+
+    assert_equal excepted_values, values
+  end
+
+  test "pluck: logs deprecation warning" do
+    e = assert_raises(ActiveRecord::UnknownAttributeReference) do
+      Post.includes(:comments).pluck(:title, "REPLACE(title, 'misc', 'zzzz')")
+    end
+
+    assert_match(/Query method called with non-attribute argument\(s\):/, e.message)
+  end
+end