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

data/test/cases/validations_test.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-require 'models/person'
-require 'models/developer'
-require 'models/computer'
-require 'models/parrot'
-require 'models/company'
+require "models/topic"
+require "models/reply"
+require "models/developer"
+require "models/computer"
+require "models/parrot"
+require "models/company"
+require "models/price_estimate"
 
 class ValidationsTest < ActiveRecord::TestCase
   fixtures :topics, :developers
@@ -17,7 +19,7 @@ class ValidationsTest < ActiveRecord::TestCase
   def test_valid_uses_create_context_when_new
     r = WrongReply.new
     r.title = "Wrong Create"
-    assert_not r.valid?
+    assert_not_predicate r, :valid?
     assert r.errors[:title].any?, "A reply with a bad title should mark that attribute as invalid"
     assert_equal ["is Wrong Create"], r.errors[:title], "A reply with a bad content should contain an error"
   end
@@ -36,8 +38,8 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_valid_using_special_context
-    r = WrongReply.new(:title => "Valid title")
-    assert !r.valid?(:special_case)
+    r = WrongReply.new(title: "Valid title")
+    assert_not r.valid?(:special_case)
     assert_equal "Invalid", r.errors[:author_name].join
 
     r.author_name = "secret"
@@ -53,7 +55,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_invalid_using_multiple_contexts
-    r = WrongReply.new(:title => 'Wrong Create')
+    r = WrongReply.new(title: "Wrong Create")
     assert r.invalid?([:special_case, :create])
     assert_equal "Invalid", r.errors[:author_name].join
     assert_equal "is Wrong Create", r.errors[:title].join
@@ -95,7 +97,7 @@ class ValidationsTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::RecordInvalid) do
       WrongReply.new.validate!(:special_case)
     end
-    r = WrongReply.new(:title => "Valid title", :author_name => "secret", :content => "Good")
+    r = WrongReply.new(title: "Valid title", author_name: "secret", content: "Good")
     assert r.validate!(:special_case)
   end
 
@@ -107,7 +109,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_exception_on_create_bang_with_block
     assert_raise(ActiveRecord::RecordInvalid) do
-      WrongReply.create!({ "title" => "OK" }) do |r|
+      WrongReply.create!("title" => "OK") do |r|
         r.content = nil
       end
     end
@@ -123,8 +125,8 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_save_without_validation
     reply = WrongReply.new
-    assert !reply.save
-    assert reply.save(:validate => false)
+    assert_not reply.save
+    assert reply.save(validate: false)
   end
 
   def test_validates_acceptance_of_with_non_existent_table
@@ -137,14 +139,23 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_throw_away_typing
     d = Developer.new("name" => "David", "salary" => "100,000")
-    assert !d.valid?
+    assert_not_predicate d, :valid?
     assert_equal 100, d.salary
     assert_equal "100,000", d.salary_before_type_cast
   end
 
+  def test_validates_acceptance_of_with_undefined_attribute_methods
+    klass = Class.new(Topic)
+    klass.validates_acceptance_of(:approved)
+    topic = klass.new(approved: true)
+    klass.undefine_attribute_methods
+    assert topic.approved
+  end
+
   def test_validates_acceptance_of_as_database_column
-    Topic.validates_acceptance_of(:approved)
-    topic = Topic.create("approved" => true)
+    klass = Class.new(Topic)
+    klass.validates_acceptance_of(:approved)
+    topic = klass.create("approved" => true)
     assert topic["approved"]
   end
 
@@ -161,10 +172,10 @@ class ValidationsTest < ActiveRecord::TestCase
       validates_numericality_of :wibble, only_integer: true
     end
 
-    topic = klass.new(wibble: '123-4567')
-    topic.wibble.gsub!('-', '')
+    topic = klass.new(wibble: "123-4567")
+    topic.wibble.gsub!("-", "")
 
-    assert topic.valid?
+    assert_predicate topic, :valid?
   end
 
   def test_numericality_validation_checks_against_raw_value
@@ -173,17 +184,41 @@ class ValidationsTest < ActiveRecord::TestCase
         ActiveModel::Name.new(self, nil, "Topic")
       end
       attribute :wibble, :decimal, scale: 2, precision: 9
-      validates_numericality_of :wibble, greater_than_or_equal_to: BigDecimal.new("97.18")
+      validates_numericality_of :wibble, greater_than_or_equal_to: BigDecimal("97.18")
     end
 
