activerecord-spanner-adapter 0.3.0 → 0.5.0

data/acceptance/cases/transactions/read_write_transactions_test.rb

@@ -0,0 +1,248 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+# frozen_string_literal: true
+
+require "test_helper"
+require "models/author"
+require "models/post"
+require "models/comment"
+require "models/organization"
+
+module ActiveRecord
+  module Transactions
+    class ReadWriteTransactionsTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Associations::TestHelper
+
+      attr_accessor :organization, :author, :post, :comment
+
+      def create_test_records
+        @organization = Organization.create name: "Organization 1"
+        @author = Author.create name: "David", organization: organization
+        @post = Post.create title: "Title - 1", author: author
+        @comment = Comment.create comment: "Comment - 1", post: post
+      end
+
+      def teardown
+        super
+
+        delete_test_records
+      end
+
+      def delete_test_records
+        Comment.destroy_all
+        Post.destroy_all
+        Author.destroy_all
+        Organization.destroy_all
+      end
+
+      # Runs the given block in a transaction with the given isolation level, or without a transaction if isolation is
+      # nil.
+      def run_in_transaction isolation
+        if isolation
+          Base.transaction isolation: isolation do
+            yield
+          end
+        else
+          yield
+        end
+      end
+
+      def test_create_multiple_records
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          initial_author_count = Author.count
+          initial_posts_count = Post.count
+          initial_comment_count = Comment.count
+
+          run_in_transaction isolation do
+            author = Author.create name: "Author 1", organization: organization
+            posts = Post.create [{title: "Post 1", author: author}, {title: "Post 2", author: author}]
+            Comment.create [
+                             {comment: "Comment 1", post: posts[0]},
+                             {comment: "Comment 2", post: posts[1]}
+                           ]
+          end
+
+          # Verify that all the records were created.
+          assert_equal initial_author_count + 1, Author.count
+          assert_equal initial_posts_count + 2, Post.count
+          assert_equal initial_comment_count + 2, Comment.count
+        end
+      end
+
+      def test_update_multiple_records
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          create_test_records
+
+          run_in_transaction isolation do
+            organization.update name: "Updated name #{isolation}"
+            author.update name: "Updated name #{isolation}"
+            post.update title: "Updated title #{isolation}"
+            comment.update comment: "Updated comment #{isolation}"
+          end
+
+          assert_equal "Updated name #{isolation}", organization.reload.name
+          assert_equal "Updated name #{isolation}", author.reload.name
+          assert_equal "Updated title #{isolation}", post.reload.title
+          assert_equal "Updated comment #{isolation}", comment.reload.comment
+        end
+      end
+
+      def test_destroy_multiple_records
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          create_test_records
+
+          run_in_transaction isolation do
+            comment.destroy
+            post.destroy
+            author.destroy
+            organization.destroy
+          end
+
+          assert_equal 0, Organization.count
+          assert_equal 0, Author.count
+          assert_equal 0, Post.count
+          assert_equal 0, Comment.count
+        end
+      end
+
+      def test_delete_multiple_records
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          create_test_records
+
+          run_in_transaction isolation do
+            comment.delete
+            post.delete
+            author.delete
+            organization.delete
+          end
+
+          assert_equal 0, Organization.count
+          assert_equal 0, Author.count
+          assert_equal 0, Post.count
+          assert_equal 0, Comment.count
+        end
+      end
+
+      def test_destroy_parent_record
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          create_test_records
+
+          run_in_transaction isolation do
+            # Only destroy the top-level record. This should cascade to the author records, as those are
+            # marked with `dependent: destroy`. The dependants of Author are however not marked with
+            # `dependent: destroy`, which means that those will not be deleted, but the reference to Author will
+            # be set to nil.
+            organization.destroy
+          end
+
+          assert_equal 0, Organization.count
+          assert_equal 0, Author.count
+          assert_equal 1, Post.count # These are not marked with `dependent: destroy`
+          assert_nil Post.find(post.id).author # The author is set to NULL instead of deleting the posts.
+          assert_equal 1, Comment.count
+
+          # Delete all remaining test records to make sure the next iteration starts clean.
+          delete_test_records
+        end
+      end
+
+      def test_multiple_consecutive_transactions
+        isolation_levels = [nil, :serializable, :buffered_mutations]
+        isolation_levels.each do |isolation|
+
+          run_in_transaction isolation do
+            create_test_records
+          end
+
+          isolation_levels.each do |isolation|
+            run_in_transaction isolation do
+              create_test_records
+            end
+          end
+
+          transaction_count = isolation_levels.length + 1
+          assert_equal transaction_count, Organization.count
+          assert_equal transaction_count, Author.count
+          assert_equal transaction_count, Post.count
+          assert_equal transaction_count, Comment.count
+
+          delete_test_records
+        end
+      end
+
+      def test_read_your_writes
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          initial_author_count = Author.count
+          initial_posts_count = Post.count
+          initial_comment_count = Comment.count
+
+          run_in_transaction isolation do
+            author = Author.create name: "Author 1", organization: organization
+            posts = Post.create [{title: "Post 1", author: author}, {title: "Post 2", author: author}]
+            Comment.create [
+                             {comment: "Comment 1", post: posts[0]},
+                             {comment: "Comment 2", post: posts[1]}
+                           ]
+
+            # Verify that the new records are visible, unless we are working with an actual transaction that
+            # uses buffered mutations. Implicit transactions (isolation = nil) will also use mutations, but each
+            # create call will automatically be committed, and the changes will be visible here.
+            unless isolation == :buffered_mutations
+              assert_equal initial_author_count + 1, Author.count
+              assert_equal initial_posts_count + 2, Post.count
+              assert_equal initial_comment_count + 2, Comment.count
+            else
+              assert_equal initial_author_count, Author.count
+              assert_equal initial_posts_count, Post.count
+              assert_equal initial_comment_count, Comment.count
+            end
+          end
+        end
+      end
+
+      def test_create_commit_timestamp
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          current_timestamp = Organization.connection.select_all("SELECT CURRENT_TIMESTAMP() AS t").to_a[0]["t"]
+          organization = nil
+          run_in_transaction isolation do
+            organization = Organization.create name: "Org with commit timestamp", last_updated: :commit_timestamp
+          end
+
+          organization.reload
+          assert organization.last_updated
+          assert organization.last_updated > current_timestamp
+        end
+      end
+
+      def test_update_commit_timestamp
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          organization = Organization.create name: "Org without commit timestamp"
+          current_timestamp = Organization.connection.select_all("SELECT CURRENT_TIMESTAMP() AS t").to_a[0]["t"]
+
+          run_in_transaction isolation do
+            organization.update last_updated: :commit_timestamp
+          end
+
+          organization.reload
+          assert organization.last_updated
+          assert organization.last_updated > current_timestamp
+        end
+      end
+
+      def test_pdml
+        create_test_records
+        assert Comment.count > 0
+
+        Comment.transaction isolation: :pdml do
+          Comment.delete_all
+        end
+
+        assert_equal 0, Comment.count
+      end
+    end
+  end
+end

