activerecord-import 0.10.0 → 1.0.8

data/test/sqlite3/import_test.rb

@@ -1,52 +1,4 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../support/sqlite3/import_examples')
 
-describe "#supports_imports?" do
-  context "and SQLite is 3.7.11 or higher" do
-    it "supports import" do
-      version = ActiveRecord::ConnectionAdapters::SQLite3Adapter::Version.new("3.7.11")
-      assert ActiveRecord::Base.supports_import?(version)
-
-      version = ActiveRecord::ConnectionAdapters::SQLite3Adapter::Version.new("3.7.12")
-      assert ActiveRecord::Base.supports_import?(version)
-    end
-  end
-
-  context "and SQLite less than 3.7.11" do
-    it "doesn't support import" do
-      version = ActiveRecord::ConnectionAdapters::SQLite3Adapter::Version.new("3.7.10")
-      assert !ActiveRecord::Base.supports_import?(version)
-    end
-  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
-
+should_support_sqlite3_import_functionality

data/test/support/active_support/test_case_extensions.rb

@@ -1,19 +1,29 @@
 class ActiveSupport::TestCase
   include ActiveRecord::TestFixtures
-  self.use_transactional_fixtures = true
-  
+
+  if ENV['AR_VERSION'].to_f >= 5.0
+    self.use_transactional_tests = true
+  else
+    self.use_transactional_fixtures = true
+  end
+
   class << self
+    def requires_active_record_version(version_string, &blk)
+      return unless Gem::Dependency.new('', version_string).match?('', ActiveRecord::VERSION::STRING)
+      instance_eval(&blk)
+    end
+
     def assertion(name, &block)
-      mc = class << self ; self ; end
+      mc = class << self; self; end
       mc.class_eval do
         define_method(name) do
           it(name, &block)
         end
       end
     end
-    
+
     def asssertion_group(name, &block)
-      mc = class << self ; self ; end
+      mc = class << self; self; end
       mc.class_eval do
         define_method(name, &block)
       end
@@ -24,8 +34,8 @@ class ActiveSupport::TestCase
         define_method(name, &block)
       end
     end
-    
-    def describe(description, toplevel=nil, &blk)
+
+    def describe(description, toplevel = nil, &blk)
       text = toplevel ? description : "#{name} #{description}"
       klass = Class.new(self)
 
@@ -42,10 +52,10 @@ class ActiveSupport::TestCase
         end
       end
 
-      klass.instance_eval &blk
+      klass.instance_eval(&blk)
     end
-    alias_method :context, :describe
-    
+    alias context describe
+
     def let(name, &blk)
       define_method(name) do
         instance_variable_name = "@__let_#{name}"
@@ -53,15 +63,13 @@ class ActiveSupport::TestCase
         instance_variable_set(instance_variable_name, instance_eval(&blk))
       end
     end
-    
+
     def it(description, &blk)
       define_method("test_#{name}_#{description}", &blk)
     end
   end
-  
 end
 
 def describe(description, &blk)
   ActiveSupport::TestCase.describe(description, true, &blk)
 end
-

data/test/support/{mysql/assertions.rb → assertions.rb}

@@ -1,5 +1,5 @@
 class ActiveSupport::TestCase
-  module MySQLAssertions
+  module ImportAssertions
     def self.extended(klass)
       klass.instance_eval do
         assertion(:should_not_update_created_at_on_timestamp_columns) do
@@ -19,9 +19,18 @@ class ActiveSupport::TestCase
           end
         end
 
+        assertion(:should_not_update_updated_at_on_timestamp_columns) do
+          time = Chronic.parse("5 minutes from now")
+          Timecop.freeze time do
+            perform_import
+            assert_in_delta @topic.updated_at.to_i, updated_topic.updated_at.to_i, 1
+            assert_in_delta @topic.updated_on.to_i, updated_topic.updated_on.to_i, 1
+          end
+        end
+
         assertion(:should_not_update_timestamps) do
           Timecop.freeze Chronic.parse("5 minutes from now") do
