mass_insert 0.0.1

data/spec/mass_insert/adapters/helpers/timestamp_spec.rb

@@ -0,0 +1,79 @@
+require './spec/spec_helper'
+require "./lib/mass_insert"
+
+describe MassInsert::Adapters::Helpers::Timestamp do
+  before :each do
+    @adapter = MassInsert::Adapters::Adapter.new([], {})
+  end
+
+  subject{ @adapter }
+
+  describe "#timestamp?" do
+    it "should respond_to timestamp? method" do
+      subject.respond_to?(:timestamp?).should be_true
+    end
+
+    context "when respond to timestamp columns" do
+      it "should return true" do
+        subject.stub(:column_names).and_return([:updated_at, :created_at])
+        subject.timestamp?.should be_true
+      end
+    end
+
+    context "when not respond to timestamp columns" do
+      it "should return false" do
+        subject.stub(:column_names).and_return([:created_at])
+        subject.timestamp?.should be_false
+      end
+    end
+  end
+
+  describe "#timestamp_format" do
+    it "should respond_to timestamp_format method" do
+      subject.respond_to?(:timestamp_format).should be_true
+    end
+
+    it "should return the default timestamp format" do
+      subject.timestamp_format.should eq("%Y-%m-%d %H:%M:%S.%6N")
+    end
+  end
+
+  describe "#timestamp" do
+    it "should respond_to timestamp method" do
+      subject.respond_to?(:timestamp).should be_true
+    end
+
+    it "should return the default timestamp value with correct format" do
+      subject.stub(:timestamp_format).and_return("%Y-%m-%d %H:%M:%S")
+      timestamp_value = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      subject.timestamp.should eq(timestamp_value)
+    end
+  end
+
+  describe "#timestamp_values" do
+    it "should respond_to timestamp_values method" do
+      subject.respond_to?(:timestamp_values).should be_true
+    end
+
+    context "when have high precision" do
+      it "should no be equals" do
+        timestamp_values = {
+          :created_at => subject.timestamp,
+          :updated_at => subject.timestamp
+        }
+        subject.timestamp_values.should_not eq(timestamp_values)
+      end
+    end
+
+    context "when do not have precision" do
+      it "should be equals" do
+        subject.stub(:timestamp_format).and_return("%Y-%m-%d %H:%M:%S")
+        timestamp_values = {
+          :created_at => subject.timestamp,
+          :updated_at => subject.timestamp
+        }
+        subject.timestamp_values.should eq(timestamp_values)
+      end
+    end
+  end
+end

data/spec/mass_insert/adapters/helpers_spec.rb

@@ -0,0 +1,16 @@
+require './spec/spec_helper'
+require "./lib/mass_insert"
+
+describe MassInsert::Adapters::Helpers do
+  it 'should be defined' do
+    should be
+  end
+
+  it 'should define Timestamp module' do
+    MassInsert::Adapters::Helpers::Timestamp.should be
+  end
+
+  it 'should define Sanitizer module' do
+    MassInsert::Adapters::Helpers::Sanitizer.should be
+  end
+end

data/spec/mass_insert/adapters/mysql_adapter_spec.rb

@@ -0,0 +1,39 @@
+require './spec/spec_helper'
+require "./lib/mass_insert"
+
+describe MassInsert::Adapters::Mysql2Adapter do
+  before :each do
+    @adapter = MassInsert::Adapters::Mysql2Adapter.new([], {})
+  end
+
+  subject{ @adapter }
+
+  it "should inherit from Adapter class" do
+    subject.should be_a(MassInsert::Adapters::Adapter)
+  end
+
+  describe "instance methods" do
+    describe "#timestamp_format" do
+      it "should respond to timestamp_format method" do
+        subject.respond_to?(:timestamp_format).should be_true
+      end
+
+      it "should return the format string" do
+        subject.timestamp_format.should eq("%Y-%m-%d %H:%M:%S")
+      end
+    end
+
+    describe "#execute" do
+      it "should respond to execute method" do
+        subject.respond_to?(:execute).should be_true
+      end
+
+      it "call methods and returns their values concatenated" do
+        subject.stub(:begin_string).and_return("a")
+        subject.stub(:string_columns).and_return("b")
+        subject.stub(:string_values).and_return("c")
+        subject.execute.should eq("abc")
+      end
+    end
+  end
+end

data/spec/mass_insert/adapters/postgresql_adapter_spec.rb

@@ -0,0 +1,29 @@
+require './spec/spec_helper'
+require "./lib/mass_insert"
+
+describe MassInsert::Adapters::PostgreSQLAdapter do
+  before :each do
+    @adapter = MassInsert::Adapters::PostgreSQLAdapter.new([], {})
+  end
+
+  subject{ @adapter }
+
+  it "should inherit from Adapter class" do
+    subject.should be_a(MassInsert::Adapters::Adapter)
+  end
+
+  describe "instance methods" do
+    describe "#execute" do
+      it "should respond to execute method" do
+        subject.respond_to?(:execute).should be_true
+      end
+
+      it "call methods and returns their values concatenated" do
+        subject.stub(:begin_string).and_return("a")
+        subject.stub(:string_columns).and_return("b")
+        subject.stub(:string_values).and_return("c")
+        subject.execute.should eq("abc")
+      end
+    end
+  end
+end

