mass_insert 0.1.1 → 0.1.2

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

@@ -1,75 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-
-describe MassInsert::Adapters::AdapterHelpers::Timestamp do
-  let!(:subject){ MassInsert::Adapters::Adapter.new([], {}) }
-
-  describe "#timestamp?" do
-    it "should respond_to timestamp? method" do
-      expect(subject).to respond_to(:timestamp?)
-    end
-
-    context "when respond to timestamp columns" do
-      it "should return true" do
-        subject.stub(:columns).and_return([:updated_at, :created_at])
-        expect(subject.timestamp?).to be_true
-      end
-    end
-
-    context "when not respond to timestamp columns" do
-      it "should return false" do
-        subject.stub(:columns).and_return([:created_at])
-        expect(subject.timestamp?).to be_false
-      end
-    end
-  end
-
-  describe "#timestamp_format" do
-    it "should respond_to timestamp_format method" do
-      expect(subject).to respond_to(:timestamp_format)
-    end
-
-    it "should return the default timestamp format" do
-      expect(subject.timestamp_format).to eq("%Y-%m-%d %H:%M:%S.%6N")
-    end
-  end
-
-  describe "#timestamp" do
-    it "should respond_to timestamp method" do
-      expect(subject).to respond_to(:timestamp)
-    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")
-      expect(subject.timestamp).to eq(timestamp_value)
-    end
-  end
-
-  describe "#timestamp_hash" do
-    it "should respond_to timestamp_hash method" do
-      expect(subject).to respond_to(:timestamp_hash)
-    end
-
-    context "when have high precision" do
-      it "should no be equals" do
-        timestamp_hash_expected = {
-          :created_at => subject.timestamp,
-          :updated_at => subject.timestamp
-        }
-        expect(subject.timestamp_hash).not_to eq(timestamp_hash_expected)
-      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_hash_expected = {
-          :created_at => subject.timestamp,
-          :updated_at => subject.timestamp
-        }
-        expect(subject.timestamp_hash).to eq(timestamp_hash_expected)
-      end
-    end
-  end
-end

data/spec/mass_insert/adapters/adapter_helpers_spec.rb

@@ -1,24 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-
-describe MassInsert::Adapters::AdapterHelpers do
-  it 'should be defined' do
-    expect(MassInsert::Adapters::AdapterHelpers).to be
-  end
-
-  it 'should define AbstractQuery module' do
-    expect(MassInsert::Adapters::AdapterHelpers::AbstractQuery).to be
-  end
-
-  it 'should define ColumnValue class' do
-    expect(MassInsert::Adapters::AdapterHelpers::ColumnValue).to be
-  end
-
-  it 'should define Timestamp module' do
-    expect(MassInsert::Adapters::AdapterHelpers::Timestamp).to be
-  end
-
-  it 'should define Sanitizer module' do
-    expect(MassInsert::Adapters::AdapterHelpers::Sanitizer).to be
-  end
-end

data/spec/mass_insert/adapters/adapter_spec.rb

@@ -1,79 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-require "./spec/dummy_models/test"
-
-describe MassInsert::Adapters::Adapter do
-  let!(:subject){ MassInsert::Adapters::Adapter.new([], {}) }
-
-  describe "instance methods" do
-    describe "#initialize" do
-      let(:adapter){MassInsert::Adapters::Adapter.new("values", "options")}
-
-      it "should initialize the values" do
-        expect(adapter.values).to eq("values")
-      end
-
-      it "should initialize the options" do
-        expect(adapter.options).to eq("options")
-      end
-    end
-
-    describe "#class_name" do
-      it "should returns the class_name in options" do
-        subject.options = {:class_name => Test}
-        expect(subject.class_name).to eq(Test)
-      end
-    end
-
-    describe "#table_name" do
-      it "should returns the table_name in options" do
-        subject.options = {:table_name => "users"}
-        expect(subject.table_name).to eq("users")
-      end
-    end
-
-    describe "#columns" do
-      before :each do
-        subject.options.merge!({
-          :class_name       => Test,
-          :primary_key      => :id,
-          :primary_key_mode => :auto
-        })
-      end
-
-      it "should respond to columns method" do
-        expect(subject).to respond_to(:columns)
-      end
-
-      context "when primary_key is auto" do
-        it "should return an array without primary key column" do
-          column_names = [:name, :email]
-          expect(subject.columns).to eq(column_names)
-        end
-      end
-
-      context "when primary key is manual" do
-        it "should return an array with primary key column" do
-          subject.options.merge!({:primary_key_mode => :manual})
-          columns_expected = [:id, :name, :email]
-          expect(subject.columns).to eq(columns_expected)
-        end
-      end
-    end
-
-    describe "#primary_key" do
-      it "should returns the primary_key in options" do
-        subject.options = {:primary_key => :user_id}
-        expect(subject.primary_key).to eq(:user_id)
-      end
-    end
-
-    describe "#primary_key_mode" do
-      it "should returns the primary_key_mode in options" do
-        subject.options = {:primary_key_mode => :auto}
-        expect(subject.primary_key_mode).to eq(:auto)
-      end
-    end
-
-  end
-end

