mass_insert 0.0.2 → 0.0.3

data/spec/mass_insert/adapters/column_value_spec.rb

@@ -2,130 +2,117 @@ require './spec/spec_helper'
 require "./lib/mass_insert"
 
 describe MassInsert::Adapters::ColumnValue do
-  before :each do
-    @options = {
-      :class_name				=> User,
-      :table_name				=> "users",
-      :primary_key			=> :id,
-      :primary_key_mode => :auto
-    }
-    @row = {
-      :name		=> "name",
-      :email	=> "email",
-      :age		=> 10
-    }
-    @colum_value = MassInsert::Adapters::ColumnValue.new(@row, :name, @options)
-  end
-
-  subject{ @colum_value }
+  let(:options) {{ :class_name	=> User }}
+  let(:row) {{ :name	=> "name", :age	=> 10 }}
+  let(:column){ :name }
+  let!(:subject){ MassInsert::Adapters::ColumnValue.new(row, column, options) }
 
   describe "#initialize" do
     it "should assign options param to option attribute" do
-      subject.options.should eq(@options)
+      expect(subject.options).to eq(options)
     end
 
     it "should assign column param to column attribute" do
-      subject.column.should eq(:name)
+      expect(subject.column).to eq(column)
     end
 
     it "should assign row param to row attribute" do
-      subject.row.should eq(@row)
+      expect(subject.row).to eq(row)
     end
   end
 
   describe "#class_name" do
     it "should respond to class_name method" do
-      subject.respond_to?(:class_name).should be_true
+      expect(subject).to respond_to(:class_name)
     end
 
     it "should return the class_name in options" do
-      subject.class_name.should eq(User)
+      expect(subject.class_name).to eq(User)
     end
   end
 
   describe "#column_type" do
     it "should respond to column_type method" do
-      subject.respond_to?(:column_type).should be_true
+      expect(subject).to respond_to(:column_type)
     end
 
-    context "when is a string column" do
-      it "should return symbol :string" do
-        subject.column = :name
-        subject.column_type.should eq(:string)
-      end
-    end
-
-    context "when is a integer column" do
-      it "should return symbol :integer" do
-        subject.column = :age
-        subject.column_type.should eq(:integer)
-      end
+    it "should return symbol :string" do
+      expect(subject.column_type).to eq(:string)
     end
   end
 
   describe "#colum_value" do
     it "should respond to column_value method" do
-      subject.respond_to?(:column_value).should be_true
+      expect(subject).to respond_to(:column_value)
     end
 
-    it "should return symbol :string" do
-      subject.column = :age
-      subject.column_value.should eq(10)
+    it "should return row value to this column" do
+      expect(subject.column_value).to eq("name")
     end
   end
 
   describe "#adapter" do
     it "should respond to adapter method" do
-      subject.respond_to?(:adapter).should be_true
+      expect(subject).to respond_to(:adapter)
     end
 
     it "should return the adapter type" do
       config = {"config" => {:adapter => "sql"}}
-      ActiveRecord::Base.connection.stub(:instance_values).and_return(config)
-      subject.adapter.should eq("sql")
+      connection = ActiveRecord::Base.connection
+      connection.stub(:instance_values).and_return(config)
+      expect(subject.adapter).to eq("sql")
     end
   end
 
   describe "#default_value" do
     it "should respond to default_value method" do
-      subject.respond_to?(:default_value).should be_true
+      expect(subject).to respond_to(:default_value)
     end
 
     context "when default_db_value is nil" do
       it "should return 'null' string" do
         subject.stub(:default_db_value).and_return(nil)
-        subject.default_value.should eq("null")
+        expect(subject.default_value).to eq("null")
       end
     end
 
     context "when default_db_value is not nil" do
       it "should return the correct value" do
         subject.stub(:default_db_value).and_return("default_value")
-        subject.default_value.should eq("default_value")
+        expect(subject.default_value).to eq("default_value")
       end
     end
   end
 
   describe "#default_db_value" do
     it "should respond to default_db_value method" do
