activerecord-import 0.19.1 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2ccaefe9611ff80d350abf4beca0e741a23c0167
-  data.tar.gz: 374da8395b259808c29d102df17bde738046d428
+  metadata.gz: b4613a9ba2a76e71320a6e8107b9b557f2413212
+  data.tar.gz: 2fb7c7b7a5f801cd591e5cea93b088f0f6d52499
 SHA512:
-  metadata.gz: 527652ab74bcf4a44014ba016b846f403e0d94a1b57450d36ea35a65702fcd15a9c273ab82de42278c0fc1c7dd84baee16425d0afab17d425ba36cebbb500d56
-  data.tar.gz: 82f9e31dfe9c002eddedb59e34b4a6f3d3763504f5932d8fbd15a8c39630ae385a5fdbe6006d5aaef5841a6d158eedc19f8158b090f9e1fd7fd43ef219d6aa8d
+  metadata.gz: 72af6c0e217ef61e3bb87b1d078193d979f7d42e34dc5c721d5a26e72c50f1ce2b5a4a68808a2e4514b4a48135017c96cfef29e0dff4283fbc801d87b5039e18
+  data.tar.gz: 8b22f10f28ac4e0d7f7d66c4422abb6c4d7ff616a108ad5192cd4ba257e464c15b0dcb1f802c97a4f27bce1e6b57edaa48903d9ccfe68e75cd6c89ec0fa1229e

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## Changes in 0.20.0
+
+### New Features
+
+* Allow returning columns to be specified for PostgreSQL. Thanks to
+  @tjwp via \#433.
+
+### Fixes
+
+* Fixes an issue when bypassing uniqueness validators. Thanks to @vmaxv via \#444.
+* For AR < 4.2, prevent type casting for binary columns on Postgresql. Thanks to @mwalsher via \#446.
+* Fix issue logging class name on import. Thanks to @sophylee, @jkowens via \#447.
+* Copy belongs_to association id to foreign key column before importing. Thanks to @jkowens via \#448.
+* Reset model instance on validate. Thanks to @vmaxv via \#449.
+
 ## Changes in 0.19.1
 
 ### Fixes

data/Gemfile

@@ -3,7 +3,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :development, :test do
-  gem 'rubocop', '~> 0.38.0'
+  gem 'rubocop', '~> 0.40.0'
   gem 'rake'
 end
 

data/benchmarks/lib/cli_parser.rb

@@ -42,7 +42,8 @@ module BenchmarkOptionParser
       table_types: {},
       delete_on_finish: true,
       number_of_objects: [],
-      outputs: [] )
+      outputs: []
+    )
 
     opt_parser = OptionParser.new do |opts|
       opts.banner = BANNER

data/lib/activerecord-import/adapters/abstract_adapter.rb

@@ -16,7 +16,7 @@ module ActiveRecord::Import::AbstractAdapter
       sql2insert = base_sql + values.join( ',' ) + post_sql
       insert( sql2insert, *args )
 
-      [number_of_inserts, []]
+      ActiveRecord::Import::Result.new([], number_of_inserts, [], [])
     end
 
     def pre_sql_statements(options)

data/lib/activerecord-import/adapters/mysql_adapter.rb

@@ -49,7 +49,7 @@ module ActiveRecord::Import::MysqlAdapter
       end
     end
 
-    [number_of_inserts, []]
+    ActiveRecord::Import::Result.new([], number_of_inserts, [], [])
   end
 
   # Returns the maximum number of bytes that the server will allow

data/lib/activerecord-import/adapters/postgresql_adapter.rb

@@ -5,9 +5,10 @@ module ActiveRecord::Import::PostgreSQLAdapter
   MIN_VERSION_FOR_UPSERT = 90_500
 
   def insert_many( sql, values, options = {}, *args ) # :nodoc:
-    primary_key = options[:primary_key]
     number_of_inserts = 1
