activerecord-spanner-adapter 0.3.0 → 0.5.0

data/acceptance/cases/migration/references_foreign_key_test.rb

@@ -0,0 +1,259 @@
+# 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 ReferencesForeignKeyInCreateTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+
+      def setup
+        skip_test_table_create!
+        super
+        connection.ddl_batch do
+          @connection.create_table(:testing_parents, force: true)
+        end
+      end
+
+      def teardown
+        @connection.ddl_batch do
+          @connection.drop_table "testings", if_exists: true
+          @connection.drop_table "testing_parents", if_exists: true
+        end
+      end
+
+      def test_create_foreign_key_with_table_create
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.references :testing_parent, foreign_key: true
+          end
+        end
+
+        fk = connection.foreign_keys("testings").first
+        assert_equal "testings", fk.from_table
+        assert_equal "testing_parents", fk.to_table
+      end
+
+      def test_create_foreign_key_created_by_default
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.references :testing_parent
+          end
+        end
+
+        assert_equal [], @connection.foreign_keys("testings")
+      end
+
+      def test_options_can_be_passed
+        connection.ddl_batch do
+          connection.change_table :testing_parents do |t|
+            t.references :other, index: { unique: true }
+          end
+          connection.create_table :testings do |t|
+            t.references :testing_parent, foreign_key: { primary_key: :other_id }
+          end
+        end
+
+        fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
+        assert_equal "other_id", fk.primary_key
+      end
+
+      def test_to_table_options_can_be_passed
+        connection.ddl_batch do
+          @connection.create_table :testings do |t|
+            t.references :parent, foreign_key: { to_table: :testing_parents }
+          end
+        end
+        fks = @connection.foreign_keys("testings")
+        assert_equal([["testings", "testing_parents", "parent_id"]],
+                      fks.map { |fk| [fk.from_table, fk.to_table, fk.column] })
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class Migration
+    class ReferencesForeignKeyTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+      include ActiveSupport::Testing::Stream
+
+      def setup
+        skip_test_table_create!
+        super
+        connection = ActiveRecord::Base.connection
+        connection.ddl_batch do
+          connection.create_table(:testing_parents, force: true)
+        end
+      end
+
+      def teardown
+        connection.ddl_batch do
+          connection.drop_table "testings", if_exists: true
+          connection.drop_table "testing_parents", if_exists: true
+        end
+      end
+
+      def test_create_foreign_key_with_changing_table
+        connection.ddl_batch do
+          connection.create_table :testings
+          connection.change_table :testings do |t|
+            t.references :testing_parent, foreign_key: true
+          end
+        end
+
+        fk = connection.foreign_keys("testings").first
+        assert_equal "testings", fk.from_table
+        assert_equal "testing_parents", fk.to_table
+      end
+
+      def test_foreign_key_not_added_by_default_on_table_change
+        connection.create_table :testings
+        connection.change_table :testings do |t|
+          t.references :testing_parent
+        end
+
+        assert_equal [], connection.foreign_keys("testings")
+      end
+
+      def test_foreign_key_accept_option_on_table_change
+        connection.ddl_batch do
+          connection.change_table :testing_parents do |t|
+            t.references :other, index: { unique: true }
+          end
+          connection.create_table :testings
+        end
+        connection.change_table :testings do |t|
+          t.references :testing_parent, foreign_key: { primary_key: :other_id }
+        end
+
+        fk = connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
+        assert_equal "other_id", fk.primary_key
+      end
+
+      def test_foreign_key_column_can_be_removed
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.references :testing_parent, index: true, foreign_key: true
+          end
+        end
+
+        connection.remove_reference :testings, :testing_parent, foreign_key: true
+        assert_equal 0, connection.foreign_keys('testings').size
+      end
+
+      def test_remove_column_removes_foreign_key
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.references :testing_parent, index: true, foreign_key: true
+          end
+        end
+
+        connection.ddl_batch do
+          connection.remove_column :testings, :testing_parent_id
+        end
+        assert_equal 0, connection.foreign_keys('testings').size
+      end
+
+      def test_foreign_key_respect_pluralize_table_names
+        original_pluralize_table_names = ActiveRecord::Base.pluralize_table_names
+        ActiveRecord::Base.pluralize_table_names = false
+        connection.create_table :testing
+        connection.ddl_batch do
+          connection.change_table :testing_parents do |t|
+            t.references :testing, foreign_key: true
+          end
+        end
+
+        fk = connection.foreign_keys("testing_parents").first
+        assert_equal "testing_parents", fk.from_table
+        assert_equal "testing", fk.to_table
+
+        assert_difference "@connection.foreign_keys('testing_parents').size", -1 do
+          connection.remove_reference :testing_parents, :testing, foreign_key: true
+        end
+      ensure
+        ActiveRecord::Base.pluralize_table_names = original_pluralize_table_names
+        connection.ddl_batch do
+          connection.drop_table "testing", if_exists: true
+        end
+      end
+
+      class CreateDogsMigration < ActiveRecord::Migration::Current
+        def up
+          connection.ddl_batch do
+            create_table :dog_owners
+
+            create_table :dogs do |t|
+              t.references :dog_owner, foreign_key: true
+            end
+          end
+        end
+
+        def down
+          connection.ddl_batch do
+            drop_table :dogs, if_exists: true
+            drop_table :dog_owners, if_exists: true
+          end
+        end
+      end
+
+      def test_references_foreign_key_with_prefix
+        ActiveRecord::Base.table_name_prefix = "p_"
+        migration = CreateDogsMigration.new
+        silence_stream($stdout) { migration.migrate(:up) }
+        assert_equal 1, @connection.foreign_keys("p_dogs").size
+      ensure
+        silence_stream($stdout) { migration.migrate(:down) }
+        ActiveRecord::Base.table_name_prefix = nil
+      end
+
+      def test_references_foreign_key_with_suffix
+        ActiveRecord::Base.table_name_suffix = "_s"
+        migration = CreateDogsMigration.new
+        silence_stream($stdout) { migration.migrate(:up) }
+        assert_equal 1, @connection.foreign_keys("dogs_s").size
+      ensure
+        silence_stream($stdout) { migration.migrate(:down) }
+        ActiveRecord::Base.table_name_suffix = nil
+      end
+
+      def test_multiple_foreign_keys_can_added_to_same_table
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.references :parent1, foreign_key: { to_table: :testing_parents }
+            t.references :parent2, foreign_key: { to_table: :testing_parents }
+          end
+        end
+
+        fks = connection.foreign_keys("testings").sort_by(&:column)
+
+        fk_definitions = fks.map { |fk| [fk.from_table, fk.to_table, fk.column] }
+        assert_equal([["testings", "testing_parents", "parent1_id"],
+                      ["testings", "testing_parents", "parent2_id"]], fk_definitions)
+      end
+
+      def test_multiple_foreign_keys_removed
+        connection.create_table :testings do |t|
+          t.references :parent1, foreign_key: { to_table: :testing_parents }
+          t.references :parent2, foreign_key: { to_table: :testing_parents }
+        end
+
+        connection.remove_reference :testings, :parent1, foreign_key: { to_table: :testing_parents }
+
+        assert_equal 1, connection.foreign_keys('testings').size
+
+        fks = connection.foreign_keys("testings").sort_by(&:column)
+
+        fk_definitions = fks.map { |fk| [fk.from_table, fk.to_table, fk.column] }
+        assert_equal([["testings", "testing_parents", "parent2_id"]], fk_definitions)
+      end
+    end
+  end
+end

