mass_insert 0.0.2 → 0.0.3

data/spec/mass_insert/base_spec.rb

@@ -10,22 +10,22 @@ describe MassInsert::Base do
       end
 
       it "should respond to mass_insert class method" do
-        Test.respond_to?(:mass_insert).should be_true
+        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"}
-        Test.mass_insert(values, options).should be_true
+        expect(Test.mass_insert(values, options)).to be_true
       end
 
       it "should can receive only values" do
         values  = [{:name => "name"}]
-        Test.mass_insert(values).should be_true
+        expect(Test.mass_insert(values)).to be_true
       end
 
       it "should not can called with values" do
-        lambda{ Test.mass_insert }.should raise_error
+        expect(lambda{ Test.mass_insert }).to raise_error
       end
 
       it "should call execute ProcessControl method" do
@@ -43,7 +43,7 @@ describe MassInsert::Base do
 
     describe ".mass_insert_results" do
       it "should respond to mass_insert_results class method" do
-        Test.respond_to?(:mass_insert_results).should be_true
+        expect(Test).to respond_to(:mass_insert_results)
       end
 
       context "when mass_insert_process instance variable exists" do
@@ -61,52 +61,52 @@ describe MassInsert::Base 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)
+          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)
-          options[:class_name].should eq("OtherClass")
+          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)
-          options[:table_name].should eq(Test.table_name)
+          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)
-          options[:table_name].should eq("OtherTable")
+          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)
-          options[:primary_key].should eq(:id)
+          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)
-          options[:primary_key].should eq(:user_id)
+          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)
-          options[:primary_key_mode].should eq(:auto)
+          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)
-          options[:primary_key_mode].should eq(:manual)
+          expect(options[:primary_key_mode]).to eq(:manual)
         end
       end
     end

data/spec/mass_insert/process_control_spec.rb

@@ -2,39 +2,29 @@ require './spec/spec_helper'
 require "./lib/mass_insert"
 
 describe MassInsert::ProcessControl do
-
-  before :each do
-    @process = MassInsert::ProcessControl.new([], {})
-  end
-
-  subject{ @process }
+  let!(:subject){ MassInsert::ProcessControl.new([], {}) }
 
   describe "instance methods" do
     describe "#initialize" do
-
-      before :each do
-        @values  = [{:name => "name"}]
-        @options = {:option_one => 10}
-        @process = MassInsert::ProcessControl.new(@values, @options)
-      end
+      let(:process){ MassInsert::ProcessControl.new("values", "options") }
 
       it "should initialize the values" do
-        @process.values.should eq(@values)
+        expect(process.values).to eq("values")
       end
 
       it "should initialize the options" do
-        @process.options.should eq(@options)
+        expect(process.options).to eq("options")
       end
     end
 
     describe "#start" do
       before :each do
-        subject.stub(:build_query).and_return(true)
-        subject.stub(:execute_query).and_return(true)
+        subject.stub(:build_query)
+        subject.stub(:execute_query)
       end
 
       it "should respond to start method" do
-        subject.respond_to?(:start).should be_true
+        expect(subject).to respond_to(:start)
       end
 
       it "should call build_query" do
@@ -44,7 +34,7 @@ describe MassInsert::ProcessControl do
 
       it "should define instance variable @build_time" do
         subject.start
-        subject.instance_variables.include?(:@build_time).should be_true
+        expect(subject.instance_variables).to include(:@build_time)
       end
 
       it "should call execute_query" do
@@ -54,31 +44,32 @@ describe MassInsert::ProcessControl do
 
       it "should define instance variable @execute_time" do
         subject.start
-        subject.instance_variables.include?(:@execute_time).should be_true
+        expect(subject.instance_variables).to include(:@execute_time)
       end
     end
 
     describe "#execute_query" do
+      before :each do
+        @execution = MassInsert::QueryExecution.any_instance
+        @execution.stub(:execute)
+      end
+
       it "should respond to execute_query method" do
-        subject.respond_to?(:execute_query).should be_true
+        expect(subject).to respond_to(:execute_query)
       end
 
-      context "when query instance variable exists" do
+      context "when query instance variable returns not nil" do
         it "should instance and call QueryExecution class" do
           subject.instance_variable_set(:@query, "query")
-          execution = MassInsert::QueryExecution.any_instance
-          execution.stub(:execute).and_return("executed")
-          execution.should_receive(:execute).exactly(1).times
+          @execution.should_receive(:execute).exactly(1).times
           subject.execute_query
         end
       end
 
