ibm_db 5.6.1-arm64-darwin-24

data/test/cases/validations_test.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+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
+
+  # Most of the tests mess with the validations of Topic, so lets repair it all the time.
+  # Other classes we mess with will be dealt with in the specific tests
+  repair_validations(Topic)
+
+  def test_valid_uses_create_context_when_new
+    r = WrongReply.new
+    r.title = "Wrong Create"
+    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
+
+  def test_valid_uses_update_context_when_persisted
+    r = WrongReply.new
+    r.title = "Bad"
+    r.content = "Good"
+    assert r.save, "First validation should be successful"
+
+    r.title = "Wrong Update"
+    assert_not r.valid?, "Second validation should fail"
+
+    assert r.errors[:title].any?, "A reply with a bad title should mark that attribute as invalid"
+    assert_equal ["is Wrong Update"], r.errors[:title], "A reply with a bad content should contain an error"
+  end
+
+  def test_valid_using_special_context
+    r = WrongReply.new(title: "Valid title")
+    assert_not r.valid?(:special_case)
+    assert_equal "Invalid", r.errors[:author_name].join
+
+    r.author_name = "secret"
+    r.content = "Good"
+    assert r.valid?(:special_case)
+
+    r.author_name = nil
+    assert_not r.valid?(:special_case)
+    assert_equal "Invalid", r.errors[:author_name].join
+
+    r.author_name = "secret"
+    assert r.valid?(:special_case)
+  end
+
+  def test_invalid_using_multiple_contexts
+    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
+  end
+
+  def test_validate
+    r = WrongReply.new
+
+    r.validate
+    assert_empty r.errors[:author_name]
+
+    r.validate(:special_case)
+    assert_not_empty r.errors[:author_name]
+
+    r.author_name = "secret"
+
+    r.validate(:special_case)
+    assert_empty r.errors[:author_name]
+  end
+
+  def test_invalid_record_exception
+    assert_raise(ActiveRecord::RecordInvalid) { WrongReply.create! }
+    assert_raise(ActiveRecord::RecordInvalid) { WrongReply.new.save! }
+
+    r = WrongReply.new
+    invalid = assert_raise ActiveRecord::RecordInvalid do
+      r.save!
+    end
+    assert_equal r, invalid.record
+  end
+
+  def test_validate_with_bang
+    assert_raise(ActiveRecord::RecordInvalid) do
+      WrongReply.new.validate!
+    end
+  end
+
+  def test_validate_with_bang_and_context
+    assert_raise(ActiveRecord::RecordInvalid) do
+      WrongReply.new.validate!(:special_case)
+    end
+    r = WrongReply.new(title: "Valid title", author_name: "secret", content: "Good")
+    assert r.validate!(:special_case)
+  end
+
+  def test_exception_on_create_bang_many
+    assert_raise(ActiveRecord::RecordInvalid) do
+      WrongReply.create!([ { "title" => "OK" }, { "title" => "Wrong Create" }])
+    end
+  end
+
+  def test_exception_on_create_bang_with_block
+    assert_raise(ActiveRecord::RecordInvalid) do
+      WrongReply.create!("title" => "OK") do |r|
+        r.content = nil
+      end
+    end
+  end
+
+  def test_exception_on_create_bang_many_with_block
+    assert_raise(ActiveRecord::RecordInvalid) do
+      WrongReply.create!([{ "title" => "OK" }, { "title" => "Wrong Create" }]) do |r|
+        r.content = nil
+      end
+    end
+  end
+
+  def test_save_without_validation
+    reply = WrongReply.new
+    assert_not reply.save
+    assert reply.save(validate: false)
+  end
+
+  def test_validates_acceptance_of_with_non_existent_table
+    Object.const_set :IncorporealModel, Class.new(ActiveRecord::Base)
+
+    assert_nothing_raised do
+      IncorporealModel.validates_acceptance_of(:incorporeal_column)
+    end
+  end
+
+  def test_throw_away_typing
+    d = Developer.new("name" => "David", "salary" => "100,000")
+    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
+    klass = Class.new(Topic)
+    klass.validates_acceptance_of(:approved)
+    topic = klass.create("approved" => true)
+    assert topic["approved"]
+  end
+
+  def test_validators
+    assert_equal 1, Parrot.validators.size
+    assert_equal 1, Company.validators.size
+    assert_equal 1, Parrot.validators_on(:name).size
+    assert_equal 1, Company.validators_on(:name).size
+  end
+
+  def test_numericality_validation_with_mutation
+    klass = Class.new(Topic) do
+      attribute :wibble, :string
+      validates_numericality_of :wibble, only_integer: true
+    end
+
+    topic = klass.new(wibble: "123-4567")
+    topic.wibble.gsub!("-", "")
+
+    assert_predicate topic, :valid?
+  end
+
+  def test_numericality_validation_checks_against_raw_value
+    klass = Class.new(Topic) do
+      def self.model_name
+        ActiveModel::Name.new(self, nil, "Topic")
+      end
+      attribute :wibble, :decimal, scale: 2, precision: 9
+      validates_numericality_of :wibble, greater_than_or_equal_to: BigDecimal("97.18")
+    end
+
+    ["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"
+    end
+    klass.reset_column_information
+
+    assert_no_queries do
+      klass.validates_acceptance_of(:foo)
+    end
+  end
+end

data/test/cases/view_test.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/book"
+require "support/schema_dumping_helper"
+
+module ViewBehavior
+  include SchemaDumpingHelper
+  extend ActiveSupport::Concern
+
+  included do
+    fixtures :books
+  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
+      SELECT id, name, status FROM books WHERE format = 'ebook'
+    SQL
+  end
+
+  def teardown
+    super
+    drop_view "ebooks"
+  end
+
+  def test_reading
+    books = Ebook.all
+    assert_equal [books(:rfr).id], books.map(&:id)
+    assert_equal ["Ruby for Rails"], books.map(&:name)
+  end
+
+  def test_views
+    assert_equal [Ebook.table_name], @connection.views
+  end
+
+  def test_view_exists
+    view_name = Ebook.table_name
+    assert @connection.view_exists?(view_name), "'#{view_name}' view should exist"
+  end
+
+  def test_table_exists
+    view_name = Ebook.table_name
+    assert_not @connection.table_exists?(view_name), "'#{view_name}' table should not exist"
+  end
+
+  def test_views_ara_valid_data_sources
+    view_name = Ebook.table_name
+    assert @connection.data_source_exists?(view_name), "'#{view_name}' should be a data source"
+  end
+
+  def test_column_definitions
+    assert_equal([["id", :integer],
+                  ["name", :string],
+                  ["status", :integer]], Ebook.columns.map { |c| [c.name, c.type] })
+  end
+
+  def test_attributes
+    assert_equal({ "id" => 2, "name" => "Ruby for Rails", "status" => 0 },
+                 Ebook.first.attributes)
+  end
+
+  def test_does_not_assume_id_column_as_primary_key
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "ebooks"
+    end
+    assert_nil model.primary_key
+  end
+
+  def test_does_not_dump_view_as_table
+    schema = dump_table_schema "ebooks"
+    assert_no_match %r{create_table "ebooks"}, schema
+  end
+
+  private
+    def quote_table_name(name)
+      @connection.quote_table_name(name)
+    end
+end
+
+if ActiveRecord::Base.connection.supports_views?
+  class ViewWithPrimaryKeyTest < ActiveRecord::TestCase
+    include ViewBehavior
+
+    private
+      def create_view(name, query)
+        @connection.execute "CREATE VIEW #{quote_table_name(name)} AS #{query}"
+      end
+
+      def drop_view(name)
+        @connection.execute "DROP VIEW #{quote_table_name(name)}" if @connection.view_exists? 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
+
+    def test_views
+      assert_equal [Paperback.table_name], @connection.views
+    end
+
+    def test_view_exists
+      view_name = Paperback.table_name
+      assert @connection.view_exists?(view_name), "'#{view_name}' view should exist"
+    end
+
+    def test_table_exists
+      view_name = Paperback.table_name
+      assert_not @connection.table_exists?(view_name), "'#{view_name}' table should not exist"
+    end
+
+    def test_column_definitions
+      assert_equal([["name", :string],
+                    ["status", :integer]], Paperback.columns.map { |c| [c.name, c.type] })
+    end
+
+    def test_attributes
+      assert_equal({ "name" => "Agile Web Development with Rails", "status" => 2 },
+                   Paperback.first.attributes)
+    end
+
+    def test_does_not_have_a_primary_key
+      assert_nil Paperback.primary_key
+    end
+
+    def test_does_not_dump_view_as_table
+      schema = dump_table_schema "paperbacks"
+      assert_no_match %r{create_table "paperbacks"}, schema
+    end
+  end
+
+  # 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 of `if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter, :SQLServerAdapter)`
+end # end of `if ActiveRecord::Base.connection.supports_views?`
+
+if ActiveRecord::Base.connection.supports_materialized_views?
+  class MaterializedViewTest < ActiveRecord::PostgreSQLTestCase
+    include ViewBehavior
+
+    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 #{quote_table_name(name)}" if @connection.view_exists? name
+      end
+  end
+end

data/test/cases/yaml_serialization_test.rb

@@ -0,0 +1,166 @@
+# 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, :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)
+      assert_nothing_raised { topic.to_yaml }
+    end
+  end
+
+  def test_roundtrip
+    topic = Topic.first
+    assert 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)
+  end
+
+  def test_psych_roundtrip
+    topic = Topic.first
+    assert topic
+    t = yaml_load Psych.dump topic
+    assert_equal topic, t
+  end
+
+  def test_psych_roundtrip_new_object
+    topic = Topic.new
+    assert topic
+    t = yaml_load Psych.dump topic
+    assert_equal topic.attributes, t.attributes
+  end
+
+  def test_active_record_relation_serialization
+    [Topic.all].to_yaml
+  end
+
+  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
+  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
+  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"
+
+    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"
+
+    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"
+  end
+
+  def test_types_of_virtual_columns_are_not_changed_on_round_trip
+    author = Author.select("authors.*, count(posts.id) as posts_count")
+      .joins(:posts)
+      .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))
+
+    assert_equal 5, author.posts_count
+    assert_equal 5, dumped.posts_count
+  end
+
+  def test_a_yaml_version_is_provided_for_future_backwards_compat
+    coder = {}
+    Topic.first.encode_with(coder)
+
+    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 = assert_deprecated do
+      yaml_load(yaml_fixture("rails_4_1"))
+    end
+
+    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 = assert_deprecated do
+      yaml_load(yaml_fixture("rails_4_2_0"))
+    end
+
+    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_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))
+
+    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