-            perform_import :timestamps => false
+            perform_import timestamps: false
             assert_in_delta @topic.created_at.to_i, updated_topic.created_at.to_i, 1
             assert_in_delta @topic.created_on.to_i, updated_topic.created_on.to_i, 1
             assert_in_delta @topic.updated_at.to_i, updated_topic.updated_at.to_i, 1
@@ -39,6 +48,15 @@ class ActiveSupport::TestCase
           assert_equal "johndoe@example.com", updated_topic.author_email_address
         end
 
+        assertion(:should_raise_update_fields_mentioned) do
+          assert_raise ActiveRecord::RecordNotUnique do
+            perform_import
+          end
+
+          assert_equal "Book", updated_topic.title
+          assert_equal "john@doe.com", updated_topic.author_email_address
+        end
+
         assertion(:should_update_fields_mentioned_with_hash_mappings) do
           perform_import
           assert_equal "johndoe@example.com", updated_topic.title

data/test/support/factories.rb

@@ -1,39 +1,64 @@
-FactoryGirl.define do
-  sequence(:book_title) {|n| "Book #{n}"}
-  sequence(:chapter_title) {|n| "Chapter #{n}"}
-  sequence(:end_note) {|n| "Endnote #{n}"}
+FactoryBot.define do
+  sequence(:book_title) { |n| "Book #{n}" }
+  sequence(:chapter_title) { |n| "Chapter #{n}" }
+  sequence(:end_note) { |n| "Endnote #{n}" }
 
   factory :group do
     sequence(:order) { |n| "Order #{n}" }
   end
 
-  factory :invalid_topic, :class => "Topic" do
-    sequence(:title){ |n| "Title #{n}"}
-    author_name nil
+  factory :invalid_topic, class: "Topic" do
+    sequence(:title) { |n| "Title #{n}" }
+    author_name { nil }
   end
 
   factory :topic do
-    sequence(:title){ |n| "Title #{n}"}
-    sequence(:author_name){ |n| "Author #{n}"}
+    sequence(:title) { |n| "Title #{n}" }
+    sequence(:author_name) { |n| "Author #{n}" }
+    sequence(:content) { |n| "Content #{n}" }
   end
 
   factory :widget do
-    sequence(:w_id){ |n| n}
+    sequence(:w_id) { |n| n }
   end
 
-  factory :topic_with_book, :parent=>:topic do |m|
+  factory :question do
+    sequence(:body) { |n| "Text #{n}" }
+
+    trait :with_rule do
+      after(:build) do |question|
+        question.build_rule(FactoryBot.attributes_for(:rule))
+      end
+    end
+  end
+
+  factory :rule do
+    sequence(:id) { |n| n }
+    sequence(:condition_text) { |n| "q_#{n}_#{n}" }
+  end
+
+  factory :topic_with_book, parent: :topic do
     after(:build) do |topic|
       2.times do
-        book = topic.books.build(:title=>FactoryGirl.generate(:book_title), :author_name=>'Stephen King')
+        book = topic.books.build(title: FactoryBot.generate(:book_title), author_name: 'Stephen King')
         3.times do
-          book.chapters.build(:title => FactoryGirl.generate(:chapter_title))
+          book.chapters.build(title: FactoryBot.generate(:chapter_title))
         end
 
         4.times do
-          book.end_notes.build(:note => FactoryGirl.generate(:end_note))
+          book.end_notes.build(note: FactoryBot.generate(:end_note))
         end
       end
     end
   end
 
+  factory :book do
+    title { 'Tortilla Flat' }
+    author_name { 'John Steinbeck' }
+  end
+
+  factory :car do
+    sequence(:Name) { |n| n }
+    sequence(:Features) { |n| "Feature #{n}" }
+  end
 end

data/test/support/generate.rb

@@ -1,29 +1,29 @@
 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 || {}
+    factory_bot_args = args.shift || {}
 
     if n
-      Array.new.tap do |collection|
-        n.times.each { collection << FactoryGirl.build(factory.to_s.singularize.to_sym, factory_girl_args) }
+      [].tap do |collection|
+        n.times.each { collection << FactoryBot.build(factory.to_s.singularize.to_sym, factory_bot_args) }
       end
     else
