activerecord-spanner-adapter 0.1.0 → 0.7.0

data/acceptance/cases/models/query_test.rb

@@ -0,0 +1,171 @@
+# 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"
+require "models/author"
+require "models/post"
+require "models/comment"
+require "models/address"
+
+module ActiveRecord
+  module Model
+    class QueryTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Associations::TestHelper
+
+      attr_accessor :author, :post, :comment
+
+      def setup
+        super
+
+        @author = Author.create name: "David"
+        @post = Post.create title: "Title - 1", author: author
+        @comment = Comment.create comment: "Comment - 1", post: post
+      end
+
+      def teardown
+        super
+        Comment.destroy_all
+        Post.destroy_all
+        Author.destroy_all
+      end
+
+      def test_in_clause_is_correctly_sliced
+        author2 = Author.create name: "John"
+
+        assert_equal 2, Author.count
+        assert_equal [author], Author.where(name: "David", id: [author.id, author2.id])
+      end
+
+      def test_type_casting_nested_joins
+        assert_equal [comment], Comment.joins(post: :author).where(authors: { id: author.id })
+      end
+
+      def test_where_copies_bind_params
+        posts  = author.posts.where("posts.id = #{post.id}")
+        joined = Post.where(id: posts)
+
+        assert_operator joined.length, :>, 0
+
+        joined.each { |j_post|
+          assert_equal author, j_post.author
+          assert_equal post.id, j_post.id
+        }
+      end
+
+      def test_where_or_with_relation
+        post2 = Post.create title: "Title - 2", author: author
+        expected = Post.where("id = #{post.id} or id = #{post2.id}").to_a
+        assert_equal expected, Post.where("id = #{post.id}").or(Post.where("id = #{post2.id}")).to_a
+      end
+
+      def test_joins_and_preload
+        assert_nothing_raised do
+          Post.includes(:author).or(Post.includes(:author))
+          Post.eager_load(:author).or(Post.eager_load(:author))
+          Post.preload(:author).or(Post.preload(:author))
+          Post.group(:author_id).or(Post.group(:author_id))
+          Post.joins(:author).or(Post.joins(:author))
+          Post.left_outer_joins(:author).or(Post.left_outer_joins(:author))
+          Post.from("posts")
+        end
+      end
+
+      def test_not_inverts_where_clause
+        relation = Post.where.not(title: "hello")
+        expected_where_clause = Post.where(title: "hello").where_clause.invert
+
+        assert_equal expected_where_clause, relation.where_clause
+      end
+
+      def test_range
+        post2 = Post.create title: "Title - 1", author: author
+        comment2 = Comment.create comment: "Comment - 2", post: post2
+
+        assert_equal 2, Post.where(comments_count: 1..3).count
+      end
+
+      def test_with_infinite_upper_bound_range
+        assert_equal 1, Post.where(comments_count: 1..Float::INFINITY).count
+      end
+
+      def test_offset_and_limit
+        post = Post.create title: "Title - 1", author: author
+        5.times.each do |i|
+          Comment.create comment: "Comment - #{i+1}", post: post
+        end
+
+        assert_equal 5, post.comments.count
+        assert_equal 3, Comment.offset(1).limit(3).count
+      end
+
+      def test_select
+        post = Post.select(:title).to_a.first
+
+        assert_nil post.id
+        assert_equal "Title - 1", post.title
+      end
+
+      def test_order_and_pluck
+        post = Post.create title: "Title - 2", author: author
+        titles = Post.order("title").pluck("posts.title")
+
+        assert_equal ["Title - 1", "Title - 2"], titles
+      end
+
+      def test_time_value
+        time_value = Time.new(2016, 05, 11, 19, 0, 0)
+        post = Post.create(published_time: time_value)
+        assert_equal post, Post.find_by(published_time: time_value)
+      end
+
+      def test_timestamp_value
+        timestamp_value = Time.now
+        post = Post.create(published_time: timestamp_value)
+        assert_equal post, Post.find_by(published_time: timestamp_value)
+      end
+
+      def test_date_value
+        date = Date.new(2016, 05, 11)
+        post = Post.create(post_date: date)
+        assert_equal post, Post.find_by(post_date: date)
+      end
+
+      def test_relation_merging
+        post.comments << Comment.new(comment: "Comment - 2")
+
+        posts = Post.where("comments_count >= 0").merge(Post.limit(2)).merge(Post.order("id ASC"))
+
+        assert_equal [post], posts.to_a
+      end
+
+      def test_statement_hint
+        post = Post.optimizer_hints("statement_hint: @{USE_ADDITIONAL_PARALLELISM=TRUE}")
+                   .select(:title).to_a.first
+
+        assert_nil post.id
+        assert_equal "Title - 1", post.title
+      end
+
+      def test_table_hint
+        post = Post.optimizer_hints("table_hint: posts@{FORCE_INDEX=_BASE_TABLE}")
+                   .select(:title).to_a.first
+
+        assert_nil post.id
+        assert_equal "Title - 1", post.title
+      end
+
+      def test_join_hint
+        post = Post.joins("inner join @{JOIN_TYPE=HASH_JOIN} comments on posts.id=comments.post_id")
+                   .select(:title).to_a.first
+
+        assert_nil post.id
+        assert_equal "Title - 1", post.title
+      end
+    end
+  end
+end

