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

data/test/cases/coders/yaml_column_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 require "cases/helper"
 
@@ -5,54 +6,56 @@ module ActiveRecord
   module Coders
     class YAMLColumnTest < ActiveRecord::TestCase
       def test_initialize_takes_class
-        coder = YAMLColumn.new(Object)
+        coder = YAMLColumn.new("attr_name", Object)
         assert_equal Object, coder.object_class
       end
 
       def test_type_mismatch_on_different_classes_on_dump
-        coder = YAMLColumn.new(Array)
-        assert_raises(SerializationTypeMismatch) do
+        coder = YAMLColumn.new("tags", Array)
+        error = assert_raises(SerializationTypeMismatch) do
           coder.dump("a")
         end
+        assert_equal %{can't dump `tags`: was supposed to be a Array, but was a String. -- "a"}, error.to_s
       end
 
       def test_type_mismatch_on_different_classes
-        coder = YAMLColumn.new(Array)
-        assert_raises(SerializationTypeMismatch) do
+        coder = YAMLColumn.new("tags", Array)
+        error = assert_raises(SerializationTypeMismatch) do
           coder.load "--- foo"
         end
+        assert_equal %{can't load `tags`: was supposed to be a Array, but was a String. -- "foo"}, error.to_s
       end
 
       def test_nil_is_ok
-        coder = YAMLColumn.new
+        coder = YAMLColumn.new("attr_name")
         assert_nil coder.load "--- "
       end
 
       def test_returns_new_with_different_class
-        coder = YAMLColumn.new SerializationTypeMismatch
+        coder = YAMLColumn.new("attr_name", SerializationTypeMismatch)
         assert_equal SerializationTypeMismatch, coder.load("--- ").class
       end
 
       def test_returns_string_unless_starts_with_dash
-        coder = YAMLColumn.new
-        assert_equal 'foo', coder.load("foo")
+        coder = YAMLColumn.new("attr_name")
+        assert_equal "foo", coder.load("foo")
       end
 
       def test_load_handles_other_classes
-        coder = YAMLColumn.new
+        coder = YAMLColumn.new("attr_name")
         assert_equal [], coder.load([])
       end
 
       def test_load_doesnt_swallow_yaml_exceptions
-        coder = YAMLColumn.new
-        bad_yaml = '--- {'
+        coder = YAMLColumn.new("attr_name")
+        bad_yaml = "--- {"
         assert_raises(Psych::SyntaxError) do
           coder.load(bad_yaml)
         end
       end
 
       def test_load_doesnt_handle_undefined_class_or_module
-        coder = YAMLColumn.new
+        coder = YAMLColumn.new("attr_name")
         missing_class_yaml = '--- !ruby/object:DoesNotExistAndShouldntEver {}\n'
         assert_raises(ArgumentError) do
           coder.load(missing_class_yaml)

data/test/cases/collection_cache_key_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/computer"
 require "models/developer"
@@ -5,24 +7,25 @@ require "models/project"
 require "models/topic"
 require "models/post"
 require "models/comment"
+require "models/ship"
 
 module ActiveRecord
   class CollectionCacheKeyTest < ActiveRecord::TestCase
     fixtures :developers, :projects, :developers_projects, :topics, :comments, :posts
 
     test "collection_cache_key on model" do
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, Developer.collection_cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, Developer.collection_cache_key)
     end
 
     test "cache_key for relation" do
       developers = Developer.where(salary: 100000).order(updated_at: :desc)
       last_developer_timestamp = developers.first.updated_at
 
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
 
-      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
 
-      assert_equal Digest::MD5.hexdigest(developers.to_sql), $1
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
       assert_equal developers.count.to_s, $2
       assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
     end
@@ -31,11 +34,25 @@ module ActiveRecord
       developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5)
       last_developer_timestamp = developers.first.updated_at
 
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for relation with custom select and limit" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5)
+      developers_with_select = developers.select("developers.*")
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers_with_select.cache_key)
 
-      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers_with_select.cache_key
 
