ibm_db 5.2.0-x86-mingw32 → 5.3.2-x86-mingw32

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class CopyTableTest < ActiveRecord::SQLite3TestCase
@@ -10,8 +12,8 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
     end
   end
 
-  def test_copy_table(from = 'customers', to = 'customers2', options = {})
-    assert_nothing_raised {copy_table(from, to, options)}
+  def test_copy_table(from = "customers", to = "customers2", options = {})
+    assert_nothing_raised { copy_table(from, to, options) }
     assert_equal row_count(from), row_count(to)
 
     if block_given?
@@ -24,68 +26,69 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
   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')
+    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}"
     end
   end
 
   def test_copy_table_allows_to_pass_options_to_create_table
-    @connection.create_table('blocker_table')
-    test_copy_table('customers', 'blocker_table', force: true)
+    @connection.create_table("blocker_table")
+    test_copy_table("customers", "blocker_table", force: true)
   end
 
   def test_copy_table_with_index
-    test_copy_table('comments', 'comments_with_index') do
-      @connection.add_index('comments_with_index', ['post_id', 'type'])
-      test_copy_table('comments_with_index', 'comments_with_index2') do
-        assert_equal table_indexes_without_name('comments_with_index'),
-                     table_indexes_without_name('comments_with_index2')
+    test_copy_table("comments", "comments_with_index") do
+      @connection.add_index("comments_with_index", ["post_id", "type"])
+      test_copy_table("comments_with_index", "comments_with_index2") do
+        assert_nil table_indexes_without_name("comments_with_index")
+        assert_nil table_indexes_without_name("comments_with_index2")
       end
     end
   end
 
   def test_copy_table_without_primary_key
-    test_copy_table('developers_projects', 'programmers_projects') do
-      assert_nil @connection.primary_key('programmers_projects')
+    test_copy_table("developers_projects", "programmers_projects") do
+      assert_nil @connection.primary_key("programmers_projects")
     end
   end
 
   def test_copy_table_with_id_col_that_is_not_primary_key
-    test_copy_table('goofy_string_id', 'goofy_string_id2') do
-      original_id = @connection.columns('goofy_string_id').detect{|col| col.name == 'id' }
-      copied_id = @connection.columns('goofy_string_id2').detect{|col| col.name == 'id' }
+    test_copy_table("goofy_string_id", "goofy_string_id2") do
+      original_id = @connection.columns("goofy_string_id").detect { |col| col.name == "id" }
+      copied_id = @connection.columns("goofy_string_id2").detect { |col| col.name == "id" }
       assert_equal original_id.type, copied_id.type
       assert_equal original_id.sql_type, copied_id.sql_type
-      assert_equal original_id.limit, copied_id.limit
+      assert_nil original_id.limit
+      assert_nil copied_id.limit
     end
   end
 
   def test_copy_table_with_unconventional_primary_key
-    test_copy_table('owners', 'owners_unconventional') do
-      original_pk = @connection.primary_key('owners')
-      copied_pk = @connection.primary_key('owners_unconventional')
+    test_copy_table("owners", "owners_unconventional") do
+      original_pk = @connection.primary_key("owners")
+      copied_pk = @connection.primary_key("owners_unconventional")
       assert_equal original_pk, copied_pk
     end
   end
 
   def test_copy_table_with_binary_column
-    test_copy_table 'binaries', 'binaries2'
+    test_copy_table "binaries", "binaries2"
   end
 
-protected
+private
   def copy_table(from, to, options = {})
-    @connection.copy_table(from, to, {:temporary => true}.merge(options))
+    @connection.copy_table(from, to, { temporary: true }.merge(options))
   end
 
   def column_names(table)
-    @connection.table_structure(table).map {|column| column['name']}
+    @connection.table_structure(table).map { |column| column["name"] }
   end
 
   def column_values(table, column)
-    @connection.select_all("SELECT #{column} FROM #{table} ORDER BY id").map {|row| row[column]}
+    @connection.select_all("SELECT #{column} FROM #{table} ORDER BY id").map { |row| row[column] }
   end
 
   def table_indexes_without_name(table)
@@ -93,6 +96,6 @@ protected
   end
 
   def row_count(table)
-    @connection.select_one("SELECT COUNT(*) AS count FROM #{table}")['count']
+    @connection.select_one("SELECT COUNT(*) AS count FROM #{table}")["count"]
   end
 end

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

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/developer'
-require 'models/computer'
+require "models/author"
+require "models/post"
 
 class SQLite3ExplainTest < ActiveRecord::SQLite3TestCase
-  fixtures :developers
+  fixtures :authors
 
   def test_explain_for_one_query
