activerecord-spanner-adapter 0.3.0 → 0.5.0

data/acceptance/cases/interleaved_associations/has_many_associations_using_interleaved_test.rb

@@ -0,0 +1,211 @@
+# 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"
+require "models/album"
+require "models/track"
+
+module ActiveRecord
+  module Associations
+    class HasManyUsingInterleavedTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Associations::TestHelper
+
+      attr_accessor :singer, :album1, :album2
+
+      def setup
+        super
+
+        @singer = Singer.create first_name: "FirstName1", last_name: "LastName1"
+
+        @album2 = Album.create title: "Title2", singer: singer
+        @album1 = Album.create title: "Title1", singer: singer
+
+        @track2_1 = Track.create title: "Title2_1", album: album2, duration: 3.6
+        @track2_2 = Track.create title: "Title2_2", album: album2, duration: 3.3
+        @track1_1 = Track.create title: "Title1_1", album: album1, duration: 4.5
+        @track1_2 = Track.create title: "Title1_2", album: album1
+      end
+
+      def teardown
+        Album.destroy_all
+        Singer.destroy_all
+      end
+
+      def test_has_many
+        assert_equal 2, singer.albums.count
+        assert_equal singer.albums.pluck(:title).sort, %w[Title1 Title2]
+
+        assert_equal 4, singer.tracks.count
+        assert_equal singer.tracks.pluck(:title).sort, %w[Title1_1 Title1_2 Title2_1 Title2_2]
+
+        assert_equal 2, album1.tracks.count
+        assert_equal album1.tracks.pluck(:title).sort, %w[Title1_1 Title1_2]
+        assert_equal 2, album2.tracks.count
+        assert_equal album2.tracks.pluck(:title).sort, %w[Title2_1 Title2_2]
+      end
+
+      def test_finding_using_associated_fields
+        assert_equal Album.where(singerid: singer.id).to_a, singer.albums.to_a
+        assert_equal Track.where(singerid: singer.id).to_a, singer.tracks.to_a
+      end
+
+      def test_successful_build_association
+        album = singer.albums.build title: "New Title"
+        assert album.save
+
+        singer.reload
+        assert_equal album, singer.albums.find(album.id)
+      end
+
+      def test_successful_build_nested_association
+        track = album1.tracks.build title: "New Title", duration: 4.45
+        assert track.save
+
+        album1.reload
+        assert_equal track, album1.tracks.find(track.id)
+      end
+
+      def test_create_and_destroy_associated_records
+        singer2 = Singer.new first_name: "First", last_name: "Last"
+        singer2.albums.build title: "New Title 1"
+        singer2.albums.build title: "New Title 2"
+        singer2.save!
+
+        singer2.reload
+
+        assert_equal 2, singer2.albums.count
+        assert_equal 4, Album.count
+
+        singer2.albums.destroy_all
+        singer2.reload
+
+        assert_equal 0, singer2.albums.count
+        assert_equal 2, Album.count
+      end
+
+      def test_create_and_destroy_nested_associated_records
+        album3 = Album.new singer: singer, title: "Title 3"
+        album3.tracks.build title: "Title3_1", duration: 2.5, singer: singer
+        album3.tracks.build title: "Title3_2", singer: singer
+        album3.save!
+
+        album3.reload
+
+        assert_equal 2, album3.tracks.count
+        assert_equal 6, singer.tracks.count
+        assert_equal 6, Track.count
+
+        album3.tracks.destroy_all
+        album3.reload
+
+        assert_equal 0, album3.tracks.count
+        assert_equal 4, Track.count
+      end
+
+      def test_create_and_delete_associated_records
+        singer2 = Singer.new first_name: "First", last_name: "Last"
+        singer2.albums.build title: "Album - 11"
+        singer2.albums.build title: "Album - 12"
+        singer2.save!
+
+        singer2.reload
+
+        assert_equal 2, singer2.albums.count
+        assert_equal 4, Album.count
+
+        assert_equal 2, singer2.albums.delete_all
+        singer2.reload
+
+        assert_equal 0, singer2.albums.count
+        assert_equal 2, Album.count
+      end
+
+      def test_create_and_delete_nested_associated_records
+        album3 = Album.new title: "Album 3", singer: singer
+        album3.tracks.build title: "Track - 31", singer: singer
+        album3.tracks.build title: "Track - 32", singer: singer
+        album3.save!
+
+        album3.reload
+
+        assert_equal 2, album3.tracks.count
+        assert_equal 6, Track.count
+
+        assert_equal 2, album3.tracks.delete_all
+        album3.reload
+
+        assert_equal 0, album3.tracks.count
+        assert_equal 4, Track.count
+      end
+
+      def test_update_associated_records
+        count = singer.albums.update_all title: "Title - Update"
+        assert_equal singer.albums.count, count
+
+        singer.reload
+        singer.albums.each do |album|
+          assert_equal "Title - Update", album.title
+        end
+      end
+
+      def test_update_nested_associated_records
+        count = album1.tracks.update_all title: "Title - Update", duration: 6.626
+        assert_equal album1.tracks.count, count
+
+        album1.reload
+        album1.tracks.each do |track|
+          assert_equal "Title - Update", track.title
+          assert_equal 6.626, track.duration
+        end
+      end
+
+      def test_fetch_associated_record_with_order
+        albums = singer.albums.order title: :desc
+        assert_equal %w[Title2 Title1], albums.pluck(:title)
+
+        albums = singer.albums.order title: :asc
+        assert_equal %w[Title1 Title2], albums.pluck(:title)
+      end
+
+      def test_fetch_nested_associated_record_with_order
+        tracks = album1.tracks.order duration: :desc
+        assert_equal [4.5, nil], tracks.pluck(:duration)
+
+        tracks = album1.tracks.order duration: :asc
+        assert_equal [nil, 4.5], tracks.pluck(:duration)
+      end
+
+      def test_set_counter_cache
+        singer.tracks.create! title: "New Title 1", album: album1
+        singer.tracks.create! title: "New Title 2", album: album2
+
+        singer.reload
+        assert_equal 6, singer.tracks_count
+      end
+
+      def test_cascade_destroy
+        assert_equal 4, singer.tracks.count
+
+        assert album1.destroy
+
+        singer.reload
+        assert_equal 2, singer.tracks.count
+      end
+
+      def test_cascade_delete
+        assert_equal 4, singer.tracks.count
+
+        assert album1.delete
+
+        singer.reload
+        assert_equal 2, singer.tracks.count
+      end
+    end
+  end
+end