-      assert_equal Digest::MD5.hexdigest(developers.to_sql), $1
+      assert_equal ActiveSupport::Digest.hexdigest(developers_with_select.to_sql), $1
       assert_equal developers.count.to_s, $2
       assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
     end
@@ -44,37 +61,121 @@ module ActiveRecord
       developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5).load
       last_developer_timestamp = developers.first.updated_at
 
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
 
-      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
 
-      assert_equal Digest::MD5.hexdigest(developers.to_sql), $1
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
       assert_equal developers.count.to_s, $2
       assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
     end
 
+    test "cache_key for relation with table alias" do
+      table_alias = Developer.arel_table.alias("omg_developers")
+      table_metadata = ActiveRecord::TableMetadata.new(Developer, table_alias)
+      predicate_builder = ActiveRecord::PredicateBuilder.new(table_metadata)
+
+      developers = ActiveRecord::Relation.create(
+        Developer,
+        table: table_alias,
+        predicate_builder: predicate_builder
+      )
+      developers = developers.where(salary: 100000).order(updated_at: :desc)
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/ =~ developers.cache_key
+
+      assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      assert_equal developers.count.to_s, $2
+      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+    end
+
+    test "cache_key for relation with includes" do
+      comments = Comment.includes(:post).where("posts.type": "Post")
+      assert_match(/\Acomments\/query-(\h+)-(\d+)-(\d+)\z/, comments.cache_key)
+    end
+
+    test "cache_key for loaded relation with includes" do
+      comments = Comment.includes(:post).where("posts.type": "Post").load
+      assert_match(/\Acomments\/query-(\h+)-(\d+)-(\d+)\z/, comments.cache_key)
+    end
+
+    test "update_all will update cache_key" do
+      developers = Developer.where(name: "David")
+      cache_key = developers.cache_key
+
+      developers.update_all(updated_at: Time.now.utc)
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "update_all with includes will update cache_key" do
+      developers = Developer.includes(:projects).where("projects.name": "Active Record")
+      cache_key = developers.cache_key
+
+      developers.update_all(updated_at: Time.now.utc)
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "delete_all will update cache_key" do
+      developers = Developer.where(name: "David")
+      cache_key = developers.cache_key
+
+      developers.delete_all
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "delete_all with includes will update cache_key" do
+      developers = Developer.includes(:projects).where("projects.name": "Active Record")
+      cache_key = developers.cache_key
+
+      developers.delete_all
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
+    test "destroy_all will update cache_key" do
+      developers = Developer.where(name: "David")
+      cache_key = developers.cache_key
+
+      developers.destroy_all
+
+      assert_not_equal cache_key, developers.cache_key
+    end
+
     test "it triggers at most one query" do
-      developers =  Developer.where(name: "David")
+      developers = Developer.where(name: "David")
 
       assert_queries(1) { developers.cache_key }
-      assert_queries(0) { developers.cache_key }
+      assert_no_queries { developers.cache_key }
     end
 
     test "it doesn't trigger any query if the relation is already loaded" do
-      developers =  Developer.where(name: "David").load
-      assert_queries(0) { developers.cache_key }
+      developers = Developer.where(name: "David").load
+      assert_no_queries { developers.cache_key }
+    end
+
+    test "it doesn't trigger any query if collection_cache_versioning is enabled" do
+      with_collection_cache_versioning do
+        developers = Developer.where(name: "David")
+        assert_no_queries { developers.cache_key }
+      end
     end
 
     test "relation cache_key changes when the sql query changes" do
       developers = Developer.where(name: "David")
-      other_relation =  Developer.where(name: "David").where("1 = 1")
+      other_relation = Developer.where(name: "David").where("1 = 1")
 
       assert_not_equal developers.cache_key, other_relation.cache_key
     end
 
     test "cache_key for empty relation" do
       developers = Developer.where(name: "Non Existent Developer")
-      assert_match(/\Adevelopers\/query-(\h+)-0\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-0\z/, developers.cache_key)
     end
 
     test "cache_key with custom timestamp column" do