data/spec/mass_insert/adapters/mysql_adapter_spec.rb

@@ -1,22 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-
-describe MassInsert::Adapters::Mysql2Adapter do
-  let!(:subject){ MassInsert::Adapters::Mysql2Adapter.new([], {}) }
-
-  it "should inherit from Adapter class" do
-    expect(subject).to be_a(MassInsert::Adapters::Adapter)
-  end
-
-  describe "instance methods" do
-    describe "#timestamp_format" do
-      it "should respond to timestamp_format method" do
-        expect(subject).to respond_to(:timestamp_format)
-      end
-
-      it "should return the format string" do
-        expect(subject.timestamp_format).to eq("%Y-%m-%d %H:%M:%S")
-      end
-    end
-  end
-end

data/spec/mass_insert/adapters/postgresql_adapter_spec.rb

@@ -1,11 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-
-describe MassInsert::Adapters::PostgreSQLAdapter do
-  let!(:subject){ MassInsert::Adapters::PostgreSQLAdapter.new([], {}) }
-
-  it "should inherit from Adapter class" do
-    expect(subject).to be_a(MassInsert::Adapters::Adapter)
-  end
-
-end

data/spec/mass_insert/adapters/sqlite3_adapter_spec.rb

@@ -1,84 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-
-describe MassInsert::Adapters::SQLite3Adapter do
-  let!(:subject){ MassInsert::Adapters::SQLite3Adapter.new([], {}) }
-
-  it "should inherit from Adapter class" do
-    expect(subject).to be_a(MassInsert::Adapters::Adapter)
-  end
-
-  describe "instance methods" do
-    describe "#string_values" do
-      it "should respond to string_values method" do
-        expect(subject).to respond_to(:string_values)
-      end
-
-      it "should returns correct string to values" 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
-      it "should respond to string_rows_values method" do
-        expect(subject).to respond_to(:string_rows_values)
-      end
-
-      context "when only have one value hash" do
-        it "should 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 have two or more value hashes" do
-        it "should returns the correct string" do
-          subject.stub(:string_single_row_values).and_return("row")
-          subject.values = [{}, {}]
-          expect(subject.string_rows_values).to eq("row UNION SELECT row")
-        end
-      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
-
-      it "should respond to execute method" do
-        expect(subject).to respond_to(:execute)
-      end
-
-      context "when have less than 500 values" do
-        it "call methods and returns their values concatenated" do
-          subject.values = [{}]
-          expect(subject.execute).to eq(["abc"])
-        end
-      end
-
-      context "when have more than 500 values" do
-        it "call methods and returns their values concatenated" do
-          800.times{ subject.values << {} }
-          expect(subject.execute).to eq(["abc", "abc"])
-        end
-      end
-    end
-  end
-
-  describe "MAX_VALUES_PER_INSERTION" do
-    let(:class_name){ MassInsert::Adapters::SQLite3Adapter }
-
-    it "should respond_to" do
-      constant   = :MAX_VALUES_PER_INSERTION
-      expect(class_name.const_defined?(constant)).to be_true
-    end
-
-    it "should return 1000" do
-      expect(class_name::MAX_VALUES_PER_INSERTION).to eq(500)
-    end
-  end
-end

data/spec/mass_insert/adapters/sqlserver_adapter_spec.rb