data/acceptance/cases/migration/change_schema_test.rb

@@ -0,0 +1,433 @@
+# 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 ChangeSchemaTest < SpannerAdapter::TestCase
+      include SpannerAdapter::Migration::TestHelper
+
+      attr_reader :connection, :table_name
+
+      def setup
+        skip_test_table_create!
+        super
+        @table_name = :testings
+      end
+
+      def teardown
+        connection.ddl_batch do
+          connection.drop_table :testings rescue nil
+        end
+        ActiveRecord::Base.primary_key_prefix_type = nil
+        ActiveRecord::Base.clear_cache!
+      end
+
+      def test_add_column
+        testing_table_with_only_foo_attribute do
+          assert_equal connection.columns(:testings).size, 2
+          connection.add_column :testings, :name, :string
+          assert_equal connection.columns(:testings).size, 3
+        end
+      end
+
+      def test_create_table_adds_id
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :string
+          end
+        end
+
+        assert_equal %w[id foo].sort, connection.columns(:testings).map(&:name).sort
+        assert_equal "id", connection.primary_key(:testings)
+
+        column = connection.columns(:testings).find { |c| c.name == "id" }
+
+        assert_equal "id", column.name
+        assert_equal :integer, column.type
+      end
+
+      def test_create_table_with_custom_primary_key
+        connection.ddl_batch do
+          connection.create_table :testings, force: true, primary_key: :email do |t|
+            t.string :name
+          end
+        end
+
+        assert_equal "email", connection.primary_key(:testings)
+      end
+
+      def test_create_table_with_custom_primary_key_using_options
+        connection.ddl_batch do
+          connection.create_table :testings, force: true, id: false do |t|
+            t.string :phone, primary_key: true
+            t.string :name
+          end
+        end
+
+        assert_equal "phone", connection.primary_key(:testings)
+      end
+
+      def test_create_table_with_custom_primary_key_using_type
+        connection.ddl_batch do
+          connection.create_table :testings, force: true, id: false do |t|
+            t.primary_key :username, limit: 255
+            t.string :name
+          end
+        end
+
+        assert_equal "username", connection.primary_key(:testings)
+
+        column = connection.columns(:testings).find { |c| c.name == "username" }
+
+        assert_equal "username", column.name
+        assert_equal :integer, column.type
+      end
+
+      def test_create_table_with_custom_primary_key_type
+        connection.ddl_batch do
+          connection.create_table :testings, force: true, id: false do |t|
+            t.primary_key :user_id, :integer
+            t.string :name
+          end
+        end
+
+        assert_equal "user_id", connection.primary_key(:testings)
+
+        column = connection.columns(:testings).find { |c| c.name == "user_id" }
+
+        assert_equal "user_id", column.name
+        assert_equal :integer, column.type
+      end
+
+      def test_create_table_with_not_null_column
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :string, null: false
+          end
+        end
+
+        assert_raises ActiveRecord::StatementInvalid do
+          connection.transaction {
+            connection.execute "insert into testings (id, foo) values (#{generate_id}, NULL)"
+          }
+        end
+      end
+
+      def test_create_table_with_limits
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :string, limit: 255
+            t.column :default_int, :integer
+          end
+        end
+
+        columns = connection.columns :testings
+        foo = columns.detect { |c| c.name == "foo" }
+        assert_equal "STRING(255)", foo.sql_type
+        assert_equal 255, foo.limit
+
+        default_int = columns.detect { |c| c.name == "default_int" }
+        assert_equal "INT64", default_int.sql_type
+      end
+
+      def test_create_table_with_primary_key_prefix_as_table_name_with_underscore
+        ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
+
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :string
+          end
+        end
+
+        assert_equal "testing_id", connection.primary_key(:testings)
+
+        columns = connection.columns(:testings)
+        assert_equal %w[testing_id foo].sort, columns.map(&:name).sort
+      end
+
+      def test_create_table_with_primary_key_prefix_as_table_name
+        ActiveRecord::Base.primary_key_prefix_type = :table_name
+
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :string
+          end
+        end
+
+        assert_equal "testingid", connection.primary_key(:testings)
+
+        columns = connection.columns(:testings)
+        assert_equal %w[testingid foo].sort, columns.map(&:name).sort
+      end
+
+      def test_create_table_raises_when_redefining_primary_key_column
+        error = assert_raise ArgumentError do
+          connection.ddl_batch do
+            connection.create_table :testings do |t|
+              t.column :id, :string
+            end
+          end
+        end
+
+        assert_equal "you can't redefine the primary key column 'id'. To define a custom primary key, pass { id: false } to create_table.", error.message
+      end
+
+      def test_create_table_raises_when_redefining_custom_primary_key_column
+        error = assert_raise ArgumentError do
+          connection.ddl_batch do
+            connection.create_table :testings, primary_key: :testing_id do |t|
+              t.column :testing_id, :string
+            end
+          end
+        end
+
+        assert_equal "you can't redefine the primary key column 'testing_id'. To define a custom primary key, pass { id: false } to create_table.", error.message
+      end
+
+      def test_create_table_raises_when_defining_existing_column
+        error = assert_raise ArgumentError do
+          connection.ddl_batch do
+            connection.create_table :testings do |t|
+              t.column :testing_column, :string
+              t.column :testing_column, :integer
+            end
+          end
+        end
+
+        assert_equal "you can't define an already defined column 'testing_column'.", error.message
+      end
+
+      def test_create_table_with_timestamps_should_create_datetime_columns
+        connection.ddl_batch do
+          connection.create_table table_name do |t|
+            t.timestamps
+          end
+        end
+        created_columns = connection.columns table_name
+
+        created_at_column = created_columns.detect { |c| c.name == "created_at" }
+        updated_at_column = created_columns.detect { |c| c.name == "updated_at" }
+
+        assert_not created_at_column.null
+        assert_not updated_at_column.null
+      end
+
+      def test_create_table_with_timestamps_should_create_datetime_columns_with_options
+        connection.ddl_batch do
+          connection.create_table table_name do |t|
+            t.timestamps null: true
+          end
+        end
+        created_columns = connection.columns table_name
+
+        created_at_column = created_columns.detect { |c| c.name == "created_at" }
+        updated_at_column = created_columns.detect { |c| c.name == "updated_at" }
+
+        assert created_at_column.null
+        assert updated_at_column.null
+      end
+
+      def test_create_table_without_a_block
+        connection.create_table table_name
+      end
+
+      def test_add_column_not_null_without_default
+        skip "Unimplemented error: Cannot add NOT NULL column to existing table"
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :string
+          end
+          connection.add_column :testings, :bar, :string, null: false
+        end
+
+        assert_raise ActiveRecord::NotNullViolation do
+          connection.transaction {
+            connection.execute "insert into testings (id, foo, bar) values (#{generate_id}, 'hello', NULL)"
+          }
+        end
+      end
+
+      def test_add_column_with_timestamp_type
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :timestamp
+          end
+        end
+
+        column = connection.columns(:testings).find { |c| c.name == "foo" }
+
+        assert_equal :time, column.type
+        assert_equal "TIMESTAMP", column.sql_type
+      end
+
+      def test_change_column_quotes_column_names
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :select, :string
+          end
+        end
+        # These two changes cannot be in one batch, as the change_column operation will check whether the column
+        # actually exists before executing any DDL statements.
+        connection.ddl_batch do
+          connection.change_column :testings, :select, :string, limit: 10
+        end
+
+        connection.transaction {
+          connection.execute "insert into testings (#{connection.quote_column_name 'id'},"\
+            "#{connection.quote_column_name 'select'}) values (#{generate_id}, '7 chars')"
+        }
+      end
+
+      def test_keeping_notnull_constraints_on_change
+        person_klass = Class.new ActiveRecord::Base
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :title, :string
+          end
+          person_klass.table_name = "testings"
+          person_klass.connection.add_column "testings", "wealth", :integer, null: false
+        end
+
+        person_klass.reset_column_information
+        assert_equal false, person_klass.columns_hash["wealth"].null
+
+        assert_nothing_raised {
+          person_klass.connection.transaction {
+            person_klass.connection.execute("insert into testings (id, title, wealth) values (#{generate_id}, 'tester', 100000)")
+          }
+        }
+
+        # change column, make it nullable
+        connection.ddl_batch do
+          person_klass.connection.change_column "testings", "wealth", :integer, null: true
+        end
+        person_klass.reset_column_information
+        assert_nil person_klass.columns_hash["wealth"].default
+        assert_equal true, person_klass.columns_hash["wealth"].null
+      end
+
+      def test_change_column_null
+        testing_table_with_only_foo_attribute do
+          notnull_migration = Class.new(ActiveRecord::Migration::Current) do
+            def change
+              change_column_null :testings, :foo, false
+            end
+          end
+          notnull_migration.new.suppress_messages do
+            notnull_migration.migrate(:up)
+            assert_equal false, connection.columns(:testings).find { |c| c.name == "foo" }.null
+            notnull_migration.migrate(:down)
+            assert connection.columns(:testings).find { |c| c.name == "foo" }.null
+          end
+        end
+      end
+
+      def test_column_exists
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :string
+          end
+        end
+
+        assert connection.column_exists?(:testings, :foo)
+        assert_not connection.column_exists?(:testings, :bar)
+      end
+
+      def test_column_exists_with_type
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :string
+            t.column :bar, :float
+          end
+        end
+
+        assert connection.column_exists?(:testings, :foo, :string)
+        assert_not connection.column_exists?(:testings, :foo, :integer)
+
+        assert connection.column_exists?(:testings, :bar, :float)
+        assert_not connection.column_exists?(:testings, :bar, :integer)
+      end
+
+      def test_column_exists_with_definition
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :string, limit: 100
+            t.column :bar, :float
+            t.column :taggable_id, :integer, null: false
+            t.column :taggable_type, :string
+          end
+        end
+
+        assert connection.column_exists?(:testings, :foo, :string, limit: 100)
+        assert_not connection.column_exists?(:testings, :foo, :string, limit: nil)
+        assert connection.column_exists?(:testings, :bar, :float)
+        assert connection.column_exists?(:testings, :taggable_id, :integer, null: false)
+        assert_not connection.column_exists?(:testings, :taggable_id, :integer, null: true)
+        assert connection.column_exists?(:testings, :taggable_type, :string, default: nil)
+      end
+
+      def test_column_exists_on_table_with_no_options_parameter_supplied
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.string :foo
+          end
+        end
+        connection.change_table :testings do |t|
+          assert t.column_exists?(:foo)
+          assert_not (t.column_exists?(:bar))
+        end
+      end
+
+      def test_drop_table_if_exists
+        connection.ddl_batch do
+          connection.create_table(:testings)
+        end
+        assert connection.table_exists?(:testings)
+        connection.ddl_batch do
+          connection.drop_table(:testings, if_exists: true)
+        end
+        assert_not connection.table_exists?(:testings)
+      end
+
+      def test_drop_table_if_exists_nothing_raised
+        assert_nothing_raised { connection.drop_table(:nonexistent, if_exists: true) }
+      end
+
+      def test_drop_and_create_table_with_indexes
+        connection.ddl_batch do
+          connection.create_table :testings, force: true do |t|
+            t.string :name, index: true
+          end
+        end
+
+        assert_nothing_raised {
+          connection.create_table :testings, force: true do |t|
+            t.string :name, index: true
+          end
+        }
+
+        assert_equal true, connection.table_exists?(:testings)
+        assert_equal true, connection.index_exists?(:testings, :name)
+      end
+
+      private
+
+      def testing_table_with_only_foo_attribute
+        connection.ddl_batch do
+          connection.create_table :testings do |t|
+            t.column :foo, :string
+          end
+        end
+
+        yield
+      end
+    end
+  end
+end