activerecord-spanner-adapter 0.3.0 → 1.0.0

data/acceptance/cases/migration/references_statements_test.rb

@@ -0,0 +1,166 @@
+# 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
+  class Migration
+    class ReferencesStatementsTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+
+      attr_reader :table_name
+
+      def setup
+        super
+        @table_name = :test_models
+
+        connection.ddl_batch do
+          add_column table_name, :supplier_id, :integer, index: true
+        end
+      end
+
+      def test_creates_reference_id_column
+        connection.ddl_batch do
+          add_reference table_name, :user
+        end
+        assert column_exists?(table_name, :user_id, :integer)
+      end
+
+      def test_does_not_create_reference_type_column
+        connection.ddl_batch do
+          add_reference table_name, :taggable
+        end
+        assert_not column_exists?(table_name, :taggable_type, :string)
+      end
+
+      def test_creates_reference_type_column
+        connection.ddl_batch do
+          add_reference table_name, :taggable, polymorphic: true
+        end
+        assert column_exists?(table_name, :taggable_id, :integer)
+        assert column_exists?(table_name, :taggable_type, :string)
+      end
+
+      def test_does_not_create_reference_id_index_if_index_is_false
+        connection.ddl_batch do
+          add_reference table_name, :user, index: false
+        end
+        assert_not index_exists?(table_name, :user_id)
+      end
+
+      def test_create_reference_id_index_even_if_index_option_is_not_passed
+        connection.ddl_batch do
+          add_reference table_name, :user
+        end
+        assert index_exists?(table_name, :user_id)
+      end
+
+      def test_creates_polymorphic_index
+        connection.ddl_batch do
+          add_reference table_name, :taggable, polymorphic: true, index: true
+        end
+        assert index_exists?(table_name, [:taggable_type, :taggable_id])
+      end
+
+      def test_creates_reference_type_column_with_not_null
+        connection.ddl_batch do
+          connection.create_table table_name, force: true do |t|
+            t.references :taggable, null: false, polymorphic: true
+          end
+        end
+        assert column_exists?(table_name, :taggable_id, :integer, null: false)
+        assert column_exists?(table_name, :taggable_type, :string, null: false)
+      end
+
+      def test_creates_named_index
+        connection.ddl_batch do
+          add_reference table_name, :tag, index: { name: "index_taggings_on_tag_id" }
+        end
+        assert index_exists?(table_name, :tag_id, name: "index_taggings_on_tag_id")
+      end
+
+      def test_creates_named_unique_index
+        connection.ddl_batch do
+          add_reference table_name, :tag, index: { name: "index_taggings_on_tag_id", unique: true }
+        end
+        assert index_exists?(table_name, :tag_id, name: "index_taggings_on_tag_id", unique: true)
+      end
+
+      def test_creates_reference_id_with_specified_type
+        connection.ddl_batch do
+          add_reference table_name, :user, type: :string
+        end
+        assert column_exists?(table_name, :user_id, :string)
+      end
+
+      def test_deletes_reference_id_column
+        connection.ddl_batch do
+          remove_reference table_name, :supplier
+        end
+        assert_not column_exists?(table_name, :supplier_id, :string)
+      end
+
+      def test_deletes_reference_id_index
+        connection.ddl_batch do
+          remove_reference table_name, :supplier
+        end
+        assert_not index_exists?(table_name, :supplier_id)
+      end
+
+      def test_does_not_delete_reference_type_column
+        with_polymorphic_column do
+          connection.ddl_batch do
+            remove_reference table_name, :supplier
+          end
+
+          assert_not column_exists?(table_name, :supplier_id, :string)
+          assert column_exists?(table_name, :supplier_type, :string)
+        end
+      end
+
+      def test_deletes_reference_type_column
+        with_polymorphic_column do
+          remove_reference table_name, :supplier, polymorphic: true
+          assert_not column_exists?(table_name, :supplier_type, :string)
+        end
+      end
+
+      def test_deletes_polymorphic_index
+        with_polymorphic_column do
+          remove_reference table_name, :supplier, polymorphic: true
+          assert_not index_exists?(table_name, [:supplier_id, :supplier_type])
+        end
+      end
+
+      def test_add_belongs_to_alias
+        connection.ddl_batch do
+          add_belongs_to table_name, :user
+        end
+        assert column_exists?(table_name, :user_id, :integer)
+      end
+
+      def test_remove_belongs_to_alias
+        connection.ddl_batch do
+          remove_belongs_to table_name, :supplier
+        end
+        assert_not column_exists?(table_name, :supplier_id, :integer)
+      end
+
+      private
+
+      def with_polymorphic_column
+        connection.ddl_batch do
+          add_column table_name, :supplier_type, :string
+          add_index table_name, [:supplier_id, :supplier_type]
+        end
+
+        yield
+      end
+    end
+  end
+end