data/test/config.example.yml

@@ -0,0 +1,97 @@
+default_connection: <%= defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3' %>
+
+connections:
+  jdbcderby:
+    arunit:  activerecord_unittest
+    arunit2: activerecord_unittest2
+
+  jdbch2:
+    arunit:  activerecord_unittest
+    arunit2: activerecord_unittest2
+
+  jdbchsqldb:
+    arunit:  activerecord_unittest
+    arunit2: activerecord_unittest2
+
+  jdbcmysql:
+    arunit:
+      username: rails
+      encoding: utf8
+    arunit2:
+      username: rails
+      encoding: utf8
+
+  jdbcpostgresql:
+    arunit:
+      username: <%= ENV['user'] || 'rails' %>
+    arunit2:
+      username: <%= ENV['user'] || 'rails' %>
+
+  jdbcsqlite3:
+    arunit:
+      database: <%= FIXTURES_ROOT %>/fixture_database.sqlite3
+      timeout:  5000
+    arunit2:
+      database: <%= FIXTURES_ROOT %>/fixture_database_2.sqlite3
+      timeout:  5000
+
+  mysql2:
+    arunit:
+      username: rails
+      encoding: utf8mb4
+      collation: utf8mb4_unicode_ci
+<% if ENV['MYSQL_PREPARED_STATEMENTS'] %>
+      prepared_statements: true
+<% end %>
+<% if ENV['MYSQL_HOST'] %>
+      host: <%= ENV['MYSQL_HOST'] %>
+<% end %>
+    arunit2:
+      username: rails
+      encoding: utf8mb4
+      collation: utf8mb4_general_ci
+<% if ENV['MYSQL_PREPARED_STATEMENTS'] %>
+      prepared_statements: true
+<% end %>
+<% if ENV['MYSQL_HOST'] %>
+      host: <%= ENV['MYSQL_HOST'] %>
+<% end %>
+
+  oracle:
+     arunit:
+       adapter: oracle_enhanced
+       database: <%= ENV['ARUNIT_DB_NAME'] || 'orcl' %>
+       username: <%= ENV['ARUNIT_USER_NAME'] || 'arunit' %>
+       password: <%= ENV['ARUNIT_PASSWORD'] || 'arunit' %>
+       emulate_oracle_adapter: true
+     arunit2:
+       adapter: oracle_enhanced
+       database: <%= ENV['ARUNIT_DB_NAME'] || 'orcl' %>
+       username: <%= ENV['ARUNIT2_USER_NAME'] || 'arunit2' %>
+       password: <%= ENV['ARUNIT2_PASSWORD'] || 'arunit2' %>
+       emulate_oracle_adapter: true
+
+  postgresql:
+    arunit:
+      min_messages: warning
+    arunit_without_prepared_statements:
+      min_messages: warning
+      prepared_statements: false
+    arunit2:
+      min_messages: warning
+
+  sqlite3:
+    arunit:
+      database: <%= FIXTURES_ROOT %>/fixture_database.sqlite3
+      timeout:  5000
+    arunit2:
+      database: <%= FIXTURES_ROOT %>/fixture_database_2.sqlite3
+      timeout:  5000
+
+  sqlite3_mem:
+    arunit:
+      adapter: sqlite3
+      database: ':memory:'
+    arunit2:
+      adapter: sqlite3
+      database: ':memory:'