ibm_db 5.6.1 → 5.7.0

data/test/cases/adapters/sqlite3/copy_table_test.rb

@@ -6,10 +6,7 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
   fixtures :customers
 
   def setup
-    @connection = ActiveRecord::Base.connection
-    class << @connection
-      public :copy_table, :table_structure, :indexes
-    end
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def test_copy_table(from = "customers", to = "customers2", options = {})
@@ -25,12 +22,22 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
     @connection.drop_table(to) rescue nil
   end
 
+  def test_copy_table_with_column_with_default
+    test_copy_table("comments", "comments_with_default") do
+      @connection.add_column("comments_with_default", "options", "json", default: {})
+      test_copy_table("comments_with_default", "comments_with_default2") do
+        column = @connection.columns("comments_with_default2").find { |col| col.name == "options" }
+        assert_equal "{}", column.default
+      end
+    end
+  end
+
   def test_copy_table_renaming_column
     test_copy_table("customers", "customers2",
         rename: { "name" => "person_name" }) do |from, to, options|
       expected = column_values(from, "name")
       assert_equal expected, column_values(to, "person_name")
-      assert expected.any?, "No values in table: #{expected.inspect}"
+      assert_predicate expected, :any?, "No values in table: #{expected.inspect}"
     end
   end
 
@@ -78,13 +85,27 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
     test_copy_table "binaries", "binaries2"
   end
 
+  def test_copy_table_with_virtual_column
+    @connection.create_table :virtual_columns, force: true do |t|
+      t.string  :name
+      t.virtual :upper_name, type: :string, as: "UPPER(name)", stored: true
+    end
+
+    test_copy_table("virtual_columns", "virtual_columns2") do
+      column = @connection.columns("virtual_columns2").find { |col| col.name == "upper_name" }
+      assert_predicate column, :virtual_stored?
+      assert_equal :string, column.type
+      assert_equal "UPPER(name)", column.default_function
+    end
+  end
+
 private
   def copy_table(from, to, options = {})
-    @connection.copy_table(from, to, { temporary: true }.merge(options))
+    @connection.send(:copy_table, from, to, { temporary: true }.merge(options))
   end
 
   def column_names(table)
-    @connection.table_structure(table).map { |column| column["name"] }
+    @connection.send(:table_structure, table).map { |column| column["name"] }
   end
 
   def column_values(table, column)

data/test/cases/adapters/sqlite3/dbconsole_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/testing/method_call_assertions"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3DbConsoleTest < ActiveRecord::SQLite3TestCase
+      include ActiveSupport::Testing::MethodCallAssertions
+
+      def test_sqlite3
+        config = make_db_config(adapter: "sqlite3", database: "db.sqlite3")
+
+        assert_find_cmd_and_exec_called_with(["sqlite3", root.join("db.sqlite3").to_s]) do
+          SQLite3Adapter.dbconsole(config)
+        end
+      end
+
+      def test_sqlite3_mode
+        config = make_db_config(adapter: "sqlite3", database: "db.sqlite3")
+
+        assert_find_cmd_and_exec_called_with(["sqlite3", "-html", root.join("db.sqlite3").to_s]) do
+          SQLite3Adapter.dbconsole(config, mode: "html")
+        end
+      end
+
+      def test_sqlite3_header
+        config = make_db_config(adapter: "sqlite3", database: "db.sqlite3")
+
+        assert_find_cmd_and_exec_called_with(["sqlite3", "-header", root.join("db.sqlite3").to_s]) do
+          SQLite3Adapter.dbconsole(config, header: true)
+        end
+      end
+
+      def test_sqlite3_db_absolute_path
+        config = make_db_config(adapter: "sqlite3", database: "/tmp/db.sqlite3")
+
+        assert_find_cmd_and_exec_called_with(["sqlite3", "/tmp/db.sqlite3"]) do
+          SQLite3Adapter.dbconsole(config)
+        end
+      end
+
+      def test_sqlite3_db_with_defined_rails_root
+        config = make_db_config(adapter: "sqlite3", database: "config/db.sqlite3")
+
+        root = method(:root)
+        mod = Module.new { define_singleton_method(:root, &root) }
+
+        stub_const(Object, :Rails, mod, exists: defined?(Rails)) do
+          assert_find_cmd_and_exec_called_with(["sqlite3", Rails.root.join("config/db.sqlite3").to_s]) do
+            SQLite3Adapter.dbconsole(config)
+          end
+        end
+      end
+
+      def test_sqlite3_can_use_alternative_cli
+        ActiveRecord.database_cli[:sqlite] = "sqlitecli"
+        config = make_db_config(adapter: "sqlite3", database: "config/db.sqlite3", database_cli: "sqlitecli")
+
+        assert_find_cmd_and_exec_called_with(["sqlitecli", root.join("config/db.sqlite3").to_s]) do
+          SQLite3Adapter.dbconsole(config)
+        end
+      ensure
+        ActiveRecord.database_cli[:sqlite] = "sqlite3"
+      end
+
+      private
+        def root
+          Pathname(__dir__).join("../../../..")
+        end
+
+        def make_db_config(config)
+          ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+        end
+
+        def assert_find_cmd_and_exec_called_with(args, &block)
+          assert_called_with(SQLite3Adapter, :find_cmd_and_exec, args, &block)
+        end
+    end
+  end
+end

