activerecord-import 2.2.0 → 2.3.0

data/test/support/shared_examples/recursive_import.rb

@@ -1,352 +0,0 @@
-# frozen_string_literal: true
-
-def should_support_recursive_import
-  describe "importing objects with associations" do
-    let(:new_topics) { Build(num_topics, :topic_with_book) }
-    let(:new_topics_with_invalid_chapter) do
-      chapter = new_topics.first.books.first.chapters.first
-      chapter.title = nil
-      new_topics
-    end
-    let(:num_topics) { 3 }
-    let(:num_books) { 6 }
-    let(:num_chapters) { 18 }
-    let(:num_endnotes) { 24 }
-
-    let(:new_question_with_rule) { FactoryBot.build :question, :with_rule }
-
-    it 'imports top level' do
-      assert_difference "Topic.count", +num_topics do
-        Topic.import new_topics, recursive: true
-        new_topics.each do |topic|
-          assert_not_nil topic.id
-        end
-      end
-    end
-
-    it 'imports first level associations' do
-      assert_difference "Book.count", +num_books do
-        Topic.import new_topics, recursive: true
-        new_topics.each do |topic|
-          topic.books.each do |book|
-            assert_equal topic.id, book.topic_id
-          end
-        end
-      end
-    end
-
-    it 'imports polymorphic associations' do
-      discounts = Array.new(1) { |i| Discount.new(amount: i) }
-      books = Array.new(1) { |i| Book.new(author_name: "Author ##{i}", title: "Book ##{i}") }
-      books.each do |book|
-        book.discounts << discounts
-      end
-      Book.import books, recursive: true
-      books.each do |book|
-        book.discounts.each do |discount|
-          assert_not_nil discount.discountable_id
-          assert_equal 'Book', discount.discountable_type
-        end
-      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
-          Topic.import new_topics, import_options
-        end
-      end
-    end
-
-    it 'imports deeper nested associations' do
-      assert_difference "Chapter.count", +num_chapters do
-        assert_difference "EndNote.count", +num_endnotes do
-          Topic.import new_topics, recursive: true
-          new_topics.each do |topic|
-            topic.books.each do |book|
-              book.chapters.each do |chapter|
-                assert_equal book.id, chapter.book_id
-              end
-              book.end_notes.each do |endnote|
-                assert_equal book.id, endnote.book_id
-              end
-            end
-          end
-        end
-      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
-      end
-    end
-
-    it 'imports has_one associations' do
-      assert_difference 'Rule.count' do
-        Question.import [new_question_with_rule], recursive: true
-      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
-
-      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_nil 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
-
-        if ENV['AR_VERSION'].to_f >= 7.1
-          it "should import models with auto-incrementing ID successfully with recursive set to true" do
-            author = Author.create!(name: "Foo Barson")
-            books = []
-            2.times do |i|
-              books << CompositeBook.new(author_id: author.id, title: "Book #{i}", composite_chapters: [
-                                           CompositeChapter.new(title: "Book #{i} composite chapter 1"),
-                                           CompositeChapter.new(title: "Book #{i} composite chapter 2"),
-                                         ])
-            end
-            assert_difference "CompositeBook.count", +2 do
-              assert_difference "CompositeChapter.count", +4 do
-                CompositeBook.import books, recursive: true
-              end
-            end
-          end
-        end
-      end
-    end
-
-    describe "all_or_none" do
-      [Book, Chapter, Topic, EndNote].each do |type|
-        it "creates #{type}" do
-          assert_difference "#{type}.count", 0 do
-            Topic.import new_topics_with_invalid_chapter, all_or_none: true, recursive: true
-          end
-        end
-      end
-    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
-
-      describe "recursive_on_duplicate_key_update" do
-        let(:new_topics) { Build(1, :topic_with_book) }
-
-        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: [:id],
-              recursive_on_duplicate_key_update: {
-                books: { conflict_target: [:id], columns: [:author_name] }
-              }
-          end
-          Topic.find(topic.id).books.each do |book|
-            assert_equal new_author_name, book.author_name
-          end
-        end
-
-        it "updates nested associated objects" do
-          new_chapter_title = 'The Final Chapter'
-          book = new_topics.first.books.first
-          book.author_name = 'Richard Bachman'
-
-          example_chapter = book.chapters.first
-          example_chapter.title = new_chapter_title
-
-          assert_nothing_raised do
-            Topic.import new_topics,
-              recursive: true,
-              on_duplicate_key_update: [:id],
-              recursive_on_duplicate_key_update: {
-                books: { conflict_target: [:id], columns: [:author_name] },
-                chapters: { conflict_target: [:id], columns: [:title] }
-              }
-          end
-          assert_equal new_chapter_title, Chapter.find(example_chapter.id).title
-        end
-
-        context "when a non-standard association name is used" do
-          let(:new_topics) do
-            topic = Build(:topic)
-
-            2.times do
-              novel = topic.novels.build(title: FactoryBot.generate(:book_title), author_name: 'Stephen King')
-              3.times do
-                novel.chapters.build(title: FactoryBot.generate(:chapter_title))
-              end
-
-              4.times do
-                novel.end_notes.build(note: FactoryBot.generate(:end_note))
-              end
-            end
-
-            [topic]
-          end
-
-          it "updates nested associated objects" do
-            new_chapter_title = 'The Final Chapter'
-            novel = new_topics.first.novels.first
-            novel.author_name = 'Richard Bachman'
-
-            example_chapter = novel.chapters.first
-            example_chapter.title = new_chapter_title
-
-            assert_nothing_raised do
-              Topic.import new_topics,
-                recursive: true,
-                on_duplicate_key_update: [:id],
-                recursive_on_duplicate_key_update: {
-                  novels: { conflict_target: [:id], columns: [:author_name] },
-                  chapters: { conflict_target: [:id], columns: [:title] }
-                }
-            end
-            assert_equal new_chapter_title, Chapter.find(example_chapter.id).title
-          end
-        end
-      end
-    end
-
-    # 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 "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, 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
-        end
-      end
-    end
-  end
-end