-      subject.respond_to?(:default_db_value).should be_true
+      expect(subject).to respond_to(:default_db_value)
     end
 
     it "should return the default database value" do
-      subject.column = :name
-      subject.default_db_value.should eq(nil)
+      expect(subject.default_db_value).to eq(nil)
     end
   end
 
   describe "#build" do
     it "should respond to build method" do
-      subject.respond_to?(:build).should be_true
+      expect(subject).to respond_to(:build)
+    end
+
+    context "when column_value is nil" do
+      it "should return 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
 
-    it "should call a method according to column type" do
-      subject.stub(:column_type).and_return("string")
-      subject.stub(:column_value_string).and_return("column_value_string")
-      subject.build.should eq("column_value_string")
+    context "when column_value is not nil" do
+      it "should call 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
 
@@ -138,89 +125,59 @@ describe MassInsert::Adapters::ColumnValue do
     :timestamp,
     :binary
   ].each do |column_type|
-    method = "column_value_#{column_type}".to_sym
+    method = :"column_value_#{column_type}"
 
-    describe "#column_value_#{method.to_s}" do
+    describe "##{method.to_s}" do
       it "should respond to #{method.to_s} method" do
-        subject.respond_to?(method).should be_true
+        expect(subject).to respond_to(method)
       end
 
-      context "when column_value is nil" do
-        it "should return the default value" do
-          subject.stub(:column_value).and_return(nil)
-          subject.stub(:default_value).and_return("default_value")
-          subject.send(method).should eq("default_value")
-        end
-      end
-
-      context "when column_value is not nil" do
-        it "should return the column value" do
-          subject.stub(:column_value).and_return("name")
-          subject.send(method).should eq("'name'")
-        end
+      it "should return the column value" do
+        subject.stub(:column_value).and_return("name")
+        expect(subject.send(method)).to eq("'name'")
       end
     end
   end
 
   describe "#column_value_integer" do
     it "should respond to column_value_integer method" do
-      subject.respond_to?(:column_value_integer).should be_true
+      expect(subject).to respond_to(:column_value_integer)
     end
 
-    context "when column_value is nil" do
-      it "should return the default value" do
-        subject.stub(:column_value).and_return(nil)
-        subject.stub(:default_value).and_return("default_value")
-        subject.column_value_integer.should eq("default_value")
+    context "when is a integer value" do
+      it "should return the same integer value" do
+        subject.stub(:column_value).and_return(20)
+        expect(subject.column_value_integer).to eq("20")
       end
     end
 
-    context "when column_value is not nil" do
-      context "when is a integer value" do
-        it "should return the same integer value" do
-          subject.stub(:column_value).and_return(20)
-          subject.column_value_integer.should eq("20")
-        end
-      end
-
-      context "when is not a integer value" do
-        it "should convert it to integer value" do
-          subject.stub(:column_value).and_return("name")
-          subject.column_value_integer.should eq("0")
-        end
+    context "when is not a integer value" do
+      it "should convert 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}".to_sym
+    method = :"column_value_#{column_type}"
 
-    describe "#column_value_#{method.to_s}" do
+    describe "##{method.to_s}" do
       it "should respond to #{method.to_s} method" do
-        subject.respond_to?(method).should be_true
+        expect(subject).to respond_to(method)
       end
 
-      context "when column_value is nil" do
-        it "should return the default value" do
-          subject.stub(:column_value).and_return(nil)
-          subject.stub(:default_value).and_return("default_value")
-          subject.send(method).should eq("default_value")
+      context "when is a decimal value" do
+        it "should return 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 column_value is not nil" do
-        context "when is a decimal value" do
-          it "should return the same decimal value" do
-            subject.stub(:column_value).and_return(20.5)
-            subject.send(method).should eq("20.5")
-          end
-        end
-
-        context "when is not a decimal value" do
-          it "should convert it to decimal value" do
-            subject.stub(:column_value).and_return("name")
-            subject.send(method).should eq("0.0")
-          end
+      context "when is not a decimal value" do
+        it "should convert it to decimal value" do
+          subject.stub(:column_value).and_return("name")
+          expect(subject.send(method)).to eq("0.0")
         end
       end
     end
