activerecord-import 0.12.0 → 0.13.0

data/test/support/generate.rb

@@ -1,11 +1,11 @@
 class ActiveSupport::TestCase
-  def Build(*args)
+  def Build(*args) # rubocop:disable Style/MethodName
     n = args.shift if args.first.is_a?(Numeric)
     factory = args.shift
     factory_girl_args = args.shift || {}
 
     if n
-      Array.new.tap do |collection|
+      [].tap do |collection|
         n.times.each { collection << FactoryGirl.build(factory.to_s.singularize.to_sym, factory_girl_args) }
       end
     else
@@ -13,13 +13,13 @@ class ActiveSupport::TestCase
     end
   end
 
-  def Generate(*args)
+  def Generate(*args) # rubocop:disable Style/MethodName
     n = args.shift if args.first.is_a?(Numeric)
     factory = args.shift
     factory_girl_args = args.shift || {}
 
     if n
-      Array.new.tap do |collection|
+      [].tap do |collection|
         n.times.each { collection << FactoryGirl.create(factory.to_s.singularize.to_sym, factory_girl_args) }
       end
     else

data/test/support/mysql/import_examples.rb

@@ -16,68 +16,68 @@ def should_support_mysql_import_functionality
         should_update_updated_at_on_timestamp_columns
       end
 
-      macro(:perform_import){ raise "supply your own #perform_import in a context below" }
-      macro(:updated_topic){ Topic.find(@topic.id) }
+      macro(:perform_import) { raise "supply your own #perform_import in a context below" }
+      macro(:updated_topic) { Topic.find(@topic.id) }
 
-      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 ] ] }
+      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 => update_columns, :validate => false)
+        Topic.import columns, updated_values, opts.extract_options!.merge(on_duplicate_key_update: update_columns, validate: false)
       end
 
       setup do
-        Topic.import columns, values, :validate => false
+        Topic.import columns, values, validate: false
         @topic = Topic.find 99
       end
 
       context "using string hash map" do
-        let(:update_columns){ { "title" => "title", "author_email_address" => "author_email_address", "parent_id" => "parent_id" } }
+        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" } }
+        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 } }
+        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 } }
+        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 :synchronization option" do
-      let(:topics){ Array.new }
-      let(:values){ [ [topics.first.id, "Jerry Carter", "title1"], [topics.last.id, "Chad Fowler", "title2"] ]}
-      let(:columns){ %W(id author_name title) }
+      let(:topics) { [] }
+      let(:values) { [[topics.first.id, "Jerry Carter", "title1"], [topics.last.id, "Chad Fowler", "title2"]] }
+      let(:columns) { %w(id author_name title) }
 
       setup do
-        topics << Topic.create!(:title=>"LDAP", :author_name=>"Big Bird")
-        topics << Topic.create!(:title=>"Rails Recipes", :author_name=>"Elmo")
+        topics << Topic.create!(title: "LDAP", author_name: "Big Bird")
+        topics << Topic.create!(title: "Rails Recipes", author_name: "Elmo")
       end
 
       it "synchronizes passed in ActiveRecord model instances with the data just imported" do
-        columns2update = [ 'author_name' ]
+        columns2update = ['author_name']
 
         expected_count = Topic.count
         Topic.import( columns, values,
-          :validate=>false,
-          :on_duplicate_key_update=>columns2update,
-          :synchronize=>topics )
+          validate: false,
+          on_duplicate_key_update: columns2update,
+          synchronize: topics )
 
         assert_equal expected_count, Topic.count, "no new records should have been created!"
-        assert_equal "Jerry Carter",  topics.first.author_name, "wrong author!"
+        assert_equal "Jerry Carter", topics.first.author_name, "wrong author!"
         assert_equal "Chad Fowler", topics.last.author_name, "wrong author!"
       end
     end

data/test/support/postgresql/import_examples.rb

@@ -20,21 +20,21 @@ def should_support_postgresql_import_functionality
 
     describe "importing objects with associations" do
       let(:new_topics) { Build(num_topics, :topic_with_book) }
-      let(:new_topics_with_invalid_chapter) {
-         chapter = new_topics.first.books.first.chapters.first
-         chapter.title = nil
-         new_topics
-      }
-      let(:num_topics) {3}
-      let(:num_books) {6}
-      let(:num_chapters) {18}
-      let(:num_endnotes) {24}
+      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) { FactoryGirl.build :question, :with_rule }
 
       it 'imports top level' do
         assert_difference "Topic.count", +num_topics do
-          Topic.import new_topics, :recursive => true
+          Topic.import new_topics, recursive: true
           new_topics.each do |topic|
             assert_not_nil topic.id
           end
@@ -43,7 +43,7 @@ def should_support_postgresql_import_functionality
 
       it 'imports first level associations' do
         assert_difference "Book.count", +num_books do