+    returned_values = []
     ids = []
+    results = []
 
     base_sql, post_sql = if sql.is_a?( String )
       [sql, '']
@@ -17,11 +18,12 @@ module ActiveRecord::Import::PostgreSQLAdapter
 
     sql2insert = base_sql + values.join( ',' ) + post_sql
 
-    if primary_key.blank? || options[:no_returning]
+    columns = returning_columns(options)
+    if columns.blank? || options[:no_returning]
       insert( sql2insert, *args )
     else
-      ids = if primary_key.is_a?( Array )
-        # Select composite primary keys
+      returned_values = if columns.size > 1
+        # Select composite columns
         select_rows( sql2insert, *args )
       else
         select_values( sql2insert, *args )
@@ -29,7 +31,34 @@ module ActiveRecord::Import::PostgreSQLAdapter
       query_cache.clear if query_cache_enabled
     end
 
-    [number_of_inserts, ids]
+    if options[:returning].blank?
+      ids = returned_values
+    elsif options[:primary_key].blank?
+      results = returned_values
+    else
+      # split primary key and returning columns
+      ids, results = split_ids_and_results(returned_values, columns, options)
+    end
+
+    ActiveRecord::Import::Result.new([], number_of_inserts, ids, results)
+  end
+
+  def split_ids_and_results(values, columns, options)
+    ids = []
+    results = []
+    id_indexes = Array(options[:primary_key]).map { |key| columns.index(key) }
+    returning_indexes = Array(options[:returning]).map { |key| columns.index(key) }
+
+    values.each do |value|
+      value_array = Array(value)
+      ids << id_indexes.map { |i| value_array[i] }
+      results << returning_indexes.map { |i| value_array[i] }
+    end
+
+    ids.map!(&:first) if id_indexes.size == 1
+    results.map!(&:first) if returning_indexes.size == 1
+
+    [ids, results]
   end
 
   def next_value_for_sequence(sequence_name)
@@ -50,14 +79,21 @@ module ActiveRecord::Import::PostgreSQLAdapter
 
     sql += super(table_name, options)
 
-    unless options[:primary_key].blank? || options[:no_returning]
-      primary_key = Array(options[:primary_key])
-      sql << " RETURNING \"#{primary_key.join('", "')}\""
+    columns = returning_columns(options)
+    unless columns.blank? || options[:no_returning]
+      sql << " RETURNING \"#{columns.join('", "')}\""
     end
 
     sql
   end
 
+  def returning_columns(options)
+    columns = []
+    columns += Array(options[:primary_key]) if options[:primary_key].present?
+    columns |= Array(options[:returning]) if options[:returning].present?
+    columns
+  end
+
   # Add a column to be updated on duplicate key update
   def add_column_for_on_duplicate_key_update( column, options = {} ) # :nodoc:
     arg = options[:on_duplicate_key_update]

data/lib/activerecord-import/adapters/sqlite3_adapter.rb

@@ -37,7 +37,7 @@ module ActiveRecord::Import::SQLite3Adapter
       end
     end
 
-    [number_of_inserts, []]
+    ActiveRecord::Import::Result.new([], number_of_inserts, [], [])
   end
 
   def pre_sql_statements( options)

data/lib/activerecord-import/import.rb

@@ -3,7 +3,7 @@ require "ostruct"
 module ActiveRecord::Import::ConnectionAdapters; end
 
 module ActiveRecord::Import #:nodoc:
-  Result = Struct.new(:failed_instances, :num_inserts, :ids)
+  Result = Struct.new(:failed_instances, :num_inserts, :ids, :results)
 
   module ImportSupport #:nodoc:
     def supports_import? #:nodoc:
@@ -38,7 +38,7 @@ module ActiveRecord::Import #:nodoc:
         model.errors.clear
 
         validate_callbacks = model._validate_callbacks.dup
