activerecord-import 0.19.0 → 1.0.0

data/test/support/postgresql/import_examples.rb

@@ -24,6 +24,36 @@ def should_support_postgresql_import_functionality
       end
     end
 
+    context "setting attributes and marking clean" do
+      let(:topic) { Build(:topics) }
+
+      setup { Topic.import([topic]) }
+
+      it "assigns ids" do
+        assert topic.id.present?
+      end
+
+      it "marks models as clean" do
+        assert !topic.changed?
+      end
+
+      if ENV['AR_VERSION'].to_f > 4.1
+        it "moves the dirty changes to previous_changes" do
+          assert topic.previous_changes.present?
+        end
+      end
+
+      it "marks models as persisted" do
+        assert !topic.new_record?
+        assert topic.persisted?
+      end
+
+      it "assigns timestamps" do
+        assert topic.created_at.present?
+        assert topic.updated_at.present?
+      end
+    end
+
     describe "with query cache enabled" do
       setup do
         unless ActiveRecord::Base.connection.query_cache_enabled
@@ -61,6 +91,76 @@ def should_support_postgresql_import_functionality
         assert_equal [], Book.import(books, no_returning: true).ids
       end
     end
+
+    describe "returning" do
+      let(:books) { [Book.new(author_name: "King", title: "It")] }
+      let(:result) { Book.import(books, returning: %w(author_name title)) }
+      let(:book_id) do
+        if RUBY_PLATFORM == 'java' || ENV['AR_VERSION'].to_i >= 5.0
+          books.first.id
+        else
+          books.first.id.to_s
+        end
+      end
+
+      it "creates records" do
+        assert_difference("Book.count", +1) { result }
+      end
+
+      it "returns ids" do
+        result
+        assert_equal [book_id], result.ids
+      end
+
+      it "returns specified columns" do
+        assert_equal [%w(King It)], result.results
+      end
+
+      context "when primary key and returning overlap" do
+        let(:result) { Book.import(books, returning: %w(id title)) }
+
+        setup { result }
+
+        it "returns ids" do
+          assert_equal [book_id], result.ids
+        end
+
+        it "returns specified columns" do
+          assert_equal [[book_id, 'It']], result.results
+        end
+      end
+
+      context "setting model attributes" do
+        let(:code) { 'abc' }
+        let(:discount) { 0.10 }
+        let(:original_promotion) do
+          Promotion.new(code: code, discount: discount)
+        end
+        let(:updated_promotion) do
+          Promotion.new(code: code, description: 'ABC discount')
+        end
+        let(:returning_columns) { %w(discount) }
+
+        setup do
+          Promotion.import([original_promotion])
+          Promotion.import([updated_promotion],
+            on_duplicate_key_update: { conflict_target: %i(code), columns: %i(description) },
+            returning: returning_columns)
+        end
+
+        it "sets model attributes" do
+          assert_equal updated_promotion.discount, discount
+        end
+
+        context "returning multiple columns" do
+          let(:returning_columns) { %w(discount description) }
+
+          it "sets model attributes" do
+            assert_equal updated_promotion.discount, discount
+          end
+        end
+      end
+    end
   end
 
   if ENV['AR_VERSION'].to_f >= 4.0
@@ -135,6 +235,17 @@ def should_support_postgresql_import_functionality
       end
     end
   end
+
+  describe "with binary field" do
+    let(:binary_value) { "\xE0'c\xB2\xB0\xB3Bh\\\xC2M\xB1m\\I\xC4r".force_encoding('ASCII-8BIT') }
+    it "imports the correct values for binary fields" do
+      alarms = [Alarm.new(device_id: 1, alarm_type: 1, status: 1, secret_key: binary_value)]
+      assert_difference "Alarm.count", +1 do
+        Alarm.import alarms
+      end
+      assert_equal(binary_value, Alarm.first.secret_key)
+    end
+  end
 end
 
 def should_support_postgresql_upsert_functionality
@@ -190,6 +301,30 @@ def should_support_postgresql_upsert_functionality
       end
 
       context "using a hash" do
+        context "with :columns :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: { conflict_target: :id, columns: :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 "should update 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
+
         context "with :columns a hash" do
           let(:columns) { %w( id title author_name author_email_address parent_id ) }
           let(:values) { [[99, "Book", "John Doe", "john@doe.com", 17]] }
@@ -204,6 +339,13 @@ def should_support_postgresql_upsert_functionality
             @topic = Topic.find 99
           end
 
+          it "should not modify the passed in :on_duplicate_key_update columns array" do
+            assert_nothing_raised do
+              columns = %w(title author_name).freeze
+              Topic.import columns, [%w(foo, bar)], { on_duplicate_key_update: { columns: columns }.freeze }.freeze
+            end
+          end
+
           context "using string hash map" do
             let(:update_columns) { { "title" => "title", "author_email_address" => "author_email_address", "parent_id" => "parent_id" } }
             should_support_on_duplicate_key_update

data/test/support/shared_examples/on_duplicate_key_update.rb

@@ -5,9 +5,240 @@ 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
+        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 +246,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

data/test/support/shared_examples/recursive_import.rb

@@ -11,7 +11,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
@@ -90,6 +90,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
@@ -102,6 +115,31 @@ def should_support_recursive_import
       end
     end
 
+    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
+    end
+
     unless ENV["SKIP_COMPOSITE_PK"]
       describe "with composite primary keys" do
         it "should import models and set id" do
@@ -119,22 +157,14 @@ 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
     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
-      end
     end
 
     # If adapter supports on_duplicate_key_update, it is only applied to top level models so that SQL with invalid