activerecord-import 0.14.1 → 1.4.1

data/test/support/shared_examples/on_duplicate_key_ignore.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+def should_support_on_duplicate_key_ignore
+  describe "#import" do
+    extend ActiveSupport::TestCase::ImportAssertions
+    let(:topic) { Topic.create!(title: "Book", author_name: "John Doe") }
+    let(:topics) { [topic] }
+
+    context "with :on_duplicate_key_ignore" do
+      it "should skip duplicates and continue import" do
+        topics << Topic.new(title: "Book 2", author_name: "Jane Doe")
+        assert_difference "Topic.count", +1 do
+          result = Topic.import topics, on_duplicate_key_ignore: true, validate: false
+          assert_not_equal topics.first.id, result.ids.first
+          assert_nil topics.last.id
+        end
+      end
+
+      unless ENV["SKIP_COMPOSITE_PK"]
+        context "with composite primary keys" do
+          it "should import array of values successfully" do
+            columns = [:tag_id, :publisher_id, :tag]
+            values = [[1, 1, 'Mystery'], [1, 1, 'Science']]
+
+            assert_difference "Tag.count", +1 do
+              Tag.import columns, values, on_duplicate_key_ignore: true, validate: false
+            end
+            assert_equal 'Mystery', Tag.first.tag
+          end
+        end
+      end
+    end
+
+    context "with :ignore" do
+      it "should skip duplicates and continue import" do
+        topics << Topic.new(title: "Book 2", author_name: "Jane Doe")
+        assert_difference "Topic.count", +1 do
+          result = Topic.import topics, ignore: true, validate: false
+          assert_not_equal topics.first.id, result.ids.first
+          assert_nil topics.last.id
+        end
+      end
+    end
+  end
+end

data/test/support/shared_examples/on_duplicate_key_update.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 def should_support_basic_on_duplicate_key_update
   describe "#import" do
     extend ActiveSupport::TestCase::ImportAssertions
@@ -5,9 +7,250 @@ def should_support_basic_on_duplicate_key_update
     macro(:perform_import) { raise "supply your own #perform_import in a context below" }
     macro(:updated_topic) { Topic.find(@topic.id) }
 
