mass_insert 0.0.2 → 0.0.3

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

@@ -2,12 +2,7 @@ require './spec/spec_helper'
 require "./lib/mass_insert"
 
 describe MassInsert::Adapters::Helpers::Sanitizer do
-
-  before :each do
-    @adapter = MassInsert::Adapters::Adapter.new([], {})
-  end
-
-  subject{ @adapter }
+  let!(:subject){ MassInsert::Adapters::Adapter.new([], {}) }
 
   describe "#sanitized_columns" do
     before :each do
@@ -20,20 +15,32 @@ describe MassInsert::Adapters::Helpers::Sanitizer do
     end
 
     it "should respond to sanitized_columns" do
-      subject.respond_to?(:sanitized_columns).should be_true
+      expect(subject).to respond_to(:sanitized_columns)
     end
 
     context "when primary_key_mode is automatic" do
       it "should returns the column without primary_key" do
-        subject.sanitized_columns.should eq([:name])
+        expect(subject.sanitized_columns).to eq([:name])
       end
     end
 
     context "when primary_key_mode is not automatic" do
       it "should returns the columns including primary_key" do
         subject.options.merge!(:primary_key_mode => :manual)
-        subject.sanitized_columns.should eq([:id, :name])
+        expect(subject.sanitized_columns).to eq([:id, :name])
       end
     end
   end
+
+  describe "#table_columns" do
+    it "should respond to table_columns method" do
+      expect(subject).to respond_to(:table_columns)
+    end
+
+    it "should returns the table_columns in ActiveRecord class" do
+      subject.options = {:class_name => Test}
+      columns = [:id, :name, :email]
+      expect(subject.table_columns).to eq(columns)
+    end
+  end
 end

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

@@ -2,57 +2,53 @@ 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 }
+  let!(:subject){ MassInsert::Adapters::Adapter.new([], {}) }
 
   describe "#timestamp?" do
     it "should respond_to timestamp? method" do
-      subject.respond_to?(:timestamp?).should be_true
+      expect(subject).to respond_to(:timestamp?)
     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
+        expect(subject.timestamp?).to 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
+        expect(subject.timestamp?).to 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
+      expect(subject).to respond_to(:timestamp_format)
     end
 
     it "should return the default timestamp format" do
-      subject.timestamp_format.should eq("%Y-%m-%d %H:%M:%S.%6N")
+      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
-      subject.respond_to?(:timestamp).should be_true
+      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")
-      subject.timestamp.should eq(timestamp_value)
+      expect(subject.timestamp).to 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
+      expect(subject).to respond_to(:timestamp_values)
     end
 
     context "when have high precision" do
@@ -61,7 +57,7 @@ describe MassInsert::Adapters::Helpers::Timestamp do
           :created_at => subject.timestamp,
           :updated_at => subject.timestamp
         }
-        subject.timestamp_values.should_not eq(timestamp_values)
+        expect(subject.timestamp_values).not_to eq(timestamp_values)
       end
     end
 
@@ -72,7 +68,7 @@ describe MassInsert::Adapters::Helpers::Timestamp do
           :created_at => subject.timestamp,
           :updated_at => subject.timestamp
         }
-        subject.timestamp_values.should eq(timestamp_values)
+        expect(subject.timestamp_values).to eq(timestamp_values)
       end
     end
   end

data/spec/mass_insert/adapters/helpers_spec.rb

@@ -3,14 +3,18 @@ require "./lib/mass_insert"
 
 describe MassInsert::Adapters::Helpers do
   it 'should be defined' do
-    should be
+    expect(MassInsert::Adapters::Helpers).to be
+  end
+
+  it 'should define AbstractQuery class' do
+    expect(MassInsert::Adapters::Helpers::AbstractQuery).to be
   end
 
   it 'should define Timestamp module' do
-    MassInsert::Adapters::Helpers::Timestamp.should be
+    expect(MassInsert::Adapters::Helpers::Timestamp).to be
   end
 
   it 'should define Sanitizer module' do
-    MassInsert::Adapters::Helpers::Sanitizer.should be
+    expect(MassInsert::Adapters::Helpers::Sanitizer).to be
   end
 end

data/spec/mass_insert/adapters/mysql_adapter_spec.rb

@@ -2,37 +2,33 @@ require './spec/spec_helper'
 require "./lib/mass_insert"
 
 describe MassInsert::Adapters::Mysql2Adapter do
-  before :each do
-    @adapter = MassInsert::Adapters::Mysql2Adapter.new([], {})
-  end
-
-  subject{ @adapter }
+  let!(:subject){ MassInsert::Adapters::Mysql2Adapter.new([], {}) }
 
   it "should inherit from Adapter class" do
-    subject.should be_a(MassInsert::Adapters::Adapter)
+    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
-        subject.respond_to?(:timestamp_format).should be_true
+        expect(subject).to respond_to(:timestamp_format)
       end
 
       it "should return the format string" do
-        subject.timestamp_format.should eq("%Y-%m-%d %H:%M:%S")
+        expect(subject.timestamp_format).to 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
+        expect(subject).to respond_to(:execute)
       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")
+        expect(subject.execute).to eq("abc")
       end
     end
   end

data/spec/mass_insert/adapters/postgresql_adapter_spec.rb