data/acceptance/cases/sessions/session_not_found_test.rb

@@ -0,0 +1,121 @@
+# 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 Sessions
+
+    # Verifies that the adapter can handle a Session not found error in all (common) scenarios.
+    class SessionNotFoundTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Associations::TestHelper
+
+      attr_accessor :organization
+
+      def setup
+        super
+
+        @organization = Organization.create name: "Organization 1"
+      end
+
+      def teardown
+        super
+
+        Organization.destroy_all
+      end
+
+      def client
+        @client ||= Google::Cloud::Spanner::V1::Spanner::Client.new do |config|
+          config.credentials = ENV["SPANNER_EMULATOR_HOST"] \
+            ? :this_channel_is_insecure \
+            : ENV["SPANNER_TEST_KEYFILE"] || ENV["GCLOUD_TEST_KEYFILE"]
+          config.endpoint = ENV["SPANNER_EMULATOR_HOST"] if ENV["SPANNER_EMULATOR_HOST"]
+        end
+      end
+
+      def delete_all_sessions
+        sessions = client.list_sessions(
+          Google::Cloud::Spanner::V1::ListSessionsRequest.new(
+            database: "projects/#{ENV["SPANNER_TEST_PROJECT"]}/instances/#{ENV["SPANNER_TEST_INSTANCE"]}/databases/#{$spanner_test_database}"
+          )
+        )
+        sessions.each do |session|
+          client.delete_session Google::Cloud::Spanner::V1::DeleteSessionRequest.new name: session.name
+        end
+      end
+
+      def test_single_read
+        delete_all_sessions
+        organization = Organization.find_by id: @organization.id
+        refute_nil organization
+      end
+
+      def test_single_mutation
+        delete_all_sessions
+        id = Organization.create name: "Organization 2"
+        assert_equal "Organization 2", Organization.find_by(id: id).name
+      end
+
+      def test_batch_mutation
+        delete_all_sessions
+        Organization.create([{name: "Organization 2"}, {name: "Organization 3"}])
+        assert_equal 3, Organization.count
+      end
+
+      def test_begin_transaction
+        delete_all_sessions
+        Organization.transaction do
+          organization = Organization.find_by id: @organization.id
+          refute_nil organization
+        end
+      end
+
+      def test_read_in_transaction
+        attempts = 0
+        Organization.transaction do
+          attempts += 1
+          delete_all_sessions if attempts == 1
+          organization = Organization.find_by id: @organization.id
+          refute_nil organization
+        end
+        # The transaction could also be aborted by the backend, hence the > 1.
+        assert attempts > 1, "Should retry at least once"
+      end
+
+      def test_dml_in_transaction
+        id = nil
+        attempts = 0
+        Organization.transaction do
+          attempts += 1
+          delete_all_sessions if attempts == 1
+          id = Organization.create name: "Organization 2"
+        end
+        assert attempts > 1, "Should retry at least once"
+        assert_equal "Organization 2", Organization.find_by(id: id).name
+      end
+
+      def test_commit
+        attempts = 0
+        Organization.transaction do
+          Organization.find_by id: @organization.id
+          attempts += 1
+          # The following is a trick for the emulator only. If a session on the emulator has an active transaction,
+          # and that session is deleted, the emulator still thinks that the transaction is active.
+          # See https://github.com/GoogleCloudPlatform/cloud-spanner-emulator/issues/30
+          Base.connection.current_spanner_transaction.shoot_and_forget_rollback if ENV["SPANNER_EMULATOR_HOST"] && attempts == 1
+          delete_all_sessions if attempts == 1
+        end
+        assert attempts > 1, "Should retry at least once"
+      end
+    end
+  end
+end