@@ -228,64 +185,60 @@ describe MassInsert::Adapters::ColumnValue do
 
   describe "#column_value_boolean" do
     it "should respond to column_value_boolean method" do
-      subject.respond_to?(:column_value_boolean).should be_true
+      expect(subject).to respond_to(:column_value_boolean)
     end
 
-    context "when adapter is mysql2, postgresql or sqlserve" do
-      context "when column value is nil" do
-        it "should return database default value" do
-          subject.stub(:adapter).and_return("mysql2")
-          subject.stub(:column_value).and_return(nil)
-          subject.stub(:default_value).and_return("default_value")
-          subject.column_value_boolean.should eq("default_value")
-        end
+    it "should call a method according to database adapter" do
+      subject.stub(:adapter).and_return("mysql2")
+      subject.stub(:mysql2_column_value_boolean).and_return("boolean_value")
+      expect(subject.column_value_boolean).to eq("boolean_value")
+    end
+  end
+
+  [
+    :mysql2,
+    :postgresql,
+    :sqlserver,
+  ].each do |adapter|
+    method = :"#{adapter}_column_value_boolean"
+
+    describe "##{method.to_s}" do
+      it "should respond to #{method.to_s} method" do
+        expect(subject).to respond_to(method)
       end
 
-      context "when column value is not nil" do
-        context "when column value is false" do
-          it "should return 'false' string" do
-            subject.stub(:adapter).and_return("mysql2")
-            subject.stub(:column_value).and_return(false)
-            subject.column_value_boolean.should eq("false")
-          end
+      context "when column_value method return true value" do
+        it "should return true string" do
+          subject.stub(:column_value).and_return(true)
+          expect(subject.send(method)).to eq("true")
         end
+      end
 
-        context "when column value is true" do
-          it "should return 'true' string" do
-            subject.stub(:adapter).and_return("mysql2")
-            subject.stub(:column_value).and_return(true)
-            subject.column_value_boolean.should eq("true")
-          end
+      context "when column_value method return false value" do
+        it "should return false string" do
+          subject.stub(:column_value).and_return(false)
+          expect(subject.send(method)).to eq("false")
         end
       end
     end
+  end
 
-    context "when adapter is sqlite3" do
-      context "when column value is nil" do
-        it "should return database default value" do
-          subject.stub(:adapter).and_return("sqlite3")
-          subject.stub(:column_value).and_return(nil)
-          subject.stub(:default_value).and_return("default_value")
-          subject.column_value_boolean.should eq("default_value")
-        end
-      end
+  describe "#sqlite3_column_value_boolean" do
+    it "should respond to sqlite3_column_value_boolean method" do
+      expect(subject).to respond_to(:sqlite3_column_value_boolean)
+    end
 
-      context "when column value is not nil" do
-        context "when column value is false" do
-          it "should return '0' string" do
-            subject.stub(:adapter).and_return("sqlite3")
-            subject.stub(:column_value).and_return(false)
-            subject.column_value_boolean.should eq("0")
-          end
-        end
+    context "when column_value method return true value" do
+      it "should return true string" do
+        subject.stub(:column_value).and_return(true)
+        expect(subject.sqlite3_column_value_boolean).to eq("1")
+      end
+    end
 
-        context "when column value is true" do
-          it "should return '1' string" do
-            subject.stub(:adapter).and_return("sqlite3")
-            subject.stub(:column_value).and_return(true)
-            subject.column_value_boolean.should eq("1")
-          end
-        end
+    context "when column_value method return false value" do
+      it "should return false string" do
+        subject.stub(:column_value).and_return(false)
+        expect(subject.sqlite3_column_value_boolean).to eq("0")
       end
     end
   end

data/spec/mass_insert/adapters/{abstract_query_spec.rb → helpers/abstract_query_spec.rb}

