# frozen_string_literal: true require "cases/helper" require "support/connection_helper" require "models/book" require "models/post" require "models/author" require "models/event" module ActiveRecord class AdapterTest < ActiveRecord::TestCase def setup @connection = ActiveRecord::Base.connection @connection.materialize_transactions @connection_handler = ActiveRecord::Base.connection_handler end ## # PostgreSQL does not support null bytes in strings unless current_adapter?(:PostgreSQLAdapter) || (current_adapter?(:SQLite3Adapter) && !ActiveRecord::Base.connection.prepared_statements) def test_update_prepared_statement b = Book.create(name: "my \x00 book") b.reload assert_equal "my \x00 book", b.name b.update(name: "my other \x00 book") b.reload assert_equal "my other \x00 book", b.name end end def test_create_record_with_pk_as_zero Book.create(id: 0) assert_equal 0, Book.find(0).id assert_nothing_raised { Book.destroy(0) } end def test_valid_column @connection.native_database_types.each_key do |type| assert @connection.valid_type?(type) end end def test_invalid_column assert_not @connection.valid_type?(:foobar) end def test_tables tables = @connection.tables assert_includes tables, "accounts" assert_includes tables, "authors" assert_includes tables, "tasks" assert_includes tables, "topics" end def test_table_exists? assert @connection.table_exists?("accounts") assert @connection.table_exists?(:accounts) assert_not @connection.table_exists?("nonexistingtable") assert_not @connection.table_exists?("'") assert_not @connection.table_exists?(nil) end def test_data_sources data_sources = @connection.data_sources assert_includes data_sources, "accounts" assert_includes data_sources, "authors" assert_includes data_sources, "tasks" assert_includes data_sources, "topics" end def test_data_source_exists? assert @connection.data_source_exists?("accounts") assert @connection.data_source_exists?(:accounts) assert_not @connection.data_source_exists?("nonexistingtable") assert_not @connection.data_source_exists?("'") assert_not @connection.data_source_exists?(nil) end def test_indexes idx_name = "accounts_idx" indexes = @connection.indexes("accounts") assert_empty indexes @connection.add_index :accounts, :firm_id, name: idx_name indexes = @connection.indexes("accounts") assert_equal "accounts", indexes.first.table assert_equal idx_name, indexes.first.name assert_not indexes.first.unique assert_equal ["firm_id"], indexes.first.columns ensure @connection.remove_index(:accounts, name: idx_name) rescue nil end def test_remove_index_when_name_and_wrong_column_name_specified index_name = "accounts_idx" @connection.add_index :accounts, :firm_id, name: index_name assert_raises ArgumentError do @connection.remove_index :accounts, name: index_name, column: :wrong_column_name end ensure @connection.remove_index(:accounts, name: index_name) end def test_remove_index_when_name_and_wrong_column_name_specified_positional_argument index_name = "accounts_idx" @connection.add_index :accounts, :firm_id, name: index_name assert_raises ArgumentError do @connection.remove_index :accounts, :wrong_column_name, name: index_name end ensure @connection.remove_index(:accounts, name: index_name) end def test_current_database if @connection.respond_to?(:current_database) assert_equal ARTest.test_configuration_hashes["arunit"]["database"], @connection.current_database end end def test_exec_query_returns_an_empty_result result = @connection.exec_query "INSERT INTO subscribers(nick) VALUES('me')" assert_instance_of(ActiveRecord::Result, result) end if current_adapter?(:Mysql2Adapter) def test_charset assert_not_nil @connection.charset assert_not_equal "character_set_database", @connection.charset assert_equal @connection.show_variable("character_set_database"), @connection.charset end def test_collation assert_not_nil @connection.collation assert_not_equal "collation_database", @connection.collation assert_equal @connection.show_variable("collation_database"), @connection.collation end def test_show_nonexistent_variable_returns_nil assert_nil @connection.show_variable("foo_bar_baz") end def test_not_specifying_database_name_for_cross_database_selects assert_nothing_raised do ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations["arunit"].except(:database)) config = ARTest.test_configuration_hashes ActiveRecord::Base.connection.execute( "SELECT #{config['arunit']['database']}.pirates.*, #{config['arunit2']['database']}.courses.* " \ "FROM #{config['arunit']['database']}.pirates, #{config['arunit2']['database']}.courses" ) end ensure ActiveRecord::Base.establish_connection :arunit end end def test_table_alias def @connection.test_table_alias_length() 10; end class << @connection alias_method :old_table_alias_length, :table_alias_length alias_method :table_alias_length, :test_table_alias_length end assert_equal "posts", @connection.table_alias_for("posts") assert_equal "posts_comm", @connection.table_alias_for("posts_comments") assert_equal "dbo_posts", @connection.table_alias_for("dbo.posts") class << @connection remove_method :table_alias_length alias_method :table_alias_length, :old_table_alias_length end end def test_preventing_writes_predicate assert_not_predicate @connection, :preventing_writes? @connection_handler.while_preventing_writes do assert_predicate @connection, :preventing_writes? end assert_not_predicate @connection, :preventing_writes? end def test_errors_when_an_insert_query_is_called_while_preventing_writes assert_no_queries do assert_raises(ActiveRecord::ReadOnlyError) do @connection_handler.while_preventing_writes do @connection.transaction do @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')", nil, false) end end end end end def test_errors_when_an_update_query_is_called_while_preventing_writes @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')") assert_no_queries do assert_raises(ActiveRecord::ReadOnlyError) do @connection_handler.while_preventing_writes do @connection.transaction do @connection.update("UPDATE subscribers SET nick = '9989' WHERE nick = '138853948594'") end end end end end def test_errors_when_a_delete_query_is_called_while_preventing_writes @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')") assert_no_queries do assert_raises(ActiveRecord::ReadOnlyError) do @connection_handler.while_preventing_writes do @connection.transaction do @connection.delete("DELETE FROM subscribers WHERE nick = '138853948594'") end end end end end def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')") @connection_handler.while_preventing_writes do result = @connection.select_all("SELECT subscribers.* FROM subscribers WHERE nick = '138853948594'") assert_equal 1, result.length end end if ActiveRecord::Base.connection.supports_common_table_expressions? def test_doesnt_error_when_a_read_query_with_a_cte_is_called_while_preventing_writes @connection.insert("INSERT INTO subscribers(nick) VALUES ('138853948594')") @connection_handler.while_preventing_writes do result = @connection.select_all(<<~SQL) WITH matching_subscribers AS (SELECT subscribers.* FROM subscribers WHERE nick = '138853948594') SELECT * FROM matching_subscribers SQL assert_equal 1, result.length end end end def test_uniqueness_violations_are_translated_to_specific_exception @connection.execute "INSERT INTO subscribers(nick) VALUES('me')" error = assert_raises(ActiveRecord::RecordNotUnique) do @connection.execute "INSERT INTO subscribers(nick) VALUES('me')" end assert_not_nil error.cause end def test_not_null_violations_are_translated_to_specific_exception error = assert_raises(ActiveRecord::NotNullViolation) do Post.create end assert_not_nil error.cause end unless current_adapter?(:SQLite3Adapter) def test_value_limit_violations_are_translated_to_specific_exception error = assert_raises(ActiveRecord::ValueTooLong) do Event.create(title: "abcdefgh") end assert_not_nil error.cause end def test_numeric_value_out_of_ranges_are_translated_to_specific_exception error = assert_raises(ActiveRecord::RangeError) do Book.connection.create("INSERT INTO books(author_id) VALUES (9223372036854775808)") end assert_not_nil error.cause end end def test_exceptions_from_notifications_are_not_translated original_error = StandardError.new("This StandardError shouldn't get translated") subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") { raise original_error } actual_error = assert_raises(StandardError) do @connection.execute("SELECT * FROM posts") end assert_equal original_error, actual_error ensure ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber end def test_database_related_exceptions_are_translated_to_statement_invalid error = assert_raises(ActiveRecord::StatementInvalid) do @connection.execute("This is a syntax error") end assert_instance_of ActiveRecord::StatementInvalid, error assert_kind_of Exception, error.cause end def test_select_all_always_return_activerecord_result result = @connection.select_all "SELECT * FROM posts" assert result.is_a?(ActiveRecord::Result) end if ActiveRecord::Base.connection.prepared_statements def test_select_all_with_legacy_binds post = Post.create!(title: "foo", body: "bar") expected = @connection.select_all("SELECT * FROM posts WHERE id = #{post.id}") result = @connection.select_all("SELECT * FROM posts WHERE id = #{Arel::Nodes::BindParam.new(nil).to_sql}", nil, [[nil, post.id]]) assert_equal expected.to_a, result.to_a end def test_insert_update_delete_with_legacy_binds binds = [[nil, 1]] bind_param = Arel::Nodes::BindParam.new(nil) id = @connection.insert("INSERT INTO events(id) VALUES (#{bind_param.to_sql})", nil, nil, nil, nil, binds) assert_equal 1, id @connection.update("UPDATE events SET title = 'foo' WHERE id = #{bind_param.to_sql}", nil, binds) result = @connection.select_all("SELECT * FROM events WHERE id = #{bind_param.to_sql}", nil, binds) assert_equal({ "id" => 1, "title" => "foo" }, result.first) @connection.delete("DELETE FROM events WHERE id = #{bind_param.to_sql}", nil, binds) result = @connection.select_all("SELECT * FROM events WHERE id = #{bind_param.to_sql}", nil, binds) assert_nil result.first end def test_insert_update_delete_with_binds binds = [Relation::QueryAttribute.new("id", 1, Type.default_value)] bind_param = Arel::Nodes::BindParam.new(nil) id = @connection.insert("INSERT INTO events(id) VALUES (#{bind_param.to_sql})", nil, nil, nil, nil, binds) assert_equal 1, id @connection.update("UPDATE events SET title = 'foo' WHERE id = #{bind_param.to_sql}", nil, binds) result = @connection.select_all("SELECT * FROM events WHERE id = #{bind_param.to_sql}", nil, binds) assert_equal({ "id" => 1, "title" => "foo" }, result.first) @connection.delete("DELETE FROM events WHERE id = #{bind_param.to_sql}", nil, binds) result = @connection.select_all("SELECT * FROM events WHERE id = #{bind_param.to_sql}", nil, binds) assert_nil result.first end end def test_select_methods_passing_a_association_relation author = Author.create!(name: "john") Post.create!(author: author, title: "foo", body: "bar") query = author.posts.where(title: "foo").select(:title) assert_equal({ "title" => "foo" }, @connection.select_one(query)) assert @connection.select_all(query).is_a?(ActiveRecord::Result) assert_equal "foo", @connection.select_value(query) assert_equal ["foo"], @connection.select_values(query) end def test_select_methods_passing_a_relation Post.create!(title: "foo", body: "bar") query = Post.where(title: "foo").select(:title) assert_equal({ "title" => "foo" }, @connection.select_one(query)) assert @connection.select_all(query).is_a?(ActiveRecord::Result) assert_equal "foo", @connection.select_value(query) assert_equal ["foo"], @connection.select_values(query) end test "type_to_sql returns a String for unmapped types" do assert_equal "special_db_type", @connection.type_to_sql(:special_db_type) end def test_supports_foreign_keys_in_create_is_deprecated assert_deprecated { @connection.supports_foreign_keys_in_create? } end def test_supports_multi_insert_is_deprecated assert_deprecated { @connection.supports_multi_insert? } end def test_column_name_length_is_deprecated assert_deprecated { @connection.column_name_length } end def test_table_name_length_is_deprecated assert_deprecated { @connection.table_name_length } end def test_columns_per_table_is_deprecated assert_deprecated { @connection.columns_per_table } end def test_indexes_per_table_is_deprecated assert_deprecated { @connection.indexes_per_table } end def test_columns_per_multicolumn_index_is_deprecated assert_deprecated { @connection.columns_per_multicolumn_index } end def test_sql_query_length_is_deprecated assert_deprecated { @connection.sql_query_length } end def test_joins_per_query_is_deprecated assert_deprecated { @connection.joins_per_query } end end class AdapterForeignKeyTest < ActiveRecord::TestCase self.use_transactional_tests = false fixtures :fk_test_has_pk def setup @connection = ActiveRecord::Base.connection end def test_foreign_key_violations_are_translated_to_specific_exception_with_validate_false klass_has_fk = Class.new(ActiveRecord::Base) do self.table_name = "fk_test_has_fk" end error = assert_raises(ActiveRecord::InvalidForeignKey) do has_fk = klass_has_fk.new has_fk.fk_id = 1231231231 has_fk.save(validate: false) end assert_not_nil error.cause end def test_foreign_key_violations_on_insert_are_translated_to_specific_exception error = assert_raises(ActiveRecord::InvalidForeignKey) do insert_into_fk_test_has_fk end assert_not_nil error.cause end def test_foreign_key_violations_on_delete_are_translated_to_specific_exception insert_into_fk_test_has_fk fk_id: 1 error = assert_raises(ActiveRecord::InvalidForeignKey) do @connection.execute "DELETE FROM fk_test_has_pk WHERE pk_id = 1" end assert_not_nil error.cause end def test_disable_referential_integrity assert_nothing_raised do @connection.disable_referential_integrity do insert_into_fk_test_has_fk # should delete created record as otherwise disable_referential_integrity will try to enable constraints # after executed block and will fail (at least on Oracle) @connection.execute "DELETE FROM fk_test_has_fk" end end end private def insert_into_fk_test_has_fk(fk_id: 0) # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method if @connection.prefetch_primary_key? id_value = @connection.next_sequence_value(@connection.default_sequence_name("fk_test_has_fk", "id")) @connection.execute "INSERT INTO fk_test_has_fk (id,fk_id) VALUES (#{id_value},#{fk_id})" else @connection.execute "INSERT INTO fk_test_has_fk (fk_id) VALUES (#{fk_id})" end end end class AdapterTestWithoutTransaction < ActiveRecord::TestCase self.use_transactional_tests = false fixtures :posts, :authors, :author_addresses def setup @connection = ActiveRecord::Base.connection end unless in_memory_db? test "reconnect after a disconnect" do assert_predicate @connection, :active? @connection.disconnect! assert_not_predicate @connection, :active? @connection.reconnect! assert_predicate @connection, :active? end test "transaction state is reset after a reconnect" do @connection.begin_transaction assert_predicate @connection, :transaction_open? @connection.reconnect! assert_not_predicate @connection, :transaction_open? end test "transaction state is reset after a disconnect" do @connection.begin_transaction assert_predicate @connection, :transaction_open? @connection.disconnect! assert_not_predicate @connection, :transaction_open? ensure @connection.reconnect! end end def test_truncate assert_operator Post.count, :>, 0 @connection.truncate("posts") assert_equal 0, Post.count ensure reset_fixtures("posts") end def test_truncate_with_query_cache @connection.enable_query_cache! assert_operator Post.count, :>, 0 @connection.truncate("posts") assert_equal 0, Post.count ensure reset_fixtures("posts") @connection.disable_query_cache! end def test_truncate_tables assert_operator Post.count, :>, 0 assert_operator Author.count, :>, 0 assert_operator AuthorAddress.count, :>, 0 @connection.truncate_tables("author_addresses", "authors", "posts") assert_equal 0, Post.count assert_equal 0, Author.count assert_equal 0, AuthorAddress.count ensure reset_fixtures("posts", "authors", "author_addresses") end def test_truncate_tables_with_query_cache @connection.enable_query_cache! assert_operator Post.count, :>, 0 assert_operator Author.count, :>, 0 assert_operator AuthorAddress.count, :>, 0 @connection.truncate_tables("author_addresses", "authors", "posts") assert_equal 0, Post.count assert_equal 0, Author.count assert_equal 0, AuthorAddress.count ensure reset_fixtures("posts", "authors", "author_addresses") @connection.disable_query_cache! end # test resetting sequences in odd tables in PostgreSQL if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!) require "models/movie" require "models/subscriber" def test_reset_empty_table_with_custom_pk Movie.delete_all Movie.connection.reset_pk_sequence! "movies" assert_equal 1, Movie.create(name: "fight club").id end def test_reset_table_with_non_integer_pk Subscriber.delete_all Subscriber.connection.reset_pk_sequence! "subscribers" sub = Subscriber.new(name: "robert drake") sub.id = "bob drake" assert_nothing_raised { sub.save! } end end private def reset_fixtures(*fixture_names) ActiveRecord::FixtureSet.reset_cache fixture_names.each do |fixture_name| ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, fixture_name) end end end end if ActiveRecord::Base.connection.supports_advisory_locks? class AdvisoryLocksEnabledTest < ActiveRecord::TestCase include ConnectionHelper def test_advisory_locks_enabled? assert ActiveRecord::Base.connection.advisory_locks_enabled? run_without_connection do |orig_connection| ActiveRecord::Base.establish_connection( orig_connection.merge(advisory_locks: false) ) assert_not ActiveRecord::Base.connection.advisory_locks_enabled? ActiveRecord::Base.establish_connection( orig_connection.merge(advisory_locks: true) ) assert ActiveRecord::Base.connection.advisory_locks_enabled? end end end end