activerecord-spanner-adapter 0.3.0 → 0.5.0

data/acceptance/cases/migration/ddl_batching_test.rb

@@ -0,0 +1,80 @@
+# 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 DDLBatchingTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+      include ActiveSupport::Testing::Stream
+
+      class Box < ActiveRecord::Base
+      end
+
+      class CreateBoxMigration < ActiveRecord::Migration::Current
+        def change
+          connection.ddl_batch do
+            create_table("boxes") do |t|
+              t.string :name
+            end
+
+            add_column :boxes, :length, :integer
+          end
+
+          Box.create(name: "Box1", length: 10)
+        end
+      end
+
+      def setup
+        skip_test_table_create!
+
+        super
+      end
+
+      def teardown
+        super
+
+        connection.ddl_batch do
+          [:boxes, :ddl_batch_test].each do |name|
+            if connection.table_exists?(name)
+              connection.drop_table name
+            end
+          end
+        end
+      end
+
+      def test_ddl_batching
+        information_schema = connection.send :information_schema
+
+        connection.ddl_batch do
+          connection.create_table("ddl_batch_test") do |t|
+            t.string :name
+          end
+          connection.add_column :ddl_batch_test, :created_at, :time
+
+          assert_not information_schema.table(:ddl_batch_test)
+        end
+
+        assert information_schema.table(:ddl_batch_test)
+      end
+
+      def test_ddl_batching_with_dml_statement
+        migration = CreateBoxMigration.new
+        silence_stream($stdout) { migration.migrate(:up) }
+
+        assert connection.table_exists?(:boxes)
+        assert connection.column_exists?(:boxes, :length, :integer)
+
+        assert_equal 1, Box.count
+        box = Box.first
+        assert_equal 10, box.length
+      end
+    end
+  end
+end

data/acceptance/cases/migration/foreign_key_test.rb