data/acceptance/cases/type/all_types_test.rb

@@ -0,0 +1,152 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+# frozen_string_literal: true
+
+require "test_helper"
+require "models/all_types"
+
+module ActiveRecord
+  module Type
+    class AllTypesTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Associations::TestHelper
+
+      # Runs the given block in a transaction with the given isolation level, or without a transaction if isolation is
+      # nil.
+      def run_in_transaction isolation
+        if isolation
+          Base.transaction isolation: isolation do
+            yield
+          end
+        else
+          yield
+        end
+      end
+
+      def create_test_record
+        AllTypes.create col_string: "string", col_int64: 100, col_float64: 3.14, col_numeric: 6.626, col_bool: true,
+          col_bytes: StringIO.new("bytes"), col_date: ::Date.new(2021, 6, 23),
+          col_timestamp: ::Time.new(2021, 6, 23, 17, 8, 21, "+02:00"),
+          col_array_string: ["string1", nil, "string2"],
+          col_array_int64: [100, nil, 200],
+          col_array_float64: [3.14, nil, 2.0/3.0],
+          col_array_numeric: [6.626, nil, 3.20],
+          col_array_bool: [true, nil, false],
+          col_array_bytes: [StringIO.new("bytes1"), nil, StringIO.new("bytes2")],
+          col_array_date: [::Date.new(2021, 6, 23), nil, ::Date.new(2021, 6, 24)],
+          col_array_timestamp: [::Time.new(2021, 6, 23, 17, 8, 21, "+02:00"), nil, \
+                                ::Time.new(2021, 6, 24, 17, 8, 21, "+02:00")]
+      end
+
+      def test_create_record
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          initial_count = AllTypes.count
+          record = nil
+          run_in_transaction isolation do
+            record = create_test_record
+          end
+
+          # Verify that the record was created and that the data can be read back.
+          assert_equal initial_count + 1, AllTypes.count
+
+          record = AllTypes.find record.id
+          assert_equal "string", record.col_string
+          assert_equal 100, record.col_int64
+          assert_equal 3.14, record.col_float64
+          assert_equal 6.626, record.col_numeric
+          assert_equal true, record.col_bool
+          assert_equal StringIO.new("bytes").read, record.col_bytes.read
+          assert_equal ::Date.new(2021, 6, 23), record.col_date
+          assert_equal ::Time.new(2021, 6, 23, 17, 8, 21, "+02:00").utc, record.col_timestamp.utc
+
+          assert_equal ["string1", nil, "string2"], record.col_array_string
+          assert_equal [100, nil, 200], record.col_array_int64
+          assert_equal [3.14, nil, 2.0/3.0], record.col_array_float64
+          assert_equal [6.626, nil, 3.20], record.col_array_numeric
+          assert_equal [true, nil, false], record.col_array_bool
+          assert_equal [StringIO.new("bytes1"), nil, StringIO.new("bytes2")].map { |bytes| bytes&.read },
+                       record.col_array_bytes.map { |bytes| bytes&.read }
+          assert_equal [::Date.new(2021, 6, 23), nil, ::Date.new(2021, 6, 24)], record.col_array_date
+          assert_equal [::Time.new(2021, 6, 23, 17, 8, 21, "+02:00"), \
+                            nil, \
+                            ::Time.new(2021, 6, 24, 17, 8, 21, "+02:00")].map { |timestamp| timestamp&.utc },
+                       record.col_array_timestamp.map { |timestamp| timestamp&.utc}
+        end
+      end
+
+      def test_update_record
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          # First create a test record outside a transaction.
+          record = create_test_record
+
+          run_in_transaction isolation do
+            # Update the record in a transaction using different isolation levels.
+            record.update col_string: "new string", col_int64: 200, col_float64: 6.28, col_numeric: 10.1,
+                          col_bool: false, col_bytes: StringIO.new("new bytes"),
+                          col_date: ::Date.new(2021, 6, 28),
+                          col_timestamp: ::Time.new(2021, 6, 28, 11, 22, 21, "+02:00"),
+                          col_array_string: ["new string 1", "new string 2"],
+                          col_array_int64: [300, 200, 100],
+                          col_array_float64: [1.1, 2.2, 3.3],
+                          col_array_numeric: [3.3, 2.2, 1.1],
+                          col_array_bool: [false, true, false],
+                          col_array_bytes: [StringIO.new("new bytes 1"), StringIO.new("new bytes 2")],
+                          col_array_date: [::Date.new(2021, 6, 28)],
+                          col_array_timestamp: [::Time.utc(2020, 12, 31, 0, 0, 0)]
+          end
+
+          # Verify that the record was updated.
+          record = AllTypes.find record.id
+          assert_equal "new string", record.col_string
+          assert_equal 200, record.col_int64
+          assert_equal 6.28, record.col_float64
+          assert_equal 10.1, record.col_numeric
+          assert_equal false, record.col_bool
+          assert_equal StringIO.new("new bytes").read, record.col_bytes.read
+          assert_equal ::Date.new(2021, 6, 28), record.col_date
+          assert_equal ::Time.new(2021, 6, 28, 11, 22, 21, "+02:00").utc, record.col_timestamp.utc
+
+          assert_equal ["new string 1", "new string 2"], record.col_array_string
+          assert_equal [300, 200, 100], record.col_array_int64
+          assert_equal [1.1, 2.2, 3.3], record.col_array_float64
+          assert_equal [3.3, 2.2, 1.1], record.col_array_numeric
+          assert_equal [false, true, false], record.col_array_bool
+          assert_equal [StringIO.new("new bytes 1"), StringIO.new("new bytes 2")].map(&:read),
+                       record.col_array_bytes.map(&:read)
+          assert_equal [::Date.new(2021, 6, 28)], record.col_array_date
+          assert_equal [::Time.utc(2020, 12, 31, 0, 0, 0)], record.col_array_timestamp.map(&:utc)
+        end
+      end
+
+      def test_create_empty_arrays
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          record = nil
+          run_in_transaction isolation do
+            record = AllTypes.create \
+              col_array_string: [],
+              col_array_int64: [],
+              col_array_float64: [],
+              col_array_numeric: [],
+              col_array_bool: [],
+              col_array_bytes: [],
+              col_array_date: [],
+              col_array_timestamp: []
+          end
+
+          record = AllTypes.find record.id
+          assert_equal [], record.col_array_string
+          assert_equal [], record.col_array_int64
+          assert_equal [], record.col_array_float64
+          assert_equal [], record.col_array_numeric
+          assert_equal [], record.col_array_bool
+          assert_equal [], record.col_array_bytes
+          assert_equal [], record.col_array_date
+          assert_equal [], record.col_array_timestamp
+        end
+      end
+    end
+  end
+end