-    assert_not klass.new(wibble: "97.179").valid?
-    assert_not klass.new(wibble: 97.179).valid?
-    assert_not klass.new(wibble: BigDecimal.new("97.179")).valid?
+    ["97.179", 97.179, BigDecimal("97.179")].each do |raw_value|
+      subject = klass.new(wibble: raw_value)
+      assert_equal BigDecimal("97.18"), subject.wibble
+      assert_predicate subject, :valid?
+    end
+
+    ["97.174", 97.174, BigDecimal("97.174")].each do |raw_value|
+      subject = klass.new(wibble: raw_value)
+      assert_equal BigDecimal("97.17"), subject.wibble
+      assert_not_predicate subject, :valid?
+    end
+  end
+
+  def test_numericality_validator_wont_be_affected_by_custom_getter
+    price_estimate = PriceEstimate.new(price: 50)
+
+    assert_equal "$50.00", price_estimate.price
+    assert_equal 50, price_estimate.price_before_type_cast
+    assert_equal 50, price_estimate.read_attribute(:price)
+
+    assert_predicate price_estimate, :price_came_from_user?
+    assert_predicate price_estimate, :valid?
+
+    price_estimate.save!
+
+    assert_not_predicate price_estimate, :price_came_from_user?
+    assert_predicate price_estimate, :valid?
   end
 
   def test_acceptance_validator_doesnt_require_db_connection
     klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'posts'
+      self.table_name = "posts"
     end
     klass.reset_column_information
 

data/test/cases/view_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/book"
 require "support/schema_dumping_helper"
@@ -11,13 +13,14 @@ module ViewBehavior
   end
 
   class Ebook < ActiveRecord::Base
+    self.table_name = "ebooks"
     self.primary_key = "id"
   end
 
   def setup
     super
     @connection = ActiveRecord::Base.connection
-    create_view "ebooks", <<-SQL
+    create_view "ebooks", <<~SQL
       SELECT id, name, status FROM books WHERE format = 'ebook'
     SQL
   end
@@ -44,8 +47,7 @@ module ViewBehavior
 
   def test_table_exists
     view_name = Ebook.table_name
-    # TODO: switch this assertion around once we changed #tables to not return views.
-    ActiveSupport::Deprecation.silence { assert @connection.table_exists?(view_name), "'#{view_name}' table should exist" }
+    assert_not @connection.table_exists?(view_name), "'#{view_name}' table should not exist"
   end
 
   def test_views_ara_valid_data_sources
@@ -60,7 +62,7 @@ module ViewBehavior
   end
 
   def test_attributes
-    assert_equal({"id" => 2, "name" => "Ruby for Rails", "status" => 0},
+    assert_equal({ "id" => 2, "name" => "Ruby for Rails", "status" => 0 },
                  Ebook.first.attributes)
   end
 
@@ -75,142 +77,146 @@ module ViewBehavior
     schema = dump_table_schema "ebooks"
     assert_no_match %r{create_table "ebooks"}, schema
   end
-end
-
-if ActiveRecord::Base.connection.supports_views?
-class ViewWithPrimaryKeyTest < ActiveRecord::TestCase
-  include ViewBehavior
 
   private
-  def create_view(name, query)
-    @connection.execute "CREATE VIEW #{name} AS #{query}"
-  end
-
-  def drop_view(name)
-    @connection.execute "DROP VIEW #{name}" if @connection.view_exists? name
-  end
+    def quote_table_name(name)
+      @connection.quote_table_name(name)
+    end
 end
 
-class ViewWithoutPrimaryKeyTest < ActiveRecord::TestCase
-  include SchemaDumpingHelper
-  fixtures :books
-
-  class Paperback < ActiveRecord::Base; end
-
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.execute <<-SQL
-      CREATE VIEW paperbacks
-        AS SELECT name, status FROM books WHERE format = 'paperback'
-    SQL
-  end
-
-  teardown do
-    @connection.execute "DROP VIEW paperbacks" if @connection.view_exists? "paperbacks"
-  end
-
-  def test_reading
-    books = Paperback.all
-    assert_equal ["Agile Web Development with Rails"], books.map(&:name)
-  end
+if ActiveRecord::Base.connection.supports_views?
+  class ViewWithPrimaryKeyTest < ActiveRecord::TestCase
+    include ViewBehavior
 
-  def test_views
-    assert_equal [Paperback.table_name], @connection.views
-  end
+    private
+      def create_view(name, query)
+        @connection.execute "CREATE VIEW #{quote_table_name(name)} AS #{query}"
+      end
 
-  def test_view_exists
-    view_name = Paperback.table_name
-    assert @connection.view_exists?(view_name), "'#{view_name}' view should exist"
+      def drop_view(name)
+        @connection.execute "DROP VIEW #{quote_table_name(name)}" if @connection.view_exists? name
+      end
   end
 
-  def test_table_exists
-    view_name = Paperback.table_name
-    # TODO: switch this assertion around once we changed #tables to not return views.
-    ActiveSupport::Deprecation.silence { assert @connection.table_exists?(view_name), "'#{view_name}' table should exist" }
-  end
+  class ViewWithoutPrimaryKeyTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+    fixtures :books
 
-  def test_column_definitions
-    assert_equal([["name", :string],
-                  ["status", :integer]], Paperback.columns.map { |c| [c.name, c.type] })
-  end
+    class Paperback < ActiveRecord::Base; end
 
-  def test_attributes
-    assert_equal({"name" => "Agile Web Development with Rails", "status" => 2},
-                 Paperback.first.attributes)
-  end
+    setup do
+      @connection = ActiveRecord::Base.connection
+      @connection.execute <<~SQL
+        CREATE VIEW paperbacks
+          AS SELECT name, status FROM books WHERE format = 'paperback'
+      SQL
+    end
 
-  def test_does_not_have_a_primary_key
-    assert_nil Paperback.primary_key
-  end
+    teardown do
+      @connection.execute "DROP VIEW paperbacks" if @connection.view_exists? "paperbacks"
+    end
 
-  def test_does_not_dump_view_as_table
-    schema = dump_table_schema "paperbacks"
-    assert_no_match %r{create_table "paperbacks"}, schema
-  end
-end
+    def test_reading
+      books = Paperback.all
+      assert_equal ["Agile Web Development with Rails"], books.map(&:name)
+    end
 
-# sqlite dose not support CREATE, INSERT, and DELETE for VIEW
-if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter, :SQLServerAdapter)
-class UpdateableViewTest < ActiveRecord::TestCase
-  self.use_transactional_tests = false
-  fixtures :books
+    def test_views
+      assert_equal [Paperback.table_name], @connection.views
+    end
 