data/test/support/sqlite3/import_examples.rb

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-
-def should_support_sqlite3_import_functionality
-  if ActiveRecord::Base.connection.supports_on_duplicate_key_update?
-    should_support_sqlite_upsert_functionality
-  end
-
-  describe "#supports_imports?" do
-    it "should support import" do
-      assert ActiveRecord::Base.supports_import?
-    end
-  end
-
-  describe "#import" do
-    it "imports with a single insert on SQLite 3.7.11 or higher" do
-      assert_difference "Topic.count", +507 do
-        result = Topic.import Build(7, :topics)
-        assert_equal 1, result.num_inserts, "Failed to issue a single INSERT statement. Make sure you have a supported version of SQLite3 (3.7.11 or higher) installed"
-        assert_equal 7, Topic.count, "Failed to insert all records. Make sure you have a supported version of SQLite3 (3.7.11 or higher) installed"
-
-        result = Topic.import Build(500, :topics)
-        assert_equal 1, result.num_inserts, "Failed to issue a single INSERT statement. Make sure you have a supported version of SQLite3 (3.7.11 or higher) installed"
-        assert_equal 507, Topic.count, "Failed to insert all records. Make sure you have a supported version of SQLite3 (3.7.11 or higher) installed"
-      end
-    end
-
-    it "imports with a two inserts on SQLite 3.7.11 or higher" do
-      assert_difference "Topic.count", +501 do
-        result = Topic.import Build(501, :topics)
-        assert_equal 2, result.num_inserts, "Failed to issue a two INSERT statements. Make sure you have a supported version of SQLite3 (3.7.11 or higher) installed"
-        assert_equal 501, Topic.count, "Failed to insert all records. Make sure you have a supported version of SQLite3 (3.7.11 or higher) installed"
-      end
-    end
-
-    it "imports with a five inserts on SQLite 3.7.11 or higher" do
-      assert_difference "Topic.count", +2500 do
-        result = Topic.import Build(2500, :topics)
-        assert_equal 5, result.num_inserts, "Failed to issue a two INSERT statements. Make sure you have a supported version of SQLite3 (3.7.11 or higher) installed"
-        assert_equal 2500, Topic.count, "Failed to insert all records. Make sure you have a supported version of SQLite3 (3.7.11 or higher) installed"
-      end
-    end
-  end
-end
-
-def should_support_sqlite_upsert_functionality
-  should_support_basic_on_duplicate_key_update
-  should_support_on_duplicate_key_ignore
-
-  describe "#import" do
-    extend ActiveSupport::TestCase::ImportAssertions
-
-    macro(:perform_import) { raise "supply your own #perform_import in a context below" }
-    macro(:updated_topic) { Topic.find(@topic.id) }
-
-    context "with :on_duplicate_key_ignore and validation checks turned off" do
-      let(:columns) { %w( id title author_name author_email_address parent_id ) }
-      let(:values) { [[99, "Book", "John Doe", "john@doe.com", 17]] }
-      let(:updated_values) { [[99, "Book - 2nd Edition", "Author Should Not Change", "johndoe@example.com", 57]] }
-
-      setup do
-        Topic.import columns, values, validate: false
-      end
-
-      it "should not update any records" do
-        result = Topic.import columns, updated_values, on_duplicate_key_ignore: true, validate: false
-        assert_equal [], result.ids
-      end
-    end
-
-    context "with :on_duplicate_key_update and validation checks turned off" do
-      asssertion_group(:should_support_on_duplicate_key_update) do
-        should_not_update_fields_not_mentioned
-        should_update_foreign_keys
-        should_not_update_created_at_on_timestamp_columns
-        should_update_updated_at_on_timestamp_columns
-      end
-
-      context "using a hash" do
-        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]] }
-          let(:updated_values) { [[99, "Book - 2nd Edition", "Author Should Not Change", "johndoe@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: update_columns }, validate: false)
-          end
-
-          setup do
-            Topic.import columns, values, validate: false
-            @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 }
-            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
-            should_update_fields_mentioned
-          end
-
-          context "using string hash map, but specifying column mismatches" do
-            let(:update_columns) { { "title" => "author_email_address", "author_email_address" => "title", "parent_id" => "parent_id" } }
-            should_support_on_duplicate_key_update
-            should_update_fields_mentioned_with_hash_mappings
-          end
-
-          context "using symbol hash map" do
-            let(:update_columns) { { title: :title, author_email_address: :author_email_address, parent_id: :parent_id } }
-            should_support_on_duplicate_key_update
-            should_update_fields_mentioned
-          end
-
-          context "using symbol hash map, but specifying column mismatches" do
-            let(:update_columns) { { title: :author_email_address, author_email_address: :title, parent_id: :parent_id } }
-            should_support_on_duplicate_key_update
-            should_update_fields_mentioned_with_hash_mappings
-          end
-        end
-
-        context 'with :index_predicate' do
-          let(:columns) { %w( id device_id alarm_type status metadata ) }
-          let(:values) { [[99, 17, 1, 1, 'foo']] }
-          let(:updated_values) { [[99, 17, 1, 2, 'bar']] }
-
-          macro(:perform_import) do |*opts|
-            Alarm.import columns, updated_values, opts.extract_options!.merge(on_duplicate_key_update: { conflict_target: [:device_id, :alarm_type], index_predicate: 'status <> 0', columns: [:status] }, validate: false)
-          end
-
-          macro(:updated_alarm) { Alarm.find(@alarm.id) }
-
-          setup do
-            Alarm.import columns, values, validate: false
-            @alarm = Alarm.find 99
-          end
-
-          context 'supports on duplicate key update for partial indexes' do
-            it 'should not update created_at timestamp columns' do
-              Timecop.freeze Chronic.parse("5 minutes from now") do
-                perform_import
-                assert_in_delta @alarm.created_at.to_i, updated_alarm.created_at.to_i, 1
-              end
-            end
-
-            it 'should update updated_at timestamp columns' do
-              time = Chronic.parse("5 minutes from now")
-              Timecop.freeze time do
-                perform_import
-                assert_in_delta time.to_i, updated_alarm.updated_at.to_i, 1
-              end
-            end
-
-            it 'should not update fields not mentioned' do
-              perform_import
-              assert_equal 'foo', updated_alarm.metadata
-            end
-
-            it 'should update fields mentioned with hash mappings' do
-              perform_import
-              assert_equal 2, updated_alarm.status
-            end
-          end
-        end
-
-        context 'with :condition' do
-          let(:columns) { %w( id device_id alarm_type status metadata) }
-          let(:values) { [[99, 17, 1, 1, 'foo']] }
-          let(:updated_values) { [[99, 17, 1, 1, 'bar']] }
-
-          macro(:perform_import) do |*opts|
-            Alarm.import(
-              columns,
-              updated_values,
-              opts.extract_options!.merge(
-                on_duplicate_key_update: {
-                  conflict_target: [:id],
-                  condition: "alarms.metadata NOT LIKE '%foo%'",
-                  columns: [:metadata]
-                },
-                validate: false
-              )
-            )
-          end
-
-          macro(:updated_alarm) { Alarm.find(@alarm.id) }
-
-          setup do
-            Alarm.import columns, values, validate: false
-            @alarm = Alarm.find 99
-          end
-
-          it 'should not update fields not matched' do
-            perform_import
-            assert_equal 'foo', updated_alarm.metadata
-          end
-        end
-
-        context "with no :conflict_target" do
-          context "with no primary key" do
-            it "raises ArgumentError" do
-              error = assert_raises ArgumentError do
-                Rule.import Build(3, :rules), on_duplicate_key_update: [:condition_text], validate: false
-              end
-              assert_match(/Expected :conflict_target to be specified/, error.message)
-            end
-          end
-        end
-
-        context "with no :columns" do
-          let(:columns) { %w( id title author_name author_email_address ) }
-          let(:values) { [[100, "Book", "John Doe", "john@doe.com"]] }
-          let(:updated_values) { [[100, "Title Should Not Change", "Author Should Not Change", "john@nogo.com"]] }
-
-          macro(:perform_import) do |*opts|
-            Topic.import columns, updated_values, opts.extract_options!.merge(on_duplicate_key_update: { conflict_target: :id }, validate: false)
-          end
-
-          setup do
-            Topic.import columns, values, validate: false
-            @topic = Topic.find 100
-          end
-
-          should_update_updated_at_on_timestamp_columns
-        end
-      end
-    end
-  end
-end

data/test/synchronize_test.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('../test_helper', __FILE__)
-
-describe ".synchronize" do
-  let(:topics) { Generate(3, :topics) }
-  let(:titles) { %w(one two three) }
-
-  setup do
-    # update records outside of ActiveRecord knowing about it
-    Topic.connection.execute( "UPDATE #{Topic.table_name} SET title='#{titles[0]}_haha' WHERE id=#{topics[0].id}", "Updating record 1 without ActiveRecord" )
-    Topic.connection.execute( "UPDATE #{Topic.table_name} SET title='#{titles[1]}_haha' WHERE id=#{topics[1].id}", "Updating record 2 without ActiveRecord" )
-    Topic.connection.execute( "UPDATE #{Topic.table_name} SET title='#{titles[2]}_haha' WHERE id=#{topics[2].id}", "Updating record 3 without ActiveRecord" )
-  end
-
-  it "reloads data for the specified records" do
-    Topic.synchronize topics
-
-    actual_titles = topics.map(&:title)
-    assert_equal "#{titles[0]}_haha", actual_titles[0], "the first record was not correctly updated"
-    assert_equal "#{titles[1]}_haha", actual_titles[1], "the second record was not correctly updated"
-    assert_equal "#{titles[2]}_haha", actual_titles[2], "the third record was not correctly updated"
-  end
-
-  it "the synchronized records aren't dirty" do
-    # Update the in memory records so they're dirty
-    topics.each { |topic| topic.title = 'dirty title' }
-
-    Topic.synchronize topics
-
-    assert_equal false, topics[0].changed?, "the first record was dirty"
-    assert_equal false, topics[1].changed?, "the second record was dirty"
-    assert_equal false, topics[2].changed?, "the third record was dirty"
-  end
-
-  it "ignores default scope" do
-    # update records outside of ActiveRecord knowing about it
-    Topic.connection.execute( "UPDATE #{Topic.table_name} SET approved='0' WHERE id=#{topics[0].id}", "Updating record 1 without ActiveRecord" )
-
-    Topic.synchronize topics
-    assert_equal false, topics[0].approved
-  end
-end