@@ -1,83 +1,80 @@
 require './spec/spec_helper'
 require "./lib/mass_insert"
 
-describe MassInsert::Adapters::AbstractQuery do
-  before :each do
-    @adapter = MassInsert::Adapters::Adapter.new([], {})
-  end
-
-  subject{ @adapter }
+describe MassInsert::Adapters::Helpers::AbstractQuery do
+  let!(:subject){ MassInsert::Adapters::Adapter.new([], {}) }
 
   describe "#begin_string" do
     it "should respond to begin_string method" do
-      subject.respond_to?(:begin_string).should be_true
+      expect(subject).to respond_to(:begin_string)
     end
 
     it "should returns the correct string" do
       subject.stub(:table_name).and_return("users")
-      string = "INSERT INTO users "
-      subject.begin_string.should eq(string)
+      expect(subject.begin_string).to eq("INSERT INTO users ")
     end
   end
 
   describe "#string_columns" do
     it "should respond to string_columns method" do
-      subject.respond_to?(:string_columns).should be_true
+      expect(subject).to respond_to(:string_columns)
     end
 
     it "should returns correct string to columns" do
       subject.stub(:column_names).and_return([:name, :email])
-      subject.string_columns.should eq("(name, email) ")
+      expect(subject.string_columns).to eq("(name, email) ")
     end
   end
 
   describe "#string_values" do
     it "should respond to string_values method" do
-      subject.respond_to?(:string_values).should be_true
+      expect(subject).to respond_to(:string_values)
     end
 
     it "should returns correct string to values" do
-      subject.stub(:string_rows_values).and_return("string_rows_values")
-      subject.string_values.should eq("VALUES (string_rows_values);")
+      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
     it "should respond to string_rows_values method" do
-      subject.respond_to?(:string_rows_values).should be_true
+      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("single_row")
+        subject.stub(:string_single_row_values).and_return("row")
         subject.values = [{}]
-        subject.string_rows_values.should eq("single_row")
+        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("single_row")
+        subject.stub(:string_single_row_values).and_return("row")
         subject.values = [{}, {}]
-        subject.string_rows_values.should eq("single_row), (single_row")
+        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 "should respond to string_single_row_values method" do
-      subject.respond_to?(:string_single_row_values).should be_true
+      expect(subject).to respond_to(:string_single_row_values)
     end
 
     it "should returns the correct string" do
-      subject.stub(:string_single_value).and_return("single_value")
       subject.stub(:column_names).and_return([:name, :email])
-      subject.string_single_row_values({}).should eq("single_value, single_value")
+      expect(subject.string_single_row_values({})).to eq("value, value")
     end
 
     context "when respond to timestamp attributes" do
       it "should call timestamp_values method" do
-        subject.stub(:string_single_value).and_return("single_value")
         subject.stub(:column_names).and_return([:created_at, :updated_at])
         subject.stub(:timestamp_values).and_return(:test => "test")
         subject.should_receive(:timestamp_values).exactly(1).times
@@ -87,7 +84,6 @@ describe MassInsert::Adapters::AbstractQuery do
 
     context "when not respond to timestamp attributes" do
       it "should returns the correct string" do
-        subject.stub(:string_single_value).and_return("single_value")
         subject.stub(:column_names).and_return([:name, :email])
         subject.should_receive(:timestamp_values).exactly(0).times
         subject.string_single_row_values({})
@@ -97,13 +93,13 @@ describe MassInsert::Adapters::AbstractQuery do
 
   describe "#string_single_value" do
     it "should respond to string_single_value method" do
-      subject.respond_to?(:string_single_value).should be_true
+      expect(subject).to respond_to(:string_single_value)
     end
 
     it "should call build method in ColumnValue class" do
       column_value = MassInsert::Adapters::ColumnValue.any_instance
-      column_value.stub(:build).and_return("single_value")
-      subject.string_single_value({}, :name).should eq("single_value")
+      column_value.stub(:build).and_return("value")
+      expect(subject.string_single_value({}, :name)).to eq("value")
     end
   end
 end