mass_insert 0.1.1 → 0.1.2

data/spec/mass_insert/process_control_spec.rb

@@ -1,125 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-
-describe MassInsert::ProcessControl do
-  let!(:subject){ MassInsert::ProcessControl.new([], {}) }
-
-  describe "instance methods" do
-    describe "#initialize" do
-      let(:process){ MassInsert::ProcessControl.new("values", "options") }
-
-      it "should initialize the values" do
-        expect(process.values).to eq("values")
-      end
-
-      it "should initialize the options" do
-        expect(process.options).to eq("options")
-      end
-    end
-
-    describe "#start" do
-      before :each do
-        subject.stub(:build_query)
-        subject.stub(:execute_query)
-      end
-
-      it "should respond to start method" do
-        expect(subject).to respond_to(:start)
-      end
-
-      it "should call build_query" do
-        subject.should_receive(:build_query).exactly(1).times
-        subject.start
-      end
-
-      it "should define instance variable @build_time" do
-        subject.start
-        expect(subject.instance_variables).to include(:@build_time)
-      end
-
-      it "should call execute_query" do
-        subject.should_receive(:execute_query).exactly(1).times
-        subject.start
-      end
-
-      it "should define instance variable @execute_time" do
-        subject.start
-        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
-        expect(subject).to respond_to(:execute_query)
-      end
-
-      context "when query instance variable returns not nil" do
-        it "should instance and call QueryExecution class" do
-          subject.instance_variable_set(:@query, "query")
-          @execution.should_receive(:execute).exactly(1).times
-          subject.execute_query
-        end
-      end
-
-      context "when query instance variable returns nil" do
-        it "should instance and call QueryExecution class" do
-          subject.instance_variable_set(:@query, nil)
-          @execution.should_not_receive(:execute)
-          subject.execute_query
-        end
-      end
-    end
-
-    describe "#build_query" do
-      it "should respond to build_query method" do
-        expect(subject).to respond_to(:build_query)
-      end
-
-      it "should instance and call QueryBuilder class" do
-        MassInsert::QueryBuilder.any_instance.stub(:build => "query")
-        expect(subject.build_query).to eq("query")
-      end
-
-      it "should set query instance variable" do
-        MassInsert::QueryBuilder.any_instance.stub(:build)
-        subject.build_query
-        expect(subject.instance_variables).to include(:@query)
-      end
-    end
-  end
-
-  describe "#results" do
-    before :each do
-      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
-      expect(subject.results.time).to eql(20.0)
-    end
-
-    it "should return records persisted in results" do
-      subject.stub(:values => [{}, {}])
-      expect(subject.results.records).to eql(2)
-    end
-
-    it "should return build time in results" do
-      expect(subject.results.build_time).to eql(10.0)
-    end
-
-    it "should return execute time in results" do
-      expect(subject.results.execute_time).to eql(10.0)
-    end
-  end
-end

data/spec/mass_insert/query_builder_spec.rb

@@ -1,84 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-
-describe MassInsert::QueryBuilder do
-  let!(:subject){ MassInsert::QueryBuilder.new([], {}) }
-
-  describe "instance methods" do
-    describe "#initialize" do
-      let(:builder){ MassInsert::QueryBuilder.new("values", "options") }
-
-      it "should initialize the values attribute" do
-        expect(builder.values).to eq("values")
-      end
-
-      it "should initialize the options attribute" do
-        expect(builder.options).to eq("options")
-      end
-    end
-
-    describe "#build" do
-      it "should respond to build method" do
-        expect(subject).to respond_to(:build)
-      end
-
-      it "should return the query string" do
-        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
-        expect(subject).to respond_to(:adapter)
-      end
-
-      it "should return the adapter type" do
-        config = {"config" => {:adapter => "sql"}}
-        connection = ActiveRecord::Base.connection
-        connection.stub(:instance_values).and_return(config)
-        expect(subject.adapter).to eq("sql")
-      end
-    end
-
-    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
-          expect(subject.adapter_class).to eq(instance_class)
-        end
-      end
-
-      context "when adapter is postgresql" do
-        it "should return a PostgreSQLAdapter instance" do
-          subject.stub(:adapter).and_return("postgresql")
-          instance_class = MassInsert::Adapters::PostgreSQLAdapter
-          expect(subject.adapter_class).to eq(instance_class)
-        end
-      end
-
-      context "when adapter is sqlite3" do
-        it "should return a SQLite3Adapter instance" do
-          subject.stub(:adapter).and_return("sqlite3")
-          instance_class = MassInsert::Adapters::SQLite3Adapter
-          expect(subject.adapter_class).to eq(instance_class)
-        end
-      end
-
-      context "when adapter is sqlserver" do
-        it "should return a SQLServerAdapter instance" do
-          subject.stub(:adapter).and_return("sqlserver")
-          instance_class = MassInsert::Adapters::SQLServerAdapter
-          expect(subject.adapter_class).to eq(instance_class)
-        end
-      end
-    end
-  end
-end

data/spec/mass_insert/query_execution_spec.rb

@@ -1,50 +0,0 @@
-require './spec/spec_helper'
-require "./lib/mass_insert"
-
-describe MassInsert::QueryExecution do
-  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")
-          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
-          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
-        expect(subject).to respond_to(:execute)
-      end
-
-      context "when query container has one query" do
-        it "should call ActiveRecord execute one time" do
-          @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 = ["one", "two"]
-          @connection.should_receive(:execute).exactly(2).times
-          subject.execute
-        end
-      end
-    end
-  end
-end

data/spec/mass_insert_spec.rb

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