-  class PrintedBook < ActiveRecord::Base
-    self.primary_key = "id"
-  end
+    def test_view_exists
+      view_name = Paperback.table_name
+      assert @connection.view_exists?(view_name), "'#{view_name}' view should exist"
+    end
 
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.execute <<-SQL
-      CREATE VIEW printed_books
-        AS SELECT id, name, status, format FROM books WHERE format = 'paperback'
-    SQL
-  end
+    def test_table_exists
+      view_name = Paperback.table_name
+      assert_not @connection.table_exists?(view_name), "'#{view_name}' table should not exist"
+    end
 
-  teardown do
-    @connection.execute "DROP VIEW printed_books" if @connection.view_exists? "printed_books"
-  end
+    def test_column_definitions
+      assert_equal([["name", :string],
+                    ["status", :integer]], Paperback.columns.map { |c| [c.name, c.type] })
+    end
 
-  def test_update_record
-    book = PrintedBook.first
-    book.name = "AWDwR"
-    book.save!
-    book.reload
-    assert_equal "AWDwR", book.name
-  end
+    def test_attributes
+      assert_equal({ "name" => "Agile Web Development with Rails", "status" => 2 },
+                   Paperback.first.attributes)
+    end
 
-  def test_insert_record
-    PrintedBook.create! name: "Rails in Action", status: 0, format: "paperback"
+    def test_does_not_have_a_primary_key
+      assert_nil Paperback.primary_key
+    end
 
-    new_book = PrintedBook.last
-    assert_equal "Rails in Action", new_book.name
+    def test_does_not_dump_view_as_table
+      schema = dump_table_schema "paperbacks"
+      assert_no_match %r{create_table "paperbacks"}, schema
+    end
   end
 