data/test/cases/adapters/sqlite3/explain_test.rb

@@ -5,16 +5,16 @@ require "models/author"
 require "models/post"
 
 class SQLite3ExplainTest < ActiveRecord::SQLite3TestCase
-  fixtures :authors
+  fixtures :authors, :author_addresses
 
   def test_explain_for_one_query
-    explain = Author.where(id: 1).explain
+    explain = Author.where(id: 1).explain.inspect
     assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\? \[\["id", 1\]\]|1)), explain
     assert_match(/(SEARCH )?(TABLE )?authors USING (INTEGER )?PRIMARY KEY/, explain)
   end
 
   def test_explain_with_eager_loading
-    explain = Author.where(id: 1).includes(:posts).explain
+    explain = Author.where(id: 1).includes(:posts).explain.inspect
     assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\? \[\["id", 1\]\]|1)), explain
     assert_match(/(SEARCH )?(TABLE )?authors USING (INTEGER )?PRIMARY KEY/, explain)
     assert_match %r(EXPLAIN for: SELECT "posts"\.\* FROM "posts" WHERE "posts"\."author_id" = (?:\? \[\["author_id", 1\]\]|1)), explain

data/test/cases/adapters/sqlite3/quoting_test.rb

@@ -7,7 +7,26 @@ require "securerandom"
 class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
   def setup
     super
