ibm_db 4.0.0-x86-mingw32 → 5.1.0-x86-mingw32

data/test/cases/clone_test.rb

@@ -1,40 +1,40 @@
-require "cases/helper"
-require 'models/topic'
-
-module ActiveRecord
-  class CloneTest < ActiveRecord::TestCase
-    fixtures :topics
-
-    def test_persisted
-      topic = Topic.first
-      cloned = topic.clone
-      assert topic.persisted?, 'topic persisted'
-      assert cloned.persisted?, 'topic persisted'
-      assert !cloned.new_record?, 'topic is not new'
-    end
-
-    def test_stays_frozen
-      topic = Topic.first
-      topic.freeze
-
-      cloned = topic.clone
-      assert cloned.persisted?, 'topic persisted'
-      assert !cloned.new_record?, 'topic is not new'
-      assert cloned.frozen?, 'topic should be frozen'
-    end
-
-    def test_shallow
-      topic = Topic.first
-      cloned = topic.clone
-      topic.author_name = 'Aaron'
-      assert_equal 'Aaron', cloned.author_name
-    end
-
-    def test_freezing_a_cloned_model_does_not_freeze_clone
-      cloned = Topic.new
-      clone = cloned.clone
-      cloned.freeze
-      assert_not clone.frozen?
-    end
-  end
-end
+require "cases/helper"
+require 'models/topic'
+
+module ActiveRecord
+  class CloneTest < ActiveRecord::TestCase
+    fixtures :topics
+
+    def test_persisted
+      topic = Topic.first
+      cloned = topic.clone
+      assert topic.persisted?, 'topic persisted'
+      assert cloned.persisted?, 'topic persisted'
+      assert !cloned.new_record?, 'topic is not new'
+    end
+
+    def test_stays_frozen
+      topic = Topic.first
+      topic.freeze
+
+      cloned = topic.clone
+      assert cloned.persisted?, 'topic persisted'
+      assert !cloned.new_record?, 'topic is not new'
+      assert cloned.frozen?, 'topic should be frozen'
+    end
+
+    def test_shallow
+      topic = Topic.first
+      cloned = topic.clone
+      topic.author_name = 'Aaron'
+      assert_equal 'Aaron', cloned.author_name
+    end
+
+    def test_freezing_a_cloned_model_does_not_freeze_clone
+      cloned = Topic.new
+      clone = cloned.clone
+      cloned.freeze
+      assert_not clone.frozen?
+    end
+  end
+end

data/test/cases/coders/json_test.rb

@@ -1,15 +1,15 @@
-require "cases/helper"
-
-module ActiveRecord
-  module Coders
-    class JSONTest < ActiveRecord::TestCase
-      def test_returns_nil_if_empty_string_given
-        assert_nil JSON.load("")
-      end
-
-      def test_returns_nil_if_nil_given
-        assert_nil JSON.load(nil)
-      end
-    end
-  end
-end
+require "cases/helper"
+
+module ActiveRecord
+  module Coders
+    class JSONTest < ActiveRecord::TestCase
+      def test_returns_nil_if_empty_string_given
+        assert_nil JSON.load("")
+      end
+
+      def test_returns_nil_if_nil_given
+        assert_nil JSON.load(nil)
+      end
+    end
+  end
+end

data/test/cases/coders/yaml_column_test.rb