-  def test_update_record_to_fail_view_conditions
-    book = PrintedBook.first
-    book.format = "ebook"
-    book.save!
-
-    assert_raises ActiveRecord::RecordNotFound do
-      book.reload
+  # sqlite dose not support CREATE, INSERT, and DELETE for VIEW
+  if current_adapter?(:Mysql2Adapter, :SQLServerAdapter, :PostgreSQLAdapter, :IBM_DBAdapter)
+
+    class UpdateableViewTest < ActiveRecord::TestCase
+      self.use_transactional_tests = false
+      fixtures :books
+
+      class PrintedBook < ActiveRecord::Base
+        self.primary_key = "id"
+      end
+
+      setup do
+        @connection = ActiveRecord::Base.connection
+        @connection.execute <<~SQL
+          CREATE VIEW printed_books
+            AS SELECT id, name, status, format FROM books WHERE format = 'paperback'
+        SQL
+      end
+
+      teardown do
+        @connection.execute "DROP VIEW printed_books" if @connection.view_exists? "printed_books"
+      end
+
+      def test_update_record
+        book = PrintedBook.first
+        book.name = "AWDwR"
+        book.save!
+        book.reload
+        assert_equal "AWDwR", book.name
+      end
+
+      def test_insert_record
+        PrintedBook.create! name: "Rails in Action", status: 0, format: "paperback"
+
+        new_book = PrintedBook.last
+        assert_equal "Rails in Action", new_book.name
+      end
+
+      def test_update_record_to_fail_view_conditions
+        book = PrintedBook.first
+        book.format = "ebook"
+        book.save!
+
+        assert_raises ActiveRecord::RecordNotFound do
+          book.reload
+        end
+      end
     end
-  end
-end
-end # end fo `if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter, :SQLServerAdapter)`
-end # end fo `if ActiveRecord::Base.connection.supports_views?`
+  end # end of `if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter, :SQLServerAdapter)`
+end # end of `if ActiveRecord::Base.connection.supports_views?`
 
-if ActiveRecord::Base.connection.respond_to?(:supports_materialized_views?) &&
-    ActiveRecord::Base.connection.supports_materialized_views?
-class MaterializedViewTest < ActiveRecord::PostgreSQLTestCase
-  include ViewBehavior
+if ActiveRecord::Base.connection.supports_materialized_views?
+  class MaterializedViewTest < ActiveRecord::PostgreSQLTestCase
+    include ViewBehavior
 
-  private
-  def create_view(name, query)
-    @connection.execute "CREATE MATERIALIZED VIEW #{name} AS #{query}"
-  end
+    private
+      def create_view(name, query)
+        @connection.execute "CREATE MATERIALIZED VIEW #{quote_table_name(name)} AS #{query}"
+      end
 
-  def drop_view(name)
-    @connection.execute "DROP MATERIALIZED VIEW #{name}" if @connection.view_exists? name
+      def drop_view(name)
+        @connection.execute "DROP MATERIALIZED VIEW #{quote_table_name(name)}" if @connection.view_exists? name
+      end
   end
 end
-end

data/test/cases/yaml_serialization_test.rb

@@ -1,15 +1,17 @@
-require 'cases/helper'
-require 'models/topic'
-require 'models/reply'
-require 'models/post'
-require 'models/author'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+require "models/post"
+require "models/author"
 
 class YamlSerializationTest < ActiveRecord::TestCase
-  fixtures :topics, :authors, :posts
+  fixtures :topics, :authors, :author_addresses, :posts
 
   def test_to_yaml_with_time_with_zone_should_not_raise_exception
     with_timezone_config aware_attributes: true, zone: "Pacific Time (US & Canada)" do
-      topic = Topic.new(:written_on => DateTime.now)
+      topic = Topic.new(written_on: DateTime.now)
       assert_nothing_raised { topic.to_yaml }
     end
   end
@@ -17,26 +19,26 @@ class YamlSerializationTest < ActiveRecord::TestCase
   def test_roundtrip
     topic = Topic.first
     assert topic
-    t = YAML.load YAML.dump topic
+    t = yaml_load YAML.dump topic
     assert_equal topic, t
   end
 
   def test_roundtrip_serialized_column
-    topic = Topic.new(:content => {:omg=>:lol})
-    assert_equal({:omg=>:lol}, YAML.load(YAML.dump(topic)).content)
+    topic = Topic.new(content: { omg: :lol })
+    assert_equal({ omg: :lol }, yaml_load(YAML.dump(topic)).content)
   end
 
   def test_psych_roundtrip
     topic = Topic.first
     assert topic
-    t = Psych.load Psych.dump topic
+    t = yaml_load Psych.dump topic
     assert_equal topic, t
   end
 
   def test_psych_roundtrip_new_object
     topic = Topic.new
     assert topic
-    t = Psych.load Psych.dump topic
+    t = yaml_load Psych.dump topic
     assert_equal topic.attributes, t.attributes
   end
 
@@ -47,38 +49,38 @@ class YamlSerializationTest < ActiveRecord::TestCase
   def test_raw_types_are_not_changed_on_round_trip
     topic = Topic.new(parent_id: "123")
     assert_equal "123", topic.parent_id_before_type_cast
-    assert_equal "123", YAML.load(YAML.dump(topic)).parent_id_before_type_cast
+    assert_equal "123", yaml_load(YAML.dump(topic)).parent_id_before_type_cast
   end
 
   def test_cast_types_are_not_changed_on_round_trip
     topic = Topic.new(parent_id: "123")
     assert_equal 123, topic.parent_id