-        validate_callbacks.each do |callback|
+        model._validate_callbacks.each do |callback|
           validate_callbacks.delete(callback) if callback.raw_filter.is_a? ActiveRecord::Validations::UniquenessValidator
         end
 
@@ -214,18 +214,18 @@ class ActiveRecord::Base
     #
     # == Options
     # * +validate+ - true|false, tells import whether or not to use
-    #    ActiveRecord validations. Validations are enforced by default.
+    #   ActiveRecord validations. Validations are enforced by default.
     # * +ignore+ - true|false, an alias for on_duplicate_key_ignore.
     # * +on_duplicate_key_ignore+ - true|false, tells import to discard
-    #    records that contain duplicate keys. For Postgres 9.5+ it adds
-    #    ON CONFLICT DO NOTHING, for MySQL it uses INSERT IGNORE, and for
-    #    SQLite it uses INSERT OR IGNORE. Cannot be enabled on a
-    #    recursive import. For database adapters that normally support
-    #    setting primary keys on imported objects, this option prevents
-    #    that from occurring.
+    #   records that contain duplicate keys. For Postgres 9.5+ it adds
+    #   ON CONFLICT DO NOTHING, for MySQL it uses INSERT IGNORE, and for
+    #   SQLite it uses INSERT OR IGNORE. Cannot be enabled on a
+    #   recursive import. For database adapters that normally support
+    #   setting primary keys on imported objects, this option prevents
+    #   that from occurring.
     # * +on_duplicate_key_update+ - an Array or Hash, tells import to
-    #    use MySQL's ON DUPLICATE KEY UPDATE or Postgres 9.5+ ON CONFLICT
-    #    DO UPDATE ability. See On Duplicate Key Update below.
+    #   use MySQL's ON DUPLICATE KEY UPDATE or Postgres 9.5+ ON CONFLICT
+    #   DO UPDATE ability. See On Duplicate Key Update below.
     # * +synchronize+ - an array of ActiveRecord instances for the model
     #   that you are currently importing data into. This synchronizes
     #   existing model instances in memory with updates from the import.
@@ -323,7 +323,7 @@ class ActiveRecord::Base
     # conflicting constraint to be explicitly specified. Using this option
     # allows you to specify a constraint other than the primary key.
     #
-    # ====== :conflict_target
+    # ===== :conflict_target
     #
     # The :conflict_target attribute specifies the columns that make up the
     # conflicting unique constraint and can be a single column or an array of
@@ -333,7 +333,7 @@ class ActiveRecord::Base
     #
     #   BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: [ :author_id, :slug ], columns: [ :date_modified ] }
     #
-    # ====== :index_predicate
+    # ===== :index_predicate
     #
     # The :index_predicate attribute optionally specifies a WHERE condition
     # on :conflict_target, which is required for matching against partial
@@ -342,7 +342,7 @@ class ActiveRecord::Base
     #
     #   BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: [ :author_id, :slug ], index_predicate: 'status <> 0', columns: [ :date_modified ] }
     #
-    # ====== :constraint_name
+    # ===== :constraint_name
     #
     # The :constraint_name attribute explicitly identifies the conflicting
     # unique index by name. Postgres documentation discourages using this method
@@ -350,7 +350,7 @@ class ActiveRecord::Base
     #
     #   BlogPost.import columns, values, on_duplicate_key_update: { constraint_name: :blog_posts_pkey, columns: [ :date_modified ] }
     #
-    # ====== :condition
+    # ===== :condition
     #
     # The :condition attribute optionally specifies a WHERE condition
     # on :conflict_action. Only rows for which this expression returns true will be updated.
@@ -358,12 +358,12 @@ class ActiveRecord::Base
     # Below is an example:
     #
     #   BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: [ :author_id ], condition: "blog_posts.title NOT LIKE '%sample%'", columns: [ :author_name ] }
-
-    # ====== :columns
+    #
+    # ===== :columns
     #
     # The :columns attribute can be either an Array or a Hash.
     #
