Empact-activerecord-import 0.3.1 → 0.3.2

data/Rakefile

@@ -41,7 +41,9 @@ ADAPTERS.each do |adapter|
   namespace :test do
     desc "Runs #{adapter} database tests."
     Rake::TestTask.new(adapter) do |t|
-      t.test_files = FileList["test/adapters/#{adapter}.rb", "test/*_test.rb", "test/#{adapter}/**/*_test.rb"]
+      # FactoryGirl has an issue with warnings, so turn off, so noisy
+      # t.warning = true
+      t.test_files = FileList["test/adapters/#{adapter}.rb", "test/*_test.rb", "test/active_record/*_test.rb", "test/#{adapter}/**/*_test.rb"]
     end
     task adapter
   end

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.3.2

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

@@ -3,12 +3,6 @@ module ActiveRecord::Import::AbstractAdapter
   QUERY_OVERHEAD = 8 #This was shown to be true for MySQL, but it's not clear where the overhead is from.
     
   module ClassMethods
-    # Returns the sum of the sizes of the passed in objects. This should
-    # probably be moved outside this class, but to where?
-    def sum_sizes( *objects ) # :nodoc:
-      objects.inject( 0 ){|sum,o| sum += o.size }
-    end
-
     def get_insert_value_sets( values, sql_size, max_bytes ) # :nodoc:
       value_sets = []          
       arr, current_arr_values_size, current_size = [], 0, 0
@@ -51,7 +45,7 @@ module ActiveRecord::Import::AbstractAdapter
       sql_size = QUERY_OVERHEAD + base_sql.size + post_sql.size 
 
       # the number of bytes the requested insert statement values will take up
-      values_in_bytes = self.class.sum_sizes( *values )
+      values_in_bytes = values.sum {|value| value.size }
     
       # the number of bytes (commas) it will take to comma separate our values
       comma_separated_bytes = values.size-1

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

@@ -6,7 +6,16 @@ module ActiveRecord::Import::MysqlAdapter
         include ActiveRecord::Import::OnDuplicateKeyUpdateSupport
       end
     end
-  
+    
+    # Returns the maximum number of bytes that the server will allow
+    # in a single packet
+    def max_allowed_packet # :nodoc:
+      result = execute( "SHOW VARIABLES like 'max_allowed_packet';" )
+      # original Mysql gem responds to #fetch_row while Mysql2 responds to #first
+      val = result.respond_to?(:fetch_row) ? result.fetch_row[1] : result.first[1]
+      val.to_i
+    end
+    
     # Returns a generated ON DUPLICATE KEY UPDATE statement given the passed
     # in +args+. 
     def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:

data/lib/activerecord-import/base.rb

@@ -25,3 +25,4 @@ end
 this_dir = Pathname.new File.dirname(__FILE__)
 require this_dir.join("import")
 require this_dir.join("active_record/adapters/abstract_adapter")
+require this_dir.join("synchronize")

data/lib/activerecord-import/import.rb

@@ -129,6 +129,11 @@ class ActiveRecord::Base
     #  BlogPost.import posts, :synchronize=>[ post ]
     #  puts post.author_name # => 'yoda'
     #
+    #  # Example synchronizing unsaved/new instances in memory by using a uniqued imported field
+    #  posts = [BlogPost.new(:title => "Foo"), BlogPost.new(:title => "Bar")]
+    #  BlogPost.import posts, :synchronize => posts
+    #  puts posts.first.new_record? # => false
+    #
     # == On Duplicate Key Update (MySQL only)
     #
     # The :on_duplicate_key_update option can be either an Array or a Hash. 
@@ -178,6 +183,9 @@ class ActiveRecord::Base
             end
           # end
         end
+        # supports empty array
+      elsif args.last.is_a?( Array ) and args.last.empty?
+        return ActiveRecord::Import::Result.new([], 0) if args.last.empty?
         # supports 2-element array and array
       elsif args.size == 2 and args.first.is_a?( Array ) and args.last.is_a?( Array )
         column_names, array_of_attributes = args
@@ -209,7 +217,8 @@ class ActiveRecord::Base
       end
 
       if options[:synchronize]
-        synchronize( options[:synchronize] )
+        sync_keys = options[:synchronize_keys] || [self.primary_key]
+        synchronize( options[:synchronize], sync_keys)
       end
 
       return_obj.num_inserts = 0 if return_obj.num_inserts.nil?