+    context "with lock_version upsert" do
+      describe 'optimistic lock' do
+        it 'lock_version upsert after on_duplcate_key_update by model' do
+          users = [
+            User.new(name: 'Salomon'),
+            User.new(name: 'Nathan')
+          ]
+          User.import(users)
+          assert User.count == users.length
+          User.all.each do |user|
+            assert_equal 0, user.lock_version
+          end
+          updated_users = User.all.map do |user|
+            user.name += ' Rothschild'
+            user
+          end
+          User.import(updated_users, on_duplicate_key_update: [:name])
+          assert User.count == updated_users.length
+          User.all.each_with_index do |user, i|
+            assert_equal user.name, users[i].name + ' Rothschild'
+            assert_equal 1, user.lock_version
+          end
+        end
+
+        it 'lock_version upsert after on_duplcate_key_update by array' do
+          users = [
+            User.new(name: 'Salomon'),
+            User.new(name: 'Nathan')
+          ]
+          User.import(users)
+          assert User.count == users.length
+          User.all.each do |user|
+            assert_equal 0, user.lock_version
+          end
+
+          columns = [:id, :name]
+          updated_values = User.all.map do |user|
+            user.name += ' Rothschild'
+            [user.id, user.name]
+          end
+          User.import(columns, updated_values, on_duplicate_key_update: [:name])
+          assert User.count == updated_values.length
+          User.all.each_with_index do |user, i|
+            assert_equal user.name, users[i].name + ' Rothschild'
+            assert_equal 1, user.lock_version
+          end
+        end
+
+        it 'lock_version upsert after on_duplcate_key_update by hash' do
+          users = [
+            User.new(name: 'Salomon'),
+            User.new(name: 'Nathan')
+          ]
+          User.import(users)
+          assert User.count == users.length
+          User.all.each do |user|
+            assert_equal 0, user.lock_version
+          end
+          updated_values = User.all.map do |user|
+            user.name += ' Rothschild'
+            { id: user.id, name: user.name }
+          end
+          User.import(updated_values, on_duplicate_key_update: [:name])
+          assert User.count == updated_values.length
+          User.all.each_with_index do |user, i|
+            assert_equal user.name, users[i].name + ' Rothschild'
+            assert_equal 1, user.lock_version
+          end
+          updated_values2 = User.all.map do |user|
+            user.name += ' jr.'
+            { id: user.id, name: user.name }
+          end
+          User.import(updated_values2, on_duplicate_key_update: [:name])
+          assert User.count == updated_values2.length
+          User.all.each_with_index do |user, i|
+            assert_equal user.name, users[i].name + ' Rothschild jr.'
+            assert_equal 2, user.lock_version
+          end
+        end
+
+        it 'upsert optimistic lock columns other than lock_version by model' do
+          accounts = [
+            Account.new(name: 'Salomon'),
+            Account.new(name: 'Nathan')
+          ]
+          Account.import(accounts)
+          assert Account.count == accounts.length
+          Account.all.each do |user|
+            assert_equal 0, user.lock
+          end
+          updated_accounts = Account.all.map do |user|
+            user.name += ' Rothschild'
+            user
+          end
+          Account.import(updated_accounts, on_duplicate_key_update: [:id, :name])
+          assert Account.count == updated_accounts.length
+          Account.all.each_with_index do |user, i|
+            assert_equal user.name, accounts[i].name + ' Rothschild'
+            assert_equal 1, user.lock
+          end
+        end
+
+        it 'upsert optimistic lock columns other than lock_version by array' do
+          accounts = [
+            Account.new(name: 'Salomon'),
+            Account.new(name: 'Nathan')
+          ]
+          Account.import(accounts)
+          assert Account.count == accounts.length
+          Account.all.each do |user|
+            assert_equal 0, user.lock
+          end
+
+          columns = [:id, :name]
+          updated_values = Account.all.map do |user|
+            user.name += ' Rothschild'
+            [user.id, user.name]
+          end
+          Account.import(columns, updated_values, on_duplicate_key_update: [:name])
+          assert Account.count == updated_values.length
+          Account.all.each_with_index do |user, i|
+            assert_equal user.name, accounts[i].name + ' Rothschild'
+            assert_equal 1, user.lock
+          end
+        end
+
+        it 'upsert optimistic lock columns other than lock_version by hash' do
+          accounts = [
+            Account.new(name: 'Salomon'),
+            Account.new(name: 'Nathan')
+          ]
+          Account.import(accounts)
+          assert Account.count == accounts.length
+          Account.all.each do |user|
+            assert_equal 0, user.lock
+          end
+          updated_values = Account.all.map do |user|
+            user.name += ' Rothschild'
+            { id: user.id, name: user.name }
+          end
+          Account.import(updated_values, on_duplicate_key_update: [:name])
+          assert Account.count == updated_values.length
+          Account.all.each_with_index do |user, i|
+            assert_equal user.name, accounts[i].name + ' Rothschild'
+            assert_equal 1, user.lock
+          end
+        end
+
+        it 'update the lock_version of models separated by namespaces by model' do
+          makers = [
+            Bike::Maker.new(name: 'Yamaha'),
+            Bike::Maker.new(name: 'Honda')
+          ]
+          Bike::Maker.import(makers)
+          assert Bike::Maker.count == makers.length
+          Bike::Maker.all.each do |maker|
+            assert_equal 0, maker.lock_version
+          end
+          updated_makers = Bike::Maker.all.map do |maker|
+            maker.name += ' bikes'
+            maker
+          end
+          Bike::Maker.import(updated_makers, on_duplicate_key_update: [:name])
+          assert Bike::Maker.count == updated_makers.length
+          Bike::Maker.all.each_with_index do |maker, i|
+            assert_equal maker.name, makers[i].name + ' bikes'
+            assert_equal 1, maker.lock_version
+          end
+        end
+        it 'update the lock_version of models separated by namespaces by array' do
+          makers = [
+            Bike::Maker.new(name: 'Yamaha'),
+            Bike::Maker.new(name: 'Honda')
+          ]
+          Bike::Maker.import(makers)
+          assert Bike::Maker.count == makers.length
+          Bike::Maker.all.each do |maker|
+            assert_equal 0, maker.lock_version
+          end
+
+          columns = [:id, :name]
+          updated_values = Bike::Maker.all.map do |maker|
+            maker.name += ' bikes'
+            [maker.id, maker.name]
+          end
+          Bike::Maker.import(columns, updated_values, on_duplicate_key_update: [:name])
+          assert Bike::Maker.count == updated_values.length
+          Bike::Maker.all.each_with_index do |maker, i|
+            assert_equal maker.name, makers[i].name + ' bikes'
+            assert_equal 1, maker.lock_version
+          end
+        end
+
+        it 'update the lock_version of models separated by namespaces by hash' do
+          makers = [
+            Bike::Maker.new(name: 'Yamaha'),
+            Bike::Maker.new(name: 'Honda')
+          ]
+          Bike::Maker.import(makers)
+          assert Bike::Maker.count == makers.length
+          Bike::Maker.all.each do |maker|
+            assert_equal 0, maker.lock_version
+          end
+          updated_values = Bike::Maker.all.map do |maker|
+            maker.name += ' bikes'
+            { id: maker.id, name: maker.name }
+          end
+          Bike::Maker.import(updated_values, on_duplicate_key_update: [:name])
+          assert Bike::Maker.count == updated_values.length
+          Bike::Maker.all.each_with_index do |maker, i|
+            assert_equal maker.name, makers[i].name + ' bikes'
+            assert_equal 1, maker.lock_version
+          end
+        end
+      end
+    end
+
     context "with :on_duplicate_key_update" do