@@ -0,0 +1,297 @@
+# 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 ForeignKeyTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+      include ActiveSupport::Testing::Stream
+
+      class Rocket < ActiveRecord::Base
+      end
+
+      class Astronaut < ActiveRecord::Base
+      end
+
+      def setup
+        skip_test_table_create!
+        super
+
+        connection.ddl_batch do
+          connection.create_table "rockets", force: true do |t|
+            t.string :name
+          end
+
+          connection.create_table "astronauts", force: true do |t|
+            t.string :name
+            t.references :rocket
+          end
+        end
+      end
+
+      def teardown
+        connection.ddl_batch do
+          connection.drop_table "astronauts", if_exists: true
+          connection.drop_table "rockets", if_exists: true
+          connection.drop_table "fk_test_has_fk", if_exists: true
+          connection.drop_table "fk_test_has_pk", if_exists: true
+        end
+      end
+
+      def test_foreign_keys
+        connection.ddl_batch do
+          connection.create_table :fk_test_has_pk, primary_key: "pk_id", force: :cascade do |t|
+          end
+
+          connection.create_table :fk_test_has_fk, force: true do |t|
+            t.references :fk, null: false
+            t.foreign_key :fk_test_has_pk, column: "fk_id", name: "fk_name", primary_key: "pk_id"
+          end
+        end
+
+        foreign_keys = connection.foreign_keys("fk_test_has_fk")
+        assert_equal 1, foreign_keys.size
+
+        fk = foreign_keys.first
+        assert_equal "fk_test_has_fk", fk.from_table
+        assert_equal "fk_test_has_pk", fk.to_table
+        assert_equal "fk_id", fk.column
+        assert_equal "pk_id", fk.primary_key
+      end
+
+      def test_add_foreign_key_inferes_column
+        connection.ddl_batch do
+          connection.add_foreign_key :astronauts, :rockets
+        end
+
+        foreign_keys = connection.foreign_keys("astronauts")
+        assert_equal 1, foreign_keys.size
+
+        fk = foreign_keys.first
+        assert_equal "astronauts", fk.from_table
+        assert_equal "rockets", fk.to_table
+        assert_equal "rocket_id", fk.column
+        assert_equal "id", fk.primary_key
+      end
+
+      def test_add_foreign_key_with_column
+        connection.ddl_batch do
+          connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
+        end
+
+        foreign_keys = connection.foreign_keys("astronauts")
+        assert_equal 1, foreign_keys.size
+
+        fk = foreign_keys.first
+        assert_equal "astronauts", fk.from_table
+        assert_equal "rockets", fk.to_table
+        assert_equal "rocket_id", fk.column
+        assert_equal "id", fk.primary_key
+      end
+
+      def test_add_foreign_key_with_non_standard_primary_key
+        connection.ddl_batch do
+          connection.create_table :space_shuttles, id: false, force: true do |t|
+            t.integer :pk, primary_key: true
+          end
+
+          connection.add_foreign_key(:astronauts, :space_shuttles,
+            column: "rocket_id", primary_key: "pk", name: "custom_pk")
+        end
+
+        foreign_keys = connection.foreign_keys("astronauts")
+        assert_equal 1, foreign_keys.size
+
+        fk = foreign_keys.first
+        assert_equal "astronauts", fk.from_table
+        assert_equal "space_shuttles", fk.to_table
+        assert_equal "pk", fk.primary_key
+      ensure
+        connection.ddl_batch do
+          connection.remove_foreign_key :astronauts, name: "custom_pk", to_table: "space_shuttles"
+          connection.drop_table :space_shuttles
+        end
+      end
+
+      def test_foreign_key_exists
+        connection.ddl_batch do
+          connection.add_foreign_key :astronauts, :rockets
+        end
+
+        assert connection.foreign_key_exists?(:astronauts, :rockets)
+        assert_not connection.foreign_key_exists?(:astronauts, :stars)
+      end
+
+      def test_foreign_key_exists_by_column
+        connection.ddl_batch do
+          connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
+        end
+
+        assert connection.foreign_key_exists?(:astronauts, column: "rocket_id")
+        assert_not connection.foreign_key_exists?(:astronauts, column: "star_id")
+      end
+
+      def test_foreign_key_exists_by_name
+        connection.ddl_batch do
+          connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
+        end
+
+        assert connection.foreign_key_exists?(:astronauts, name: "fancy_named_fk")
+        assert_not connection.foreign_key_exists?(:astronauts, name: "other_fancy_named_fk")
+      end
+
+      def test_foreign_key_exists_in_change_table
+        connection.change_table(:astronauts) do |t|
+          t.foreign_key :rockets, column: "rocket_id", name: "fancy_named_fk"
+
+          assert t.foreign_key_exists?(column: "rocket_id")
+          assert_not t.foreign_key_exists?(column: "star_id")
+        end
+      end
+
+      def test_remove_foreign_key_inferes_column
+        connection.ddl_batch do
+          connection.add_foreign_key :astronauts, :rockets
+        end
+
+        assert_equal 1, connection.foreign_keys("astronauts").size
+        connection.ddl_batch do
+          @connection.remove_foreign_key :astronauts, :rockets
+        end
+        assert_equal [], connection.foreign_keys("astronauts")
+      end
+
+      def test_remove_foreign_key_by_column
+        connection.ddl_batch do
+          connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
+        end
+
+        assert_equal 1, connection.foreign_keys("astronauts").size
+        connection.ddl_batch do
+          @connection.remove_foreign_key :astronauts, column: "rocket_id"
+        end
+        assert_equal [], connection.foreign_keys("astronauts")
+      end
+
+      def test_remove_foreign_key_by_symbol_column
+        connection.ddl_batch do
+          connection.add_foreign_key :astronauts, :rockets, column: :rocket_id
+        end
+
+        assert_equal 1, connection.foreign_keys("astronauts").size
+        connection.ddl_batch do
+          connection.remove_foreign_key :astronauts, column: :rocket_id
+        end
+        assert_equal [], connection.foreign_keys("astronauts")
+      end
+
+      def test_remove_foreign_key_by_name
+        connection.ddl_batch do
+          connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
+        end
+
+        assert_equal 1, connection.foreign_keys("astronauts").size
+        connection.ddl_batch do
+          connection.remove_foreign_key :astronauts, name: "fancy_named_fk"
+        end
+        assert_equal [], connection.foreign_keys("astronauts")
+      end
+
+      def test_remove_foreign_non_existing_foreign_key_raises
+        e = assert_raises ArgumentError do
+          connection.remove_foreign_key :astronauts, :rockets
+        end
+        assert_equal "Table 'astronauts' has no foreign key for rockets", e.message
+      end
+
+      def test_remove_foreign_key_by_the_select_one_on_the_same_table
+        connection.ddl_batch do
+          connection.add_foreign_key :astronauts, :rockets
+          connection.add_reference :astronauts, :myrocket, foreign_key: { to_table: :rockets }
+        end
+
+        assert_equal 2, connection.foreign_keys("astronauts").size
+
+        connection.ddl_batch do
+          connection.remove_foreign_key :astronauts, :rockets, column: "myrocket_id"
+        end
+
+        assert_equal [["astronauts", "rockets", "rocket_id"]],
+          connection.foreign_keys("astronauts").map { |fk| [fk.from_table, fk.to_table, fk.column] }
+      end
+
+      class CreateCitiesAndHousesMigration < ActiveRecord::Migration::Current
+        def change
+          connection.ddl_batch do
+            create_table("cities") { |t| }
+
+            create_table("houses") do |t|
+              t.references :city
+            end
+            add_foreign_key :houses, :cities, column: "city_id"
+          end
+
+          # remove and re-add to test that schema is updated and not accidentally cached
+          remove_foreign_key :houses, :cities
+          add_foreign_key :houses, :cities, column: "city_id"
+        end
+      end
+
+      def test_add_foreign_key_is_reversible
+        migration = CreateCitiesAndHousesMigration.new
+        silence_stream($stdout) { migration.migrate(:up) }
+        assert_equal 1, connection.foreign_keys("houses").size
+      ensure
+        silence_stream($stdout) { migration.migrate(:down) }
+      end
+
+      class CreateSchoolsAndClassesMigration < ActiveRecord::Migration::Current
+        def up
+          connection.ddl_batch do
+            create_table(:schools)
+
+            create_table(:classes) do |t|
+              t.references :school
+            end
+            add_foreign_key :classes, :schools
+          end
+        end
+
+        def down
+          connection.ddl_batch do
+            drop_table :classes, if_exists: true
+            drop_table :schools, if_exists: true
+          end
+        end
+      end
+
+      def test_add_foreign_key_with_prefix
+        ActiveRecord::Base.table_name_prefix = "p_"
+        migration = CreateSchoolsAndClassesMigration.new
+        silence_stream($stdout) { migration.migrate(:up) }
+        assert_equal 1, connection.foreign_keys("p_classes").size
+      ensure
+        silence_stream($stdout) { migration.migrate(:down) }
+        ActiveRecord::Base.table_name_prefix = nil
+      end
+
+      def test_add_foreign_key_with_suffix
+        ActiveRecord::Base.table_name_suffix = "_s"
+        migration = CreateSchoolsAndClassesMigration.new
+        silence_stream($stdout) { migration.migrate(:up) }
+        assert_equal 1, connection.foreign_keys("classes_s").size
+      ensure
+        silence_stream($stdout) { migration.migrate(:down) }
+        ActiveRecord::Base.table_name_suffix = nil
+      end
+    end
+  end
+end
+

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