@@ -2,27 +2,23 @@ require './spec/spec_helper'
 require "./lib/mass_insert"
 
 describe MassInsert::Adapters::PostgreSQLAdapter do
-  before :each do
-    @adapter = MassInsert::Adapters::PostgreSQLAdapter.new([], {})
-  end
-
-  subject{ @adapter }
+  let!(:subject){ MassInsert::Adapters::PostgreSQLAdapter.new([], {}) }
 
   it "should inherit from Adapter class" do
-    subject.should be_a(MassInsert::Adapters::Adapter)
+    expect(subject).to 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
+        expect(subject).to respond_to(:execute)
       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")
+        expect(subject.execute).to eq("abc")
       end
     end
   end

data/spec/mass_insert/adapters/sqlite3_adapter_spec.rb

@@ -2,89 +2,83 @@ require './spec/spec_helper'
 require "./lib/mass_insert"
 
 describe MassInsert::Adapters::SQLite3Adapter do
-  before :each do
-    @adapter = MassInsert::Adapters::SQLite3Adapter.new([], {})
-  end
-
-  subject{ @adapter }
+  let!(:subject){ MassInsert::Adapters::SQLite3Adapter.new([], {}) }
 
   it "should inherit from Adapter class" do
-    subject.should be_a(MassInsert::Adapters::Adapter)
+    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
-        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("SELECT string_rows_values;")
+        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
-        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 = [{}, {}]
-          string = "single_row UNION SELECT single_row"
-          subject.string_rows_values.should eq(string)
+          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
-        subject.respond_to?(:execute).should be_true
+        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 = [{}]
-          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"])
+          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
-          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"])
+          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
-      class_name = MassInsert::Adapters::SQLite3Adapter
-      constant   = "MAX_VALUES_PER_INSERTION".to_sym
-      class_name.const_defined?(constant).should be_true
+      constant   = :MAX_VALUES_PER_INSERTION
+      expect(class_name.const_defined?(constant)).to be_true
     end
 
     it "should return 1000" do
-      class_name = MassInsert::Adapters::SQLite3Adapter
-      class_name::MAX_VALUES_PER_INSERTION.should eq(500)
+      expect(class_name::MAX_VALUES_PER_INSERTION).to eq(500)
     end
   end
 end

data/spec/mass_insert/adapters/sqlserver_adapter_spec.rb

@@ -2,55 +2,50 @@ require './spec/spec_helper'
 require "./lib/mass_insert"
 
 describe MassInsert::Adapters::SQLServerAdapter do
-  before :each do
-    @adapter = MassInsert::Adapters::SQLServerAdapter.new([], {})
-  end
-
-  subject{ @adapter }
+  let!(:subject){ MassInsert::Adapters::SQLServerAdapter.new([], {}) }
 
   it "should inherit from Adapter class" do
-    subject.should be_a(MassInsert::Adapters::Adapter)
+    expect(subject).to be_a(MassInsert::Adapters::Adapter)
   end
 
   describe "instance methods" do
     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
-        subject.respond_to?(:execute).should be_true
+        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 = [{}]
-          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"])
+          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
-          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"])
+          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
-      class_name = MassInsert::Adapters::SQLServerAdapter
-      constant   = "MAX_VALUES_PER_INSERTION".to_sym
-      class_name.const_defined?(constant).should be_true
+      constant   = :MAX_VALUES_PER_INSERTION
+      expect(class_name.const_defined?(constant)).to be_true
     end
 
     it "should return 1000" do
-      class_name = MassInsert::Adapters::SQLServerAdapter
-      class_name::MAX_VALUES_PER_INSERTION.should eq(1000)
+      expect(class_name::MAX_VALUES_PER_INSERTION).to eq(1000)
     end
   end
 end

data/spec/mass_insert/adapters_spec.rb

@@ -3,38 +3,34 @@ require "./lib/mass_insert"
 
 describe MassInsert::Adapters do
   it 'should be defined' do
-    should be
+    expect(MassInsert::Adapters).to 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
+    expect(MassInsert::Adapters::Adapter).to be
   end
 
   it 'should define ColumnValue class' do
-    MassInsert::Adapters::ColumnValue.should be
+    expect(MassInsert::Adapters::ColumnValue).to be
   end
 
   it 'should define ColumnValue class' do
-    MassInsert::Adapters::Helpers.should be
+    expect(MassInsert::Adapters::Helpers).to be
   end
 
   it 'should define MysqlAdapter class' do
-    MassInsert::Adapters::Mysql2Adapter.should be
+    expect(MassInsert::Adapters::Mysql2Adapter).to be
   end
 
   it 'should define PostgreSQLAdapter class' do
-    MassInsert::Adapters::PostgreSQLAdapter.should be
+    expect(MassInsert::Adapters::PostgreSQLAdapter).to be
   end
 
   it 'should define SQLite3Adapter class' do
-    MassInsert::Adapters::SQLite3Adapter.should be
+    expect(MassInsert::Adapters::SQLite3Adapter).to be
   end
 
   it 'should define SQLServerAdapter class' do
-    MassInsert::Adapters::SQLServerAdapter.should be
+    expect(MassInsert::Adapters::SQLServerAdapter).to be
   end
 end