@@ -1,63 +1,63 @@
-
-require "cases/helper"
-
-module ActiveRecord
-  module Coders
-    class YAMLColumnTest < ActiveRecord::TestCase
-      def test_initialize_takes_class
-        coder = YAMLColumn.new(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.dump("a")
-        end
-      end
-
-      def test_type_mismatch_on_different_classes
-        coder = YAMLColumn.new(Array)
-        assert_raises(SerializationTypeMismatch) do
-          coder.load "--- foo"
-        end
-      end
-
-      def test_nil_is_ok
-        coder = YAMLColumn.new
-        assert_nil coder.load "--- "
-      end
-
-      def test_returns_new_with_different_class
-        coder = YAMLColumn.new 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")
-      end
-
-      def test_load_handles_other_classes
-        coder = YAMLColumn.new
-        assert_equal [], coder.load([])
-      end
-
-      def test_load_doesnt_swallow_yaml_exceptions
-        coder = YAMLColumn.new
-        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
-        missing_class_yaml = '--- !ruby/object:DoesNotExistAndShouldntEver {}\n'
-        assert_raises(ArgumentError) do
-          coder.load(missing_class_yaml)
-        end
-      end
-    end
-  end
-end
+
+require "cases/helper"
+
+module ActiveRecord
+  module Coders
+    class YAMLColumnTest < ActiveRecord::TestCase
+      def test_initialize_takes_class
+        coder = YAMLColumn.new(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.dump("a")
+        end
+      end
+
+      def test_type_mismatch_on_different_classes
+        coder = YAMLColumn.new(Array)
+        assert_raises(SerializationTypeMismatch) do
+          coder.load "--- foo"
+        end
+      end
+
+      def test_nil_is_ok
+        coder = YAMLColumn.new
+        assert_nil coder.load "--- "
+      end
+
+      def test_returns_new_with_different_class
+        coder = YAMLColumn.new 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")
+      end
+
+      def test_load_handles_other_classes
+        coder = YAMLColumn.new
+        assert_equal [], coder.load([])
+      end
+
+      def test_load_doesnt_swallow_yaml_exceptions
+        coder = YAMLColumn.new
+        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
+        missing_class_yaml = '--- !ruby/object:DoesNotExistAndShouldntEver {}\n'
+        assert_raises(ArgumentError) do
+          coder.load(missing_class_yaml)
+        end
+      end
+    end
+  end
+end

data/test/cases/collection_cache_key_test.rb

@@ -1,115 +1,115 @@
-require "cases/helper"
-require "models/computer"
-require "models/developer"
-require "models/project"
-require "models/topic"
-require "models/post"
-require "models/comment"
-
-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)
-    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)
-
-      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
-
-      assert_equal Digest::MD5.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 limit" do
-      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)
-
-      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
-
-      assert_equal Digest::MD5.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 loaded relation" do
-      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)
-
-      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
-
-      assert_equal Digest::MD5.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 "it triggers at most one query" do
-      developers =  Developer.where(name: "David")
-
-      assert_queries(1) { developers.cache_key }
-      assert_queries(0) { 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 }
-    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")
-
-      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)
-    end
-
-    test "cache_key with custom timestamp column" do
-      topics = Topic.where("title like ?", "%Topic%")
-      last_topic_timestamp = topics(:fifth).written_on.utc.to_s(:usec)
-      assert_match(last_topic_timestamp, topics.cache_key(:written_on))
-    end
-
-    test "cache_key with unknown timestamp column" do
-      topics = Topic.where("title like ?", "%Topic%")
-      assert_raises(ActiveRecord::StatementInvalid) { topics.cache_key(:published_at) }
-    end
-
-    test "collection proxy provides a cache_key" do
-      developers = projects(:active_record).developers
-      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
-    end
-
-    test "cache_key for loaded collection with zero size" do
-      Comment.delete_all
-      posts = Post.includes(:comments)
-      empty_loaded_collection = posts.first.comments
-
-      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)
-    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)
-    end
-  end
-end
+require "cases/helper"
+require "models/computer"
+require "models/developer"
+require "models/project"
+require "models/topic"
+require "models/post"
+require "models/comment"
+
+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)
+    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)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
+
+      assert_equal Digest::MD5.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 limit" do
+      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)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
+
+      assert_equal Digest::MD5.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 loaded relation" do
+      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)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
+
+      assert_equal Digest::MD5.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 "it triggers at most one query" do
+      developers =  Developer.where(name: "David")
+
+      assert_queries(1) { developers.cache_key }
+      assert_queries(0) { 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 }
+    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")
+
+      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)
+    end
+
+    test "cache_key with custom timestamp column" do
+      topics = Topic.where("title like ?", "%Topic%")
+      last_topic_timestamp = topics(:fifth).written_on.utc.to_s(:usec)
+      assert_match(last_topic_timestamp, topics.cache_key(:written_on))
+    end
+
+    test "cache_key with unknown timestamp column" do
+      topics = Topic.where("title like ?", "%Topic%")
+      assert_raises(ActiveRecord::StatementInvalid) { topics.cache_key(:published_at) }
+    end
+
+    test "collection proxy provides a cache_key" do
+      developers = projects(:active_record).developers
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+    end
+
+    test "cache_key for loaded collection with zero size" do
+      Comment.delete_all
+      posts = Post.includes(:comments)
+      empty_loaded_collection = posts.first.comments
+
+      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)
+    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)
+    end
+  end
+end