@@ -236,7 +245,9 @@ 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
       arr.each_with_index do |hsh,i|
-        instance = new( hsh )
+        instance = new do |model|
+          hsh.each_pair{ |k,v| model.send("#{k}=", v) }
+        end
         if not instance.valid?
           array_of_attributes[ i ] = nil
           failed_instances << instance
@@ -255,9 +266,11 @@ class ActiveRecord::Base
     # information on +column_names+, +array_of_attributes_ and
     # +options+.
     def import_without_validations_or_callbacks( column_names, array_of_attributes, options={} )
+      columns = column_names.map { |name| columns_hash[name.to_s] }
+
       columns_sql = "(#{column_names.map{|name| connection.quote_column_name(name) }.join(',')})"
       insert_sql = "INSERT #{options[:ignore] ? 'IGNORE ':''}INTO #{quoted_table_name} #{columns_sql} VALUES "
-      values_sql = values_sql_for_column_names_and_attributes(column_names, array_of_attributes)
+      values_sql = values_sql_for_columns_and_attributes(columns, array_of_attributes)
       if not supports_import?
         number_inserted = 0
         values_sql.each do |values|
@@ -280,15 +293,14 @@ class ActiveRecord::Base
 
     # Returns SQL the VALUES for an INSERT statement given the passed in +columns+
     # and +array_of_attributes+.
-    def values_sql_for_column_names_and_attributes(column_names, array_of_attributes)   # :nodoc:
-      columns = column_names.map { |name| columns_hash[name] }
-
+    def values_sql_for_columns_and_attributes(columns, array_of_attributes)   # :nodoc:
       array_of_attributes.map do |arr|
         my_values = arr.each_with_index.map do |val,j|
-          if !sequence_name.blank? && column_names[j] == primary_key && val.nil?
+          column = columns[j]
+          if !sequence_name.blank? && column.name == primary_key && val.nil?
              connection.next_value_for_sequence(sequence_name)
           else
-             connection.quote(val, columns[j])
+            connection.quote(column.type_cast(val), column)
           end
         end
         "(#{my_values.join(',')})"

data/lib/activerecord-import/synchronize.rb

@@ -0,0 +1,55 @@
+module ActiveRecord # :nodoc:
+  class Base # :nodoc:
+      
+    # Synchronizes the passed in ActiveRecord instances with data
+    # from the database. This is like calling reload on an individual
+    # ActiveRecord instance but it is intended for use on multiple instances. 
+    # 
+    # This uses one query for all instance updates and then updates existing
+    # instances rather sending one query for each instance
+    #
+    # == Examples
+    # # Synchronizing existing models by matching on the primary key field
+    # posts = Post.find_by_author("Zach")
+    # <.. out of system changes occur to change author name from Zach to Zachary..>
+    # Post.synchronize posts
+    # posts.first.author # => "Zachary" instead of Zach
+    # 
+    # # Synchronizing using custom key fields
+    # posts = Post.find_by_author("Zach")
+    # <.. out of system changes occur to change the address of author 'Zach' to 1245 Foo Ln ..>
+    # Post.synchronize posts, [:name] # queries on the :name column and not the :id column
+    # posts.first.address # => "1245 Foo Ln" instead of whatever it was
+    #
+    def self.synchronize(instances, keys=[self.primary_key])
+      return if instances.empty?
+
+      conditions = {}
+      order = ""
+      
+      key_values = keys.map { |key| instances.map(&"#{key}".to_sym) }
+      keys.zip(key_values).each { |key, values| conditions[key] = values }
+      order = keys.map{ |key| "#{key} ASC" }.join(",")
+      
+      klass = instances.first.class
+
+      fresh_instances = klass.find( :all, :conditions=>conditions, :order=>order )
+      instances.each do |instance|
+        matched_instance = fresh_instances.detect do |fresh_instance|
+          keys.all?{ |key| fresh_instance.send(key) == instance.send(key) }
+        end
+        
+        if matched_instance
+          instance.clear_aggregation_cache
+          instance.clear_association_cache
+          instance.instance_variable_set '@attributes', matched_instance.attributes
+        end
+      end
+    end
+
+    # See ActiveRecord::ConnectionAdapters::AbstractAdapter.synchronize
+    def synchronize(instances, key=[ActiveRecord::Base.primary_key])
+      self.class.synchronize(instances, key)
+    end
+  end
+end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: Empact-activerecord-import
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 3
-  - 1
-  version: 0.3.1
+  prerelease: 
+  version: 0.3.2
 platform: ruby
 authors: 
 - Zach Dennis