-          Topic.import new_topics, :recursive => true
+          Topic.import new_topics, recursive: true
           new_topics.each do |topic|
             topic.books.each do |book|
               assert_equal topic.id, book.topic_id
@@ -52,8 +52,23 @@ def should_support_postgresql_import_functionality
         end
       end
 
-      [{:recursive => false}, {}].each do |import_options|
-        it "skips recursion for #{import_options.to_s}" do
+      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
+
+      [{ 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
@@ -63,7 +78,7 @@ def should_support_postgresql_import_functionality
       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
+            Topic.import new_topics, recursive: true
             new_topics.each do |topic|
               topic.books.each do |book|
                 book.chapters.each do |chapter|
@@ -80,7 +95,7 @@ def should_support_postgresql_import_functionality
 
       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
+          Topic.import new_topics_with_invalid_chapter, validate: false, recursive: true
         end
       end
 
@@ -95,15 +110,15 @@ def should_support_postgresql_import_functionality
       # 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|
-          it "creates #{type.to_s}" do
-            assert_difference "#{type.to_s}.count", send("num_#{type.to_s.downcase}s") do
-              Topic.import new_topics_with_invalid_chapter, :all_or_none => true, :recursive => true
+          it "creates #{type}" do
+            assert_difference "#{type}.count", send("num_#{type.to_s.downcase}s") 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
+            Topic.import new_topics_with_invalid_chapter, all_or_none: true, recursive: true
           end
         end
       end
@@ -141,35 +156,35 @@ def should_support_postgresql_upsert_functionality
   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) }
+    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 ] ] }
+      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_ignore => value, :validate => false)
+        Topic.import columns, updated_values, opts.extract_options!.merge(on_duplicate_key_ignore: value, validate: false)
       end
 
       setup do
-        Topic.import columns, values, :validate => false
+        Topic.import columns, values, validate: false
         @topic = Topic.find 99
       end
 
       context "using true" do
-        let(:value){ true }
+        let(:value) { true }
         should_not_update_updated_at_on_timestamp_columns
       end
 
       context "using hash with :conflict_target" do
-        let(:value){ { conflict_target: :id } }
+        let(:value) { { conflict_target: :id } }
         should_not_update_updated_at_on_timestamp_columns
       end
 
       context "using hash with :constraint_target" do
-        let(:value){ { constraint_name: :topics_pkey } }
+        let(:value) { { constraint_name: :topics_pkey } }
         should_not_update_updated_at_on_timestamp_columns
       end
     end
@@ -184,101 +199,114 @@ def should_support_postgresql_upsert_functionality
 
       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 ] ] }
+          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)
+            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.import columns, values, validate: false
             @topic = Topic.find 99
           end
 
           context "using string hash map" do
-            let(:update_columns){ { "title" => "title", "author_email_address" => "author_email_address", "parent_id" => "parent_id" } }
+            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" } }
+            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 } }
+            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 } }
+            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 :constraint_name" do
-          let(:columns){  %w( id title author_name author_email_address parent_id ) }
-          let(:values){ [ [ 100, "Book", "John Doe", "john@doe.com", 17 ] ] }
-          let(:updated_values){ [ [ 100, "Book - 2nd Edition", "Author Should Not Change", "johndoe@example.com", 57 ] ] }
+          let(:columns) { %w( id title author_name author_email_address parent_id ) }
+          let(:values) { [[100, "Book", "John Doe", "john@doe.com", 17]] }
+          let(:updated_values) { [[100, "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 => { :constraint_name => :topics_pkey, :columns => update_columns }, :validate => false)
+            Topic.import columns, updated_values, opts.extract_options!.merge(on_duplicate_key_update: { constraint_name: :topics_pkey, columns: update_columns }, validate: false)
           end
 
           setup do
-            Topic.import columns, values, :validate => false
+            Topic.import columns, values, validate: false
             @topic = Topic.find 100
           end
 
-          let(:update_columns){ [ :title, :author_email_address, :parent_id ] }
+          let(:update_columns) { [:title, :author_email_address, :parent_id] }
           should_support_on_duplicate_key_update
           should_update_fields_mentioned
         end
 
         context "with no :conflict_target or :constraint_name" do
-          let(:columns){  %w( id title author_name author_email_address parent_id ) }
-          let(:values){ [ [ 100, "Book", "John Doe", "john@doe.com", 17 ] ] }
-          let(:updated_values){ [ [ 100, "Book - 2nd Edition", "Author Should Not Change", "johndoe@example.com", 57 ] ] }
+          let(:columns) { %w( id title author_name author_email_address parent_id ) }
+          let(:values) { [[100, "Book", "John Doe", "john@doe.com", 17]] }
+          let(:updated_values) { [[100, "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 => { :columns => update_columns }, :validate => false)
+            Topic.import columns, updated_values, opts.extract_options!.merge(on_duplicate_key_update: { columns: update_columns }, validate: false)
           end
 
           setup do
-            Topic.import columns, values, :validate => false
+            Topic.import columns, values, validate: false
             @topic = Topic.find 100
           end
 
           context "default to the primary key" do
-            let(:update_columns){ [ :title, :author_email_address, :parent_id ] }
+            let(:update_columns) { [:title, :author_email_address, :parent_id] }
             should_support_on_duplicate_key_update
             should_update_fields_mentioned
           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" ] ] }
+          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)
+            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.import columns, values, validate: false
             @topic = Topic.find 100
           end
 
           should_update_updated_at_on_timestamp_columns
         end
       end
+
+      context "with recursive: true" 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
+      end
     end
   end
 end

data/test/support/shared_examples/on_duplicate_key_update.rb

@@ -2,8 +2,8 @@ def should_support_basic_on_duplicate_key_update
   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) }
+    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_update and validation checks turned off" do
       asssertion_group(:should_support_on_duplicate_key_update) do
@@ -13,51 +13,51 @@ def should_support_basic_on_duplicate_key_update
         should_update_updated_at_on_timestamp_columns
       end
 
-      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 ] ] }
+      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 => update_columns , :validate => false)
+        Topic.import columns, updated_values, opts.extract_options!.merge(on_duplicate_key_update: update_columns, validate: false)
       end
 
       setup do
