Merge pull request #23953 from kamipo/fix_tests_failure_with_prepared_statements_false

Fix tests failure with `prepared_statements: false`

11 files changed, 95 insertions, 135 deletions

diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index 0ee147cdba..a9f1993842 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -11,7 +11,8 @@ module ActiveRecord
 
     ##
     # PostgreSQL does not support null bytes in strings
-    unless current_adapter?(:PostgreSQLAdapter)
+    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
diff --git a/activerecord/test/cases/adapters/mysql2/explain_test.rb b/activerecord/test/cases/adapters/mysql2/explain_test.rb
index 4fc7414b18..b783b5fcd9 100644
--- a/activerecord/test/cases/adapters/mysql2/explain_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/explain_test.rb
@@ -2,26 +2,20 @@ require "cases/helper"
 require 'models/developer'
 require 'models/computer'
 
-module ActiveRecord
-  module ConnectionAdapters
-    class Mysql2Adapter
-      class ExplainTest < ActiveRecord::Mysql2TestCase
-        fixtures :developers
+class Mysql2ExplainTest < ActiveRecord::Mysql2TestCase
+  fixtures :developers
 
-        def test_explain_for_one_query
-          explain = Developer.where(:id => 1).explain
-          assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers` WHERE `developers`.`id` = 1), explain
-          assert_match %r(developers |.* const), explain
-        end
+  def test_explain_for_one_query
+    explain = Developer.where(id: 1).explain
+    assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers` WHERE `developers`.`id` = 1), explain
+    assert_match %r(developers |.* const), explain
+  end
 
-        def test_explain_with_eager_loading
-          explain = Developer.where(:id => 1).includes(:audit_logs).explain
-          assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers` WHERE `developers`.`id` = 1), explain
-          assert_match %r(developers |.* const), explain
-          assert_match %(EXPLAIN for: SELECT `audit_logs`.* FROM `audit_logs` WHERE `audit_logs`.`developer_id` = 1), explain
-          assert_match %r(audit_logs |.* ALL), explain
-        end
-      end
-    end
+  def test_explain_with_eager_loading
+    explain = Developer.where(id: 1).includes(:audit_logs).explain
+    assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers` WHERE `developers`.`id` = 1), explain
+    assert_match %r(developers |.* const), explain
+    assert_match %(EXPLAIN for: SELECT `audit_logs`.* FROM `audit_logs` WHERE `audit_logs`.`developer_id` = 1), explain
+    assert_match %r(audit_logs |.* ALL), explain
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/bit_string_test.rb b/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
index 6f72fa6e0f..cec6081aec 100644
--- a/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bit_string_test.rb
@@ -57,9 +57,11 @@ class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
     assert_match %r{t\.bit_varying\s+"a_bit_varying",\s+limit: 4,\s+default: "0011"$}, output
   end
 
-  def test_assigning_invalid_hex_string_raises_exception
-    assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit: "FF" }
-    assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit_varying: "FF" }
+  if ActiveRecord::Base.connection.prepared_statements
+    def test_assigning_invalid_hex_string_raises_exception
+      assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit: "FF" }
+      assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit_varying: "F" }
+    end
   end
 
   def test_roundtrip
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index d559de3e28..f8403bfe1a 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -125,14 +125,16 @@ module ActiveRecord
       assert_equal 'SCHEMA', @subscriber.logged[0][1]
     end
 
-    def test_statement_key_is_logged
-      bind = Relation::QueryAttribute.new(nil, 1, Type::Value.new)
-      @connection.exec_query('SELECT $1::integer', 'SQL', [bind], prepare: true)
-      name = @subscriber.payloads.last[:statement_name]
-      assert name
-      res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(1)")
-      plan = res.column_types['QUERY PLAN'].deserialize res.rows.first.first
-      assert_operator plan.length, :>, 0
+    if ActiveRecord::Base.connection.prepared_statements
+      def test_statement_key_is_logged
+        bind = Relation::QueryAttribute.new(nil, 1, Type::Value.new)
+        @connection.exec_query('SELECT $1::integer', 'SQL', [bind], prepare: true)
+        name = @subscriber.payloads.last[:statement_name]
+        assert name
+        res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(1)")
+        plan = res.column_types['QUERY PLAN'].deserialize res.rows.first.first
+        assert_operator plan.length, :>, 0
+      end
     end
 
     # Must have PostgreSQL >= 9.2, or with_manual_interventions set to
diff --git a/activerecord/test/cases/adapters/postgresql/explain_test.rb b/activerecord/test/cases/adapters/postgresql/explain_test.rb
index 4d0fd640aa..29bf2c15ea 100644
--- a/activerecord/test/cases/adapters/postgresql/explain_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/explain_test.rb
@@ -6,15 +6,15 @@ class PostgreSQLExplainTest < ActiveRecord::PostgreSQLTestCase
   fixtures :developers
 
   def test_explain_for_one_query