-    # ======== Using an Array
+    # ===== Using an Array
     #
     # The :columns attribute can be an array of column names. The column names
     # are the only fields that are updated if a duplicate record is found.
@@ -371,7 +371,7 @@ class ActiveRecord::Base
     #
     #   BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: :slug, columns: [ :date_modified, :content, :author ] }
     #
-    # ========  Using a Hash
+    # =====  Using a Hash
     #
     # The :columns option can be a hash of column names to model attribute name
     # mappings. This gives you finer grained control over what fields are updated
@@ -384,6 +384,7 @@ class ActiveRecord::Base
     # * failed_instances - an array of objects that fails validation and were not committed to the database. An empty array if no validation is performed.
     # * num_inserts - the number of insert statements it took to import the data
     # * ids - the primary keys of the imported ids if the adapter supports it, otherwise an empty array.
+    # * results - import results if the adapter supports it, otherwise an empty array.
     def import(*args)
       if args.first.is_a?( Array ) && args.first.first.is_a?(ActiveRecord::Base)
         options = {}
@@ -445,6 +446,10 @@ class ActiveRecord::Base
         end
 
         array_of_attributes = models.map do |model|
+          if support_setting_primary_key_of_imported_objects?
+            load_association_ids(model)
+          end
+
           column_names.map do |name|
             if stored_attrs.key?(name.to_sym) ||
                serialized_attrs.key?(name) ||
@@ -525,8 +530,7 @@ class ActiveRecord::Base
           import_with_validations( column_names, array_of_attributes, options )
         end
       else
-        (num_inserts, ids) = import_without_validations_or_callbacks( column_names, array_of_attributes, options )
-        ActiveRecord::Import::Result.new([], num_inserts, ids)
+        import_without_validations_or_callbacks( column_names, array_of_attributes, options )
       end
 
       if options[:synchronize]
@@ -537,7 +541,7 @@ class ActiveRecord::Base
 
       # if we have ids, then set the id on the models and mark the models as clean.
       if models && support_setting_primary_key_of_imported_objects?
-        set_attributes_and_mark_clean(models, return_obj, timestamps)
+        set_attributes_and_mark_clean(models, return_obj, timestamps, options)
 
         # if there are auto-save associations on the models we imported that are new, import them as well
         import_associations(models, options.dup) if options[:recursive]
@@ -566,8 +570,8 @@ class ActiveRecord::Base
 
         # keep track of the instance and the position it is currently at. if this fails
         # validation we'll use the index to remove it from the array_of_attributes
-        model = new
         arr.each_with_index do |hsh, i|
+          model = new
           hsh.each_pair { |k, v| model[k] = v }
           next if validator.valid_model? model
           raise(ActiveRecord::RecordInvalid, model) if options[:raise_error]
@@ -580,12 +584,12 @@ class ActiveRecord::Base
 
       array_of_attributes.compact!
 
-      num_inserts, ids = if array_of_attributes.empty? || options[:all_or_none] && failed_instances.any?
-        [0, []]
+      result = if array_of_attributes.empty? || options[:all_or_none] && failed_instances.any?
+        ActiveRecord::Import::Result.new([], 0, [], [])
       else
         import_without_validations_or_callbacks( column_names, array_of_attributes, options )
       end
-      ActiveRecord::Import::Result.new(failed_instances, num_inserts, ids)
+      ActiveRecord::Import::Result.new(failed_instances, result.num_inserts, result.ids, result.results)
     end
 
     # Imports the passed in +column_names+ and +array_of_attributes+
@@ -627,6 +631,7 @@ class ActiveRecord::Base
 
       number_inserted = 0
       ids = []
+      results = []
       if supports_import?
         # generate the sql
         post_sql_statements = connection.post_sql_statements( quoted_table_name, options )