-      context "when query instance variable does not exists" do
+      context "when query instance variable returns nil" do
         it "should instance and call QueryExecution class" do
           subject.instance_variable_set(:@query, nil)
-          execution = MassInsert::QueryExecution.any_instance
-          execution.stub(:execute).and_return("executed")
-          execution.should_not_receive(:execute)
+          @execution.should_not_receive(:execute)
           subject.execute_query
         end
       end
@@ -86,47 +77,49 @@ describe MassInsert::ProcessControl do
 
     describe "#build_query" do
       it "should respond to build_query method" do
-        subject.respond_to?(:build_query).should be_true
+        expect(subject).to respond_to(:build_query)
       end
 
       it "should instance and call QueryBuilder class" do
-        builder = MassInsert::QueryBuilder.any_instance
-        builder.stub(:build).and_return("query")
-        subject.build_query.should eq("query")
+        MassInsert::QueryBuilder.any_instance.stub(:build => "query")
+        expect(subject.build_query).to eq("query")
       end
 
       it "should set query instance variable" do
-        builder = MassInsert::QueryBuilder.any_instance
-        builder.stub(:build).and_return("query")
+        MassInsert::QueryBuilder.any_instance.stub(:build)
         subject.build_query
-        subject.instance_variables.include?(:@query).should be_true
+        expect(subject.instance_variables).to include(:@query)
       end
     end
   end
 
   describe "#results" do
     before :each do
-      subject.stub(:values).and_return([{}, {}])
       a = Benchmark.measure{}
       a.stub(:total).and_return(10.0)
       subject.instance_variable_set(:@build_time, a)
       subject.instance_variable_set(:@execute_time, a)
     end
 
+    it "should respond to results method" do
+      expect(subject).to respond_to(:results)
+    end
+
     it "should return total time in results" do
-      subject.results.time.should eql(20.0)
+      expect(subject.results.time).to eql(20.0)
     end
 
     it "should return records persisted in results" do
-      subject.results.records.should eql(2)
+      subject.stub(:values => [{}, {}])
+      expect(subject.results.records).to eql(2)
     end
 
     it "should return build time in results" do
-      subject.results.build_time.should eql(10.0)
+      expect(subject.results.build_time).to eql(10.0)
     end
 
     it "should return execute time in results" do
-      subject.results.execute_time.should eql(10.0)
+      expect(subject.results.execute_time).to eql(10.0)
     end
   end
 end

data/spec/mass_insert/query_builder_spec.rb

@@ -2,61 +2,57 @@ require './spec/spec_helper'
 require "./lib/mass_insert"
 
 describe MassInsert::QueryBuilder do
-  before :each do
-    @builder = MassInsert::QueryBuilder.new([], {})
-  end
-
-  subject{ @builder }
+  let!(:subject){ MassInsert::QueryBuilder.new([], {}) }
 
   describe "instance methods" do
     describe "#initialize" do
-      before :each do
-        @builder = MassInsert::QueryBuilder.new("values", "options")
-      end
+      let(:builder){ MassInsert::QueryBuilder.new("values", "options") }
 
       it "should initialize the values attribute" do
-        @builder.values.should eq("values")
+        expect(builder.values).to eq("values")
       end
 
       it "should initialize the options attribute" do
-        @builder.options.should eq("options")
+        expect(builder.options).to eq("options")
       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
 
       it "should return the query string" do
-        subject.stub(:adapter_instance_class).and_return("adapter_instance")
-        subject.adapter_instance_class.stub(:execute).and_return("query_string")
-        subject.build.should eq("query_string")
+        subject.stub(:adapter_class).and_return("adapter_class")
+        subject.adapter_class.stub(:new).and_return("adapter_instance")
+        subject.adapter_class.new.stub(:execute).and_return("query")
+        expect(subject.build).to eq("query")
       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 "#adapter_instance_class" do
-      it "should respond to adapter_instance_class method" do
-        subject.respond_to?(:adapter_instance_class).should be_true
+    describe "#adapter_class" do
+      it "should respond to adapter_class method" do
+        expect(subject).to respond_to(:adapter_class)
       end
 
       context "when adapter is mysql2" do
         it "should return a Mysql2Adapter instance" do
           subject.stub(:adapter).and_return("mysql2")
           instance_class = MassInsert::Adapters::Mysql2Adapter