data/acceptance/cases/migration/references_index_test.rb

@@ -0,0 +1,135 @@
+# 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 ReferencesIndexTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+
+      attr_reader :table_name
+
+      def setup
+        skip_test_table_create!
+        super
+
+        @table_name = :testings
+      end
+
+      def teardown
+        connection.ddl_batch do
+          connection.drop_table :testings
+        end rescue nil
+      end
+
+      def test_creates_index
+        connection.ddl_batch do
+          connection.create_table table_name do |t|
+            t.references :foo, index: true
+          end
+        end
+
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
+      end
+
+      def test_creates_index_by_default_even_if_index_option_is_not_passed
+        connection.ddl_batch do
+          connection.create_table table_name do |t|
+            t.references :foo
+          end
+        end
+
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
+      end
+
+      def test_does_not_create_index_explicit
+        connection.ddl_batch do
+          connection.create_table table_name do |t|
+            t.references :foo, index: false
+          end
+        end
+
+        assert_not connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
+      end
+
+      def test_creates_index_with_options
+        connection.ddl_batch do
+          connection.create_table table_name do |t|
+            t.references :foo, index: { name: :index_testings_on_yo_momma }
+            t.references :bar, index: { unique: true }
+          end
+        end
+
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_yo_momma)
+        assert connection.index_exists?(table_name, :bar_id, name: :index_testings_on_bar_id, unique: true)
+      end
+
+      def test_creates_polymorphic_index
+        connection.ddl_batch do
+          connection.create_table table_name do |t|
+            t.references :foo, polymorphic: true, index: true
+          end
+        end
+
+        if ActiveRecord::gem_version < Gem::Version.create('6.1.0')
+          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo_type_and_foo_id)
+        else
+          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo)
+        end
+      end
+
+      def test_creates_index_for_existing_table
+        connection.ddl_batch do
+          connection.create_table table_name
+          connection.change_table table_name do |t|
+            t.references :foo, index: true
+          end
+        end
+
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
+      end
+
+      def test_creates_index_for_existing_table_even_if_index_option_is_not_passed
+        connection.ddl_batch do
+          connection.create_table table_name
+          connection.change_table table_name do |t|
+            t.references :foo
+          end
+        end
+
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
+      end
+
+      def test_does_not_create_index_for_existing_table_explicit
+        connection.ddl_batch do
+          connection.create_table table_name
+          connection.change_table table_name do |t|
+            t.references :foo, index: false
+          end
+        end
+        assert_not connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo)
+      end
+
+      def test_creates_polymorphic_index_for_existing_table
+        connection.ddl_batch do
+          connection.create_table table_name
+          connection.change_table table_name do |t|
+            t.references :foo, polymorphic: true, index: true
+          end
+        end
+
+        if ActiveRecord::gem_version < Gem::Version.create('6.1.0')
+          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo_type_and_foo_id)
+        else
+          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo)
+        end
+      end
+    end
+  end
+end

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