mass_insert 0.1.3 → 0.2.0

data/spec/lib/mass_insert/builder/adapters/adapter_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Builder::Adapters::Adapter do
-  let!(:subject){ described_class.new([], {}) }
-
-  describe "#initialize" do
-    it "initializes values" do
-      expect(subject.values).to eq([])
-    end
-
-    it "initializes options" do
-      expect(subject.options).to eq({})
-    end
-  end
-
-  describe "#class_name" do
-    it "returns class_name option value" do
-      subject.options = {:class_name => "FakeModel"}
-      expect(subject.class_name).to eq("FakeModel")
-    end
-  end
-
-  describe "#primary_key" do
-    it "returns primary_key option value" do
-      subject.options = {:primary_key => true}
-      expect(subject.primary_key).to be_true
-    end
-  end
-
-  describe "#each_slice" do
-    it "returns each_slice option value" do
-      subject.options = {:each_slice => 10000}
-      expect(subject.each_slice).to be 10000
-    end
-  end
-
-  describe "#columns" do
-    context "when instance columns variable isn't defined" do
-      it "returns sanitized_columns result" do
-        subject.stub(:sanitized_columns).and_return("sanitized_columns")
-        expect(subject.columns).to eq("sanitized_columns")
-      end
-    end
-
-    context "when instance columns variable has been defined" do
-      it "returns instance columns variable" do
-        subject.stub(:sanitized_columns).and_return("sanitized_columns")
-        subject.columns
-        subject.stub(:sanitized_columns).and_return("sanitized_columns_other")
-        expect(subject.columns).to eq("sanitized_columns")
-      end
-    end
-  end
-
-  describe "#sanitized_columns" do
-    before :each do
-      subject.options.merge!({:class_name => User})
-      User.stub(:column_names).and_return(["id", "name", "email"])
-    end
-
-    context "when primary_key is false" do
-      it "returns the columns array without primary key column" do
-        subject.options.merge!({:primary_key => false})
-        expect(subject.columns).to eq([:name, :email])
-      end
-    end
-
-    context "when primary key is true" do
-      it "returns the columns array with primary key column" do
-        subject.options.merge!({:primary_key => true})
-        expect(subject.columns).to eq([:id, :name, :email])
-      end
-    end
-  end
-
-  describe "#timestamp?" do
-    context "when respond to timestamp columns" do
-      it "returns true" do
-        subject.stub(:columns).and_return([:updated_at, :created_at])
-        expect(subject.timestamp?).to be_true
-      end
-    end
-
-    context "when doesn't respond to timestamp columns" do
-      it "returns false" do
-        subject.stub(:columns).and_return([:created_at])
-        expect(subject.timestamp?).to be_false
-      end
-    end
-  end
-
-  describe "#timestamp_hash" do
-    it "returns a timestamp hash" do
-      time = Time.now
-      Time.stub(:now).and_return(time)
-      expect(subject.timestamp_hash).to eq({:created_at => Time.now, :updated_at => Time.now})
-    end
-  end
-
-  describe "#values_per_insertion" do
-    context "when each_slice option is not false" do
-      it "returns each_slice value" do
-        subject.options.merge!(each_slice: 10)
-        expect(subject.values_per_insertion).to eq(10)
-      end
-    end
-
-    context "when each_slice option is false" do
-      it "returns length of values" do
-        subject.values = [{}, {}]
-        subject.options.merge!(each_slice: false)
-        expect(subject.values_per_insertion).to eq(2)
-      end
-    end
-  end
-end

data/spec/lib/mass_insert/builder/adapters/helpers/abstract_query_spec.rb

@@ -1,130 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Builder::Adapters::Helpers::AbstractQuery do
-  let!(:subject){ MassInsert::Builder::Adapters::Adapter.new([], {}) }
-
-  describe "#begin_string" do
-    it "returns the basic beginning of the query" do
-      subject.stub(:class_name).and_return(User)
-      expect(subject.begin_string).to eq("INSERT INTO users ")
-    end
-  end
-
-  describe "#string_columns" do
-    it "returns the correct columns string" do
-      subject.stub(:columns).and_return([:name, :email])
-      expect(subject.string_columns).to eq("(name, email) ")
-    end
-  end
-
-  describe "#string_values" do
-    it "returns the correct values string" do
-      subject.stub(:string_rows_values).and_return("rows_values")
-      expect(subject.string_values).to eq("VALUES (rows_values);")
-    end
-  end
-
-  describe "#string_rows_values" do
-    context "when is one value" do
-      it "returns the correct string" do
-        subject.stub(:string_single_row_values).and_return("row")
-        subject.values = [{}]
-        expect(subject.string_rows_values).to eq("row")
-      end
-    end
-
-    context "when are two or more values" do
-      it "returns the correct string" do
-        subject.stub(:string_single_row_values).and_return("row")
-        subject.values = [{}, {}]
-        expect(subject.string_rows_values).to eq("row), (row")
-      end
-    end
-  end
-
-  describe "#string_single_row_values" do
-    before :each do
-      subject.stub(:string_single_value).and_return("value")
-    end
-
-    it "returns the correct string" do
-      subject.stub(:columns).and_return([:name, :email])
-      expect(subject.string_single_row_values({})).to eq("value, value")
-    end
-
-    context "when responds to timestamp attributes" do
-      it "calls timestamp_values method" do
-        subject.stub(:columns).and_return([:created_at, :updated_at])
-        subject.stub(:timestamp_hash).and_return(:test => "test")
-        subject.should_receive(:timestamp_hash).exactly(1).times
-        subject.string_single_row_values({})
-      end
-    end
-
-    context "when not respond to timestamp attributes" do
-      it "should returns the correct string" do
-        subject.stub(:columns).and_return([:name, :email])
-        subject.should_receive(:timestamp_hash).exactly(0).times
-        subject.string_single_row_values({})
-      end
-    end
-  end
-
-  describe "#string_single_value" do
-    let(:row){ Hash.new }
-    let(:column){ :name }
-    let(:column_value_class){ MassInsert::Builder::Adapters::Helpers::ColumnValue }
-
-    before :each do
-      subject.stub(:class_name).and_return(User)
-    end
-
-    it "instances ColumnValue class exactly one time" do
-      column_value_class.stub(:new).and_return("column_value_instance")
-      column_value_class.new.stub(:build).and_return("column_value")
-      column_value_class.should_receive(:new).exactly(1).times
-      subject.string_single_value(row, column)
-    end
-
-    it "instances ColumnValue class with the correct params" do
-      column_value_class.stub(:new).and_return("column_value_instance")
-      column_value_class.new.stub(:build).and_return("column_value")
-      column_value_class.should_receive(:new).with(row, column, User)
-      subject.string_single_value(row, column)
-    end
-
-    it "calls ColumnValue#build exactly one time" do
-      column_value_class.any_instance.should_receive(:build).exactly(1).times
-      subject.string_single_value(row, column)
-    end
-
-    it "returns ColumnValue#build method result" do
-      column_value_class.any_instance.stub(:build).and_return("column_value1")
-      expect(subject.string_single_value(row, column)).to eq("column_value1")
-    end
-  end
-
-  describe "#execute" do
-    before :each do
-      subject.stub(:begin_string).and_return("a")
-      subject.stub(:string_columns).and_return("b")
-      subject.stub(:string_values).and_return("c")
-    end
-
-    context "when have less or equal values than values_per_insertion" do
-      it "generates one query" do
-        subject.values = [{}]
-        subject.stub(:values_per_insertion).and_return(1)
-        expect(subject.execute).to eq(["abc"])
-      end
-    end
-
-    context "when have more values than values_per_insertion" do
-      it "generates queries according to the slices" do
-        subject.values = [{}, {}]
-        subject.stub(:values_per_insertion).and_return(1)
-        expect(subject.execute).to eq(["abc", "abc"])
-      end
-    end
-  end
-end

data/spec/lib/mass_insert/builder/adapters/helpers/column_value_spec.rb

@@ -1,222 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Builder::Adapters::Helpers::ColumnValue do
-  let(:class_name) { User }
-  let(:row) {{ :name	=> "name", :age	=> 10 }}
-  let(:column){ :name }
-  let!(:subject){ described_class.new(row, column, class_name) }
-
-  describe "#initialize" do
-    it "sets class_name attribute" do
-      expect(subject.class_name).to eq(class_name)
-    end
-
-    it "sets column attribute" do
-      expect(subject.column).to eq(column)
-    end
-
-    it "sets row attribute" do
-      expect(subject.row).to eq(row)
-    end
-  end
-
-  describe "#column_type" do
-    it "returns column type symbol" do
-      subject.stub(:class_name).and_return(User)
-      subject.class_name.stub(:columns_hash).and_return({"name" => "SomeObject"})
-      subject.class_name.columns_hash["name"].stub(:type).and_return(:column_type)
-      expect(subject.column_type).to eq(:column_type)
-    end
-  end
-
-  describe "#colum_value" do
-    it "returns row value to this column" do
-      expect(subject.column_value).to eq("name")
-    end
-  end
-
-  describe "#default_value" do
-    context "when default_db_value is nil" do
-      it "returns 'null' string" do
-        subject.stub(:default_db_value).and_return(nil)
-        expect(subject.default_value).to eq("null")
-      end
-    end
-
-    context "when default_db_value is not nil" do
-      it "returns the correct value" do
-        subject.stub(:default_db_value).and_return("default_value")
-        expect(subject.default_value).to eq("default_value")
-      end
-    end
-  end
-
-  describe "#default_db_value" do
-    it "returns the default database value" do
-      subject.stub(:class_name).and_return(User)
-      subject.class_name.stub(:columns_hash).and_return({"name" => "SomeObject"})
-      subject.class_name.columns_hash["name"].stub(:default).and_return(:default_db_value)
-      expect(subject.default_db_value).to eq(:default_db_value)
-    end
-  end
-
-  describe "#build" do
-    context "when column_value is nil" do
-      it "returns the default value" do
-        subject.stub(:column_value).and_return(nil)
-        subject.stub(:default_value).and_return("default_value")
-        expect(subject.build).to eq("default_value")
-      end
-    end
-
-    context "when column_value is not nil" do
-      it "calls a method according to column type" do
-        subject.stub(:column_type).and_return("string")
-        subject.stub(:column_value_string).and_return("column_value_string")
-        expect(subject.build).to eq("column_value_string")
-      end
-    end
-  end
-
-  [
-    :string,
-    :text,
-    :date,
-    :binary
-  ].each do |column_type|
-    method = :"column_value_#{column_type}"
-
-    describe "##{method.to_s}" do
-      it "returns the column value" do
-        subject.stub(:column_value).and_return("name")
-        expect(subject.send(method)).to eq("'name'")
-      end
-    end
-  end
-
-  [
-    :time,
-    :datetime,
-    :timestamp,
-  ].each do |column_type|
-    method = :"column_value_#{column_type}"
-
-    describe "##{method.to_s}" do
-      before :each do
-        time = Time.now
-        Time.stub(:now).and_return(time)
-        subject.stub(:column_value).and_return(Time.now)
-      end
-
-      context "when adapter is mysql2" do
-        it "returns date with the correct format" do
-          MassInsert::Builder::Utilities.stub(:adapter).and_return('mysql2')
-          expect(subject.send(method)).to eq("'#{Time.now.strftime("%Y-%m-%d %H:%M:%S")}'")
-        end
-      end
-
-      context "when adapter is sqlserver" do
-        it "returns date with the correct format" do
-          MassInsert::Builder::Utilities.stub(:adapter).and_return('sqlserver')
-          expect(subject.send(method)).to eq("'#{Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")}'")
-        end
-      end
-
-      context "when adapter is sqlite3" do
-        it "returns date with the correct format" do
-          MassInsert::Builder::Utilities.stub(:adapter).and_return('sqlite3')
-          expect(subject.send(method)).to eq("'#{Time.now.strftime("%Y-%m-%d %H:%M:%S.%6N")}'")
-        end
-      end
-
-      context "when adapter is postgresql" do
-        it "returns date with the correct format" do
-          MassInsert::Builder::Utilities.stub(:adapter).and_return('postgresql')
-          expect(subject.send(method)).to eq("'#{Time.now.strftime("%Y-%m-%d %H:%M:%S.%6N")}'")
-        end
-      end
-    end
-  end
-
-  describe "#column_value_integer" do
-    context "when is a integer value" do
-      it "returns the same integer value" do
-        subject.stub(:column_value).and_return(20)
-        expect(subject.column_value_integer).to eq("20")
-      end
-    end
-
-    context "when is not a integer value" do
-      it "converts it to integer value" do
-        subject.stub(:column_value).and_return("name")
-        expect(subject.column_value_integer).to eq("0")
-      end
-    end
-  end
-
-  [:decimal, :float].each do |column_type|
-    method = :"column_value_#{column_type}"
-
-    describe "##{method.to_s}" do
-      context "when is a decimal value" do
-        it "returns the same decimal value" do
-          subject.stub(:column_value).and_return(20.5)
-          expect(subject.send(method)).to eq("20.5")
-        end
-      end
-
-      context "when is not a decimal value" do
-        it "converts it to decimal value" do
-          subject.stub(:column_value).and_return("name")
-          expect(subject.send(method)).to eq("0.0")
-        end
-      end
-    end
-  end
-
-  describe "#column_value_boolean" do
-    [:mysql2, :postgresql].each do |adapter|
-      context "when the adapter is #{adapter}" do
-        before :each do
-          MassInsert::Builder::Utilities.stub(:adapter).and_return(adapter.to_s)
-        end
-
-        context "when the column value evals to true" do
-          it "returns true" do
-            subject.stub(:column_value).and_return(true)
-            expect(subject.column_value_boolean).to eq("true")
-          end
-        end
-
-        context "when the column value evals to false" do
-          it "returns false" do
-            subject.stub(:column_value).and_return(false)
-            expect(subject.column_value_boolean).to eq("false")
-          end
-        end
-      end
-    end
-
-    [:sqlite3, :sqlserver].each do |adapter|
-      context "when the adapter is #{adapter}" do
-        before :each do
-          MassInsert::Builder::Utilities.stub(:adapter).and_return(adapter.to_s)
-        end
-
-        context "when the column value evals to true" do
-          it "returns true" do
-            subject.stub(:column_value).and_return(true)
-            expect(subject.column_value_boolean).to eq("1")
-          end
-        end
-
-        context "when the column value evals to false" do
-          it "returns false" do
-            subject.stub(:column_value).and_return(false)
-            expect(subject.column_value_boolean).to eq("0")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/mass_insert/builder/adapters/mysql_adapter_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Builder::Adapters::Mysql2Adapter do
-  let!(:subject){ described_class.new([], {}) }
-
-  it "inherits from Adapter class" do
-    expect(described_class < MassInsert::Builder::Adapters::Adapter).to be_true
-  end
-end

data/spec/lib/mass_insert/builder/adapters/postgresql_adapter_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Builder::Adapters::PostgreSQLAdapter do
-  let!(:subject){ described_class.new([], {}) }
-
-  it "inherits from Adapter class" do
-    expect(described_class < MassInsert::Builder::Adapters::Adapter).to be_true
-  end
-end

data/spec/lib/mass_insert/builder/adapters/sqlite3_adapter_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Builder::Adapters::SQLite3Adapter do
-  let!(:subject){ described_class.new([], {}) }
-
-  it "inherits from Adapter class" do
-    expect(described_class < MassInsert::Builder::Adapters::Adapter).to be_true
-  end
-
-  describe "#values_per_insertion" do
-    context "when each_slice option isn't false" do
-      it "returns each_slice option value" do
-        subject.options.merge!(each_slice: 10)
-        expect(subject.values_per_insertion).to eq(10)
-      end
-    end
-
-    context "when each_slice option is false" do
-      it "returns 500" do
-        subject.options.merge!(each_slice: false)
-        expect(subject.values_per_insertion).to eq(500)
-      end
-    end
-  end
-
-  describe "#string_values" do
-    it "returns the correct values string" do
-      subject.stub(:string_rows_values).and_return("rows_values")
-      expect(subject.string_values).to eq("SELECT rows_values;")
-    end
-  end
-
-  describe "#string_rows_values" do
-    before :each do
-      subject.stub(:string_single_row_values).and_return("row_values")
-    end
-
-    context "when is one value" do
-      it "returns the correct string" do
-        subject.values = [{}]
-        expect(subject.string_rows_values).to eq("row_values")
-      end
-    end
-
-    context "when are two values" do
-      it "returns the correct string" do
-        subject.values = [{}, {}]
-        expect(subject.string_rows_values).to eq("row_values UNION SELECT row_values")
-      end
-    end
-  end
-end

data/spec/lib/mass_insert/builder/adapters/sqlserver_adapter_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Builder::Adapters::SQLServerAdapter do
-  let!(:subject){ described_class.new([], {}) }
-
-  it "inherits from Adapter class" do
-    expect(described_class < MassInsert::Builder::Adapters::Adapter).to be_true
-  end
-
-  describe "#string_columns" do
-    it "returns the correct columns string to SQLServer" do
-      subject.stub(:columns).and_return([:name, :email])
-      expect(subject.string_columns).to eq("([name], [email]) ")
-    end
-  end
-
-  describe "#values_per_insertion" do
-    context "when each_slice option isn't false" do
-      it "returns each_slice option value" do
-        subject.options.merge!(each_slice: 10)
-        expect(subject.values_per_insertion).to eq(10)
-      end
-    end
-
-    context "when each_slice option is false" do
-      it "returns 1000" do
-        subject.options.merge!(each_slice: false)
-        expect(subject.values_per_insertion).to eq(1000)
-      end
-    end
-  end
-end

data/spec/lib/mass_insert/builder/adapters_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Builder::Adapters do
-  it 'loads Adapter class' do
-    expect(described_class::Adapter).to be
-  end
-
-  it 'loads MysqlAdapter class' do
-    expect(described_class::Mysql2Adapter).to be
-  end
-
-  it 'loads PostgreSQLAdapter class' do
-    expect(described_class::PostgreSQLAdapter).to be
-  end
-
-  it 'loads SQLite3Adapter class' do
-    expect(described_class::SQLite3Adapter).to be
-  end
-
-  it 'loads SQLServerAdapter class' do
-    expect(described_class::SQLServerAdapter).to be
-  end
-
-  it 'loads Helpers AbstractQuery module' do
-    expect(described_class::Helpers::AbstractQuery).to be
-  end
-
-  it 'loads Helpers ColumnValue class' do
-    expect(described_class::Helpers::ColumnValue).to be
-  end
-end

data/spec/lib/mass_insert/builder/base_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Builder::Base do
-  describe "#build" do
-    adapters_supported.each do |adapter_type, adapter_class|
-      context "when adapter_class is #{adapter_class}" do
-        it "returns the queries" do
-          adapter = "MassInsert::Builder::Adapters::#{adapter_class}".constantize
-          adapter.any_instance.stub(:execute).and_return("#{adapter_type}_queries")
-          subject.stub(:adapter_class).and_return(adapter)
-          expect(subject.build("values", "options")).to eq("#{adapter_type}_queries")
-        end
-      end
-    end
-  end
-
-  describe "#adapter_class" do
-    adapters_supported.each do |adapter_type, adapter_class|
-      context "when adapter is #{adapter_type}" do
-        it "returns #{adapter_class}" do
-          MassInsert::Builder::Utilities.stub(:adapter).and_return(adapter_type)
-          adapter = "MassInsert::Builder::Adapters::#{adapter_class}".constantize
-          expect(subject.adapter_class).to eq(adapter)
-        end
-      end
-    end
-  end
-end

data/spec/lib/mass_insert/builder/utilities_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Builder::Utilities do
-  describe ".adapter" do
-    it "returns adapter type" do
-      connection = ActiveRecord::Base.connection
-      connection.stub(:instance_values => {"config" => {:adapter => "mysql2"}})
-      expect(described_class.adapter).to eq("mysql2")
-    end
-  end
-end

data/spec/lib/mass_insert/executer_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe MassInsert::Executer do
-  let!(:subject){ MassInsert::Executer.new }
-
-  describe "#execute" do
-    before :each do
-      @connection = ActiveRecord::Base.connection
-      @connection.stub(:execute)
-    end
-
-    context "when receives an array without queries" do
-      it "doesn't call ActiveRecord::Base.connection.execute" do
-        @connection.should_not_receive(:execute)
-        subject.execute([])
-      end
-    end
-
-    context "when receives an array with one query" do
-      it "calls ActiveRecord::Base.connection.execute one time" do
-        @connection.should_receive(:execute).exactly(1).times
-        subject.execute("one")
-      end
-    end
-
-    context "when receives an array with more than one query" do
-      it "calls ActiveRecord::Base.connection.execute two times" do
-        @connection.should_receive(:execute).exactly(2).times
-        subject.execute(["one", "two"])
-      end
-    end
-  end
-end