@@ -15,8 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-17 00:00:00 -08:00
-default_executable: 
+date: 2011-05-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -25,44 +20,43 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 0
-        - 0
         version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: jeweler
+  name: rake
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 4
-        - 0
-        version: 1.4.0
+        version: "0"
   type: :development
   prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: activerecord
+  name: jeweler
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 0
-        - 0
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *id003
+  version_requirements: *id004
 description: Extraction of the ActiveRecord::Base#import functionality from ar-extensions for Rails 3 and beyond
 email: ben.woosley@gmail.com
 executables: []
@@ -91,28 +85,7 @@ files:
 - lib/activerecord-import/mysql2.rb
 - lib/activerecord-import/postgresql.rb
 - lib/activerecord-import/sqlite3.rb
-- test/active_record/connection_adapter_test.rb
-- test/adapters/mysql.rb
-- test/adapters/mysql2.rb
-- test/adapters/postgresql.rb
-- test/adapters/sqlite3.rb
-- test/import_test.rb
-- test/models/book.rb
-- test/models/group.rb
-- test/models/topic.rb
-- test/mysql/import_test.rb
-- test/mysql2/import_test.rb
-- test/postgresql/import_test.rb
-- test/schema/generic_schema.rb
-- test/schema/mysql_schema.rb
-- test/schema/version.rb
-- test/support/active_support/test_case_extensions.rb
-- test/support/factories.rb
-- test/support/generate.rb
-- test/support/mysql/assertions.rb
-- test/support/mysql/import_examples.rb
-- test/test_helper.rb
-has_rdoc: true
+- lib/activerecord-import/synchronize.rb
 homepage: http://github.com/Empact/activerecord-import
 licenses: []
 
@@ -126,7 +99,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -4502227035676277865
+      hash: -2706600043388041365
       segments: 
       - 0
       version: "0"
@@ -135,35 +108,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: Bulk-loading extension for ActiveRecord
-test_files: 
-- test/active_record/connection_adapter_test.rb
-- test/adapters/mysql.rb
-- test/adapters/mysql2.rb
-- test/adapters/postgresql.rb
-- test/adapters/sqlite3.rb
-- test/import_test.rb
-- test/models/book.rb
-- test/models/group.rb
-- test/models/topic.rb
-- test/mysql/import_test.rb
-- test/mysql2/import_test.rb
-- test/postgresql/import_test.rb
-- test/schema/generic_schema.rb
-- test/schema/mysql_schema.rb
-- test/schema/version.rb
-- test/support/active_support/test_case_extensions.rb
-- test/support/factories.rb
-- test/support/generate.rb
-- test/support/mysql/assertions.rb
-- test/support/mysql/import_examples.rb
-- test/test_helper.rb
+test_files: []
+

data/test/active_record/connection_adapter_test.rb

@@ -1,52 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-describe "ActiveRecord::ConnectionAdapter::AbstractAdapter" do
-  context "#get_insert_value_sets - computing insert value sets" do
-    let(:adapter){ ActiveRecord::ConnectionAdapters::AbstractAdapter }
-    let(:base_sql){ "INSERT INTO atable (a,b,c)" }
-    let(:values){ [ "(1,2,3)", "(2,3,4)", "(3,4,5)" ] }
-    
-    context "when the max allowed bytes is 33 and the base SQL is 26 bytes" do
-      it "should return 3 value sets when given 3 value sets of 7 bytes a piece" do
-        value_sets = adapter.get_insert_value_sets values, base_sql.size, max_allowed_bytes = 33
-        assert_equal 3, value_sets.size
-      end
-    end
-  
-    context "when the max allowed bytes is 40 and the base SQL is 26 bytes" do
-      it "should return 3 value sets when given 3 value sets of 7 bytes a piece" do
-        value_sets = adapter.get_insert_value_sets values, base_sql.size, max_allowed_bytes = 40
-        assert_equal 3, value_sets.size
-      end
-    end
-      
-    context "when the max allowed bytes is 41 and the base SQL is 26 bytes" do
-      it "should return 2 value sets when given 2 value sets of 7 bytes a piece" do
-        value_sets = adapter.get_insert_value_sets values, base_sql.size, max_allowed_bytes = 41
-        assert_equal 2, value_sets.size
-      end
-    end
-      
-    context "when the max allowed bytes is 48 and the base SQL is 26 bytes" do
-      it "should return 2 value sets when given 2 value sets of 7 bytes a piece" do
-        value_sets = adapter.get_insert_value_sets values, base_sql.size, max_allowed_bytes = 48
-        assert_equal 2, value_sets.size
-      end
-    end
-      
-    context "when the max allowed bytes is 49 and the base SQL is 26 bytes" do
-      it "should return 1 value sets when given 1 value sets of 7 bytes a piece" do
-        value_sets = adapter.get_insert_value_sets values, base_sql.size, max_allowed_bytes = 49
-        assert_equal 1, value_sets.size
-      end
-    end
-      
-    context "when the max allowed bytes is 999999 and the base SQL is 26 bytes" do
-      it "should return 1 value sets when given 1 value sets of 7 bytes a piece" do
-        value_sets = adapter.get_insert_value_sets values, base_sql.size, max_allowed_bytes = 999999
-        assert_equal 1, value_sets.size
-      end
-    end
-  end
-  
-end

