activerecord-spanner-adapter 0.3.0 → 1.0.0

data/acceptance/cases/migration/index_test.rb

@@ -0,0 +1,211 @@
+# 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 IndexTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+
+      attr_reader :table_name
+
+      def setup
+        skip_test_table_create!
+        super
+
+        @table_name = :testings
+
+        connection.ddl_batch do
+          connection.create_table table_name do |t|
+            t.column :foo, :string, limit: 100
+            t.column :bar, :string, limit: 100
+
+            t.string :first_name
+            t.string :last_name, limit: 100
+            t.string :key,       limit: 100
+            t.boolean :administrator
+          end
+        end
+      end
+
+      def teardown
+        connection.ddl_batch do
+          connection.drop_table :testings
+        end rescue nil
+        ActiveRecord::Base.primary_key_prefix_type = nil
+      end
+
+      def test_rename_index
+        connection.add_index(table_name, [:foo], name: "old_idx")
+        connection.ddl_batch do
+          connection.rename_index(table_name, "old_idx", "new_idx")
+        end
+
+        assert_not connection.index_name_exists?(table_name, "old_idx")
+        assert connection.index_name_exists?(table_name, "new_idx")
+      end
+
+      def test_rename_index_too_long
+        too_long_index_name = good_index_name + "x"
+        connection.add_index(table_name, [:foo], name: "old_idx")
+        e = assert_raises(ArgumentError) {
+          connection.rename_index(table_name, "old_idx", too_long_index_name)
+        }
+        assert_match(/too long; the limit is #{connection.index_name_length} characters/, e.message)
+
+        assert connection.index_name_exists?(table_name, "old_idx")
+      end
+
+      def test_remove_nonexistent_index
+        assert_raise(ArgumentError) { connection.remove_index(table_name, "no_such_index") }
+      end
+
+      def test_add_index_works_with_long_index_names
+        connection.add_index(table_name, "foo", name: good_index_name)
+
+        assert connection.index_name_exists?(table_name, good_index_name)
+        connection.remove_index(table_name, name: good_index_name)
+      end
+
+      def test_add_index_does_not_accept_too_long_index_names
+        too_long_index_name = good_index_name + "x"
+
+        e = assert_raises(ArgumentError) {
+          connection.add_index(table_name, "foo", name: too_long_index_name)
+        }
+        assert_match(/too long; the limit is #{connection.index_name_length} characters/, e.message)
+
+        assert_not connection.index_name_exists?(table_name, too_long_index_name)
+        connection.add_index(table_name, "foo", name: good_index_name)
+      end
+
+      def test_internal_index_with_name_matching_database_limit
+        good_index_name = "x" * connection.index_name_length
+        connection.add_index(table_name, "foo", name: good_index_name)
+
+        assert connection.index_name_exists?(table_name, good_index_name)
+        connection.remove_index(table_name, name: good_index_name)
+      end
+
+      def test_index_symbol_names
+        connection.add_index table_name, :foo, name: :symbol_index_name
+        assert connection.index_exists?(table_name, :foo, name: :symbol_index_name)
+
+        connection.remove_index table_name, name: :symbol_index_name
+        assert_not connection.index_exists?(table_name, :foo, name: :symbol_index_name)
+      end
+
+      def test_index_exists
+        connection.add_index :testings, :foo
+
+        assert connection.index_exists?(:testings, :foo)
+        assert_not connection.index_exists?(:testings, :bar)
+      end
+
+      def test_index_exists_on_multiple_columns
+        connection.add_index :testings, [:foo, :bar]
+
+        assert connection.index_exists?(:testings, [:foo, :bar])
+      end
+
+      def test_index_exists_with_custom_name_checks_columns
+        connection.add_index :testings, [:foo, :bar], name: "my_index"
+        assert connection.index_exists?(:testings, [:foo, :bar], name: "my_index")
+        assert_not connection.index_exists?(:testings, [:foo], name: "my_index")
+      end
+
+      def test_valid_index_options
+        assert_raise ArgumentError do
+          connection.add_index :testings, :foo, unqiue: true
+        end
+      end
+
+      def test_unique_index_exists
+        connection.add_index :testings, :foo, unique: true
+
+        assert connection.index_exists?(:testings, :foo, unique: true)
+      end
+
+      def test_order_index_exists
+        connection.add_index :testings, :foo, order: { foo: :desc }
+
+        assert connection.index_exists?(:testings, :foo)
+
+        index = connection.indexes(:testings).first
+        assert_equal({ foo: :desc }, index.orders)
+      end
+
+      def test_named_index_exists
+        connection.add_index :testings, :foo, name: "custom_index_name"
+
+        assert connection.index_exists?(:testings, :foo)
+        assert connection.index_exists?(:testings, :foo, name: "custom_index_name")
+        assert_not connection.index_exists?(:testings, :foo, name: "other_index_name")
+      end
+
+      def test_remove_named_index
+        connection.add_index :testings, :foo, name: "index_testings_on_custom_index_name"
+
+        assert connection.index_exists?(:testings, :foo)
+
+        assert_raise(ArgumentError) { connection.remove_index(:testings, "custom_index_name") }
+
+        connection.remove_index :testings, :foo
+        assert_not connection.index_exists?(:testings, :foo)
+      end
+
+      def test_add_index
+        connection.add_index("testings", "last_name")
+        connection.remove_index("testings", "last_name")
+
+        connection.add_index("testings", ["last_name", "first_name"])
+        connection.remove_index("testings", column: ["last_name", "first_name"])
+
+        connection.add_index("testings", ["last_name", "first_name"])
+        connection.remove_index("testings", name: :index_testings_on_last_name_and_first_name)
+        connection.add_index("testings", ["last_name", "first_name"])
+        connection.remove_index("testings", "last_name_and_first_name")
+
+        connection.add_index("testings", ["last_name", "first_name"])
+        connection.remove_index("testings", ["last_name", "first_name"])
+
+        connection.add_index("testings", "key", unique: true)
+        connection.remove_index("testings", "key")
+
+        connection.add_index("testings", ["key"], name: "key_idx", unique: true)
+        connection.remove_index("testings", name: "key_idx")
+
+        connection.add_index("testings", %w(last_name first_name administrator), name: "named_admin")
+        connection.remove_index("testings", name: "named_admin")
+
+        connection.add_index("testings", ["last_name"], order: { last_name: :desc })
+        connection.remove_index("testings", ["last_name"])
+        connection.add_index("testings", ["last_name", "first_name"], order: { last_name: :desc })
+        connection.remove_index("testings", ["last_name", "first_name"])
+        connection.add_index("testings", ["last_name", "first_name"], order: { last_name: :desc, first_name: :asc })
+        connection.remove_index("testings", ["last_name", "first_name"])
+        connection.add_index("testings", ["last_name", "first_name"], order: :desc)
+        connection.remove_index("testings", ["last_name", "first_name"])
+      end
+
+      def test_add_interleaved_index
+        connection.add_index "albums", ["singerid", "title"], interleave_in: :singers
+        index = connection.indexes(:albums).first
+
+        assert index, "Could not find interleaved index"
+        assert_equal "singers", index.interleave_in
+      end
+
+      private
+      def good_index_name
+        "x" * connection.index_name_length
+      end
+    end
+  end
+end

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