+      describe 'using :all' do
+        let(:columns) { %w( id title author_name author_email_address parent_id ) }
+        let(:updated_values) { [[99, "Book - 2nd Edition", "Jane Doe", "janedoe@example.com", 57]] }
+
+        macro(:perform_import) do |*opts|
+          Topic.import columns, updated_values, opts.extract_options!.merge(on_duplicate_key_update: :all, validate: false)
+        end
+
+        setup do
+          values = [[99, "Book", "John Doe", "john@doe.com", 17, 3]]
+          Topic.import columns + ['replies_count'], values, validate: false
+        end
+
+        it 'updates all specified columns' do
+          perform_import
+          updated_topic = Topic.find(99)
+          assert_equal 'Book - 2nd Edition', updated_topic.title
+          assert_equal 'Jane Doe', updated_topic.author_name
+          assert_equal 'janedoe@example.com', updated_topic.author_email_address
+          assert_equal 57, updated_topic.parent_id
+          assert_equal 3, updated_topic.replies_count
+        end
+      end
+
       describe "argument safety" do
-        it "should not modify the passed in :on_duplicate_key_update columns array" do
+        it "should not modify the passed in :on_duplicate_key_update array" do
           assert_nothing_raised do
             columns = %w(title author_name).freeze
             Topic.import columns, [%w(foo, bar)], on_duplicate_key_update: columns
@@ -15,6 +258,26 @@ def should_support_basic_on_duplicate_key_update
         end
       end
 
+      context "with timestamps enabled" do
+        let(:time) { Chronic.parse("5 minutes from now") }
+
+        it 'should not overwrite changed updated_at with current timestamp' do
+          topic = Topic.create(author_name: "Jane Doe", title: "Book")
+          timestamp = Time.now.utc
+          topic.updated_at = timestamp
+          Topic.import [topic], on_duplicate_key_update: :all, validate: false
+          assert_equal timestamp.to_s, Topic.last.updated_at.to_s
+        end
+
+        it 'should update updated_at with current timestamp' do
+          topic = Topic.create(author_name: "Jane Doe", title: "Book")
+          Timecop.freeze(time) do
+            Topic.import [topic], on_duplicate_key_update: [:updated_at], validate: false
+            assert_in_delta time.to_i, topic.reload.updated_at.to_i, 1.second
+          end
+        end
+      end
+
       context "with validation checks turned off" do
         asssertion_group(:should_support_on_duplicate_key_update) do
           should_not_update_fields_not_mentioned