data/spec/mass_insert/adapters/sqlite3_adapter_spec.rb

@@ -0,0 +1,90 @@
+require './spec/spec_helper'
+require "./lib/mass_insert"
+
+describe MassInsert::Adapters::SQLite3Adapter do
+  before :each do
+    @adapter = MassInsert::Adapters::SQLite3Adapter.new([], {})
+  end
+
+  subject{ @adapter }
+
+  it "should inherit from Adapter class" do
+    subject.should be_a(MassInsert::Adapters::Adapter)
+  end
+
+  describe "instance methods" do
+    describe "#string_values" do
+      it "should respond to string_values method" do
+        subject.respond_to?(:string_values).should be_true
+      end
+
+      it "should returns correct string to values" do
+        subject.stub(:string_rows_values).and_return("string_rows_values")
+        subject.string_values.should eq("SELECT string_rows_values;")
+      end
+    end
+
+    describe "#string_rows_values" do
+      it "should respond to string_rows_values method" do
+        subject.respond_to?(:string_rows_values).should be_true
+      end
+
+      context "when only have one value hash" do
+        it "should returns the correct string" do
+          subject.stub(:string_single_row_values).and_return("single_row")
+          subject.values = [{}]
+          subject.string_rows_values.should eq("single_row")
+        end
+      end
+
+      context "when have two or more value hashes" do
+        it "should returns the correct string" do
+          subject.stub(:string_single_row_values).and_return("single_row")
+          subject.values = [{}, {}]
+          string = "single_row UNION SELECT single_row"
+          subject.string_rows_values.should eq(string)
+        end
+      end
+    end
+
+    describe "#execute" do
+      it "should respond to execute method" do
+        subject.respond_to?(:execute).should be_true
+      end
+
+      context "when have less than 500 values" do
+        it "call methods and returns their values concatenated" do
+          subject.values = [{}]
+          subject.stub(:begin_string).and_return("a")
+          subject.stub(:string_columns).and_return("b")
+          subject.stub(:string_values).and_return("c")
+          subject.execute.should eq(["abc"])
+        end
+      end
+
+      context "when have more than 500 values" do
+        it "call methods and returns their values concatenated" do
+          subject.values = []
+          800.times{ subject.values << {} }
+          subject.stub(:begin_string).and_return("a")
+          subject.stub(:string_columns).and_return("b")
+          subject.stub(:string_values).and_return("c")
+          subject.execute.should eq(["abc", "abc"])
+        end
+      end
+    end
+  end
+
+  describe "MAX_VALUES_PER_INSERTION" do
+    it "should respond_to" do
+      class_name = MassInsert::Adapters::SQLite3Adapter
+      constant   = "MAX_VALUES_PER_INSERTION".to_sym
+      class_name.const_defined?(constant).should be_true
+    end
+
+    it "should return 1000" do
+      class_name = MassInsert::Adapters::SQLite3Adapter
+      class_name::MAX_VALUES_PER_INSERTION.should eq(500)
+    end
+  end
+end

data/spec/mass_insert/adapters/sqlserver_adapter_spec.rb

@@ -0,0 +1,56 @@
+require './spec/spec_helper'
+require "./lib/mass_insert"
+
+describe MassInsert::Adapters::SQLServerAdapter do
+  before :each do
+    @adapter = MassInsert::Adapters::SQLServerAdapter.new([], {})
+  end
+
+  subject{ @adapter }
+
+  it "should inherit from Adapter class" do
+    subject.should be_a(MassInsert::Adapters::Adapter)
+  end
+
+  describe "instance methods" do
+    describe "#execute" do
+      it "should respond to execute method" do
+        subject.respond_to?(:execute).should be_true
+      end
+
+      context "when have less than 1000 values" do
+        it "call methods and returns their values concatenated" do
+          subject.values = [{}]
+          subject.stub(:begin_string).and_return("a")
+          subject.stub(:string_columns).and_return("b")
+          subject.stub(:string_values).and_return("c")
+          subject.execute.should eq(["abc"])
+        end
+      end
+
+      context "when have more than 1000 values" do
+        it "call methods and returns their values concatenated" do
+          subject.values = []
+          1500.times{ subject.values << {} }
+          subject.stub(:begin_string).and_return("a")
+          subject.stub(:string_columns).and_return("b")
+          subject.stub(:string_values).and_return("c")
+          subject.execute.should eq(["abc", "abc"])
+        end
+      end
+    end
+  end
+
+  describe "MAX_VALUES_PER_INSERTION" do
+    it "should respond_to" do
+      class_name = MassInsert::Adapters::SQLServerAdapter
+      constant   = "MAX_VALUES_PER_INSERTION".to_sym
+      class_name.const_defined?(constant).should be_true
+    end
+
+    it "should return 1000" do
+      class_name = MassInsert::Adapters::SQLServerAdapter
+      class_name::MAX_VALUES_PER_INSERTION.should eq(1000)
+    end
+  end
+end