-        Topic.import columns, values, :validate => false
+        Topic.import columns, values, validate: false
         @topic = Topic.find 99
       end
 
       context "using an empty array" do
-        let(:update_columns){ [] }
+        let(:update_columns) { [] }
         should_not_update_fields_not_mentioned
         should_update_updated_at_on_timestamp_columns
       end
 
       context "using string column names" do
-        let(:update_columns){ [ "title", "author_email_address", "parent_id" ] }
+        let(:update_columns) { %w(title author_email_address parent_id) }
         should_support_on_duplicate_key_update
         should_update_fields_mentioned
       end
 
       context "using symbol column names" do
-        let(:update_columns){ [ :title, :author_email_address, :parent_id ] }
+        let(:update_columns) { [:title, :author_email_address, :parent_id] }
         should_support_on_duplicate_key_update
         should_update_fields_mentioned
       end
     end
 
     context "with a table that has a non-standard primary key" do
-      let(:columns){ [ :promotion_id, :code ] }
-      let(:values){ [ [ 1, 'DISCOUNT1' ] ] }
-      let(:updated_values){ [ [ 1, 'DISCOUNT2'] ] }
-      let(:update_columns){ [ :code ] }
+      let(:columns) { [:promotion_id, :code] }
+      let(:values) { [[1, 'DISCOUNT1']] }
+      let(:updated_values) { [[1, 'DISCOUNT2']] }
+      let(:update_columns) { [:code] }
 
       macro(:perform_import) do |*opts|
-        Promotion.import columns, updated_values, opts.extract_options!.merge(:on_duplicate_key_update => update_columns, :validate => false)
+        Promotion.import columns, updated_values, opts.extract_options!.merge(on_duplicate_key_update: update_columns, validate: false)
       end
-      macro(:updated_promotion){ Promotion.find(@promotion.promotion_id) }
+      macro(:updated_promotion) { Promotion.find(@promotion.promotion_id) }
 
       setup do
-        Promotion.import columns, values, :validate => false
+        Promotion.import columns, values, validate: false
         @promotion = Promotion.find 1
       end
 
@@ -68,17 +68,17 @@ def should_support_basic_on_duplicate_key_update
     end
 
     context "with :on_duplicate_key_update turned off" do
-      let(:columns){  %w( id title author_name author_email_address parent_id ) }
-      let(:values){ [ [ 100, "Book", "John Doe", "john@doe.com", 17 ] ] }
-      let(:updated_values){ [ [ 100, "Book - 2nd Edition", "This should raise an exception", "john@nogo.com", 57 ] ] }
+      let(:columns) { %w( id title author_name author_email_address parent_id ) }
+      let(:values) { [[100, "Book", "John Doe", "john@doe.com", 17]] }
+      let(:updated_values) { [[100, "Book - 2nd Edition", "This should raise an exception", "john@nogo.com", 57]] }
 
       macro(:perform_import) do |*opts|
-        # `:on_duplicate_key_update => false` is the tested feature
-        Topic.import columns, updated_values, opts.extract_options!.merge(:on_duplicate_key_update => false, :validate => false)
+        # `on_duplicate_key_update: false` is the tested feature
+        Topic.import columns, updated_values, opts.extract_options!.merge(on_duplicate_key_update: false, validate: false)
       end
 
       setup do
-        Topic.import columns, values, :validate => false
+        Topic.import columns, values, validate: false
         @topic = Topic.find 100
       end