@@ -76,6 +339,20 @@ def should_support_basic_on_duplicate_key_update
           assert_equal 'DISCOUNT2', updated_promotion.code
         end
       end
+
+      unless ENV["SKIP_COMPOSITE_PK"]
+        context "with composite primary keys" do
+          it "should import array of values successfully" do
+            columns = [:tag_id, :publisher_id, :tag]
+            Tag.import columns, [[1, 1, 'Mystery']], validate: false
+
+            assert_difference "Tag.count", +0 do
+              Tag.import columns, [[1, 1, 'Science']], on_duplicate_key_update: [:tag], validate: false
+            end
+            assert_equal 'Science', Tag.first.tag
+          end
+        end
+      end
     end
 
     context "with :on_duplicate_key_update turned off" do

data/test/support/shared_examples/recursive_import.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 def should_support_recursive_import
   describe "importing objects with associations" do
     let(:new_topics) { Build(num_topics, :topic_with_book) }
@@ -11,7 +13,7 @@ def should_support_recursive_import
     let(:num_chapters) { 18 }
     let(:num_endnotes) { 24 }
 
-    let(:new_question_with_rule) { FactoryGirl.build :question, :with_rule }
+    let(:new_question_with_rule) { FactoryBot.build :question, :with_rule }
 
     it 'imports top level' do
       assert_difference "Topic.count", +num_topics do
@@ -48,6 +50,22 @@ def should_support_recursive_import
       end
     end
 
+    it 'imports polymorphic associations from subclass' do
+      discounts = Array.new(1) { |i| Discount.new(amount: i) }
+      dictionaries = Array.new(1) { |i| Dictionary.new(author_name: "Author ##{i}", title: "Book ##{i}") }
+      dictionaries.each do |dictionary|
+        dictionary.discounts << discounts
+      end
+      Dictionary.import dictionaries, recursive: true
+      assert_equal 1, Dictionary.last.discounts.count
+      dictionaries.each do |dictionary|
+        dictionary.discounts.each do |discount|
+          assert_not_nil discount.discountable_id
+          assert_equal 'Book', discount.discountable_type
+        end
+      end
+    end
+
     [{ recursive: false }, {}].each do |import_options|
       it "skips recursion for #{import_options}" do
         assert_difference "Book.count", 0 do
@@ -74,6 +92,19 @@ def should_support_recursive_import
       end
     end
 
+    # Models are only valid if all associations are valid
+    it "only imports models with valid associations" do
+      assert_difference "Topic.count", 2 do
+        assert_difference "Book.count", 4 do
+          assert_difference "Chapter.count", 12 do
+            assert_difference "EndNote.count", 16 do
+              Topic.import new_topics_with_invalid_chapter, recursive: true
+            end
+          end
+        end
+      end
+    end
+
     it "skips validation of the associations if requested" do
       assert_difference "Chapter.count", +num_chapters do
         Topic.import new_topics_with_invalid_chapter, validate: false, recursive: true
@@ -86,32 +117,126 @@ def should_support_recursive_import
       end
     end
 