data/acceptance/cases/migration/rename_column_test.rb

@@ -0,0 +1,96 @@
+# 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
+  class Migration
+    class RenameColumnsTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+
+      class RenameColumnPost < ActiveRecord::Base
+      end
+
+      class RenameColumnComment < ActiveRecord::Base
+      end
+
+      def setup
+        skip_test_table_create!
+        super
+
+        connection.drop_table :rename_column_comments, if_exists: true
+        connection.drop_table :rename_column_posts, if_exists: true
+
+        connection.create_table(:rename_column_posts) do |t|
+          t.string :name, limit: 128
+          t.integer :comment_count
+        end
+
+        connection.create_table(:rename_column_comments) do |t|
+          t.string :comment
+          # The Spanner ActiveRecord adapter does not support creating an index on a column that also has a foreign key,
+          # as Cloud Spanner automatically creates a managed index for the foreign key. The index is therefore created
+          # separately.
+          t.references :rename_column_post, foreign_key: true
+          t.index :rename_column_post_id
+        end
+
+        RenameColumnPost.reset_column_information
+        RenameColumnComment.reset_column_information
+      end
+
+      def teardown
+        super
+        connection.drop_table :rename_column_comments, if_exists: true
+        connection.drop_table :rename_column_posts, if_exists: true
+      end
+
+      def test_rename_column
+        assert connection.column_exists?(:rename_column_posts, :name, :string, limit: 128)
+
+        RenameColumnPost.create!(name: "Post1", comment_count: 1)
+        RenameColumnPost.create!(name: "Post2", comment_count: 2)
+
+        connection.rename_column :rename_column_posts, :name, :title
+
+        RenameColumnPost.reset_column_information
+
+        assert connection.column_exists?(:rename_column_posts, :title, :string, limit: 128)
+
+        assert_equal ["Post1", "Post2"].sort, RenameColumnPost.pluck(:title).sort
+        assert_equal [1, 2], RenameColumnPost.pluck(:comment_count).sort
+      end
+
+      def test_rename_column_with_index_and_foreign_key
+        assert connection.column_exists?(:rename_column_comments, :rename_column_post_id, :integer)
+        assert connection.index_exists?(:rename_column_comments, :rename_column_post_id)
+        assert connection.foreign_key_exists?(:rename_column_comments, :rename_column_posts)
+
+        post = RenameColumnPost.create!(name: "Post1")
+        RenameColumnComment.create!(comment: "Comment1", rename_column_post_id: post.id)
+        RenameColumnComment.create!(comment: "Comment2", rename_column_post_id: post.id)
+
+        connection.rename_column :rename_column_comments, :rename_column_post_id, :post_id
+
+        RenameColumnComment.reset_column_information
+
+        assert connection.column_exists?(:rename_column_comments, :post_id, :integer)
+        assert connection.index_exists?(:rename_column_comments, :post_id)
+
+        foreign_keys = connection.foreign_keys("rename_column_comments")
+        assert_equal 1, foreign_keys.length
+
+        fk = foreign_keys.first
+        assert_equal "rename_column_comments", fk.from_table
+        assert_equal "post_id", fk.column
+
+        assert_equal [post.id, post.id].sort, RenameColumnComment.pluck(:post_id)
+      end
+    end
+  end
+end

data/acceptance/cases/models/calculation_query_test.rb