-          subject.adapter_instance_class.class.should be(instance_class)
+          expect(subject.adapter_class).to eq(instance_class)
         end
       end
 
@@ -64,7 +60,7 @@ describe MassInsert::QueryBuilder do
         it "should return a PostgreSQLAdapter instance" do
           subject.stub(:adapter).and_return("postgresql")
           instance_class = MassInsert::Adapters::PostgreSQLAdapter
-          subject.adapter_instance_class.class.should be(instance_class)
+          expect(subject.adapter_class).to eq(instance_class)
         end
       end
 
@@ -72,7 +68,7 @@ describe MassInsert::QueryBuilder do
         it "should return a SQLite3Adapter instance" do
           subject.stub(:adapter).and_return("sqlite3")
           instance_class = MassInsert::Adapters::SQLite3Adapter
-          subject.adapter_instance_class.class.should be(instance_class)
+          expect(subject.adapter_class).to eq(instance_class)
         end
       end
 
@@ -80,7 +76,7 @@ describe MassInsert::QueryBuilder do
         it "should return a SQLServerAdapter instance" do
           subject.stub(:adapter).and_return("sqlserver")
           instance_class = MassInsert::Adapters::SQLServerAdapter
-          subject.adapter_instance_class.class.should be(instance_class)
+          expect(subject.adapter_class).to eq(instance_class)
         end
       end
     end

data/spec/mass_insert/query_execution_spec.rb

@@ -2,49 +2,46 @@ require './spec/spec_helper'
 require "./lib/mass_insert"
 
 describe MassInsert::QueryExecution do
-
-  before :each do
-    @execution = MassInsert::QueryExecution.new("query string")
-  end
-
-  subject{ @execution }
+  let!(:subject){ MassInsert::QueryExecution.new("query string") }
 
   describe "instance methods" do
     describe "#initialize" do
       context "when params passed is a string" do
         it "query_container should be an array with the param" do
           execution = MassInsert::QueryExecution.new("option")
-          execution.query_container.should eq(["option"])
+          expect(execution.query_container).to eq(["option"])
         end
       end
 
       context "when params passed is an array" do
         it "query_container should be the array passed by param" do
-          params = ["option_one", "option_two"]
-          execution = MassInsert::QueryExecution.new(params)
-          execution.query_container.should eq(params)
+          execution = MassInsert::QueryExecution.new(["one", "two"])
+          expect(execution.query_container).to eq(["one", "two"])
         end
       end
     end
 
     describe "#execute" do
+      before :each do
+        @connection = ActiveRecord::Base.connection
+        @connection.stub(:execute)
+      end
+
       it "should respond to execute method" do
-        subject.respond_to?(:execute).should be_true
+        expect(subject).to respond_to(:execute)
       end
 
       context "when query container has one query" do
         it "should call ActiveRecord execute one time" do
-          ActiveRecord::Base.connection.stub(:execute)
-          ActiveRecord::Base.connection.should_receive(:execute).exactly(1).times
+          @connection.should_receive(:execute).exactly(1).times
           subject.execute
         end
       end
 
       context "when query container is an array with two queries" do
         it "should call ActiveRecord execute one time" do
-          subject.query_container = ["query1", "query2"]
-          ActiveRecord::Base.connection.stub(:execute)
-          ActiveRecord::Base.connection.should_receive(:execute).exactly(2).times
+          subject.query_container = ["one", "two"]
+          @connection.should_receive(:execute).exactly(2).times
           subject.execute
         end
       end

data/spec/mass_insert_spec.rb

@@ -3,26 +3,26 @@ require "./lib/mass_insert"
 
 describe MassInsert do
   it 'should be defined' do
-    should be
+    expect(MassInsert).to be
   end
 
   it 'should define Adapters module' do
-    MassInsert::Adapters.should be
+    expect(MassInsert::Adapters).to be
   end
 
   it 'should define Base' do
-    MassInsert::Base.should be
+    expect(MassInsert::Base).to be
   end
 
   it 'should define ProcessControl' do
-    MassInsert::ProcessControl.should be
+    expect(MassInsert::ProcessControl).to be
   end
 
   it 'should define QueryBuilder' do
-    MassInsert::QueryBuilder.should be
+    expect(MassInsert::QueryBuilder).to be
   end
 
   it 'should define QueryExecution' do
-    MassInsert::QueryExecution.should be
+    expect(MassInsert::QueryExecution).to be
   end
 end