data/test/adapters/mysql.rb

@@ -1 +0,0 @@
-ENV["ARE_DB"] = "mysql"

data/test/adapters/mysql2.rb

@@ -1 +0,0 @@
-ENV["ARE_DB"] = "mysql2"

data/test/adapters/postgresql.rb

@@ -1 +0,0 @@
-ENV["ARE_DB"] = "postgresql"

data/test/adapters/sqlite3.rb

@@ -1 +0,0 @@
-ENV["ARE_DB"] = "sqlite3"

data/test/import_test.rb

@@ -1,202 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-describe "#import" do
-  it "should return the number of inserts performed" do
-    # see ActiveRecord::ConnectionAdapters::AbstractAdapter test for more specifics
-    assert_difference "Topic.count", +10 do
-      result = Topic.import Build(3, :topics)
-      assert result.num_inserts > 0
-    
-      result = Topic.import Build(7, :topics)
-      assert result.num_inserts > 0
-    end
-  end
-
-  context "with :validation option" do
-    let(:columns) { %w(title author_name) }
-    let(:valid_values) { [[ "LDAP", "Jerry Carter"], ["Rails Recipes", "Chad Fowler"]] }
-    let(:invalid_values) { [[ "The RSpec Book", ""], ["Agile+UX", ""]] }
-  
-    context "with validation checks turned off" do
-      it "should import valid data" do
-        assert_difference "Topic.count", +2 do
-          result = Topic.import columns, valid_values, :validate => false
-        end
-      end
-  
-      it "should import invalid data" do
-        assert_difference "Topic.count", +2 do
-          result = Topic.import columns, invalid_values, :validate => false
-        end
-      end
-    end
-  
-    context "with validation checks turned on" do
-      it "should import valid data" do
-        assert_difference "Topic.count", +2 do
-          result = Topic.import columns, valid_values, :validate => true
-        end
-      end
-  
-      it "should not import invalid data" do
-        assert_no_difference "Topic.count" do
-          result = Topic.import columns, invalid_values, :validate => true
-        end
-      end
-  
-      it "should report the failed instances" do
-        results = Topic.import columns, invalid_values, :validate => true
-        assert_equal invalid_values.size, results.failed_instances.size
-        results.failed_instances.each{ |e| assert_kind_of Topic, e }
-      end
-  
-      it "should import valid data when mixed with invalid data" do
-        assert_difference "Topic.count", +2 do
-          result = Topic.import columns, valid_values + invalid_values, :validate => true
-        end
-        assert_equal 0, Topic.find_all_by_title(invalid_values.map(&:first)).count
-      end
-    end
-  end
-  
-  context "with an array of unsaved model instances" do
-    let(:topic) { Build(:topic, :title => "The RSpec Book", :author_name => "David Chelimsky")}
-    let(:topics) { Build(9, :topics) }
-    let(:invalid_topics){ Build(7, :invalid_topics)}
-    
-    it "should import records based on those model's attributes" do
-      assert_difference "Topic.count", +9 do
-        result = Topic.import topics
-      end
-      
-      Topic.import [topic]
-      assert Topic.find_by_title_and_author_name("The RSpec Book", "David Chelimsky")
-    end
-  
-    it "should not overwrite existing records" do
-      topic = Generate(:topic, :title => "foobar")
-      assert_no_difference "Topic.count" do
-        begin
-          Topic.transaction do
-            topic.title = "baz"
-            Topic.import [topic]
-          end
-        rescue Exception
-          # PostgreSQL raises PgError due to key constraints
-          # I don't know why ActiveRecord doesn't catch these. *sigh*
-        end
-      end
-      assert_equal "foobar", topic.reload.title
-    end
-    
-    context "with validation checks turned on" do
-      it "should import valid models" do
-        assert_difference "Topic.count", +9 do
-          result = Topic.import topics, :validate => true
-        end
-      end
-      
-      it "should not import invalid models" do
-        assert_no_difference "Topic.count" do
-          result = Topic.import invalid_topics, :validate => true
-        end
-      end
-    end
-    
-    context "with validation checks turned off" do
-      it "should import invalid models" do
-        assert_difference "Topic.count", +7 do
-          result = Topic.import invalid_topics, :validate => false
-        end
-      end
-    end
-  end
-  
-  context "with an array of columns and an array of unsaved model instances" do
-    let(:topics) { Build(2, :topics) }
-    
-    it "should import records populating the supplied columns with the corresponding model instance attributes" do
-      assert_difference "Topic.count", +2 do
-        result = Topic.import [:author_name, :title], topics
-      end
-      
-      # imported topics should be findable by their imported attributes
-      assert Topic.find_by_author_name(topics.first.author_name)
-      assert Topic.find_by_author_name(topics.last.author_name)
-    end
-  
-    it "should not populate fields for columns not imported" do
-      topics.first.author_email_address = "zach.dennis@gmail.com"
-      assert_difference "Topic.count", +2 do
-        result = Topic.import [:author_name, :title], topics
-      end
-      
-      assert !Topic.find_by_author_email_address("zach.dennis@gmail.com")
-    end
-  end
-  
-  context "ActiveRecord timestamps" do
-    context "when the timestamps columns are present" do
-      setup do
-        Delorean.time_travel_to("5 minutes ago") do
-          assert_difference "Book.count", +1 do
-            result = Book.import [:title, :author_name, :publisher], [["LDAP", "Big Bird", "Del Rey"]]
-          end
-        end
-        @book = Book.last
-      end
-    
-      it "should set the created_at column for new records"  do
-        assert_equal 5.minutes.ago.strftime("%H:%M"), @book.created_at.strftime("%H:%M")
-      end
-  
-      it "should set the created_on column for new records" do
-        assert_equal 5.minutes.ago.strftime("%H:%M"), @book.created_on.strftime("%H:%M")
-      end
-  
-      it "should set the updated_at column for new records" do
-        assert_equal 5.minutes.ago.strftime("%H:%M"), @book.updated_at.strftime("%H:%M")
-      end
-  
-      it "should set the updated_on column for new records" do
-        assert_equal 5.minutes.ago.strftime("%H:%M"), @book.updated_on.strftime("%H:%M")
-      end
-    end
-    
-    context "when a custom time zone is set" do
-      setup do
-        original_timezone = ActiveRecord::Base.default_timezone
-        ActiveRecord::Base.default_timezone = :utc
-        Delorean.time_travel_to("5 minutes ago") do
-          assert_difference "Book.count", +1 do
-            result = Book.import [:title, :author_name, :publisher], [["LDAP", "Big Bird", "Del Rey"]]
-          end
-        end
-        ActiveRecord::Base.default_timezone = original_timezone
-        @book = Book.last
-      end
-  
-      it "should set the created_at and created_on timestamps for new records"  do
-        assert_equal 5.minutes.ago.utc.strftime("%H:%M"), @book.created_at.strftime("%H:%M")
-        assert_equal 5.minutes.ago.utc.strftime("%H:%M"), @book.created_on.strftime("%H:%M")
-      end
-  
-      it "should set the updated_at and updated_on timestamps for new records" do
-        assert_equal 5.minutes.ago.utc.strftime("%H:%M"), @book.updated_at.strftime("%H:%M")
-        assert_equal 5.minutes.ago.utc.strftime("%H:%M"), @book.updated_on.strftime("%H:%M")
-      end
-    end
-  end
-  
-  context "importing with database reserved words" do
-    let(:group) { Build(:group, :order => "superx") }
-    
-    it "should import just fine" do
-      assert_difference "Group.count", +1 do
-        result = Group.import [group]
-      end
-      assert_equal "superx", Group.first.order
-    end
-  end
-
-end