-      FactoryGirl.build(factory.to_s.singularize.to_sym, factory_girl_args)
+      FactoryBot.build(factory.to_s.singularize.to_sym, factory_bot_args)
     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 || {}
+    factory_bot_args = args.shift || {}
 
     if n
-      Array.new.tap do |collection|
-        n.times.each { collection << FactoryGirl.create(factory.to_s.singularize.to_sym, factory_girl_args) }
+      [].tap do |collection|
+        n.times.each { collection << FactoryBot.create(factory.to_s.singularize.to_sym, factory_bot_args) }
       end
     else
-      FactoryGirl.create(factory.to_s.singularize.to_sym, factory_girl_args)
+      FactoryBot.create(factory.to_s.singularize.to_sym, factory_bot_args)
     end
   end
 end

data/test/support/mysql/import_examples.rb

@@ -1,147 +1,98 @@
 # encoding: UTF-8
 def should_support_mysql_import_functionality
   # Forcefully disable strict mode for this session.
-  ActiveRecord::Base.connection.execute "set sql_mode=''"
+  ActiveRecord::Base.connection.execute "set sql_mode='STRICT_ALL_TABLES'"
 
-  describe "#import with :on_duplicate_key_update option (mysql specific functionality)" do
-    extend ActiveSupport::TestCase::MySQLAssertions
+  should_support_basic_on_duplicate_key_update
+  should_support_on_duplicate_key_ignore
 
-    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
+  describe "#import" do
+    context "with :on_duplicate_key_update and validation checks turned off" do
+      extend ActiveSupport::TestCase::ImportAssertions
+
+      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
 
-    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 "given columns and values with :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_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 column names" do
-        let(:update_columns){ [ "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 ] }
-        should_support_on_duplicate_key_update
-        should_update_fields_mentioned
-      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 "given array of model instances with :validation checks turned off" do
-      macro(:perform_import) do |*opts|
-        @topic.title = "Book - 2nd Edition"
-        @topic.author_name = "Author Should Not Change"
-        @topic.author_email_address = "johndoe@example.com"
-        @topic.parent_id = 57
-        Topic.import [@topic], opts.extract_options!.merge(:on_duplicate_key_update => update_columns, :validate => false)
-      end
+    context "with :synchronization option" do
+      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
-        @topic = Generate(:topic, :id => 99, :author_name => "John Doe", :parent_id => 17)
+        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
 
-      context "using string column names" do
-        let(:update_columns){ [ "title", "author_email_address", "parent_id" ] }
-        should_support_on_duplicate_key_update
-        should_update_fields_mentioned
-      end
+      it "synchronizes passed in ActiveRecord model instances with the data just imported" do
+        columns2update = ['author_name']
 
-      context "using symbol column names" do
-        let(:update_columns){ [ :title, :author_email_address, :parent_id ] }
-        should_support_on_duplicate_key_update
-        should_update_fields_mentioned
-      end
+        expected_count = Topic.count
+        Topic.import( columns, values,
+          validate: false,
+          on_duplicate_key_update: columns2update,
+          synchronize: topics )
 
-      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
+        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 "Chad Fowler", topics.last.author_name, "wrong author!"
       end
     end
 
-  end
-
-  describe "#import with :synchronization option" do
-    let(:topics){ Array.new }
-    let(:values){ [ [topics.first.id, "Jerry Carter"], [topics.last.id, "Chad Fowler"] ]}
-    let(:columns){ %W(id author_name) }
+    if ENV['AR_VERSION'].to_f >= 5.1
+      context "with virtual columns" do
+        let(:books) { [Book.new(author_name: "foo", title: "bar")] }
 
-    setup do
-      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' ]
-
-      expected_count = Topic.count
-      Topic.import( columns, values,
-        :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 "Chad Fowler", topics.last.author_name, "wrong author!"
+        it "ignores virtual columns and creates record" do
+          assert_difference "Book.count", +1 do
+            Book.import books
+          end
+        end
+      end
     end
   end
-
 end