data/acceptance/cases/transactions/optimistic_locking_test.rb

@@ -0,0 +1,141 @@
+# 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/singer"
+require "models/album"
+require "models/track"
+
+module ActiveRecord
+  module Transactions
+    class OptimisticLockingTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Associations::TestHelper
+
+      def setup
+        super
+
+        singer = Singer.create first_name: "Pete", last_name: "Allison"
+        album = Album.create title: "Musical Jeans", singer: singer
+        Track.create title: "Increased Headline", album: album, singer: singer
+      end
+
+      def teardown
+        super
+
+        Track.delete_all
+        Album.delete_all
+        Singer.delete_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_update_single_record_increases_version_number
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          singer = Singer.all.sample
+          original_version = singer.lock_version
+
+          run_in_transaction isolation do
+            singer.update last_name: "Peterson-#{singer.last_name}"
+          end
+
+          singer.reload
+          assert_equal original_version + 1, singer.lock_version
+        end
+      end
+
+      def test_update_multiple_records_increases_version_numbers
+        singer = Singer.all.sample
+        album = Album.all.sample
+        track = Track.all.sample
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          original_singer_version = singer.reload.lock_version
+          original_album_version = album.reload.lock_version
+          original_track_version = track.reload.lock_version
+
+          run_in_transaction isolation do
+            singer.update last_name: "Peterson-#{singer.last_name}"
+            singer.albums.each { |album| album.update title: "Updated: #{album.title}" }
+            singer.tracks.each { |track| track.update title: "Updated: #{track.title}" }
+          end
+
+          singer.reload
+          assert_equal original_singer_version + 1, singer.lock_version
+          singer.albums.each { |album| assert_equal original_album_version + 1, album.lock_version }
+          singer.tracks.each { |track| assert_equal original_track_version + 1, track.lock_version }
+        end
+      end
+
+      def test_concurrent_update_single_record_fails
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          singer = Singer.all.sample
+          original_version = singer.lock_version
+
+          # Update the singer in a separate thread to simulate a concurrent update.
+          t = Thread.new do
+            singer2 = Singer.find singer.id
+            singer2.update last_name: "Henderson-#{singer2.last_name}"
+          end
+          t.join
+
+          run_in_transaction isolation do
+            assert_raises ActiveRecord::StaleObjectError do
+              singer.update last_name: "Peterson-#{singer.last_name}"
+            end
+          end
+
+          singer.reload
+          assert_equal original_version + 1, singer.lock_version
+          assert singer.last_name.start_with?("Henderson-")
+        end
+      end
+
+      def test_concurrent_update_multiple_records_fails
+        singer = Singer.all.sample
+        album = Album.all.sample
+        track = Track.all.sample
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          original_singer_version = singer.reload.lock_version
+          original_album_version = album.reload.lock_version
+          original_track_version = track.reload.lock_version
+
+          # Update the singer in a separate thread to simulate a concurrent update.
+          t = Thread.new do
+            singer2 = Singer.find singer.id
+            singer2.update last_name: "Henderson-#{singer2.last_name}"
+          end
+          t.join
+
+          run_in_transaction isolation do
+            assert_raises ActiveRecord::StaleObjectError do
+              singer.update last_name: "Peterson-#{singer.last_name}"
+            end
+            singer.albums.each { |album| album.update title: "Updated: #{album.title}" }
+            singer.tracks.each { |track| track.update title: "Updated: #{track.title}" }
+          end
+
+          singer.reload
+          # The singer should be updated, but only by the separate thread.
+          assert_equal original_singer_version + 1, singer.lock_version
+          assert singer.last_name.start_with? "Henderson-"
+          singer.albums.each { |album| assert_equal original_album_version + 1, album.lock_version }
+          singer.tracks.each { |track| assert_equal original_track_version + 1, track.lock_version }
+        end
+      end
+    end
+  end
+end

data/acceptance/cases/transactions/read_only_transactions_test.rb