data/test/models/book.rb

@@ -1,3 +0,0 @@
-class Book < ActiveRecord::Base
-  belongs_to :topic
-end

data/test/models/group.rb

@@ -1,3 +0,0 @@
-class Group < ActiveRecord::Base
-  self.table_name = 'group'
-end

data/test/models/topic.rb

@@ -1,7 +0,0 @@
-class Topic < ActiveRecord::Base
-  validates_presence_of :author_name
-  has_many :books
-  belongs_to :parent, :class_name => "Topic"
-  
-  composed_of :description, :mapping => [ %w(title title), %w(author_name author_name)], :allow_nil => true, :class_name => "TopicDescription"
-end

data/test/mysql/import_test.rb

@@ -1,6 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-require File.expand_path(File.dirname(__FILE__) + '/../support/mysql/assertions')
-require File.expand_path(File.dirname(__FILE__) + '/../support/mysql/import_examples')
-
-should_support_mysql_import_functionality

data/test/mysql2/import_test.rb

@@ -1,6 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-require File.expand_path(File.dirname(__FILE__) + '/../support/mysql/assertions')
-require File.expand_path(File.dirname(__FILE__) + '/../support/mysql/import_examples')
-
-should_support_mysql_import_functionality

data/test/postgresql/import_test.rb

@@ -1,20 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-describe "#supports_imports?" do
-  it "should support import" do
-    assert ActiveRecord::Base.supports_import?
-  end
-end
-
-describe "#import" do
-  it "should import with a single insert" do
-    # see ActiveRecord::ConnectionAdapters::AbstractAdapter test for more specifics
-    assert_difference "Topic.count", +10 do
-      result = Topic.import Build(3, :topics)
-      assert_equal 1, result.num_inserts
-    
-      result = Topic.import Build(7, :topics)
-      assert_equal 1, result.num_inserts
-    end
-  end
-end

data/test/schema/generic_schema.rb

@@ -1,98 +0,0 @@
-ActiveRecord::Schema.define do
-
-  create_table :schema_info, :force=>true do |t|
-    t.column :version, :integer, :unique=>true
-  end
-  SchemaInfo.create :version=>SchemaInfo::VERSION
-
-  create_table :group, :force => true do |t|
-    t.column :order, :string
-    t.timestamps
-  end
-
-  create_table :topics, :force=>true do |t|
-    t.column :title, :string, :null => false
-    t.column :author_name, :string
-    t.column :author_email_address, :string
-    t.column :written_on, :datetime
-    t.column :bonus_time, :time
-    t.column :last_read, :datetime
-    t.column :content, :text
-    t.column :approved, :boolean, :default=>'1'
-    t.column :replies_count, :integer
-    t.column :parent_id, :integer
-    t.column :type, :string
-    t.column :created_at, :datetime
-    t.column :created_on, :datetime
-    t.column :updated_at, :datetime
-    t.column :updated_on, :datetime
-  end
-
-  create_table :projects, :force=>true do |t|
-    t.column :name, :string
-    t.column :type, :string    
-  end
-  
-  create_table :developers, :force=>true do |t|
-    t.column :name, :string
-    t.column :salary, :integer, :default=>'70000'
-    t.column :created_at, :datetime
-    t.column :team_id, :integer
-    t.column :updated_at, :datetime
-  end
-
-  create_table :addresses, :force=>true do |t|
-    t.column :address, :string
-    t.column :city, :string
-    t.column :state, :string
-    t.column :zip, :string
-    t.column :developer_id, :integer
-  end
-
-  create_table :teams, :force=>true do |t|
-    t.column :name, :string
-  end
-  
-  create_table :books, :force=>true do |t|
-    t.column :title, :string, :null=>false
-    t.column :publisher, :string, :null=>false, :default => 'Default Publisher'
-    t.column :author_name, :string, :null=>false
-    t.column :created_at, :datetime
-    t.column :created_on, :datetime
-    t.column :updated_at, :datetime
-    t.column :updated_on, :datetime
-    t.column :publish_date, :date
-    t.column :topic_id, :integer
-    t.column :for_sale, :boolean, :default => true
-  end  
-
-  create_table :languages, :force=>true do |t|
-    t.column :name, :string
-    t.column :developer_id, :integer
-  end
-
-  create_table :shopping_carts, :force=>true do |t|
-    t.column :name, :string, :null => true
-    t.column :created_at, :datetime
-    t.column :updated_at, :datetime
-  end
-
-  create_table :cart_items, :force => true do |t|
-    t.column :shopping_cart_id, :string, :null => false
-    t.column :book_id, :string, :null => false
-    t.column :copies, :integer, :default => 1
-    t.column :created_at, :datetime
-    t.column :updated_at, :datetime
-  end
-
-  add_index :cart_items, [:shopping_cart_id, :book_id], :unique => true, :name => 'uk_shopping_cart_books'
-
-  create_table :animals, :force => true do |t|
-    t.column :name, :string, :null => false
-    t.column :size, :string, :default => nil
-    t.column :created_at, :datetime
-    t.column :updated_at, :datetime
-  end
-  
-  add_index :animals, [:name], :unique => true, :name => 'uk_animals'
-end