@@ -90,7 +191,7 @@ module ActiveRecord
 
     test "collection proxy provides a cache_key" do
       developers = projects(:active_record).developers
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
     end
 
     test "cache_key for loaded collection with zero size" do
@@ -98,18 +199,74 @@ module ActiveRecord
       posts = Post.includes(:comments)
       empty_loaded_collection = posts.first.comments
 
-      assert_match(/\Acomments\/query-(\h+)-0\Z/, empty_loaded_collection.cache_key)
+      assert_match(/\Acomments\/query-(\h+)-0\z/, empty_loaded_collection.cache_key)
     end
 
     test "cache_key for queries with offset which return 0 rows" do
       developers = Developer.offset(20)
-      assert_match(/\Adevelopers\/query-(\h+)-0\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-0\z/, developers.cache_key)
     end
 
     test "cache_key with a relation having selected columns" do
       developers = Developer.select(:salary)
 
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+    end
+
+    test "cache_key with a relation having distinct and order" do
+      developers = Developer.distinct.order(:salary).limit(5)
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+    end
+
+    test "cache_key with a relation having custom select and order" do
+      developers = Developer.select("name AS dev_name").order("dev_name DESC").limit(5)
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+    end
+
+    test "cache_key should be stable when using collection_cache_versioning" do
+      with_collection_cache_versioning do
+        developers = Developer.where(salary: 100000)
+
+        assert_match(/\Adevelopers\/query-(\h+)\z/, developers.cache_key)
+
+        /\Adevelopers\/query-(\h+)\z/ =~ developers.cache_key
+
+        assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
+      end
+    end
+
+    test "cache_version for relation" do
+      with_collection_cache_versioning do
+        developers = Developer.where(salary: 100000).order(updated_at: :desc)
+        last_developer_timestamp = developers.first.updated_at
+
+        assert_match(/(\d+)-(\d+)\z/, developers.cache_version)
+
+        /(\d+)-(\d+)\z/ =~ developers.cache_version
+
+        assert_equal developers.count.to_s, $1
+        assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $2
+      end
+    end
+
+    test "cache_key_with_version contains key and version regardless of collection_cache_versioning setting" do
+      key_with_version_1 = Developer.all.cache_key_with_version
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, key_with_version_1)
+
+      with_collection_cache_versioning do
+        key_with_version_2 = Developer.all.cache_key_with_version
+        assert_equal(key_with_version_1, key_with_version_2)
+      end
+    end
+
+    def with_collection_cache_versioning(value = true)
+      @old_collection_cache_versioning = ActiveRecord::Base.collection_cache_versioning
+      ActiveRecord::Base.collection_cache_versioning = value
+      yield
+    ensure
+      ActiveRecord::Base.collection_cache_versioning = @old_collection_cache_versioning
     end
   end
 end

data/test/cases/column_alias_test.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/topic'
+require "models/topic"
 
 class TestColumnAlias < ActiveRecord::TestCase
   fixtures :topics
 
-  QUERY = if 'Oracle' == ActiveRecord::Base.connection.adapter_name
-            'SELECT id AS pk FROM topics WHERE ROWNUM < 2'
-          else
-            'SELECT id AS pk FROM topics'
-          end
+  QUERY = if "Oracle" == ActiveRecord::Base.connection.adapter_name
+    "SELECT id AS pk FROM topics WHERE ROWNUM < 2"
+  else
+    "SELECT id AS pk FROM topics"
+  end
 
   def test_column_alias
     records = Topic.connection.select_all(QUERY)
-    assert_equal 'pk', records[0].keys[0]
+    assert_equal "pk", records[0].keys[0]
   end
 end

data/test/cases/column_definition_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -6,86 +8,26 @@ module ActiveRecord
       def setup
         @adapter = AbstractAdapter.new(nil)
         def @adapter.native_database_types
-          {:string => "varchar"}
+          { string: "varchar" }
         end
-        @viz = @adapter.schema_creation
+        @viz = @adapter.send(:schema_creation)
       end
 
       # Avoid column definitions in create table statements like:
       # `title` varchar(255) DEFAULT NULL
       def test_should_not_include_default_clause_when_default_is_null
