activerecord-spanner-adapter 0.3.0 → 1.0.0

data/acceptance/cases/migration/column_positioning_test.rb

@@ -0,0 +1,48 @@
+# 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 ColumnPositioningTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+
+      def setup
+        skip_test_table_create!
+        super
+
+        connection.ddl_batch do
+          connection.create_table :testing_columns_position, id: false, force: true do |t|
+            t.column :first, :integer
+            t.column :second, :integer
+            t.column :third, :integer
+          end
+        end
+      end
+
+      def teardown
+        connection.ddl_batch do
+          connection.drop_table :testing_columns_position
+        end rescue nil
+        ActiveRecord::Base.primary_key_prefix_type = nil
+      end
+
+      def test_column_positioning
+        assert_equal %w(first second third), connection.columns(:testing_columns_position).map(&:name)
+      end
+
+      def test_add_column_with_positioning
+        connection.ddl_batch do
+          connection.add_column :testing_columns_position, :fourth, :integer
+        end
+        assert_equal %w(first second third fourth), connection.columns(:testing_columns_position).map(&:name)
+      end
+    end
+  end
+end

data/acceptance/cases/migration/columns_test.rb

@@ -0,0 +1,201 @@
+# 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 ColumnsTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+
+      def test_rename_column
+        connection.ddl_batch do
+          add_column "test_models", :hat_name, :string
+        end
+        assert_column TestModel, :hat_name
+
+        rename_column "test_models", :hat_name, :cap_name
+        assert_column TestModel, :cap_name
+      end
+
+      def test_change_column_default_value
+        error = assert_raise ActiveRecordSpannerAdapter::NotSupportedError do
+          change_column_default "test_models", :hat_name, "hat"
+        end
+
+        assert_equal "change column with default value not supported.", error.message
+      end
+
+      def test_remove_column_with_index
+        connection.ddl_batch do
+          add_column "test_models", :hat_name, :string
+          add_index :test_models, :hat_name
+        end
+
+        assert_equal 1, connection.indexes("test_models").size
+        connection.ddl_batch do
+          remove_column "test_models", "hat_name"
+        end
+        assert_equal 0, connection.indexes("test_models").size
+      end
+
+      def test_remove_column_with_multi_column_index
+        connection.ddl_batch do
+          add_column "test_models", :hat_size, :integer
+          add_column "test_models", :hat_style, :string, limit: 100
+          add_index "test_models", ["hat_style", "hat_size"], unique: true
+        end
+
+        assert_equal 1, connection.indexes("test_models").size
+        connection.ddl_batch do
+          remove_column "test_models", "hat_size"
+        end
+
+        assert_equal [], connection.indexes("test_models").map(&:name)
+      end
+
+      def test_change_type_of_not_null_column
+        connection.ddl_batch do
+          change_column "test_models", "updated_at", :datetime, null: false
+          change_column "test_models", "updated_at", :datetime, null: false
+        end
+
+        TestModel.reset_column_information
+        assert_equal false, TestModel.columns_hash["updated_at"].null
+      ensure
+        connection.ddl_batch do
+          change_column "test_models", "updated_at", :datetime, null: true
+        end
+      end
+
+      def test_change_column_nullability
+        connection.ddl_batch do
+          add_column "test_models", "funny", :boolean
+        end
+        assert TestModel.columns_hash["funny"].null, "Column 'funny' must initially allow nulls"
+
+        connection.ddl_batch do
+          change_column "test_models", "funny", :boolean, null: false
+        end
+
+        TestModel.reset_column_information
+        assert_not TestModel.columns_hash["funny"].null, "Column 'funny' must *not* allow nulls at this point"
+
+        connection.ddl_batch do
+          change_column "test_models", "funny", :boolean, null: true
+        end
+        TestModel.reset_column_information
+        assert TestModel.columns_hash["funny"].null, "Column 'funny' must allow nulls again at this point"
+      end
+
+      def test_change_column
+        # Only string and binary allows to change types
+        connection.ddl_batch do
+          add_column "test_models", "name", :string
+        end
+
+        old_columns = connection.columns TestModel.table_name
+
+        assert old_columns.find { |c| c.name == "name" && c.type == :string }
+
+        connection.ddl_batch do
+          change_column "test_models", "name", :binary
+        end
+
+        new_columns = connection.columns TestModel.table_name
+
+        assert_not new_columns.find { |c| c.name == "name" && c.type == :string }
+        assert new_columns.find { |c| c.name == "name" && c.type == :binary }
+      end
+
+      def test_change_column_with_custom_index_name
+        connection.ddl_batch do
+          add_column :test_models, :category, :string
+          add_index :test_models, :category, name: "test_models_categories_idx", order: { category: :desc}
+        end
+
+        assert_equal ["test_models_categories_idx"], connection.indexes("test_models").map(&:name)
+        connection.ddl_batch do
+          change_column "test_models", "category", :string, null: false
+        end
+
+        assert column_exists?(:test_models, :category, :string, null: false)
+        indexes = connection.indexes("test_models")
+        assert_equal ["test_models_categories_idx"], indexes.map(&:name)
+        assert_equal({ category: :desc }, indexes.first.orders)
+      end
+
+      def test_change_column_with_long_index_name
+        table_name_prefix = "test_models_"
+        long_index_name = table_name_prefix + ("x" * (connection.index_name_length - table_name_prefix.length))
+        connection.ddl_batch do
+          add_column "test_models", "category", :string
+          add_index :test_models, :category, name: long_index_name
+        end
+
+        connection.ddl_batch do
+          change_column "test_models", "category", :string, null: false
+        end
+
+        assert_equal [long_index_name], connection.indexes("test_models").map(&:name)
+      end
+
+      def test_remove_column_no_second_parameter_raises_exception
+        assert_raise(ArgumentError) { connection.remove_column("funny") }
+      end
+
+      def test_removing_column_preserves_custom_primary_key
+        connection.ddl_batch do
+          connection.create_table "my_table", primary_key: "my_table_id", force: true do |t|
+            t.integer "col_one"
+            t.string "col_two", limit: 128, null: false
+          end
+        end
+
+        connection.ddl_batch do
+          remove_column "my_table", "col_two"
+        end
+
+        assert_equal "my_table_id", connection.primary_key("my_table")
+
+        columns = connection.columns "my_table"
+        my_table_id = columns.detect { |c| c.name == "my_table_id" }
+        assert_equal "INT64", my_table_id.sql_type
+      ensure
+        connection.ddl_batch do
+          connection.drop_table :my_table rescue nil
+        end
+      end
+
+      def test_column_with_index
+        connection.ddl_batch do
+          connection.create_table "my_table", force: true do |t|
+            t.string :item_number, index: true
+          end
+        end
+
+        assert connection.index_exists?("my_table", :item_number, name: :index_my_table_on_item_number)
+      ensure
+        connection.ddl_batch do
+          connection.drop_table :my_table rescue nil
+        end
+      end
+
+      def test_add_column_without_column_name
+        e = assert_raise ArgumentError do
+          connection.create_table "my_table", force: true do |t|
+            t.timestamp
+          end
+        end
+        assert_equal "Missing column name(s) for timestamp", e.message
+      ensure
+        connection.drop_table :my_table, if_exists: true
+      end
+    end
+  end
+end