@@ -637,9 +642,10 @@ class ActiveRecord::Base
           result = connection.insert_many( [insert_sql, post_sql_statements].flatten,
             batch_values,
             options,
-            "#{self.class.name} Create Many Without Validations Or Callbacks" )
-          number_inserted += result[0]
-          ids += result[1]
+            "#{model_name} Create Many Without Validations Or Callbacks" )
+          number_inserted += result.num_inserts
+          ids += result.ids
+          results += result.results
         end
       else
         transaction(requires_new: true) do
@@ -649,12 +655,12 @@ class ActiveRecord::Base
           end
         end
       end
-      [number_inserted, ids]
+      ActiveRecord::Import::Result.new([], number_inserted, ids, results)
     end
 
     private
 
-    def set_attributes_and_mark_clean(models, import_result, timestamps)
+    def set_attributes_and_mark_clean(models, import_result, timestamps, options)
       return if models.nil?
       models -= import_result.failed_instances
 
@@ -670,6 +676,22 @@ class ActiveRecord::Base
         end
       end
 
+      if models.size == import_result.results.size
+        columns = Array(options[:returning])
+        single_column = "#{columns.first}=" if columns.size == 1
+        import_result.results.each_with_index do |result, index|
+          model = models[index]
+
+          if single_column
+            model.send(single_column, result)
+          else
+            columns.each_with_index do |column, col_index|
+              model.send("#{column}=", result[col_index])
+            end
+          end
+        end
+      end
+
       models.each do |model|
         if model.respond_to?(:clear_changes_information) # Rails 4.0 and higher
           model.clear_changes_information
@@ -680,6 +702,18 @@ class ActiveRecord::Base
       end
     end
 
+    # Sync belongs_to association ids with foreign key field
+    def load_association_ids(model)
+      association_reflections = model.class.reflect_on_all_associations(:belongs_to)
+      association_reflections.each do |association_reflection|
+        association = model.association(association_reflection.name)
+        association = association.target
+        if association && association.id
+          model.public_send("#{association_reflection.foreign_key}=", association.id)
+        end
+      end
+    end
+
     def import_associations(models, options)
       # now, for all the dirty associations, collect them into a new set of models, then recurse.
       # notes:
@@ -754,7 +788,9 @@ class ActiveRecord::Base
               if serialized_attributes.include?(column.name)
                 val = serialized_attributes[column.name].dump(val)
               end
-              connection_memo.quote(column.type_cast(val), column)
+              # Fixes #443 to support binary (i.e. bytea) columns on PG
+              val = column.type_cast(val) unless column.type.to_sym == :binary
+              connection_memo.quote(val, column)
             end
           end
         end

data/lib/activerecord-import/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Import
-    VERSION = "0.19.1".freeze
+    VERSION = "0.20.0".freeze
   end
 end

data/test/import_test.rb

@@ -121,12 +121,12 @@ describe "#import" do
   end
 
   context "with :validation option" do
-    let(:columns) { %w(title author_name) }
-    let(:valid_values) { [["LDAP", "Jerry Carter"], ["Rails Recipes", "Chad Fowler"]] }
-    let(:valid_values_with_context) { [[1111, "Jerry Carter"], [2222, "Chad Fowler"]] }
-    let(:invalid_values) { [["The RSpec Book", ""], ["Agile+UX", ""]] }
-    let(:valid_models) { valid_values.map { |title, author_name| Topic.new(title: title, author_name: author_name) } }
-    let(:invalid_models) { invalid_values.map { |title, author_name| Topic.new(title: title, author_name: author_name) } }
+    let(:columns) { %w(title author_name content) }
+    let(:valid_values) { [["LDAP", "Jerry Carter", "Putting Directories to Work."], ["Rails Recipes", "Chad Fowler", "A trusted collection of solutions."]] }
+    let(:valid_values_with_context) { [[1111, "Jerry Carter", "1111"], [2222, "Chad Fowler", "2222"]] }
+    let(:invalid_values) { [["The RSpec Book", "David Chelimsky", "..."], ["Agile+UX", "", "All about Agile in UX."]] }
+    let(:valid_models) { valid_values.map { |title, author_name, content| Topic.new(title: title, author_name: author_name, content: content) } }
+    let(:invalid_models) { invalid_values.map { |title, author_name, content| Topic.new(title: title, author_name: author_name, content: content) } }
 
     context "with validation checks turned off" do
       it "should import valid data" do