-    explain = Developer.where(id: 1).explain
-    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = (?:\? \[\["id", 1\]\]|1)), explain
-    assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+    explain = Author.where(id: 1).explain
+    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 = Developer.where(id: 1).includes(:audit_logs).explain
-    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = (?:\? \[\["id", 1\]\]|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)
+    explain = Author.where(id: 1).includes(:posts).explain
+    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
+    assert_match(/(SEARCH |(SCAN )?(TABLE ))posts/, explain)
   end
 end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "cases/json_shared_test_cases"
+
+class SQLite3JSONTest < ActiveRecord::SQLite3TestCase
+  include JSONSharedTestCases
+
+  def setup
+    super
+    @connection.create_table("json_data_type") do |t|
+      t.json "payload", default: {}
+      t.json "settings"
+    end
+  end
+
+  def test_default
+    @connection.add_column "json_data_type", "permissions", column_type, default: { "users": "read", "posts": ["read", "write"] }
+    klass.reset_column_information
+
+    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, klass.column_defaults["permissions"])
+    assert_equal({ "users" => "read", "posts" => ["read", "write"] }, klass.new.permissions)
+  end
+
+  private
+    def column_type
+      :json
+    end
+end

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'bigdecimal'
-require 'yaml'
-require 'securerandom'
+require "bigdecimal"
+require "securerandom"
 
 class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
   def setup
+    super
     @conn = ActiveRecord::Base.connection
   end
 
@@ -15,71 +17,21 @@ class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
     assert_equal expected, @conn.type_cast(binary)
   end
 
-  def test_type_cast_symbol
-    assert_equal 'foo', @conn.type_cast(:foo)
-  end
-
-  def test_type_cast_date
-    date = Date.today
-    expected = @conn.quoted_date(date)
-    assert_equal expected, @conn.type_cast(date)
-  end
-
-  def test_type_cast_time
-    time = Time.now
-    expected = @conn.quoted_date(time)
-    assert_equal expected, @conn.type_cast(time)
-  end
-
-  def test_type_cast_numeric
-    assert_equal 10, @conn.type_cast(10)
-    assert_equal 2.2, @conn.type_cast(2.2)
-  end
-
-  def test_type_cast_nil
-    assert_equal nil, @conn.type_cast(nil)
-  end
-
   def test_type_cast_true
-    assert_equal 't', @conn.type_cast(true)
+    assert_equal 1, @conn.type_cast(true)
   end
 
   def test_type_cast_false
-    assert_equal 'f', @conn.type_cast(false)
+    assert_equal 0, @conn.type_cast(false)
   end
 
   def test_type_cast_bigdecimal
-    bd = BigDecimal.new '10.0'
+    bd = BigDecimal "10.0"
     assert_equal bd.to_f, @conn.type_cast(bd)
   end
 
-  def test_type_cast_unknown_should_raise_error
-    obj = Class.new.new
-    assert_raise(TypeError) { @conn.type_cast(obj) }
-  end
-
-  def test_type_cast_object_which_responds_to_quoted_id
-    quoted_id_obj = Class.new {
-      def quoted_id
-        "'zomg'"
-      end
-
-      def id
-        10
-      end
-    }.new
-    assert_equal 10, @conn.type_cast(quoted_id_obj)
-
-    quoted_id_obj = Class.new {
-      def quoted_id
-        "'zomg'"
-      end
-    }.new
-    assert_raise(TypeError) { @conn.type_cast(quoted_id_obj) }
-  end
-
   def test_quoting_binary_strings
-    value = "hello".encode('ascii-8bit')
+    value = "hello".encode("ascii-8bit")
     type = ActiveRecord::Type::String.new
 
     assert_equal "'hello'", @conn.quote(type.serialize(value))
@@ -98,4 +50,30 @@ class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
 
     assert_equal "'2000-01-01 12:30:00.999999'", @conn.quote(type.serialize(value))
   end
+
+  def test_quoted_time_dst_utc
+    with_env_tz "America/New_York" do
+      with_timezone_config default: :utc do
+        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 ")
+
+        assert_equal expected, @conn.quoted_time(t)
+      end
+    end
+  end
+
+  def test_quoted_time_dst_local
+    with_env_tz "America/New_York" do
+      with_timezone_config default: :local do
+        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 ")
+
+        assert_equal expected, @conn.quoted_time(t)
+      end
+    end
+  end
 end

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

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/ddl_helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3AdapterPreventWritesTest < ActiveRecord::SQLite3TestCase
+      include DdlHelper
+
+      self.use_transactional_tests = false
+
+      def setup
+        @conn = ActiveRecord::Base.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
+              @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
+            ActiveRecord::Base.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
+            ActiveRecord::Base.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
+            ActiveRecord::Base.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')")
+
+          ActiveRecord::Base.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')")
+
+          ActiveRecord::Base.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
+
+    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