-        column = Column.new("title", nil, SqlTypeMetadata.new(limit: 20))
-        column_def = ColumnDefinition.new(
-          column.name, "string",
-          column.limit, column.precision, column.scale, column.default, column.null)
-          assert_equal "title varchar(20)", @viz.accept(column_def)
+        column_def = ColumnDefinition.new("title", "string", limit: 20)
+        assert_equal "title varchar(20)", @viz.accept(column_def)
       end
 
       def test_should_include_default_clause_when_default_is_present
-        column = Column.new("title", "Hello", SqlTypeMetadata.new(limit: 20))
-        column_def = ColumnDefinition.new(
-          column.name, "string",
-          column.limit, column.precision, column.scale, column.default, column.null)
-          assert_equal %Q{title varchar(20) DEFAULT 'Hello'}, @viz.accept(column_def)
+        column_def = ColumnDefinition.new("title", "string", limit: 20, default: "Hello")
+        assert_equal "title varchar(20) DEFAULT 'Hello'", @viz.accept(column_def)
       end
 
       def test_should_specify_not_null_if_null_option_is_false
-        type_metadata = SqlTypeMetadata.new(limit: 20)
-        column = Column.new("title", "Hello", type_metadata, false)
-        column_def = ColumnDefinition.new(
-          column.name, "string",
-          column.limit, column.precision, column.scale, column.default, column.null)
-          assert_equal %Q{title varchar(20) DEFAULT 'Hello' NOT NULL}, @viz.accept(column_def)
-      end
-
-      if current_adapter?(:Mysql2Adapter)
-        def test_should_set_default_for_mysql_binary_data_types
-          type = SqlTypeMetadata.new(type: :binary, sql_type: "binary(1)")
-          binary_column = MySQL::Column.new("title", "a", type)
-          assert_equal "a", binary_column.default
-
-          type = SqlTypeMetadata.new(type: :binary, sql_type: "varbinary")
-          varbinary_column = MySQL::Column.new("title", "a", type)
-          assert_equal "a", varbinary_column.default
-        end
-
-        def test_should_be_empty_string_default_for_mysql_binary_data_types
-          type = SqlTypeMetadata.new(type: :binary, sql_type: "binary(1)")
-          binary_column = MySQL::Column.new("title", "", type, false)
-          assert_equal "", binary_column.default
-
-          type = SqlTypeMetadata.new(type: :binary, sql_type: "varbinary")
-          varbinary_column = MySQL::Column.new("title", "", type, false)
-          assert_equal "", varbinary_column.default
-        end
-
-        def test_should_not_set_default_for_blob_and_text_data_types
-          assert_raise ArgumentError do
-            MySQL::Column.new("title", "a", SqlTypeMetadata.new(sql_type: "blob"))
-          end
-
-          text_type = MySQL::TypeMetadata.new(
-            SqlTypeMetadata.new(type: :text))
-          assert_raise ArgumentError do
-            MySQL::Column.new("title", "Hello", text_type)
-          end
-
-          text_column = MySQL::Column.new("title", nil, text_type)
-          assert_equal nil, text_column.default
-
-          not_null_text_column = MySQL::Column.new("title", nil, text_type, false)
-          assert_equal "", not_null_text_column.default
-        end
-
-        def test_has_default_should_return_false_for_blob_and_text_data_types
-          binary_type = SqlTypeMetadata.new(sql_type: "blob")
-          blob_column = MySQL::Column.new("title", nil, binary_type)
-          assert !blob_column.has_default?
-
-          text_type = SqlTypeMetadata.new(type: :text)
-          text_column = MySQL::Column.new("title", nil, text_type)
-          assert !text_column.has_default?
-        end
+        column_def = ColumnDefinition.new("title", "string", limit: 20, default: "Hello", null: false)
+        assert_equal "title varchar(20) DEFAULT 'Hello' NOT NULL", @viz.accept(column_def)
       end
     end
   end