data/test/models/topic.rb

@@ -2,6 +2,8 @@ class Topic < ActiveRecord::Base
   validates_presence_of :author_name
   validates :title, numericality: { only_integer: true }, on: :context_test
   validates :title, uniqueness: true
+  validates :content, uniqueness: true
+  validates :word_count, numericality: { greater_than: 0 }, if: :content?
 
   validate -> { errors.add(:title, :validate_failed) if title == 'validate_failed' }
   before_validation -> { errors.add(:title, :invalid) if title == 'invalid' }
@@ -10,4 +12,10 @@ class Topic < ActiveRecord::Base
   belongs_to :parent, class_name: "Topic"
 
   composed_of :description, mapping: [%w(title title), %w(author_name author_name)], allow_nil: true, class_name: "TopicDescription"
+
+  private
+
+  def word_count
+    @word_count ||= content.to_s.scan(/\w+/).count
+  end
 end

data/test/schema/postgresql_schema.rb

@@ -36,6 +36,7 @@ ActiveRecord::Schema.define do
     t.column :alarm_type, :integer, null: false
     t.column :status, :integer, null: false
     t.column :metadata, :text
+    t.column :secret_key, :binary
     t.datetime :created_at
     t.datetime :updated_at
   end

data/test/support/factories.rb

@@ -15,6 +15,7 @@ FactoryGirl.define do
   factory :topic do
     sequence(:title) { |n| "Title #{n}" }
     sequence(:author_name) { |n| "Author #{n}" }
+    sequence(:content) { |n| "Content #{n}" }
   end
 
   factory :widget do

data/test/support/mysql/import_examples.rb

@@ -64,8 +64,8 @@ def should_support_mysql_import_functionality
       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", content: "Putting Directories to Work.")
+        topics << Topic.create!(title: "Rails Recipes", author_name: "Elmo", content: "A trusted collection of solutions.")
       end
 
       it "synchronizes passed in ActiveRecord model instances with the data just imported" do

data/test/support/postgresql/import_examples.rb

@@ -85,6 +85,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
@@ -159,6 +229,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

data/test/support/shared_examples/recursive_import.rb

@@ -102,6 +102,19 @@ def should_support_recursive_import
       end
     end
 
+    it "imports an imported belongs_to association id" do
+      books = new_topics[0].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_not_nil book.topic_id
+      end
+    end
+
     unless ENV["SKIP_COMPOSITE_PK"]
       describe "with composite primary keys" do
         it "should import models and set id" do

data/test/value_sets_bytes_parser_test.rb

@@ -63,7 +63,8 @@ describe ActiveRecord::Import::ValueSetsBytesParser do
       values = [
         "('1','2','3')",
         "('4','5','6')",
-        "('7','8','9')"]
+        "('7','8','9')"
+      ]
 
       base_sql_size_in_bytes = 15
       max_bytes = 30
@@ -88,7 +89,8 @@ describe ActiveRecord::Import::ValueSetsBytesParser do
         # each accented e should be 2 bytes, so each entry is 6 bytes instead of 5
         values = [
           "('é')",
-          "('é')"]
+          "('é')"
+        ]
 
         base_sql_size_in_bytes = 15
         max_bytes = 26

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-import
 version: !ruby/object:Gem::Version
-  version: 0.19.1
+  version: 0.20.0
 platform: ruby
 authors:
 - Zach Dennis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-20 00:00:00.000000000 Z
+date: 2017-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord