bulk_data_methods 1.0.0

data/spec/bulk_data_methods/bulk_methods_mixin_spec.rb

@@ -0,0 +1,436 @@
+require 'spec_helper'
+require "#{File.dirname(__FILE__)}/../support/tables_spec_helper"
+
+describe "BulkMethodsMixin" do
+  include TablesSpecHelper
+
+  before do
+    class Employee < ActiveRecord::Base
+      extend BulkMethodsMixin
+    end
+    create_tables
+  end
+
+  describe "create_many" do
+
+    context "when call method with empty rows" do
+      it "returns empty array" do
+        Employee.create_many("").should == []
+      end
+    end # when call method with empty rows
+
+    context "when try to create records with the given id" do
+      it "records created" do
+        Employee.create_many([{ :id => Employee.connection.next_sequence_value(Employee.sequence_name),
+                                :name => 'Keith',
+                                :company_id => 2
+                              },
+                              { :id => Employee.connection.next_sequence_value(Employee.sequence_name),
+                                :name => 'Mike',
+                                :company_id => 3
+                              },
+                              { :id => Employee.connection.next_sequence_value(Employee.sequence_name),
+                                :name => 'Alex',
+                                :company_id => 1
+                              }])
+        Employee.all.map{ |r| r.name }.should == ["Keith", "Mike", "Alex"]
+      end
+    end # when try to create records with the given id
+
+    context "when try to create records without the given id" do
+      it "records created" do
+        Employee.create_many([{ :name => 'Keith', :company_id => 2 },
+                              { :name => 'Mike', :company_id => 3 },
+                              { :name => 'Alex', :company_id => 1 }])
+        Employee.all.map{ |r| r.name }.should == ["Keith", "Mike", "Alex"]
+      end
+    end # when try to create records without the given id
+
+    context "when try to create records with a mixture of given ids and non-given ids" do
+      it "records created" do
+        Employee.create_many([{ :name => 'Keith', :company_id => 2 },
+                              { :id => Employee.connection.next_sequence_value(Employee.sequence_name),
+                                :name => 'Mike',
+                                :company_id => 3
+                              },
+                              { :name => 'Mark', :company_id => 1 },
+                              { :id => Employee.connection.next_sequence_value(Employee.sequence_name),
+                                :name => 'Alex',
+                                :company_id => 1
+                              }])
+        Employee.all.map{ |r| r.name }.should == ["Keith", "Mike", "Mark", "Alex"]
+      end
+    end # when try to create records with a mixture of given ids and non-given ids
+
+    context "when try to create records with the given created_at" do
+      it "records created" do
+        Employee.create_many([{ :name => 'Keith',
+                                :company_id => 2,
+                                :created_at => Time.zone.parse('2012-01-02')
+                              },
+                              { :name => 'Mike',
+                                :company_id => 3,
+                                :created_at => Time.zone.parse('2012-01-03')
+                              },
+                              { :name => 'Alex',
+                                :company_id => 1,
+                                :created_at => Time.zone.parse('2012-01-04')
+                              }])
+        Employee.all.map{ |r| r.created_at }.should == [
+                                                         Time.zone.parse('2012-01-02'),
+                                                         Time.zone.parse('2012-01-03'),
+                                                         Time.zone.parse('2012-01-04')
+                                                        ]
+      end
+    end # when try to create records with the given created_at
+
+    context "when try to create records without the given created_at" do
+      it "records created" do
+        Employee.create_many([{ :name => 'Keith', :company_id => 2 },
+                              { :name => 'Mike', :company_id => 3 },
+                              { :name => 'Alex', :company_id => 1 }])
+        Employee.all.each{ |r| r.created_at.between?(Time.now - 3.minute, Time.now + 3.minute) }.
+            should be_true
+      end
+    end # when try to create records without the given created_at
+
+    context "when try to create records without options" do
+      it "generates one insert queries" do
+        Employee.should_receive(:find_by_sql).once.and_return([])
+        Employee.create_many([{ :name => 'Keith', :company_id => 2 },
+                              { :name => 'Alex', :company_id => 1 },
+                              { :name => 'Mark', :company_id => 2 },
+                              { :name => 'Phil', :company_id => 3 }])
+      end
+    end # when try to create records without options
+
+    context "when call method with option 'slice_size' equal 2" do
+      it "generates two insert queries" do
+        Employee.should_receive(:find_by_sql).twice.and_return([])
+        Employee.create_many([{ :name => 'Keith', :company_id => 2 },
+                              { :name => 'Alex', :company_id => 1 },
+                              { :name => 'Mark', :company_id => 2 },
+                              { :name => 'Phil', :company_id => 3 }],
+                              { :slice_size => 2})
+      end
+    end # when call method with option 'slice_size' equal 2
+
+    context "when create two records with options 'returning' equal id" do
+      it "returns last records id" do
+        Employee.create_many([{ :name => 'Keith', :company_id => 2 },
+                              { :name => 'Alex', :company_id => 3 }],
+                              { :returning => [:id] }).
+                   last.id.should == 2
+      end
+    end # when create two records with options 'returning' equal id
+
+    context "when try to create two records and doesn't
+             the same number of keys and options check_consistency equal false" do
+      it "records created, last salary is nil" do
+        Employee.create_many([{ :company_id => 2, :name => 'Keith', :salary => 1002 },
+                              { :name => 'Alex', :company_id => 3 }],
+                              { :check_consistency => false })
+        Employee.find(2).salary.should == nil
+      end
+    end # when try to create two records and doesn't
+        # the same number of keys and options check_consistency equal false
+
+    context "when try to create two records and doesn't the same number of keys" do
+      it "raises BulkUploadDataInconsistent" do
+        lambda { Employee.create_many([{ :company_id => 2, :name => 'Keith', :salary => 1002  },
+                                       { :name => 'Alex', :company_id => 3}])
+        }.should raise_error(BulkMethodsMixin::BulkUploadDataInconsistent)
+      end
+    end # when try to create two records and doesn't the same number of keys
+
+    context "when try to create records in the table that has all the different sql types" do
+
+      before do
+        ActiveRecord::Base.connection.execute <<-SQL
+          ALTER TABLE employees ADD COLUMN test_string character varying;
+          ALTER TABLE employees ADD COLUMN test_float float;
+          ALTER TABLE employees ADD COLUMN test_decimal decimal;
+          ALTER TABLE employees ADD COLUMN test_time time;
+          ALTER TABLE employees ADD COLUMN test_time_string time;
+          ALTER TABLE employees ADD COLUMN test_date date;
+          ALTER TABLE employees ADD COLUMN test_date_string date;
+          ALTER TABLE employees ADD COLUMN test_bytea bytea;
+          ALTER TABLE employees ADD COLUMN test_boolean boolean;
+          ALTER TABLE employees ADD COLUMN test_xml xml;
+          ALTER TABLE employees ADD COLUMN test_tsvector tsvector;
+        SQL
+        Employee.reset_column_information
+      end
+
+      after do
+        ActiveRecord::Base.connection.reset!
+      end
+
+      context "non-null values" do
+        it "returns record with all sql types" do
+          lambda { Employee.create_many([{ :name => 'Keith',
+                                           :company_id => 2,
+                                           :created_at => Time.zone.parse('2012-12-21'),
+                                           :updated_at => '2012-12-21 00:00:00',
+                                           :test_string => "string",
+                                           :test_float => 12.34,
+                                           :test_decimal => 123456789101112,
+                                           :test_time => Time.now,
+                                           :test_time_string => '00:00:00',
+                                           :test_date => Date.parse('2012-12-21'),
+                                           :test_date_string => '2012-12-21',
+                                           :test_bytea => "text".bytes.to_a,
+                                           :test_boolean => false,
+                                           :test_xml => ["text"].to_xml,
+                                           :test_tsvector => "test string",
+                                         }]) }.should_not raise_error
+          Employee.all.size.should == 1
+        end
+      end # non-null values
+
+      context "null values" do
+        it "returns record with all sql types" do
+          lambda { Employee.create_many([{ :name => 'Keith',
+                                           :company_id => 2,
+                                           :created_at => nil,
+                                           :updated_at => nil,
+                                           :salary => nil,
+                                           :test_string => nil,
+                                           :test_float => nil,
+                                           :test_decimal => nil,
+                                           :test_time => nil,
+                                           :test_time_string => nil,
+                                           :test_date => nil,
+                                           :test_date_string => nil,
+                                           :test_bytea => nil,
+                                           :test_boolean => nil,
+                                           :test_xml => nil,
+                                           :test_tsvector => nil,
+                                         }]) }.should_not raise_error
+          Employee.all.size.should == 1
+        end
+      end # null values
+
+    end # when try to create records in the table that has all the different sql types
+
+  end # create_many
+
+  describe "update_many" do
+
+    before do
+      Employee.create_many([{ :name => 'Keith', :company_id => 2 },
+                            { :name => 'Alex', :company_id => 1 },
+                            { :name => 'Mark', :company_id => 2 },
+                            { :name => 'Phil', :company_id => 3 }])
+    end
+
+    context "when call method with empty rows" do
+      it "returns empty array" do
+        Employee.update_many("").should == []
+      end
+    end # when call method with empty rows
+
+    context "when try to update records without options" do
+
+      context "input parameters is hash" do
+        it "records updated" do
+          Employee.update_many({ { :id => 1 } => {
+                                   :name => 'Elvis'
+                                 },
+                                 { :id => 2 } => {
+                                   :name => 'Freddi'
+                                 } })
+          Employee.find(1).name.should == "Elvis"
+          Employee.find(2).name.should == "Freddi"
+        end
+      end # input parameters is hash
+
+      context "input parameters is array" do
+        it "records updated" do
+          Employee.update_many([{ :id => 1,
+                                  :name => 'Elvis'
+                                },
+                                { :id => 2,
+                                  :name => 'Freddi'
+                                }])
+          Employee.find(1).name.should == "Elvis"
+          Employee.find(2).name.should == "Freddi"
+        end
+      end # input parameters is array
+
+      context "when try to update two records and doesn't the same number of keys" do
+        it "raises BulkUploadDataInconsistent" do
+          lambda { Employee.update_many([{ :id => 1, :name => 'Elvis', :salary => 1002  },
+                                         { :name => 'Freddi', :id => 2}])
+          }.should raise_error(BulkMethodsMixin::BulkUploadDataInconsistent)
+        end
+      end # when try to update two records and doesn't the same number of keys
+
+      context "when try to update records with the given updated_at" do
+        it "records created" do
+          Employee.update_many([{ :id => 1,
+                                  :updated_at => Time.zone.parse('2012-01-02')
+                                },
+                                { :id => 2,
+                                  :updated_at => Time.zone.parse('2012-01-03')
+                                },
+                                { :id => 3,
+                                  :updated_at => Time.zone.parse('2012-01-04')
+                                },
+                                { :id => 4,
+                                  :updated_at => Time.zone.parse('2012-01-05')
+                                }])
+          Employee.all.map{ |r| r.updated_at }.should == [
+                                                           Time.zone.parse('2012-01-02'),
+                                                           Time.zone.parse('2012-01-03'),
+                                                           Time.zone.parse('2012-01-04'),
+                                                           Time.zone.parse('2012-01-05')
+                                                          ]
+        end
+      end # when try to update records with the given updated_at
+
+    end # when try to update records without options
+
+    context "when call method with option :slice_size set is default" do
+      it "generates one insert queries" do
+        Employee.should_receive(:find_by_sql).once.and_return([])
+        Employee.update_many([{ :id => 1, :name => 'Elvis' },
+                              { :id => 2, :name => 'Freddi'},
+                              { :id => 3, :name => 'Patric'},
+                              { :id => 4, :name => 'Jane'}])
+      end
+    end # when call method with option :slice_size set is default
+
+
+    context "when call method with option :slice_size = 2" do
+      it "generates two insert queries" do
+        Employee.should_receive(:find_by_sql).twice.and_return([])
+        Employee.update_many([{ :id => 1, :name => 'Elvis' },
+                              { :id => 2, :name => 'Freddi'},
+                              { :id => 3, :name => 'Patric'},
+                              { :id => 4, :name => 'Jane'}],
+                              { :slice_size => 2})
+      end
+    end # when call method with option :slice_size = 2
+
+    context "when try to update two records and doesn't
+             the same number of keys and options check_consistency equal false" do
+      it "raises ActiveRecord::StatementInvalid" do
+        lambda {
+          Employee.update_many([{ :id => 1, :name => 'Elvis', :salary => 1002  },
+                                { :name => 'Freddi', :id => 2}],
+                                { :check_consistency => false })
+        }.should raise_error(ActiveRecord::StatementInvalid)
+      end
+    end # when try to update two records and doesn't
+        # the same number of keys and options check_consistency equal false
+
+    context "when update two records with options 'returning' equal :name" do
+      it "returns last records name" do
+        Employee.update_many([{ :id => 1, :name => 'Elvis' },
+                              { :id => 2, :name => 'Freddi'}],
+                              { :returning => [:name] }).
+                   last.name.should == 'Freddi'
+      end
+    end # when update two records with options 'returning' equal :name
+
+    context "when update method with options :set_array equal 'salary = datatable.salary'" do
+      it "updates only salary column" do
+        Employee.update_many([{ :id => 1, :name => 'Elvis', :salary => 12 },
+                              { :id => 2, :name => 'Freddi',:salary => 22}],
+                              { :set_array => '"salary = datatable.salary"' })
+        Employee.find(1).name.should_not == "Elvis"
+        Employee.find(1).salary.should == 12
+        Employee.find(2).name.should_not == "Freddi"
+        Employee.find(2).salary.should == 22
+      end
+    end # when update method with options :set_array equal 'salary = datatable.salary'
+
+    context "when update method with options :where" do
+      it "updates only name column, where salary equal input values" do
+        Employee.update_many([{ :id => 1, :name => 'Elvis', :salary => 12 },
+                              { :id => 2, :name => 'Freddi',:salary => 22}],
+                              { :where => '"#{table_name}.salary = datatable.salary"' })
+        Employee.find(1).name.should_not == "Elvis"
+        Employee.find(1).salary.should == 3
+        Employee.find(2).name.should_not == "Freddi"
+        Employee.find(2).salary.should == 3
+      end
+    end # when update method with options :where
+
+    context "when try to update records in the table that has all the different sql types" do
+
+      before do
+        ActiveRecord::Base.connection.execute <<-SQL
+          ALTER TABLE employees ADD COLUMN test_string character varying;
+          ALTER TABLE employees ADD COLUMN test_float float;
+          ALTER TABLE employees ADD COLUMN test_decimal decimal;
+          ALTER TABLE employees ADD COLUMN test_time time;
+          ALTER TABLE employees ADD COLUMN test_time_string time;
+          ALTER TABLE employees ADD COLUMN test_date date;
+          ALTER TABLE employees ADD COLUMN test_date_string date;
+          ALTER TABLE employees ADD COLUMN test_bytea bytea;
+          ALTER TABLE employees ADD COLUMN test_boolean boolean;
+          ALTER TABLE employees ADD COLUMN test_xml xml;
+          ALTER TABLE employees ADD COLUMN test_tsvector tsvector;
+        SQL
+        Employee.reset_column_information
+      end
+
+      after do
+        ActiveRecord::Base.connection.reset!
+      end
+
+      context "non-null values" do
+        it "returns record with all sql types" do
+          lambda { Employee.update_many([{ :id => 1,
+                                           :name => 'Keith',
+                                           :company_id => 2,
+                                           :created_at => Time.zone.parse('2012-12-21'),
+                                           :updated_at => '2012-12-21 00:00:00',
+                                           :test_string => "string",
+                                           :test_float => 12.34,
+                                           :test_decimal => 123456789101112,
+                                           :test_time => Time.now,
+                                           :test_time_string => '00:00:00',
+                                           :test_date => Date.parse('2012-12-21'),
+                                           :test_date_string => '2012-12-21',
+                                           :test_bytea => "text".bytes.to_a,
+                                           :test_boolean => false,
+                                           :test_xml => ["text"].to_xml,
+                                           :test_tsvector => "test string",
+                                         }]) }.should_not raise_error
+          Employee.find(1).test_boolean.should == false
+          Employee.find(1).test_tsvector.should == "'string' 'test'"
+        end
+      end # non-null values
+
+      context "null values" do
+        it "returns record with all sql types" do
+          lambda { Employee.update_many([{ :id => 1,
+                                           :name => 'Keith',
+                                           :company_id => 2,
+                                           :updated_at => nil,
+                                           :salary => nil,
+                                           :test_string => nil,
+                                           :test_float => nil,
+                                           :test_decimal => nil,
+                                           :test_time => nil,
+                                           :test_time_string => nil,
+                                           :test_date => nil,
+                                           :test_date_string => nil,
+                                           :test_bytea => nil,
+                                           :test_boolean => nil,
+                                           :test_xml => nil,
+                                           :test_tsvector => nil,
+                                         }]) }.should_not raise_error
+          Employee.find(1).test_boolean.should == nil
+          Employee.find(1).test_tsvector.should == nil
+        end
+      end # null values
+
+    end # when try to update records in the table that has all the different sql types
+
+  end # update_many
+
+end # BulkMethodsMixin

data/spec/dummy/.rspec

@@ -0,0 +1 @@
+--color

data/spec/dummy/README

@@ -0,0 +1 @@
+== dummy project

data/spec/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    "application", :media => "all" %>
+  <%= javascript_include_tag "application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/spec/dummy/config/application.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../boot', __FILE__)
+
+# Pick the frameworks you want:
+require "active_record/railtie"
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "active_resource/railtie"
+require "sprockets/railtie"
+# require "rails/test_unit/railtie"
+
+Bundler.require
+require "bulk_data_methods"
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Custom directories with classes and modules you want to be autoloadable.
+    # config.autoload_paths += %W(#{config.root}/extras)
+
+    # Only load the plugins named here, in the order given (default is alphabetical).
+    # :all can be used as a placeholder for all plugins not explicitly named.
+    # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+    # Activate observers that should always be running.
+    # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+
+    # Configure the default encoding used in templates for Ruby 1.9.
+    config.encoding = "utf-8"
+
+    # Configure sensitive parameters which will be filtered from the log file.
+    config.filter_parameters += [:password]
+
+    # Enable escaping HTML in JSON.
+    config.active_support.escape_html_entities_in_json = true
+
+    # Use SQL instead of Active Record's schema dumper when creating the database.
+    # This is necessary if your schema can't be completely dumped by the schema dumper,
+    # like if you have constraints or database-specific column types
+    # config.active_record.schema_format = :sql
+
+    # Enforce whitelist mode for mass assignment.
+    # This will create an empty whitelist of attributes available for mass-assignment for all models
+    # in your app. As such, your models will need to explicitly whitelist or blacklist accessible
+    # parameters by using an attr_accessible or attr_protected declaration.
+    config.active_record.whitelist_attributes = true
+
+    # Enable the asset pipeline
+    config.assets.enabled = true
+
+    # Version of your assets, change this if you want to expire all your assets
+    config.assets.version = '1.0'
+  end
+end
+

data/spec/dummy/config/boot.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+gemfile = File.expand_path('../../../../Gemfile', __FILE__)
+
+if File.exist?(gemfile)
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+  Bundler.setup
+end
+
+$:.unshift File.expand_path('../../../../lib', __FILE__)

data/spec/dummy/config/database-sample.yml

@@ -0,0 +1,32 @@
+common: &common
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  encoding: SQL_ASCII
+  template: template0
+  pool: 5
+  timeout: 5000
+
+local: &local
+  host: 127.0.0.1
+
+# -----------------
+# *** part ***
+# -----------------
+
+development:
+  <<: *common
+  <<: *local
+  database: bulk_data_methods_production
+
+production:
+  <<: *common
+  <<: *local
+  database: bulk_data_methods_production
+
+
+test:
+  <<: *common
+  <<: *local
+  database: bulk_data_methods_test
+

data/spec/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the rails application
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application
+Dummy::Application.initialize!

data/spec/dummy/config/environments/development.rb

@@ -0,0 +1,37 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # In the development environment your application's code is reloaded on
+  # every request. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Log error messages when you accidentally call methods on nil.
+  config.whiny_nils = true
+
+  # Show full error reports and disable caching
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  # Don't care if the mailer can't send
+  config.action_mailer.raise_delivery_errors = false
+
+  # Print deprecation notices to the Rails logger
+  config.active_support.deprecation = :log
+
+  # Only use best-standards-support built into browsers
+  config.action_dispatch.best_standards_support = :builtin
+
+  # Raise exception on mass assignment protection for Active Record models
+  config.active_record.mass_assignment_sanitizer = :strict
+
+  # Log the query plan for queries taking more than this (works
+  # with SQLite, MySQL, and PostgreSQL)
+  config.active_record.auto_explain_threshold_in_seconds = 0.5
+
+  # Do not compress assets
+  config.assets.compress = false
+
+  # Expands the lines which load the assets
+  config.assets.debug = true
+end