@@ -0,0 +1,130 @@
+# 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/organization"
+
+module ActiveRecord
+  module Transactions
+    class ReadOnlyTransactionsTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Associations::TestHelper
+
+      attr_accessor :organization
+
+      def setup
+        super
+
+        @organization = Organization.create name: "Organization 1"
+      end
+
+      def teardown
+        super
+
+        Organization.destroy_all
+      end
+
+      def test_read_in_snapshot
+        Base.transaction isolation: :read_only do
+          org = Organization.find @organization.id
+          assert_equal "Organization 1", org.name
+        end
+      end
+
+      def test_read_in_snapshot_at_timestamp
+        # Get a valid timestamp from the server to use for the transaction.
+        timestamp = ActiveRecord::Base.connection.select_all("SELECT CURRENT_TIMESTAMP AS ts")[0]["ts"]
+        Base.transaction isolation: { timestamp: timestamp } do
+          org = Organization.find @organization.id
+          assert_equal "Organization 1", org.name
+        end
+      end
+
+      def test_read_in_snapshot_with_staleness
+        Base.transaction isolation: { staleness: 1 } do
+          begin
+            # It could be that the record or even the table cannot be found, as the read timestamp could be
+            # before either of them were created, but the record could also be found, all depending on the execution
+            # speed of the test. All those scenarios are valid.
+            org = Organization.find @organization.id
+            assert_equal "Organization 1", org.name
+          rescue => e
+            assert e.message.include?("Table not found") || e.message.include?("Couldn't find Organization"), e.message
+          end
+        end
+      end
+
+      def test_single_read_at_timestamp
+        # Get a valid timestamp from the server to use for the transaction.
+        timestamp = ActiveRecord::Base.connection.select_all("SELECT CURRENT_TIMESTAMP AS ts")[0]["ts"]
+
+        org = Organization.optimizer_hints("read_timestamp:#{timestamp.xmlschema(9)}").find @organization.id
+        assert_equal "Organization 1", org.name
+      end
+
+      def test_single_read_at_min_read_timestamp
+        # Get a valid timestamp from the server to use for the transaction.
+        timestamp = ActiveRecord::Base.connection.select_all("SELECT CURRENT_TIMESTAMP AS ts")[0]["ts"]
+
+        org = Organization.optimizer_hints("min_read_timestamp:#{timestamp.xmlschema(9)}").find @organization.id
+        assert_equal "Organization 1", org.name
+      end
+
+      def test_single_read_with_max_staleness
+        begin
+          # It could be that the record or even the table cannot be found, as the read timestamp could be
+          # before either of them were created, but the record could also be found, all depending on the execution
+          # speed of the test. All those scenarios are valid.
+          org = Organization.optimizer_hints("max_staleness: 1").find @organization.id
+          assert_equal "Organization 1", org.name
+        rescue => e
+          assert e.message.include?("Table not found") || e.message.include?("Couldn't find Organization"), e.message
+        end
+      end
+
+      def test_single_read_with_exact_staleness
+        begin
+          # It could be that the record or even the table cannot be found, as the read timestamp could be
+          # before either of them were created, but the record could also be found, all depending on the execution
+          # speed of the test. All those scenarios are valid.
+          org = Organization.optimizer_hints("exact_staleness: 1").find @organization.id
+          assert_equal "Organization 1", org.name
+        rescue => e
+          assert e.message.include?("Table not found") || e.message.include?("Couldn't find Organization"), e.message
+        end
+      end
+
+      def test_snapshot_does_not_see_new_changes
+        Base.transaction isolation: :read_only do
+          org = Organization.find @organization.id
+          assert_equal "Organization 1", org.name
+
+          # Update the name of the organization using a separate thread (and separate transaction).
+          t = Thread.new { organization.update(name: "New name") }
+          t.join
+
+          # Reload the record using the current snapshot. The change will not be visible.
+          org.reload
+          assert_equal "Organization 1", org.name
+        end
+
+        # Now read the record outside of the snapshot. The new value should be visible.
+        org = Organization.find @organization.id
+        assert_equal "New name", org.name
+      end
+
+      def test_write_in_snapshot
+        Base.transaction isolation: :read_only do
+          err = assert_raises ActiveRecord::StatementInvalid do
+            Organization.create(name: "Created in read-only transaction")
+          end
+          assert err.cause.is_a?(Google::Cloud::InvalidArgumentError)
+        end
+      end
+    end
+  end
+end