@@ -1,61 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-
-describe MassInsert::Adapters::SQLServerAdapter do
-  let!(:subject){ MassInsert::Adapters::SQLServerAdapter.new([], {}) }
-
-  it "should inherit from Adapter class" do
-    expect(subject).to be_a(MassInsert::Adapters::Adapter)
-  end
-
-  describe "instance methods" do
-    describe "#timestamp_format" do
-      it "should respond to timestamp_format method" do
-        expect(subject).to respond_to(:timestamp_format)
-      end
-
-      it "should return the format string" do
-        expect(subject.timestamp_format).to eq("%Y-%m-%d %H:%M:%S.%3N")
-      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
-
-      it "should respond to execute method" do
-        expect(subject).to respond_to(:execute)
-      end
-
-      context "when have less than 1000 values" do
-        it "call methods and returns their values concatenated" do
-          subject.values = [{}]
-          expect(subject.execute).to eq(["abc"])
-        end
-      end
-
-      context "when have more than 1000 values" do
-        it "call methods and returns their values concatenated" do
-          1500.times{ subject.values << {} }
-          expect(subject.execute).to eq(["abc", "abc"])
-        end
-      end
-    end
-  end
-
-  describe "MAX_VALUES_PER_INSERTION" do
-    let(:class_name){ MassInsert::Adapters::SQLServerAdapter }
-
-    it "should respond_to" do
-      constant   = :MAX_VALUES_PER_INSERTION
-      expect(class_name.const_defined?(constant)).to be_true
-    end
-
-    it "should return 1000" do
-      expect(class_name::MAX_VALUES_PER_INSERTION).to eq(1000)
-    end
-  end
-end

data/spec/mass_insert/adapters_spec.rb

@@ -1,32 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-
-describe MassInsert::Adapters do
-  it 'should be defined' do
-    expect(MassInsert::Adapters).to be
-  end
-
-  it 'should define Adapter class' do
-    expect(MassInsert::Adapters::Adapter).to be
-  end
-
-  it 'should define ColumnValue class' do
-    expect(MassInsert::Adapters::AdapterHelpers).to be
-  end
-
-  it 'should define MysqlAdapter class' do
-    expect(MassInsert::Adapters::Mysql2Adapter).to be
-  end
-
-  it 'should define PostgreSQLAdapter class' do
-    expect(MassInsert::Adapters::PostgreSQLAdapter).to be
-  end
-
-  it 'should define SQLite3Adapter class' do
-    expect(MassInsert::Adapters::SQLite3Adapter).to be
-  end
-
-  it 'should define SQLServerAdapter class' do
-    expect(MassInsert::Adapters::SQLServerAdapter).to be
-  end
-end

data/spec/mass_insert/base_spec.rb

@@ -1,114 +0,0 @@
-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(:start => true)
-      end
-
-      it "should respond to mass_insert class method" do
-        expect(Test).to respond_to(:mass_insert)
-      end
-
-      it "should can receive values and many options" do
-        values  = [{:name => "name"}]
-        options = {:option_one => "one", :option_two => "two"}
-        expect(Test.mass_insert(values, options)).to be_true
-      end
-
-      it "should can receive only values" do
-        values  = [{:name => "name"}]
-        expect(Test.mass_insert(values)).to be_true
-      end
-
-      it "should not can called with values" do
-        expect(lambda{ Test.mass_insert }).to raise_error
-      end
-
-      it "should call execute ProcessControl method" do
-        process = MassInsert::ProcessControl.any_instance
-        process.should_receive(:start).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_results" do
-      it "should respond to mass_insert_results class method" do
-        expect(Test).to respond_to(:mass_insert_results)
-      end
-
-      context "when mass_insert_process instance variable exists" do
-        it "should call results method in ProcessControl class" do
-          process = MassInsert::ProcessControl
-          process.any_instance.stub(:results).and_return(true)
-          process.any_instance.should_receive(:results).exactly(1).times
-          Test.mass_insert([], {})
-          Test.mass_insert_results
-        end
-      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)
-          expect(options[:class_name]).to 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)
-          expect(options[:class_name]).to 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)
-          expect(options[:table_name]).to 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)
-          expect(options[:table_name]).to 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)
-          expect(options[:primary_key]).to 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)
-          expect(options[:primary_key]).to 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)
-          expect(options[:primary_key_mode]).to 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)
-          expect(options[:primary_key_mode]).to eq(:manual)
-        end
-      end
-    end
-  end
-end