data/test/schema/mysql_schema.rb

@@ -1,17 +0,0 @@
-ActiveRecord::Schema.define do
- 
-  create_table :books, :options=>'ENGINE=MyISAM', :force=>true do |t|
-    t.column :title, :string, :null=>false
-    t.column :publisher, :string, :null=>false, :default => 'Default Publisher'
-    t.column :author_name, :string, :null=>false
-    t.column :created_at, :datetime
-    t.column :created_on, :datetime
-    t.column :updated_at, :datetime
-    t.column :updated_on, :datetime
-    t.column :publish_date, :date
-    t.column :topic_id, :integer
-    t.column :for_sale, :boolean, :default => true
-  end
-  execute "ALTER TABLE books ADD FULLTEXT( `title`, `publisher`, `author_name` )"
-
-end

data/test/schema/version.rb

@@ -1,4 +0,0 @@
-class SchemaInfo < ActiveRecord::Base
-  set_table_name 'schema_info'
-  VERSION = 12
-end

data/test/support/active_support/test_case_extensions.rb

@@ -1,67 +0,0 @@
-class ActiveSupport::TestCase
-  include ActiveRecord::TestFixtures
-  self.use_transactional_fixtures = true
-  
-  class << self
-    def assertion(name, &block)
-      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_eval do
-        define_method(name, &block)
-      end
-    end
-
-    def macro(name, &block)
-      class_eval do
-        define_method(name, &block)
-      end
-    end
-    
-    def describe(description, toplevel=nil, &blk)
-      text = toplevel ? description : "#{name} #{description}"
-      klass = Class.new(self)
-
-      klass.class_eval <<-RUBY_EVAL
-        def self.name
-          "#{text}"
-        end
-      RUBY_EVAL
-
-      # do not inherit test methods from the superclass
-      klass.class_eval do
-        instance_methods.grep(/^test.+/) do |method|
-          undef_method method
-        end
-      end
-
-      klass.instance_eval &blk
-    end
-    alias_method :context, :describe
-    
-    def let(name, &blk)
-      values = {}
-      define_method(name) do
-        return values[name] if values.has_key?(name)
-        values[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/factories.rb

@@ -1,13 +0,0 @@
-Factory.define :group do |m|
-  m.sequence(:order) { |n| "Order #{n}" }
-end
-
-Factory.define :invalid_topic, :class => "Topic" do |m|
-  m.sequence(:title){ |n| "Title #{n}"}
-  m.author_name nil
-end
-
-Factory.define :topic do |m|
-  m.sequence(:title){ |n| "Title #{n}"}
-  m.sequence(:author_name){ |n| "Author #{n}"}
-end

data/test/support/generate.rb

@@ -1,29 +0,0 @@
-class ActiveSupport::TestCase
-  def Build(*args)
-    n = args.shift if args.first.is_a?(Numeric)
-    factory = args.shift
-    factory_girl_args = args.shift || {}
-    
-    if n
-      Array.new.tap do |collection|
-        n.times.each { collection << Factory.build(factory.to_s.singularize.to_sym, factory_girl_args) }
-      end
-    else
-      Factory.build(factory.to_s.singularize.to_sym, factory_girl_args)
-    end
-  end
-
-  def Generate(*args)
-    n = args.shift if args.first.is_a?(Numeric)
-    factory = args.shift
-    factory_girl_args = args.shift || {}
-    
-    if n
-      Array.new.tap do |collection|
-        n.times.each { collection << Factory.create(factory.to_s.singularize.to_sym, factory_girl_args) }
-      end
-    else
-      Factory.create(factory.to_s.singularize.to_sym, factory_girl_args)
-    end
-  end
-end

data/test/support/mysql/assertions.rb

@@ -1,55 +0,0 @@
-class ActiveSupport::TestCase
-  module MySQLAssertions
-    def self.extended(klass)
-      klass.instance_eval do
-        assertion(:should_not_update_created_at_on_timestamp_columns) do
-          Delorean.time_travel_to("5 minutes from now") do
-            perform_import
-            assert_equal @topic.created_at.to_i, updated_topic.created_at.to_i
-            assert_equal @topic.created_on.to_i, updated_topic.created_on.to_i
-          end
-        end
-
-        assertion(:should_update_updated_at_on_timestamp_columns) do
-          time = Chronic.parse("5 minutes from now")
-          Delorean.time_travel_to(time) do
-            perform_import
-            assert_equal time.to_i, updated_topic.updated_at.to_i
-            assert_equal time.to_i, updated_topic.updated_on.to_i
-          end
-        end
-
-        assertion(:should_not_update_timestamps) do
-          Delorean.time_travel_to("5 minutes from now") do
-            perform_import :timestamps => false
-            assert_equal @topic.created_at.to_i, updated_topic.created_at.to_i
-            assert_equal @topic.created_on.to_i, updated_topic.created_on.to_i
-            assert_equal @topic.updated_at.to_i, updated_topic.updated_at.to_i
-            assert_equal @topic.updated_on.to_i, updated_topic.updated_on.to_i
-          end
-        end
-
-        assertion(:should_not_update_fields_not_mentioned) do
-          assert_equal "John Doe", updated_topic.author_name
-        end
-
-        assertion(:should_update_fields_mentioned) do
-          perform_import
-          assert_equal "Book - 2nd Edition", updated_topic.title
-          assert_equal "johndoe@example.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
-          assert_equal "Book - 2nd Edition", updated_topic.author_email_address
-        end
-
-        assertion(:should_update_foreign_keys) do
-          perform_import
-          assert_equal 57, updated_topic.parent_id
-        end
-      end
-    end
-  end
-end

data/test/support/mysql/import_examples.rb

@@ -1,117 +0,0 @@
-def should_support_mysql_import_functionality
-  describe "#import with :on_duplicate_key_update option (mysql specific functionality)" do
-    extend ActiveSupport::TestCase::MySQLAssertions
-  
-    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) }
-  
-    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 ] ] }
-  
-      macro(:perform_import) do |*opts|
-        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 = 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" } }
-        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 "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
-    
-      setup do
-        @topic = Generate(:topic, :id => 99, :author_name => "John Doe", :parent_id => 17)
-      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" } }
-        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
-  
-  end
-end