@@ -0,0 +1,128 @@
+# 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/account"
+require "models/customer"
+require "models/firm"
+
+module ActiveRecord
+  module Model
+    class CalculationQueryTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Associations::TestHelper
+
+      attr_accessor :customer, :accounts
+
+      def setup
+        super
+
+        @customer = Customer.new name: "Customer - 1"
+        @accounts = []
+
+        [10, 21, 1007, 3].each_with_index do |credit_limit, i|
+          @accounts << Account.create!(
+            name: "Account#{i}", customer: customer, credit_limit: credit_limit
+          )
+        end
+      end
+
+      def teardown
+        super
+
+        Account.delete_all
+        Customer.delete_all
+      end
+
+      def test_pluck_single_field
+        expected_ids = @accounts.map(&:id).sort
+        ids = Account.pluck(:id).sort
+        assert_equal expected_ids, ids
+      end
+
+      def test_pluck_multi_fields
+        expected_values = @accounts.sort_by{|a| a.id }.map{|a| [a.id, a.name]}
+
+        values = Account.pluck(:id, :name).sort_by{|v| v.first }
+        assert_equal expected_values, values
+      end
+
+      def test_get_ids
+        expected_ids = @accounts.map(&:id).sort
+
+        assert_equal expected_ids, Account.ids.sort
+      end
+
+      def test_pick_one_field
+        assert_equal "Account0", Account.order(:name).pick(:name)
+      end
+
+      def test_pick_two_field
+        assert_equal ["Account0", 10], Account.order(:name).pick(:name, :credit_limit)
+      end
+
+      def test_count_all
+        assert_equal 4, Account.count(:all)
+        assert_equal 4, Account.count(:all)
+      end
+
+      def test_distinct_count
+        Account.create name: "Account-101", credit_limit: 3
+        assert_equal 4, Account.distinct.count(:credit_limit)
+      end
+
+      def test_group_count
+        Account.create name: "Account-101", credit_limit: 3
+
+        expected_values = { 3 => 2, 10 => 1, 21 => 1, 1007 => 1}
+        assert_equal expected_values, Account.group(:credit_limit).count
+      end
+
+      def test_sum_field
+        assert_equal 1041, Account.sum(:credit_limit)
+      end
+
+      def test_resolve_aliased_attributes
+        assert_equal 1041, Account.sum(:available_credit)
+      end
+
+      def test_average_field
+        assert_equal 260.25, Account.average(:credit_limit)
+      end
+
+      def test_get_maximum_of_field
+        assert_equal 1007, Account.maximum(:credit_limit)
+      end
+
+      def test_get_maximum_of_field_with_include
+        customer2 = Customer.create! name: "Customer - 2"
+        firm = Firm.create name: "Firm - 1"
+        Account.create!(customer: customer2, credit_limit: 103, firm: firm)
+        Account.create!(customer: customer2, credit_limit: 24, firm: firm)
+
+        assert_equal 103, Account.where("customer_id = ?", customer2.id).includes(:firm).maximum(:credit_limit)
+      end
+
+      def test_get_minimum_of_field
+        assert_equal 3, Account.minimum(:credit_limit)
+      end
+
+      def test_calculate_count
+        assert_equal 4, Account.calculate(:count, "*")
+        assert_equal 4, Account.calculate(:count, :all)
+      end
+
+      def test_caclulate_sum
+        assert_equal 1041, Account.calculate(:sum, :credit_limit)
+      end
+
+      def test_caclulate_average
+        assert_equal 260.25, Account.calculate(:average, :credit_limit)
+      end
+    end
+  end
+end

data/acceptance/cases/models/generated_column_test.rb