data/spec/mass_insert/adapters_spec.rb

@@ -0,0 +1,40 @@
+require './spec/spec_helper'
+require "./lib/mass_insert"
+
+describe MassInsert::Adapters do
+  it 'should be defined' do
+    should be
+  end
+
+  it 'should define Adapter class' do
+    MassInsert::Adapters::Adapter.should be
+  end
+
+  it 'should define AbstractQuery class' do
+    MassInsert::Adapters::AbstractQuery.should be
+  end
+
+  it 'should define ColumnValue class' do
+    MassInsert::Adapters::ColumnValue.should be
+  end
+
+  it 'should define ColumnValue class' do
+    MassInsert::Adapters::Helpers.should be
+  end
+
+  it 'should define MysqlAdapter class' do
+    MassInsert::Adapters::Mysql2Adapter.should be
+  end
+
+  it 'should define PostgreSQLAdapter class' do
+    MassInsert::Adapters::PostgreSQLAdapter.should be
+  end
+
+  it 'should define SQLite3Adapter class' do
+    MassInsert::Adapters::SQLite3Adapter.should be
+  end
+
+  it 'should define SQLServerAdapter class' do
+    MassInsert::Adapters::SQLServerAdapter.should be
+  end
+end

data/spec/mass_insert/base_spec.rb

@@ -0,0 +1,98 @@
+require './spec/spec_helper'
+require "./lib/mass_insert"
+require "./spec/dummy_models/test"
+
+describe MassInsert::Base do
+  describe "class methods" do
+    describe ".mass_insert" do
+      before :each do
+        MassInsert::ProcessControl.any_instance.stub(:execute => true)
+      end
+
+      it "should respond to mass_insert class method" do
+        Test.respond_to?(:mass_insert).should be_true
+      end
+
+      it "should can receive values and many options" do
+        values  = [{:name => "name"}]
+        options = {:option_one => "one", :option_two => "two"}
+        Test.mass_insert(values, options).should be_true
+      end
+
+      it "should can receive only values" do
+        values  = [{:name => "name"}]
+        Test.mass_insert(values).should be_true
+      end
+
+      it "should not can called with values" do
+        lambda{ Test.mass_insert }.should raise_error
+      end
+
+      it "should call execute ProcessControl method" do
+        process = MassInsert::ProcessControl.any_instance
+        process.should_receive(:execute).exactly(1).times
+        Test.mass_insert([], {})
+      end
+
+      it "should call mass_insert_options method" do
+        Test.any_instance.stub(:mass_insert_options)
+        Test.should_receive(:mass_insert_options).exactly(1).times
+        Test.mass_insert([], {})
+      end
+    end
+
+    describe ".mass_insert_options" do
+      describe "class_name" do
+        it "returns class name that call if that option doesn't exist" do
+          options = Test.send(:mass_insert_options)
+          options[:class_name].should eq(Test)
+        end
+
+        it "returns class_name option if is in the options" do
+          args = {:class_name => "OtherClass"}
+          options = Test.send(:mass_insert_options, args)
+          options[:class_name].should eq("OtherClass")
+        end
+      end
+
+      describe "table_name" do
+        it "returns class table_name that call if options doesn't exist" do
+          options = Test.send(:mass_insert_options)
+          options[:table_name].should eq(Test.table_name)
+        end
+
+        it "returns table_name option if is in the options" do
+          args = {:table_name => "OtherTable"}
+          options = Test.send(:mass_insert_options, args)
+          options[:table_name].should eq("OtherTable")
+        end
+      end
+
+      describe "primary_key" do
+        it "returns :id if option primary_key doesn't exist" do
+          options = Test.send(:mass_insert_options)
+          options[:primary_key].should eq(:id)
+        end
+
+        it "returns primary_key option if is in the options" do
+          args = {:primary_key => :user_id}
+          options = Test.send(:mass_insert_options, args)
+          options[:primary_key].should eq(:user_id)
+        end
+      end
+
+      describe "primary_key_mode" do
+        it "returns :auto if option primary_key_mode doesn't exist" do
+          options = Test.send(:mass_insert_options)
+          options[:primary_key_mode].should eq(:auto)
+        end
+
+        it "returns primary_key_mode option if is in the options" do
+          args = {:primary_key_mode => :manual}
+          options = Test.send(:mass_insert_options, args)
+          options[:primary_key_mode].should eq(:manual)
+        end
+      end
+    end
+  end
+end