data/acceptance/cases/type/binary_test.rb

@@ -0,0 +1,59 @@
+# Copyright 2020 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+# frozen_string_literal: true
+
+require "test_helper"
+
+module ActiveRecord
+  module Type
+    class BinaryTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Types::TestHelper
+
+      def test_convert_to_sql_type
+        assert_equal "BYTES(MAX)", connection.type_to_sql(:binary)
+        assert_equal "BYTES(1024)", connection.type_to_sql(:binary, limit: 1024)
+      end
+
+      def test_set_binary_data_io_in_create
+        data = StringIO.new "hello"
+
+        record = TestTypeModel.create(data: data)
+        record.reload
+
+        assert_equal "hello", record.data.read
+      end
+
+      def test_set_binary_data_byte_string_in_create
+        data = StringIO.new "hello1"
+
+        record = TestTypeModel.create(data: data.read)
+        record.reload
+
+        assert_equal "hello1", record.data.read
+      end
+
+      def test_check_max_limit
+        str = "a" * 256
+
+        assert_raise(ActiveRecord::StatementInvalid) {
+          TestTypeModel.create(name: str)
+        }
+      end
+
+      def test_set_binary_data_from_file
+        Tempfile.create do |f|
+          f << "hello 123"
+
+          record = TestTypeModel.create(file: f)
+          record.reload
+
+          assert_equal "hello 123", record.file.read
+        end
+      end
+    end
+  end
+end