data/test/test_helper.rb

@@ -1,46 +0,0 @@
-require 'pathname'
-test_dir = Pathname.new File.dirname(__FILE__)
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-require "fileutils"
-require "rubygems"
-
-ENV["RAILS_ENV"] = "test"
-
-require "bundler"
-Bundler.setup
-
-require "logger"
-require 'test/unit'
-require "active_record"
-require "active_record/fixtures"
-require "active_support/test_case"
-
-require "delorean"
-require "ruby-debug"
-
-adapter = ENV["ARE_DB"] || "sqlite3"
-
-FileUtils.mkdir_p 'log'
-ActiveRecord::Base.logger = Logger.new("log/test.log")
-ActiveRecord::Base.logger.level = Logger::DEBUG
-ActiveRecord::Base.configurations["test"] = YAML.load(test_dir.join("database.yml").open)[adapter]
-
-require "activerecord-import"
-ActiveRecord::Base.establish_connection "test"
-
-ActiveSupport::Notifications.subscribe(/active_record.sql/) do |event, _, _, _, hsh|
-  ActiveRecord::Base.logger.info hsh[:sql]
-end
-
-require "factory_girl"
-Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each{ |file| require file }
-
-# Load base/generic schema
-require test_dir.join("schema/version")
-require test_dir.join("schema/generic_schema")
-adapter_schema = test_dir.join("schema/#{adapter}_schema.rb")
-require adapter_schema if File.exists?(adapter_schema)
-
-Dir[File.dirname(__FILE__) + "/models/*.rb"].each{ |file| require file }