-    # These models dont validate associated.  So we expect that books and topics get inserted, but not chapters
-    # Putting a transaction around everything wouldn't work, so if you want your chapters to prevent topics from
-    # being created, you would need to have validates_associated in your models and insert with validation
+    it "imports an imported belongs_to association id" do
+      first_new_topic = new_topics[0]
+      second_new_topic = new_topics[1]
+
+      books = first_new_topic.books.to_a
+      Topic.import new_topics, validate: false
+
+      assert_difference "Book.count", books.size do
+        Book.import books, validate: false
+      end
+
+      books.each do |book|
+        assert_equal book.topic_id, first_new_topic.id
+      end
+
+      books.each { |book| book.topic_id = second_new_topic.id }
+      assert_no_difference "Book.count", books.size do
+        Book.import books, validate: false, on_duplicate_key_update: [:topic_id]
+      end
+
+      books.each do |book|
+        assert_equal book.topic_id, second_new_topic.id
+      end
+
+      books.each { |book| book.topic_id = nil }
+      assert_no_difference "Book.count", books.size do
+        Book.import books, validate: false, on_duplicate_key_update: [:topic_id]
+      end
+
+      books.each do |book|
+        assert_equal book.topic_id, nil
+      end
+    end
+
+    unless ENV["SKIP_COMPOSITE_PK"]
+      describe "with composite primary keys" do
+        it "should import models and set id" do
+          tags = []
+          tags << Tag.new(tag_id: 1, publisher_id: 1, tag: 'Mystery')
+          tags << Tag.new(tag_id: 2, publisher_id: 1, tag: 'Science')
+
+          assert_difference "Tag.count", +2 do
+            Tag.import tags
+          end
+
+          assert_equal 1, tags[0].tag_id
+          assert_equal 2, tags[1].tag_id
+        end
+      end
+    end
+
     describe "all_or_none" do
-      [Book, Topic, EndNote].each do |type|
+      [Book, Chapter, Topic, EndNote].each do |type|
         it "creates #{type}" do
-          assert_difference "#{type}.count", send("num_#{type.to_s.downcase}s") do
+          assert_difference "#{type}.count", 0 do
             Topic.import new_topics_with_invalid_chapter, all_or_none: true, recursive: true
           end
         end
       end
-      it "doesn't create chapters" do
-        assert_difference "Chapter.count", 0 do
-          Topic.import new_topics_with_invalid_chapter, all_or_none: true, recursive: true
+    end
+
+    # If adapter supports on_duplicate_key_update and specific columns are specified, it is only applied to top level models so that SQL with invalid
+    # columns, keys, etc isn't generated for child associations when doing recursive import
+    if ActiveRecord::Base.connection.supports_on_duplicate_key_update?
+      describe "on_duplicate_key_update" do
+        let(:new_topics) { Build(1, :topic_with_book) }
+
+        it "imports objects with associations" do
+          assert_difference "Topic.count", +1 do
+            Topic.import new_topics, recursive: true, on_duplicate_key_update: [:updated_at], validate: false
+            new_topics.each do |topic|
+              assert_not_nil topic.id
+            end
+          end
+        end
+
+        context "when :all fields are updated" do
+          setup do
+            Topic.import new_topics, recursive: true
+          end
+
+          it "updates associated objects" do
+            new_author_name = 'Richard Bachman'
+            topic = new_topics.first
+            topic.books.each do |book|
+              book.author_name = new_author_name
+            end
+            assert_nothing_raised do
+              Topic.import new_topics, recursive: true, on_duplicate_key_update: :all
+            end
+            Topic.find(topic.id).books.each do |book|
+              assert_equal new_author_name, book.author_name
+            end
+          end
         end
       end
     end
 
-    # If adapter supports on_duplicate_key_update, it is only applied to top level models so that SQL with invalid
+    # If returning option is provided, it is only applied to top level models so that SQL with invalid
     # columns, keys, etc isn't generated for child associations when doing recursive import
-    describe "on_duplicate_key_update" do
+    describe "returning" do
       let(:new_topics) { Build(1, :topic_with_book) }
 
       it "imports objects with associations" do
         assert_difference "Topic.count", +1 do
-          Topic.import new_topics, recursive: true, on_duplicate_key_update: [:updated_at], validate: false
+          Topic.import new_topics, recursive: true, returning: [:content], validate: false
+          new_topics.each do |topic|
+            assert_not_nil topic.id
+          end
+        end
+      end
+    end
+
+    # If no returning option is provided, it is ignored
+    describe "no returning" do
+      let(:new_topics) { Build(1, :topic_with_book) }
+
+      it "is ignored and imports objects with associations" do
+        assert_difference "Topic.count", +1 do
+          Topic.import new_topics, recursive: true, no_returning: true, validate: false
           new_topics.each do |topic|
             assert_not_nil topic.id
           end