-    explain = Developer.where(:id => 1).explain
-    assert_match %(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = $1), explain
+    explain = Developer.where(id: 1).explain
+    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = \$?1), explain
     assert_match %(QUERY PLAN), explain
   end
 
   def test_explain_with_eager_loading
-    explain = Developer.where(:id => 1).includes(:audit_logs).explain
+    explain = Developer.where(id: 1).includes(:audit_logs).explain
     assert_match %(QUERY PLAN), explain
-    assert_match %(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = $1), explain
+    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = \$?1), explain
     assert_match %(EXPLAIN for: SELECT "audit_logs".* FROM "audit_logs" WHERE "audit_logs"."developer_id" = 1), explain
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index 31e87722d9..fbdaab2fdd 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -5,6 +5,7 @@ require 'support/connection_helper'
 module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLAdapterTest < ActiveRecord::PostgreSQLTestCase
+      self.use_transactional_tests = false
       include DdlHelper
       include ConnectionHelper
 
@@ -239,30 +240,6 @@ module ActiveRecord
         @connection.drop_table 'ex2', if_exists: true
       end
 
-      def test_exec_insert_number
-        with_example_table do
-          insert(@connection, 'number' => 10)
-
-          result = @connection.exec_query('SELECT number FROM ex WHERE number = 10')
-
-          assert_equal 1, result.rows.length
-          assert_equal 10, result.rows.last.last
-        end
-      end
-
-      def test_exec_insert_string
-        with_example_table do
-          str = 'いただきます！'
-          insert(@connection, 'number' => 10, 'data' => str)
-
-          result = @connection.exec_query('SELECT number, data FROM ex WHERE number = 10')
-
-          value = result.rows.last.last
-
-          assert_equal str, value
-        end
-      end
-
       def test_table_alias_length
         assert_nothing_raised do
           @connection.table_alias_length
@@ -286,33 +263,35 @@ module ActiveRecord
         end
       end
 
-      def test_exec_with_binds
-        with_example_table do
-          string = @connection.quote('foo')
-          @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
-          result = @connection.exec_query(
-                                          'SELECT id, data FROM ex WHERE id = $1', nil, [bind_param(1)])
+      if ActiveRecord::Base.connection.prepared_statements
+        def test_exec_with_binds
+          with_example_table do
+            string = @connection.quote('foo')
+            @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
 
-          assert_equal 1, result.rows.length
-          assert_equal 2, result.columns.length
+            bind = Relation::QueryAttribute.new("id", 1, Type::Value.new)
+            result = @connection.exec_query('SELECT id, data FROM ex WHERE id = $1', nil, [bind])
 
-          assert_equal [[1, 'foo']], result.rows
+            assert_equal 1, result.rows.length
+            assert_equal 2, result.columns.length
+
+            assert_equal [[1, 'foo']], result.rows
+          end
         end
-      end
 
-      def test_exec_typecasts_bind_vals
-        with_example_table do
-          string = @connection.quote('foo')
-          @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
+        def test_exec_typecasts_bind_vals
+          with_example_table do
+            string = @connection.quote('foo')
+            @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
 
-          bind = ActiveRecord::Relation::QueryAttribute.new("id", "1-fuu", ActiveRecord::Type::Integer.new)
-          result = @connection.exec_query(
-                                          'SELECT id, data FROM ex WHERE id = $1', nil, [bind])
+            bind = Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)
+            result = @connection.exec_query('SELECT id, data FROM ex WHERE id = $1', nil, [bind])
 
-          assert_equal 1, result.rows.length
-          assert_equal 2, result.columns.length
+            assert_equal 1, result.rows.length
+            assert_equal 2, result.columns.length
 
-          assert_equal [[1, 'foo']], result.rows
+            assert_equal [[1, 'foo']], result.rows
+          end
         end
       end
 
@@ -438,19 +417,6 @@ module ActiveRecord
       end
 
       private