-    assert_equal 123, YAML.load(YAML.dump(topic)).parent_id
+    assert_equal 123, yaml_load(YAML.dump(topic)).parent_id
   end
 
   def test_new_records_remain_new_after_round_trip
     topic = Topic.new
 
     assert topic.new_record?, "Sanity check that new records are new"
-    assert YAML.load(YAML.dump(topic)).new_record?, "Record should be new after deserialization"
+    assert yaml_load(YAML.dump(topic)).new_record?, "Record should be new after deserialization"
 
     topic.save!
 
     assert_not topic.new_record?, "Saved records are not new"
-    assert_not YAML.load(YAML.dump(topic)).new_record?, "Saved record should not be new after deserialization"
+    assert_not yaml_load(YAML.dump(topic)).new_record?, "Saved record should not be new after deserialization"
 
-    topic = Topic.select('title').last
+    topic = Topic.select("title").last
 
     assert_not topic.new_record?, "Loaded records without ID are not new"
-    assert_not YAML.load(YAML.dump(topic)).new_record?, "Record should not be new after deserialization"
+    assert_not yaml_load(YAML.dump(topic)).new_record?, "Record should not be new after deserialization"
   end
 
   def test_types_of_virtual_columns_are_not_changed_on_round_trip
-    author = Author.select('authors.*, count(posts.id) as posts_count')
+    author = Author.select("authors.*, count(posts.id) as posts_count")
       .joins(:posts)
-      .group('authors.id')
+      .group("authors.id", "authors.name", "authors.author_address_id", "authors.author_address_extra_id", "authors.organization_id", "authors.owned_essay_id")
       .first
-    dumped = YAML.load(YAML.dump(author))
+    dumped = yaml_load(YAML.dump(author))
 
     assert_equal 5, author.posts_count
     assert_equal 5, dumped.posts_count
@@ -88,34 +90,77 @@ class YamlSerializationTest < ActiveRecord::TestCase
     coder = {}
     Topic.first.encode_with(coder)
 
-    assert coder['active_record_yaml_version']
+    assert coder["active_record_yaml_version"]
+  end
+
+  def test_deserializing_rails_v2_yaml
+    topic = yaml_load(yaml_fixture("rails_v2"))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+  end
+
+  def test_deserializing_rails_v1_mysql_yaml
+    topic = yaml_load(yaml_fixture("rails_v1_mysql"))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
   end
 
   def test_deserializing_rails_41_yaml
-    topic = YAML.load(yaml_fixture("rails_4_1"))
+    topic = assert_deprecated do
+      yaml_load(yaml_fixture("rails_4_1"))
+    end
 
-    assert topic.new_record?
-    assert_equal nil, topic.id
+    assert_predicate topic, :new_record?
+    assert_nil topic.id
     assert_equal "The First Topic", topic.title
     assert_equal({ omg: :lol }, topic.content)
   end
 
   def test_deserializing_rails_4_2_0_yaml
-    topic = YAML.load(yaml_fixture("rails_4_2_0"))
+    topic = assert_deprecated do
+      yaml_load(yaml_fixture("rails_4_2_0"))
+    end
 
-    assert_not topic.new_record?
+    assert_not_predicate topic, :new_record?
     assert_equal 1, topic.id
     assert_equal "The First Topic", topic.title
     assert_equal("Have a nice day", topic.content)
   end
 
-  private
+  def test_yaml_encoding_keeps_mutations
+    author = Author.first
+    author.name = "Sean"
+    dumped = yaml_load(YAML.dump(author))
+
+    assert_equal "Sean", dumped.name
+    assert_equal author.name_was, dumped.name_was
+    assert_equal author.changes, dumped.changes
+  end
+
+  def test_yaml_encoding_keeps_false_values
+    topic = Topic.first
+    topic.approved = false
+    dumped = yaml_load(YAML.dump(topic))
 
-  def yaml_fixture(file_name)
-    path = File.expand_path(
-      "../../support/yaml_compatibility_fixtures/#{file_name}.yml",
-      __FILE__
-    )
-    File.read(path)
+    assert_equal false, dumped.approved
   end
+
+  private
+    def yaml_load(payload)
+      YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
+    end
+
+    def yaml_fixture(file_name)
+      path = File.expand_path(
+        "support/yaml_compatibility_fixtures/#{file_name}.yml",
+        TEST_ROOT
+      )
+      File.read(path)
+    end
 end