@@ -0,0 +1,126 @@
+# 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"
+
+module ActiveRecord
+  module Model
+    class GeneratedColumnTest < 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 test_create_non_null
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          singer = nil
+          run_in_transaction isolation do
+            singer = Singer.create first_name: "Pete", last_name: "Allison"
+          end
+
+          singer.reload
+          assert_equal "Pete Allison", singer.full_name
+        end
+      end
+
+      def test_create_null
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          singer = nil
+          run_in_transaction isolation do
+            singer = Singer.create last_name: "Allison"
+          end
+
+          singer.reload
+          assert_equal "Allison", singer.full_name
+        end
+      end
+
+      def test_update_non_null
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          singer = Singer.create first_name: "Pete", last_name: "Allison"
+          singer.reload # reload to ensure the full_name attribute is populated.
+          run_in_transaction isolation do
+            singer.update first_name: "Alice"
+          end
+
+          singer.reload
+          assert_equal "Alice Allison", singer.full_name
+        end
+      end
+
+      def test_update_null
+        [nil, :serializable, :buffered_mutations].each do |isolation|
+          singer = Singer.create first_name: "Pete", last_name: "Allison"
+          singer.reload # reload to ensure the full_name attribute is populated.
+          run_in_transaction isolation do
+            singer.update first_name: nil
+          end
+
+          singer.reload
+          assert_equal "Allison", singer.full_name
+        end
+      end
+
+      def test_create_with_value_for_generated_column
+        # Note: The statement itself will not fail for an explicit transaction that uses buffered transactions.
+        # Instead, the commit will fail. That is tested in a separate test case.
+        [nil, :serializable].each do |isolation|
+          run_in_transaction isolation do
+            assert_raises ActiveRecord::StatementInvalid do
+              Singer.create first_name: "Pete", last_name: "Allison", full_name: "Alice Peterson"
+            end
+          end
+        end
+      end
+
+      def test_create_with_value_for_generated_column_buffered_mutations
+        # The transaction itself will raise an error, as the failure occurs during the commit.
+        assert_raises ActiveRecord::StatementInvalid do
+          Singer.transaction isolation: :buffered_mutations do
+            Singer.create first_name: "Pete", last_name: "Allison", full_name: "Alice Peterson"
+          end
+        end
+      end
+
+      def test_update_with_value_for_generated_column
+        # Note: The statement itself will not fail for an explicit transaction that uses buffered transactions.
+        # Instead, the commit will fail. That is tested in a separate test case.
+        [nil, :serializable].each do |isolation|
+          singer = Singer.create first_name: "Pete", last_name: "Allison"
+          singer.reload # reload to ensure the full_name attribute is populated.
+          run_in_transaction isolation do
+            assert_raises ActiveRecord::StatementInvalid do
+              Singer.update full_name: "Alice Peterson"
+            end
+          end
+        end
+      end
+
+      def test_update_with_value_for_generated_column_buffered_mutations
+        singer = Singer.create first_name: "Pete", last_name: "Allison"
+        singer.reload # reload to ensure the full_name attribute is populated.
+        # The transaction itself will raise an error, as the failure occurs during the commit.
+        assert_raises ActiveRecord::StatementInvalid do
+          Singer.transaction isolation: :buffered_mutations do
+            Singer.update full_name: "Alice Peterson"
+          end
+        end
+      end
+    end
+  end
+end

data/acceptance/cases/models/mutation_test.rb

@@ -0,0 +1,122 @@
+# 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"
+require "models/organization"
+
+module ActiveRecord
+  module Model
+    class MutationTest < 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
+        Organization.destroy_all
+      end
+
+      def test_update_all
+        organization = Organization.create name: "Org - 1"
+        organization.authors << author
+        organization.authors << Author.new(name: "John")
+
+        organization.reload
+
+        assert_equal 2, organization.authors.where(registered_date: nil).count
+
+        date = Date.new(2020, 01, 31)
+        organization.authors.update_all(registered_date: date)
+
+        assert_equal 0, organization.authors.where(registered_date: nil).count
+        assert_equal 2, organization.authors.where(registered_date: date).count
+      end
+
+      def test_offset_and_limit_update
+        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, post.comments.offset(1).limit(3).update_all(comment: "New Comment")
+
+        post.reload
+        assert_equal 3, post.comments.where(comment: "New Comment").count
+      end
+
+      def test_update_all_with_joins
+        post = Post.create title: "Title - 1", author: author
+        post.comments << Comment.new(comment: "Comment - 1")
+
+        posts = Post.joins(:comments).where(comments: { comment: "Comment - 1" })
+
+        assert_equal true, posts.exists?
+        assert_equal posts.count, posts.update_all(title: "Title - 1 Update")
+      end
+
+      def test_update_counters_with_joins
+        post = Post.create title: "Title - 1", author: author
+        assert_nil post.comments_count
+
+        post.comments << Comment.new(comment: "Comment - 201")
+        assert_equal 1, post.reload.comments_count
+
+        Post.joins(:comments).where(comments: { comment: "Comment - 201" }).update_counters(comments_count: 10)
+
+        assert_equal 11, post.reload.comments_count
+      end
+
+      def test_destroy_all
+        authors = Author.where name: "David"
+
+        assert_equal [author], authors.to_a
+
+        authors.destroy_all
+        assert_equal 0, Author.count
+      end
+
+      def test_dependent_destroy
+        organization = Organization.create name: "Org - 1"
+        organization.authors << author
+        organization.authors << Author.new(name: "John")
+
+        organization.reload
+        assert_equal 2, organization.authors.count
+
+        organization.destroy
+
+        assert_nil Organization.find_by(id: organization.id)
+        assert_equal 0, Author.count
+      end
+
+      def test_delete_all
+        assert_equal 1, Author.count
+
+        Author.delete_all
+
+        assert_equal 0, Author.count
+      end
+    end
+  end
+end