-      def insert(ctx, data)
-        binds = data.map { |name, value|
-          bind_param(value, name)
-        }
-        columns = binds.map(&:name)
-
-        bind_subs = columns.length.times.map { |x| "$#{x + 1}" }
-
-        sql = "INSERT INTO ex (#{columns.join(", ")})
-               VALUES (#{bind_subs.join(', ')})"
-
-        ctx.exec_insert(sql, 'SQL', binds)
-      end
 
       def with_example_table(definition = 'id serial primary key, number integer, data character varying(255)', &block)
         super(@connection, 'ex', definition, &block)
@@ -459,10 +425,6 @@ module ActiveRecord
       def connection_without_insert_returning
         ActiveRecord::Base.postgresql_connection(ActiveRecord::Base.configurations['arunit'].merge(:insert_returning => false))
       end
-
-      def bind_param(value, name = nil)
-        ActiveRecord::Relation::QueryAttribute.new(name, value, ActiveRecord::Type::Value.new)
-      end
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index a0afd922b2..285a92f60e 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -55,20 +55,22 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
       set_session_auth
       USERS.each do |u|
         set_session_auth u
-        assert_equal u, @connection.exec_query("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [bind_param(1)]).first['name']
+        assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = 1")
         set_session_auth
       end
     end
   end
 
-  def test_auth_with_bind
-    assert_nothing_raised do
-      set_session_auth
-      USERS.each do |u|
-        @connection.clear_cache!
-        set_session_auth u
-        assert_equal u, @connection.exec_query("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [bind_param(1)]).first['name']
+  if ActiveRecord::Base.connection.prepared_statements
+    def test_auth_with_bind
+      assert_nothing_raised do
         set_session_auth
+        USERS.each do |u|
+          @connection.clear_cache!
+          set_session_auth u
+          assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [bind_param(1)])
+          set_session_auth
+        end
       end
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index f50fe88b9b..00ebabc9c5 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -172,16 +172,18 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
     end
   end
 
-  def test_schema_change_with_prepared_stmt
-    altered = false
-    @connection.exec_query "select * from developers where id = $1", 'sql', [bind_param(1)]
-    @connection.exec_query "alter table developers add column zomg int", 'sql', []
-    altered = true
-    @connection.exec_query "select * from developers where id = $1", 'sql', [bind_param(1)]
-  ensure
-    # We are not using DROP COLUMN IF EXISTS because that syntax is only
-    # supported by pg 9.X
-    @connection.exec_query("alter table developers drop column zomg", 'sql', []) if altered
+  if ActiveRecord::Base.connection.prepared_statements
+    def test_schema_change_with_prepared_stmt
+      altered = false
+      @connection.exec_query "select * from developers where id = $1", 'sql', [bind_param(1)]
+      @connection.exec_query "alter table developers add column zomg int", 'sql', []
+      altered = true
+      @connection.exec_query "select * from developers where id = $1", 'sql', [bind_param(1)]
+    ensure
+      # We are not using DROP COLUMN IF EXISTS because that syntax is only
+      # supported by pg 9.X
+      @connection.exec_query("alter table developers drop column zomg", 'sql', []) if altered
+    end
   end
 
   def test_data_source_exists?
diff --git a/activerecord/test/cases/adapters/sqlite3/explain_test.rb b/activerecord/test/cases/adapters/sqlite3/explain_test.rb
index 2aec322582..a1a6e5f16a 100644
--- a/activerecord/test/cases/adapters/sqlite3/explain_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/explain_test.rb
@@ -2,26 +2,20 @@ require "cases/helper"
 require 'models/developer'
 require 'models/computer'
 
-module ActiveRecord
-  module ConnectionAdapters
-    class SQLite3Adapter
-      class ExplainTest < ActiveRecord::SQLite3TestCase
-        fixtures :developers
+class SQLite3ExplainTest < ActiveRecord::SQLite3TestCase
+  fixtures :developers
 
-        def test_explain_for_one_query
-          explain = Developer.where(:id => 1).explain
-          assert_match %(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = ?), explain
-          assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
-        end
+  def test_explain_for_one_query
+    explain = Developer.where(id: 1).explain
+    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = (?:\?|1)), explain
+    assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+  end
 
-        def test_explain_with_eager_loading
-          explain = Developer.where(:id => 1).includes(:audit_logs).explain
-          assert_match %(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = ?), explain
-          assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
-          assert_match %(EXPLAIN for: SELECT "audit_logs".* FROM "audit_logs" WHERE "audit_logs"."developer_id" = 1), explain
-          assert_match(/(SCAN )?TABLE audit_logs/, explain)
-        end
-      end
-    end
+  def test_explain_with_eager_loading
+    explain = Developer.where(id: 1).includes(:audit_logs).explain
+    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = (?:\?|1)), explain
+    assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+    assert_match %(EXPLAIN for: SELECT "audit_logs".* FROM "audit_logs" WHERE "audit_logs"."developer_id" = 1), explain
+    assert_match(/(SCAN )?TABLE audit_logs/, explain)
   end
 end
diff --git a/activerecord/test/cases/bind_parameter_test.rb b/activerecord/test/cases/bind_parameter_test.rb
index cd9c76f1f0..fa924fe4cb 100644
--- a/activerecord/test/cases/bind_parameter_test.rb
+++ b/activerecord/test/cases/bind_parameter_test.rb
@@ -31,7 +31,8 @@ module ActiveRecord
       ActiveSupport::Notifications.unsubscribe(@subscription)
     end
 
-    if ActiveRecord::Base.connection.supports_statement_cache?
+    if ActiveRecord::Base.connection.supports_statement_cache? &&
+       ActiveRecord::Base.connection.prepared_statements
       def test_bind_from_join_in_subquery
         subquery = Author.joins(:thinking_posts).where(name: 'David')
         scope = Author.from(subquery, 'authors').where(id: 1)
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 4fe76e563a..6c59d7337a 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -441,7 +441,7 @@ unless in_memory_db?
       def test_lock_sending_custom_lock_statement
         Person.transaction do
           person = Person.find(1)
-          assert_sql(/LIMIT \$\d FOR SHARE NOWAIT/) do
+          assert_sql(/LIMIT \$?\d FOR SHARE NOWAIT/) do
             person.lock!('FOR SHARE NOWAIT')
           end
         end