-    @conn = ActiveRecord::Base.connection
+    @conn = ActiveRecord::Base.lease_connection
+  end
+
+  def test_quote_string
+    assert_equal "''", @conn.quote_string("'")
+  end
+
+  def test_quote_column_name
+    [@conn, @conn.class].each do |adapter|
+      assert_equal '"foo"', adapter.quote_column_name("foo")
+      assert_equal '"hel""lo"', adapter.quote_column_name(%{hel"lo})
+    end
+  end
+
+  def test_quote_table_name
+    [@conn, @conn.class].each do |adapter|
+      assert_equal '"foo"', adapter.quote_table_name("foo")
+      assert_equal '"foo"."bar"', adapter.quote_table_name("foo.bar")
+      assert_equal '"hel""lo.wol\\d"', adapter.quote_column_name('hel"lo.wol\\d')
+    end
   end
 
   def test_type_cast_binary_encoding_without_logger
@@ -57,7 +76,7 @@ class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
         t = Time.new(2000, 7, 1, 0, 0, 0, "+04:30")
 
         expected = t.change(year: 2000, month: 1, day: 1)
-        expected = expected.getutc.to_s(:db).sub(/\A\d\d\d\d-\d\d-\d\d /, "2000-01-01 ")
+        expected = expected.getutc.to_fs(:db).sub(/\A\d\d\d\d-\d\d-\d\d /, "2000-01-01 ")
 
         assert_equal expected, @conn.quoted_time(t)
       end
@@ -70,10 +89,22 @@ class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
         t = Time.new(2000, 7, 1, 0, 0, 0, "+04:30")
 
         expected = t.change(year: 2000, month: 1, day: 1)
-        expected = expected.getlocal.to_s(:db).sub(/\A\d\d\d\d-\d\d-\d\d /, "2000-01-01 ")
+        expected = expected.getlocal.to_fs(:db).sub(/\A\d\d\d\d-\d\d-\d\d /, "2000-01-01 ")
 
         assert_equal expected, @conn.quoted_time(t)
       end
     end
   end
+
+  def test_quote_numeric_infinity
+    assert_equal "'Infinity'", @conn.quote(Float::INFINITY)
+    assert_equal "'-Infinity'", @conn.quote(-Float::INFINITY)
+    assert_equal "'Infinity'", @conn.quote(BigDecimal(Float::INFINITY))
+    assert_equal "'-Infinity'", @conn.quote(BigDecimal(-Float::INFINITY))
+  end
+
+  def test_quote_float_nan
+    assert_equal "'NaN'", @conn.quote(Float::NAN)
+    assert_equal "'NaN'", @conn.quote(BigDecimal(Float::NAN))
+  end
 end

data/test/cases/adapters/sqlite3/sqlite3_adapter_prevent_writes_test.rb

@@ -11,13 +11,13 @@ module ActiveRecord
       self.use_transactional_tests = false
 
       def setup
-        @conn = ActiveRecord::Base.connection
+        @conn = ActiveRecord::Base.lease_connection
       end
 
       def test_errors_when_an_insert_query_is_called_while_preventing_writes
         with_example_table "id int, data string" do
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            ActiveRecord::Base.while_preventing_writes do
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
               @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
             end
           end
@@ -28,8 +28,8 @@ module ActiveRecord
         with_example_table "id int, data string" do
           @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
 
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            ActiveRecord::Base.while_preventing_writes do
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
               @conn.execute("UPDATE ex SET data = '9989' WHERE data = '138853948594'")
             end
           end
@@ -40,8 +40,8 @@ module ActiveRecord
         with_example_table "id int, data string" do
           @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
 
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            ActiveRecord::Base.while_preventing_writes do
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
               @conn.execute("DELETE FROM ex where data = '138853948594'")
             end
           end
@@ -52,8 +52,8 @@ module ActiveRecord
         with_example_table "id int, data string" do
           @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
 
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            ActiveRecord::Base.while_preventing_writes do
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
               @conn.execute("REPLACE INTO ex (data) VALUES ('249823948')")
             end
           end
@@ -89,98 +89,5 @@ module ActiveRecord
           super(@conn, table_name, definition, &block)
         end
     end
-
-    class SQLite3AdapterPreventWritesLegacyTest < ActiveRecord::SQLite3TestCase
-      include DdlHelper
-      self.use_transactional_tests = false
-
-      def setup
-        @old_value = ActiveRecord::Base.legacy_connection_handling
-        ActiveRecord::Base.legacy_connection_handling = true
-
-        @conn = ActiveRecord::Base.connection
-
-        @connection_handler = ActiveRecord::Base.connection_handler
-      end
-
-      def teardown
-        ActiveRecord::Base.legacy_connection_handling = @old_value
-      end
-
-      def test_errors_when_an_insert_query_is_called_while_preventing_writes
-        with_example_table "id int, data string" do
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            @connection_handler.while_preventing_writes do
-              @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-            end
-          end
-        end
-      end
-
-      def test_errors_when_an_update_query_is_called_while_preventing_writes
-        with_example_table "id int, data string" do
-          @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            @connection_handler.while_preventing_writes do
-              @conn.execute("UPDATE ex SET data = '9989' WHERE data = '138853948594'")
-            end
-          end
-        end
-      end
-
-      def test_errors_when_a_delete_query_is_called_while_preventing_writes
-        with_example_table "id int, data string" do
-          @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            @connection_handler.while_preventing_writes do
-              @conn.execute("DELETE FROM ex where data = '138853948594'")
-            end
-          end
-        end
-      end
-
-      def test_errors_when_a_replace_query_is_called_while_preventing_writes
-        with_example_table "id int, data string" do
-          @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            @connection_handler.while_preventing_writes do
-              @conn.execute("REPLACE INTO ex (data) VALUES ('249823948')")
-            end
-          end
-        end
-      end
-
-      def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
-        with_example_table "id int, data string" do
-          @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-
-          @connection_handler.while_preventing_writes do
-            assert_equal 1, @conn.execute("SELECT data from ex WHERE data = '138853948594'").count
-          end
-        end
-      end
-
-      def test_doesnt_error_when_a_read_query_with_leading_chars_is_called_while_preventing_writes
-        with_example_table "id int, data string" do
-          @conn.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-
-          @connection_handler.while_preventing_writes do
-            assert_equal 1, @conn.execute("/*action:index*/  SELECT data from ex WHERE data = '138853948594'").count
-          end
-        end
-      end
-
-      private
-        def with_example_table(definition = nil, table_name = "ex", &block)
-          definition ||= <<~SQL
-            id integer PRIMARY KEY AUTOINCREMENT,
-            number integer
-          SQL
-          super(@conn, table_name, definition, &block)
-        end
-    end
   end
 end