data/acceptance/cases/migration/command_recorder_test.rb

@@ -0,0 +1,406 @@
+# 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 CommandRecorderTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+
+      VERSION_6_1_0 = Gem::Version.create "6.1.0"
+      VERSION_6_0_3 = Gem::Version.create "6.0.3"
+
+      def setup
+        skip_test_table_create!
+        super
+        @recorder = CommandRecorder.new(connection)
+      end
+
+      def test_respond_to_delegates
+        recorder = CommandRecorder.new(Class.new {
+          def america; end
+        }.new)
+        assert_respond_to recorder, :america
+      end
+
+      def test_send_calls_super
+        assert_raises(NoMethodError) do
+          @recorder.send(:non_existing_method, :horses)
+        end
+      end
+
+      def test_send_delegates_to_record
+        recorder = CommandRecorder.new(Class.new {
+          def create_table(name); end
+        }.new)
+        assert_respond_to recorder, :create_table
+        recorder.send(:create_table, :horses)
+        assert_equal [[:create_table, [:horses], nil]], recorder.commands
+      end
+
+      def test_unknown_commands_delegate
+        recorder = Class.new do
+          def foo(kw:)
+            kw
+          end
+        end
+        recorder = CommandRecorder.new(recorder.new)
+        assert_equal "bar", recorder.foo(kw: "bar")
+      end
+
+      def test_inverse_of_raise_exception_on_unknown_commands
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :execute, ["some sql"]
+        end
+      end
+
+      def test_irreversible_commands_raise_exception
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.revert { @recorder.execute "some sql" }
+        end
+      end
+
+      def test_record
+        @recorder.record :create_table, [:system_settings]
+        assert_equal 1, @recorder.commands.length
+      end
+
+      def test_inverted_commands_are_reversed
+        @recorder.revert do
+          @recorder.record :create_table, [:hello]
+          @recorder.record :create_table, [:world]
+        end
+        tables = @recorder.commands.map { |_cmd, args, _block| args }
+        assert_equal [[:world], [:hello]], tables
+      end
+
+      def test_revert_order
+        block = Proc.new { |t| t.string :name }
+        @recorder.instance_eval do
+          create_table("apples", &block)
+          revert do
+            create_table("bananas", &block)
+            revert do
+              create_table("clementines", &block)
+              create_table("dates")
+            end
+            create_table("elderberries")
+          end
+          revert do
+            create_table("figs", &block)
+            create_table("grapes")
+          end
+        end
+        assert_equal [[:create_table, ["apples"], block], [:drop_table, ["elderberries"], nil],
+                      [:create_table, ["clementines"], block], [:create_table, ["dates"], nil],
+                      [:drop_table, ["bananas"], block], [:drop_table, ["grapes"], nil],
+                      [:drop_table, ["figs"], block]], @recorder.commands
+      end
+
+      def test_invert_change_table
+        @recorder.revert do
+          @recorder.change_table :fruits do |t|
+            t.string :name
+            t.rename :kind, :cultivar
+          end
+        end
+
+        if RUBY_VERSION >= "2.8"
+          assert_equal [
+            [:rename_column, [:fruits, :cultivar, :kind]],
+            [:remove_column, [:fruits, :name, :string], nil],
+          ], @recorder.commands
+        else
+          assert_equal [
+            [:rename_column, [:fruits, :cultivar, :kind]],
+            [:remove_column, [:fruits, :name, :string, {}], nil],
+          ], @recorder.commands
+        end
+
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.revert do
+            @recorder.change_table :fruits do |t|
+              t.remove :kind
+            end
+          end
+        end
+      end
+
+      def test_invert_create_table
+        @recorder.revert do
+          @recorder.record :create_table, [:system_settings]
+        end
+        drop_table = @recorder.commands.first
+        assert_equal [:drop_table, [:system_settings], nil], drop_table
+      end
+
+      def test_invert_create_table_with_options_and_block
+        block = Proc.new { }
+        drop_table = @recorder.inverse_of :create_table, [:people_reminders, id: false], &block
+        assert_equal [:drop_table, [:people_reminders, id: false], block], drop_table
+      end
+
+      def test_invert_drop_table
+        block = Proc.new { }
+        create_table = @recorder.inverse_of :drop_table, [:people_reminders, id: false], &block
+        assert_equal [:create_table, [:people_reminders, id: false], block], create_table
+      end
+
+      def test_invert_drop_table_without_a_block_nor_option
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :drop_table, [:people_reminders]
+        end
+      end
+
+      def test_invert_create_join_table
+        drop_join_table = @recorder.inverse_of :create_join_table, [:musics, :artists]
+        assert_equal [:drop_join_table, [:musics, :artists], nil], drop_join_table
+      end
+
+      def test_invert_create_join_table_with_table_name
+        drop_join_table = @recorder.inverse_of :create_join_table, [:musics, :artists, table_name: :catalog]
+        assert_equal [:drop_join_table, [:musics, :artists, table_name: :catalog], nil], drop_join_table
+      end
+
+      def test_invert_drop_join_table
+        block = Proc.new { }
+        create_join_table = @recorder.inverse_of :drop_join_table, [:musics, :artists, table_name: :catalog], &block
+        assert_equal [:create_join_table, [:musics, :artists, table_name: :catalog], block], create_join_table
+      end
+
+      def test_invert_rename_table
+        rename = @recorder.inverse_of :rename_table, [:old, :new]
+        assert_equal [:rename_table, [:new, :old]], rename
+      end
+
+      def test_invert_add_column
+        remove = @recorder.inverse_of :add_column, [:table, :column, :type, {}]
+        assert_equal [:remove_column, [:table, :column, :type, {}], nil], remove
+      end
+
+      def test_invert_change_column
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :change_column, [:table, :column, :type, {}]
+        end
+      end
+
+      def test_invert_remove_column
+        add = @recorder.inverse_of :remove_column, [:table, :column, :type, {}]
+        assert_equal [:add_column, [:table, :column, :type, {}], nil], add
+      end
+
+      def test_invert_remove_column_without_type
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :remove_column, [:table, :column]
+        end
+      end
+
+      def test_invert_add_index
+        remove = @recorder.inverse_of :add_index, [:table, [:one, :two]]
+        if ActiveRecord::gem_version < Gem::Version.create('6.1.0')
+          assert_equal [:remove_index, [:table, { column: [:one, :two] }]], remove
+        else
+          assert_equal [:remove_index, [:table, [:one, :two]], nil], remove
+        end
+      end
+
+      def test_invert_add_index_with_name
+        remove = @recorder.inverse_of :add_index, [:table, [:one, :two], name: "new_index"]
+        if ActiveRecord::gem_version < Gem::Version.create('6.1.0')
+          assert_equal [:remove_index, [:table, { name: "new_index" }]], remove
+        else
+          assert_equal [:remove_index, [:table, [:one, :two], {:name=>"new_index"}], nil], remove
+        end
+      end
+
+      def test_invert_remove_index
+        add = @recorder.inverse_of :remove_index, [:table, :one]
+        assert_equal [:add_index, [:table, :one]], add
+      end
+
+      def test_invert_remove_index_with_options
+        add = @recorder.inverse_of :remove_index, [:table, { column: :one }]
+        if ActiveRecord::gem_version < Gem::Version.create('6.1.0')
+          assert_equal [:add_index, [:table, :one, {} ]], add
+        else
+          assert_equal [:add_index, [:table, :one ]], add
+        end
+      end
+
+      def test_invert_remove_index_with_positional_column
+        add = @recorder.inverse_of :remove_index, [:table, { column: [:one, :two], options: true }]
+        assert_equal [:add_index, [:table, [:one, :two], options: true]], add
+      end
+
+      def test_invert_remove_index_with_column
+        add = @recorder.inverse_of :remove_index, [:table, { column: [:one, :two], options: true }]
+        assert_equal [:add_index, [:table, [:one, :two], options: true]], add
+      end
+
+      def test_invert_remove_index_with_name
+        add = @recorder.inverse_of :remove_index, [:table, { column: [:one, :two], name: "new_index" }]
+        assert_equal [:add_index, [:table, [:one, :two], name: "new_index"]], add
+      end
+
+      def test_invert_remove_index_with_no_special_options
+        add = @recorder.inverse_of :remove_index, [:table, { column: [:one, :two] }]
+        if ActiveRecord::gem_version < Gem::Version.create('6.1.0')
+          assert_equal [:add_index, [:table, [:one, :two], {}]], add
+        else
+          assert_equal [:add_index, [:table, [:one, :two]]], add
+        end
+      end
+
+      def test_invert_remove_index_with_no_column
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse_of :remove_index, [:table, name: "new_index"]
+        end
+      end
+
+      def test_invert_rename_index
+        rename = @recorder.inverse_of :rename_index, [:table, :old, :new]
+        assert_equal [:rename_index, [:table, :new, :old]], rename
+      end
+
+      def test_invert_add_timestamps
+        remove = @recorder.inverse_of :add_timestamps, [:table]
+        assert_equal [:remove_timestamps, [:table], nil], remove
+      end
+
+      def test_invert_remove_timestamps
+        add = @recorder.inverse_of :remove_timestamps, [:table, { null: true }]
+        assert_equal [:add_timestamps, [:table, { null: true }], nil], add
+      end
+
+      def test_invert_add_reference
+        remove = @recorder.inverse_of :add_reference, [:table, :taggable, { polymorphic: true }]
+        assert_equal [:remove_reference, [:table, :taggable, { polymorphic: true }], nil], remove
+      end
+
+      def test_invert_add_belongs_to_alias
+        remove = @recorder.inverse_of :add_belongs_to, [:table, :user]
+        assert_equal [:remove_reference, [:table, :user], nil], remove
+      end
+
+      def test_invert_remove_reference
+        add = @recorder.inverse_of :remove_reference, [:table, :taggable, { polymorphic: true }]
+        assert_equal [:add_reference, [:table, :taggable, { polymorphic: true }], nil], add
+      end
+
+      def test_invert_remove_reference_with_index_and_foreign_key
+        add = @recorder.inverse_of :remove_reference, [:table, :taggable, { index: true, foreign_key: true }]
+        assert_equal [:add_reference, [:table, :taggable, { index: true, foreign_key: true }], nil], add
+      end
+
+      def test_invert_remove_belongs_to_alias
+        add = @recorder.inverse_of :remove_belongs_to, [:table, :user]
+        assert_equal [:add_reference, [:table, :user], nil], add
+      end
+
+      def test_invert_enable_extension
+        disable = @recorder.inverse_of :enable_extension, ["uuid-ossp"]
+        assert_equal [:disable_extension, ["uuid-ossp"], nil], disable
+      end
+
+      def test_invert_disable_extension
+        enable = @recorder.inverse_of :disable_extension, ["uuid-ossp"]
+        assert_equal [:enable_extension, ["uuid-ossp"], nil], enable
+      end
+
+      def test_invert_add_foreign_key
+        enable = @recorder.inverse_of :add_foreign_key, [:dogs, :people]
+        if ActiveRecord.gem_version < VERSION_6_0_3
+          assert_equal [:remove_foreign_key, [:dogs, :people]], enable
+        else
+          assert_equal [:remove_foreign_key, [:dogs, :people], nil], enable
+        end
+      end
+
+      def test_invert_remove_foreign_key
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, :people]
+        assert_equal [:add_foreign_key, [:dogs, :people]], enable
+      end
+
+      def test_invert_add_foreign_key_with_column
+        enable = @recorder.inverse_of :add_foreign_key, [:dogs, :people, column: "owner_id"]
+        if ActiveRecord.gem_version < VERSION_6_0_3
+          assert_equal [:remove_foreign_key, [:dogs, column: "owner_id"]], enable
+        else
+          assert_equal [:remove_foreign_key, [:dogs, :people, column: "owner_id"], nil], enable
+        end
+      end
+
+      def test_invert_remove_foreign_key_with_column
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, :people, column: "owner_id"]
+        assert_equal [:add_foreign_key, [:dogs, :people, column: "owner_id"]], enable
+      end
+
+      def test_invert_add_foreign_key_with_column_and_name
+        enable = @recorder.inverse_of :add_foreign_key, [:dogs, :people, column: "owner_id", name: "fk"]
+        if ActiveRecord.gem_version < VERSION_6_0_3
+          assert_equal [:remove_foreign_key, [:dogs, { name: "fk" }]], enable
+        else
+          assert_equal [:remove_foreign_key, [:dogs, :people, { column: "owner_id", name: "fk" }], nil], enable
+        end
+      end
+
+      def test_invert_remove_foreign_key_with_column_and_name
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, :people, column: "owner_id", name: "fk"]
+        assert_equal [:add_foreign_key, [:dogs, :people, column: "owner_id", name: "fk"]], enable
+      end
+
+      def test_invert_remove_foreign_key_with_primary_key
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, :people, primary_key: "person_id"]
+        assert_equal [:add_foreign_key, [:dogs, :people, primary_key: "person_id"]], enable
+      end
+
+      def test_invert_remove_foreign_key_with_primary_key_and_to_table_in_options
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, to_table: :people, primary_key: "uuid"]
+        assert_equal [:add_foreign_key, [:dogs, :people, primary_key: "uuid"]], enable
+      end
+
+      def test_invert_remove_foreign_key_with_on_delete_on_update
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, :people, on_delete: :nullify, on_update: :cascade]
+        assert_equal [:add_foreign_key, [:dogs, :people, on_delete: :nullify, on_update: :cascade]], enable
+      end
+
+      def test_invert_remove_foreign_key_with_to_table_in_options
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, to_table: :people]
+        assert_equal [:add_foreign_key, [:dogs, :people]], enable
+
+        enable = @recorder.inverse_of :remove_foreign_key, [:dogs, to_table: :people, column: :owner_id]
+        assert_equal [:add_foreign_key, [:dogs, :people, column: :owner_id]], enable
+      end
+
+      def test_invert_remove_foreign_key_is_irreversible_without_to_table
+        assert_raises ActiveRecord::IrreversibleMigration do
+          @recorder.inverse_of :remove_foreign_key, [:dogs, column: "owner_id"]
+        end
+
+        assert_raises ActiveRecord::IrreversibleMigration do
+          @recorder.inverse_of :remove_foreign_key, [:dogs, name: "fk"]
+        end
+
+        assert_raises ActiveRecord::IrreversibleMigration do
+          @recorder.inverse_of :remove_foreign_key, [:dogs]
+        end
+      end
+
+      def test_invert_transaction_with_irreversible_inside_is_irreversible
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.revert do
+            @recorder.transaction do
+              @recorder.execute "some sql"
+            end
+          end
+        end
+      end
+    end
+  end
+end