executrix 1.0.0

data/lib/executrix/helper.rb

@@ -0,0 +1,36 @@
+require 'csv'
+
+module Executrix
+  module Helper
+    extend self
+
+    CSV_OPTIONS = {
+      col_sep: ',',
+      quote_char: '"',
+      force_quotes: true,
+    }
+
+    def records_to_csv records
+      file_mock = StringIO.new
+      csv_client = CSV.new(file_mock, CSV_OPTIONS)
+      all_headers = []
+      all_rows = []
+      records.each do |hash|
+        row = CSV::Row.new([],[],false)
+        to_store = hash.inject({}) do |h, (k, v)|
+          h[k] = v.class == Array ? v.join(';') : v
+          h
+        end
+        row << to_store
+        all_headers << row.headers
+        all_rows << row
+      end
+      all_headers.flatten!.uniq!
+      csv_client << all_headers
+      all_rows.each do |row|
+        csv_client << row.fields(*all_headers)
+      end
+      file_mock.string
+    end
+  end
+end

data/lib/executrix/http.rb

@@ -0,0 +1,214 @@
+require 'net/https'
+require 'nori'
+require 'csv'
+
+module Executrix
+  module Http
+    extend self
+
+    def login *args
+      r = Http::Request.login(*args)
+      process_soap_response(nori.parse(process_http_request(r)))
+    end
+
+    def create_job *args
+      r = Http::Request.create_job(*args)
+      process_xml_response(nori.parse(process_http_request(r)))
+    end
+
+    def close_job *args
+      r = Http::Request.close_job(*args)
+      process_xml_response(nori.parse(process_http_request(r)))
+    end
+
+    def add_batch *args
+      r = Http::Request.add_batch(*args)
+      process_xml_response(nori.parse(process_http_request(r)))
+    end
+
+    def query_batch *args
+      r = Http::Request.query_batch(*args)
+      process_xml_response(nori.parse(process_http_request(r)))
+    end
+
+    def query_batch_result_id *args
+      r = Http::Request.query_batch_result_id(*args)
+      process_xml_response(nori.parse(process_http_request(r)))
+    end
+
+    def query_batch_result_data *args
+      r = Http::Request.query_batch_result_data(*args)
+      process_csv_response(process_http_request(r))
+    end
+
+    def process_http_request(r)
+      http = Net::HTTP.new(r.host, 443)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http_request = Net::HTTP.
+      const_get(r.http_method.capitalize).
+        new(r.path, r.headers)
+      http_request.body = r.body if r.body
+      http.request(http_request).body
+    end
+
+    private
+    def nori
+      Nori.new(
+        :advanced_typecasting => true,
+        :strip_namespaces => true,
+        :convert_tags_to => lambda { |tag| tag.snakecase.to_sym })
+    end
+
+    def process_xml_response res
+      if res[:error]
+        raise "#{res[:error][:exception_code]}: #{res[:error][:exception_message]}"
+      end
+
+      res.values.first
+    end
+
+    def process_csv_response res
+      CSV.parse(res.gsub(/\n\s+/, "\n"), headers: true).map{|r| r.to_hash}
+    end
+
+    def process_soap_response res
+      raw_result = res.fetch(:body){res.fetch(:envelope).fetch(:body)}
+      raise raw_result[:fault][:faultstring] if raw_result[:fault]
+
+      login_result = raw_result[:login_response][:result]
+      instance = login_result[:server_url][/^https?:\/\/(\w+)(-api)?/, 1]
+      login_result.merge(instance: instance)
+    end
+
+    class Request
+      attr_reader :path
+      attr_reader :host
+      attr_reader :body
+      attr_reader :headers
+      attr_reader :http_method
+
+      def initialize http_method, host, path, body, headers
+        @http_method  = http_method
+        @host         = host
+        @path         = path
+        @body         = body
+        @headers      = headers
+      end
+
+      def self.login sandbox, username, password, api_version
+        body =  %Q{<?xml version="1.0" encoding="utf-8" ?>
+        <env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+          <env:Body>
+            <n1:login xmlns:n1="urn:partner.soap.sforce.com">
+              <n1:username>#{username}</n1:username>
+              <n1:password>#{password}</n1:password>
+            </n1:login>
+          </env:Body>
+        </env:Envelope>}
+        headers = {
+          'Content-Type' => 'text/xml; charset=utf-8',
+          'SOAPAction' => 'login'
+        }
+        host = sandbox ? 'test.salesforce.com' : 'login.salesforce.com'
+        Http::Request.new(
+          :post,
+          host,
+          "/services/Soap/u/#{api_version}",
+          body,
+          headers)
+      end
+
+      def self.create_job instance, session_id, operation, sobject, api_version, external_field = nil
+        external_field_line = external_field ?
+          "<externalIdFieldName>#{external_field}</externalIdFieldName>" : nil
+        body = %Q{<?xml version="1.0" encoding="utf-8" ?>
+          <jobInfo xmlns="http://www.force.com/2009/06/asyncapi/dataload">
+            <operation>#{operation}</operation>
+            <object>#{sobject}</object>
+            #{external_field_line}
+            <contentType>CSV</contentType>
+          </jobInfo>
+        }
+        headers = {
+          'Content-Type' => 'application/xml; charset=utf-8',
+          'X-SFDC-Session' => session_id}
+        Http::Request.new(
+          :post,
+          "#{instance}.salesforce.com",
+          "/services/async/#{api_version}/job",
+          body,
+          headers)
+      end
+
+      def self.close_job instance, session_id, job_id, api_version
+        body = %Q{<?xml version="1.0" encoding="utf-8" ?>
+          <jobInfo xmlns="http://www.force.com/2009/06/asyncapi/dataload">
+            <state>Closed</state>
+          </jobInfo>
+        }
+        headers = {
+          'Content-Type' => 'application/xml; charset=utf-8',
+          'X-SFDC-Session' => session_id}
+        Http::Request.new(
+          :post,
+          "#{instance}.salesforce.com",
+          "/services/async/#{api_version}/job/#{job_id}",
+          body,
+          headers)
+      end
+
+      def self.add_batch instance, session_id, job_id, data, api_version
+        headers = {'Content-Type' => 'text/csv; charset=UTF-8', 'X-SFDC-Session' => session_id}
+        Http::Request.new(
+          :post,
+          "#{instance}.salesforce.com",
+          "/services/async/#{api_version}/job/#{job_id}/batch",
+          data,
+          headers)
+      end
+
+      def self.query_batch instance, session_id, job_id, batch_id, api_version
+        headers = {'X-SFDC-Session' => session_id}
+        Http::Request.new(
+          :get,
+          "#{instance}.salesforce.com",
+          "/services/async/#{api_version}/job/#{job_id}/batch/#{batch_id}",
+          nil,
+          headers)
+      end
+
+      def self.query_batch_result_id instance, session_id, job_id, batch_id, api_version
+        headers = {
+          'Content-Type' => 'application/xml; charset=utf-8',
+          'X-SFDC-Session' => session_id}
+        Http::Request.new(
+          :get,
+          "#{instance}.salesforce.com",
+          "/services/async/#{api_version}/job/#{job_id}/batch/#{batch_id}/result",
+          nil,
+          headers)
+      end
+
+      def self.query_batch_result_data(instance,
+        session_id,
+        job_id,
+        batch_id,
+        result_id,
+        api_version)
+        headers = {
+          'Content-Type' => 'text/csv; charset=UTF-8',
+          'X-SFDC-Session' => session_id}
+        Http::Request.new(
+          :get,
+          "#{instance}.salesforce.com",
+          "/services/async/#{api_version}" \
+            "/job/#{job_id}/batch/#{batch_id}/result/#{result_id}",
+          nil,
+          headers)
+      end
+    end
+  end
+end

data/lib/executrix/version.rb

@@ -0,0 +1,3 @@
+module Executrix
+  VERSION = '1.0.0'
+end

data/spec/lib/executrix/batch_spec.rb

@@ -0,0 +1,59 @@
+#encoding: utf-8
+require 'spec_helper'
+
+describe Executrix::Batch do
+  describe '#final_status' do
+    it 'should return the final status if it already exists' do
+      b = described_class.new nil, nil, nil
+      expected_status = {w: :tf}
+      b.should_not_receive(:status)
+      b.instance_variable_set '@final_status', expected_status
+      expect(b.final_status).to eq(expected_status)
+    end
+
+    it 'should return specific final status for -1 batch id' do
+      b = described_class.new nil, nil, -1
+      expected_status = {
+          state: 'Completed',
+          state_message: 'Empty Request'
+        }
+      b.should_not_receive(:status)
+      expect(b.final_status).to eq(expected_status)
+    end
+
+    it 'should query the status correctly' do
+      b = described_class.new nil, nil, nil
+      b.should_receive(:status).once.and_return({w: :tf})
+      # TODO lookup the actual result
+      b.should_receive(:results).once.and_return({g: :tfo})
+      expect(b.final_status).to eq({w: :tf, results: {g: :tfo}})
+    end
+
+    it 'should yield status correctly' do
+      expected_running_state = {
+          state: 'InProgress'
+        }
+      expected_final_state = {
+          state: 'Completed'
+        }
+      b = described_class.new nil, nil, nil
+      b.should_receive(:status).once.and_return(expected_running_state)
+      b.should_receive(:status).once.and_return(expected_running_state)
+      b.should_receive(:status).once.and_return(expected_final_state)
+      b.should_receive(:results).once.and_return({g: :tfo})
+      expect{|blk| b.final_status(0, &blk)}.
+        to yield_successive_args(expected_running_state, expected_final_state)
+    end
+
+    it 'should raise exception when batch fails' do
+      b = described_class.new nil, nil, nil
+      expected_error_message = 'Generic Error Message'
+      b.should_receive(:status).once.and_return(
+        {
+          state: 'Failed',
+          state_message: expected_error_message})
+      expect{b.final_status}.
+        to raise_error(StandardError, expected_error_message)
+    end
+  end
+end

data/spec/lib/executrix/connection_spec.rb

@@ -0,0 +1,53 @@
+#encoding: utf-8
+require 'spec_helper'
+
+describe Executrix::Connection do
+  let(:subject) { described_class.new nil, nil, nil, nil }
+
+  {
+    login: 0,
+    create_job: 3,
+    close_job: 1,
+    query_batch: 2,
+    query_batch_result_id: 2,
+    query_batch_result_data: 3,
+
+  }.each do |method_name, num_of_params|
+    describe "##{method_name}" do
+      it 'should delegate correctly to Http class' do
+        Executrix::Http.
+          should_receive(method_name).
+          and_return({})
+        subject.send(method_name, *Array.new(num_of_params))
+      end
+    end
+  end
+
+  describe '#add_query' do
+    it 'should delegate correctly to Http class' do
+      Executrix::Http.should_receive(:add_batch).
+          and_return({})
+      subject.add_query(nil, nil)
+    end
+  end
+
+  describe '#add_batch' do
+    it 'should delegate correctly to underlying classes' do
+      Executrix::Http.should_receive(:add_batch).
+          and_return({})
+      Executrix::Helper.should_receive(:records_to_csv).
+        and_return('My,Awesome,CSV')
+      subject.add_batch(nil, 'non emtpy records')
+    end
+
+    it 'should return -1 for nil input' do
+      return_code = subject.add_batch(nil, nil)
+      expect(return_code).to eq(-1)
+    end
+
+    it 'should return -1 for empty input' do
+      return_code = subject.add_batch(nil, [])
+      expect(return_code).to eq(-1)
+    end
+  end
+end

data/spec/lib/executrix/helper_spec.rb

@@ -0,0 +1,64 @@
+#encoding: utf-8
+require 'spec_helper'
+
+describe Executrix::Helper do
+  describe '.records_to_csv' do
+    it 'should return valid csv for single record' do
+      input = [
+        {'Title' => 'Awesome Title', 'Name' => 'A name'},
+      ]
+
+      expected_csv = "\"Title\",\"Name\"\n" \
+      "\"Awesome Title\",\"A name\"\n"
+      expect(described_class.records_to_csv(input)).to eq(expected_csv)
+    end
+
+    it 'should return valid csv for basic records' do
+      input = [
+        {'Title' => 'Awesome Title', 'Name' => 'A name'},
+        {'Title' => 'A second Title', 'Name' => 'A second name'},
+      ]
+
+      expected_csv = "\"Title\",\"Name\"\n" \
+      "\"Awesome Title\",\"A name\"\n" \
+      "\"A second Title\",\"A second name\"\n"
+      expect(described_class.records_to_csv(input)).to eq(expected_csv)
+    end
+
+    it 'should return valid csv when first row misses a key' do
+      input = [
+        {'Title' => 'Awesome Title', 'Name' => 'A name'},
+        {'Title' => 'A second Title', 'Name' => 'A second name', 'Something' => 'Else'},
+      ]
+
+      expected_csv = "\"Title\",\"Name\",\"Something\"\n" \
+      "\"Awesome Title\",\"A name\",\"\"\n" \
+      "\"A second Title\",\"A second name\",\"Else\"\n"
+      expect(described_class.records_to_csv(input)).to eq(expected_csv)
+    end
+
+    it 'should correctly convert Array to Multi-Picklist' do
+      input = [
+        {'Title' => 'Awesome Title', 'Picklist' => ['Several', 'Values']},
+        {'Title' => 'A second Title', 'Picklist' => ['SingleValue']},
+      ]
+
+      expected_csv = "\"Title\",\"Picklist\"\n" \
+        "\"Awesome Title\",\"Several;Values\"\n" \
+        "\"A second Title\",\"SingleValue\"\n"
+      expect(described_class.records_to_csv(input)).to eq(expected_csv)
+    end
+
+    it 'should return valid csv when order of keys varies' do
+      input = [
+        {'Title' => 'Awesome Title', 'Name' => 'A name'},
+        {'Name' => 'A second name', 'Title' => 'A second Title'},
+      ]
+
+      expected_csv = "\"Title\",\"Name\"\n" \
+      "\"Awesome Title\",\"A name\"\n" \
+      "\"A second Title\",\"A second name\"\n"
+      expect(described_class.records_to_csv(input)).to eq(expected_csv)
+    end
+  end
+end

data/spec/lib/executrix/http_spec.rb

@@ -0,0 +1,338 @@
+#encoding: utf-8
+require 'spec_helper'
+
+describe Executrix::Http do
+  describe '#process_http_request' do
+    let(:post_request) do 
+      Executrix::Http::Request.new(
+        :post,
+        'test.host',
+        '/',
+        'post body',
+        {'X-SFDC-Session' => 'super_secret'})
+    end
+  
+    let(:get_request) do 
+      Executrix::Http::Request.new(:get, 'test.host', '/', '', [])
+    end
+  
+    it 'should return a response object' do
+       expected_body = 'correct result'
+        stub_request(:post, 'https://test.host').
+          with(
+            body: post_request.body,
+            headers: post_request.headers).
+          to_return(:body => expected_body)
+       res = Executrix::Http.process_http_request(post_request)
+       expect(res).to eq(expected_body)
+    end
+  end
+
+  describe '#create_login' do
+    let(:login_error_message) do
+      'INVALID_LOGIN: Invalid username, password, security token;' \
+      'or user locked out.'
+    end
+
+    let(:sf_instance) {'cs7'}
+
+    let(:login_success) do
+      %Q{<?xml version="1.0" encoding="UTF-8"?>
+          <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns="urn:partner.soap.sforce.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+            <soapenv:Body>
+              <loginResponse>
+                <result>
+                  <metadataServerUrl>https://#{sf_instance}-api.salesforce.com/services/Soap/m/27.0/00EU00000095Y5b</metadataServerUrl>
+                  <passwordExpired>false</passwordExpired>
+                  <sandbox>true</sandbox>
+                  <serverUrl>https://#{sf_instance}-api.salesforce.com/services/Soap/u/27.0/00EU00000095Y5b</serverUrl>
+                  <sessionId>00DM00000099X9a!AQ7AQJ9BjrYfF2h_G9_VERsCRVjTMAPaWjz2zuqqRBduYvKCmHexVbKdtxFMrgTnV9Xi.M80AhIkjnwuEVxI00ChG09._Q_X</sessionId>
+                  <userId>005K001100243YPIAY</userId>
+                  <userInfo>
+                    <accessibilityMode>false</accessibilityMode>
+                    <currencySymbol xsi:nil="true"/>
+                    <orgAttachmentFileSizeLimit>2621440</orgAttachmentFileSizeLimit>
+                    <orgDefaultCurrencyIsoCode xsi:nil="true"/>
+                    <orgDisallowHtmlAttachments>false</orgDisallowHtmlAttachments>
+                    <orgHasPersonAccounts>false</orgHasPersonAccounts>
+                    <organizationId>00ID0000OrgFoo</organizationId>
+                    <organizationMultiCurrency>true</organizationMultiCurrency>
+                    <organizationName>Hinz &amp; Kunz</organizationName>
+                    <profileId>00eA0000000nJEY</profileId>
+                    <roleId xsi:nil="true"/>
+                    <sessionSecondsValid>3600</sessionSecondsValid>
+                    <userDefaultCurrencyIsoCode>EUR</userDefaultCurrencyIsoCode>
+                    <userEmail>theadmin@example.com</userEmail>
+                    <userFullName>John Doe</userFullName>
+                    <userId>005D0000002b3SPIAY</userId>
+                    <userLanguage>de</userLanguage>
+                    <userLocale>de_DE_EURO</userLocale>
+                    <userName>theadmin@exammple.com.euvconfig</userName>
+                    <userTimeZone>Europe/Berlin</userTimeZone>
+                    <userType>Standard</userType>
+                    <userUiSkin>Theme42</userUiSkin>
+                  </userInfo>
+                </result>
+              </loginResponse>
+            </soapenv:Body>
+          </soapenv:Envelope>}
+    end
+
+    let(:login_success_new) do
+      %Q{<?xml version="1.0" encoding="UTF-8"?>
+          <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns="urn:partner.soap.sforce.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+            <soapenv:Body>
+              <loginResponse>
+                <result>
+                  <metadataServerUrl>https://#{sf_instance}.salesforce.com/services/Soap/m/27.0/00EU00000095Y5b</metadataServerUrl>
+                  <passwordExpired>false</passwordExpired>
+                  <sandbox>true</sandbox>
+                  <serverUrl>https://#{sf_instance}.salesforce.com/services/Soap/u/27.0/00EU00000095Y5b</serverUrl>
+                  <sessionId>00DM00000099X9a!AQ7AQJ9BjrYfF2h_G9_VERsCRVjTMAPaWjz2zuqqRBduYvKCmHexVbKdtxFMrgTnV9Xi.M80AhIkjnwuEVxI00ChG09._Q_X</sessionId>
+                  <userId>005K001100243YPIAY</userId>
+                  <userInfo>
+                    <accessibilityMode>false</accessibilityMode>
+                    <currencySymbol xsi:nil="true"/>
+                    <orgAttachmentFileSizeLimit>2621440</orgAttachmentFileSizeLimit>
+                    <orgDefaultCurrencyIsoCode xsi:nil="true"/>
+                    <orgDisallowHtmlAttachments>false</orgDisallowHtmlAttachments>
+                    <orgHasPersonAccounts>false</orgHasPersonAccounts>
+                    <organizationId>00ID0000OrgFoo</organizationId>
+                    <organizationMultiCurrency>true</organizationMultiCurrency>
+                    <organizationName>Hinz &amp; Kunz</organizationName>
+                    <profileId>00eA0000000nJEY</profileId>
+                    <roleId xsi:nil="true"/>
+                    <sessionSecondsValid>3600</sessionSecondsValid>
+                    <userDefaultCurrencyIsoCode>EUR</userDefaultCurrencyIsoCode>
+                    <userEmail>theadmin@example.com</userEmail>
+                    <userFullName>John Doe</userFullName>
+                    <userId>005D0000002b3SPIAY</userId>
+                    <userLanguage>de</userLanguage>
+                    <userLocale>de_DE_EURO</userLocale>
+                    <userName>theadmin@exammple.com.euvconfig</userName>
+                    <userTimeZone>Europe/Berlin</userTimeZone>
+                    <userType>Standard</userType>
+                    <userUiSkin>Theme42</userUiSkin>
+                  </userInfo>
+                </result>
+              </loginResponse>
+            </soapenv:Body>
+          </soapenv:Envelope>}
+    end
+
+    let(:login_error) do
+      %Q{<?xml version="1.0" encoding="UTF-8"?>
+        <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" 
+        xmlns:sf="urn:fault.partner.soap.sforce.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+          <soapenv:Body>
+            <soapenv:Fault>
+              <faultcode>INVALID_LOGIN</faultcode>
+              <faultstring>#{login_error_message}</faultstring>
+              <detail>
+                <sf:LoginFault xsi:type="sf:LoginFault">
+                  <sf:exceptionCode>INVALID_LOGIN</sf:exceptionCode>
+                  <sf:exceptionMessage>Invalid username, password, │Your bundle is complete!security token; or user locked out.
+                  </sf:exceptionMessage>
+                </sf:LoginFault>
+              </detail>
+            </soapenv:Fault>
+          </soapenv:Body>
+        </soapenv:Envelope>}
+    end
+
+    it 'should raise an error for faulty login' do
+      Executrix::Http.should_receive(:process_http_request).
+        and_return(login_error)
+      expect{ Executrix::Http.login('a','b','c', 'd') }.
+        to raise_error(RuntimeError, login_error_message)
+    end
+
+    it 'should return hash for correct login' do
+      [login_success, login_success_new].each do |login_response|
+        Executrix::Http.should_receive(:process_http_request).
+          and_return(login_response)
+        result = Executrix::Http.login('a','b','c', 'd')
+        expect(result).to be_a(Hash)
+        expect(result).to have_key(:session_id)
+        expect(result).to have_key(:server_url)
+        expect(result[:instance]).to eq(sf_instance)
+      end
+    end
+  end
+
+  describe '#create_job' do
+    let(:create_job_success) do
+      %Q{<?xml version="1.0" encoding="UTF-8"?>
+          <jobInfo xmlns="http://www.force.com/2009/06/asyncapi/dataload">
+            <id>750D0000000002lIAA</id>
+            <operation>upsert</operation>
+            <object>Contact</object>
+            <createdById>005D0000001ALVFIA4</createdById>
+            <createdDate>2013-04-10T15:52:02.000Z</createdDate>
+            <systemModstamp>2013-04-10T15:52:02.000Z</systemModstamp>
+            <state>Open</state>
+            <externalIdFieldName>my_external_field__c</externalIdFieldName>
+            <concurrencyMode>Parallel</concurrencyMode>
+            <contentType>CSV</contentType>
+            <numberBatchesQueued>0</numberBatchesQueued>
+            <numberBatchesInProgress>0</numberBatchesInProgress>
+            <numberBatchesCompleted>0</numberBatchesCompleted>
+            <numberBatchesFailed>0</numberBatchesFailed>
+            <numberBatchesTotal>0</numberBatchesTotal>
+            <numberRecordsProcessed>0</numberRecordsProcessed>
+            <numberRetries>0</numberRetries>
+            <apiVersion>27.0</apiVersion>
+            <numberRecordsFailed>0</numberRecordsFailed>
+            <totalProcessingTime>0</totalProcessingTime>
+            <apiActiveProcessingTime>0</apiActiveProcessingTime>
+            <apexProcessingTime>0</apexProcessingTime>
+          </jobInfo>}
+    end
+
+    it 'should return hash for creating job' do
+      Executrix::Http.should_receive(:process_http_request).
+        and_return(create_job_success)
+      result = Executrix::Http.create_job('a','b','c','d', 'e')
+      expect(result).to be_a(Hash)
+      expect(result).to have_key(:id)
+      expect(result).to have_key(:operation)
+    end
+  end
+
+  describe '#add_batch' do
+    let(:add_batch_success) do
+      %Q{
+        <?xml version="1.0" encoding="UTF-8"?>
+          <batchInfo xmlns="http://www.force.com/2009/06/asyncapi/dataload">
+            <id>750M0000000B1Z6IAL</id>
+            <jobId>751K00000009x71IAA</jobId>
+            <state>Queued</state>
+            <createdDate>2013-04-10T15:53:46.000Z</createdDate>
+            <systemModstamp>2013-04-10T15:53:46.000Z</systemModstamp>
+            <numberRecordsProcessed>0</numberRecordsProcessed>
+            <numberRecordsFailed>0</numberRecordsFailed>
+            <totalProcessingTime>0</totalProcessingTime>
+            <apiActiveProcessingTime>0</apiActiveProcessingTime>
+            <apexProcessingTime>0</apexProcessingTime>
+          </batchInfo>
+      }
+    end
+
+    it 'should return hash for adding batch' do
+      Executrix::Http.should_receive(:process_http_request).
+        and_return(add_batch_success)
+      result = Executrix::Http.add_batch(:post,'a','b','c','d')
+      expect(result).to be_a(Hash)
+      expect(result).to have_key(:id)
+      expect(result).to have_key(:job_id)
+      expect(result).to have_key(:state)
+    end
+  end
+
+  describe '#close_job' do
+    let(:close_job_success) do
+      %Q{<?xml version="1.0" encoding="UTF-8"?>
+          <jobInfo xmlns="http://www.force.com/2009/06/asyncapi/dataload">
+            <id>750D0000000002jIAA</id>
+            <operation>upsert</operation>
+            <object>Contact</object>
+            <createdById>005D0000002b3SPIAY</createdById>
+            <createdDate>2013-04-10T16:27:56.000Z</createdDate>
+            <systemModstamp>2013-04-10T16:27:56.000Z</systemModstamp>
+            <state>Closed</state>
+            <externalIdFieldName>my_external_id__c</externalIdFieldName>
+            <concurrencyMode>Parallel</concurrencyMode>
+            <contentType>CSV</contentType>
+            <numberBatchesQueued>0</numberBatchesQueued>
+            <numberBatchesInProgress>0</numberBatchesInProgress>
+            <numberBatchesCompleted>1</numberBatchesCompleted>
+            <numberBatchesFailed>0</numberBatchesFailed>
+            <numberBatchesTotal>1</numberBatchesTotal>
+            <numberRecordsProcessed>4</numberRecordsProcessed>
+            <numberRetries>0</numberRetries>
+            <apiVersion>27.0</apiVersion>
+            <numberRecordsFailed>0</numberRecordsFailed>
+            <totalProcessingTime>838</totalProcessingTime>
+            <apiActiveProcessingTime>355</apiActiveProcessingTime>
+            <apexProcessingTime>253</apexProcessingTime>
+          </jobInfo>}
+    end
+
+    it 'should return hash for closing job' do
+      Executrix::Http.should_receive(:process_http_request).
+        and_return(close_job_success)
+      result = Executrix::Http.close_job('a','b','c','d')
+      expect(result).to be_a(Hash)
+      expect(result).to have_key(:id)
+      expect(result).to have_key(:object)
+      expect(result).to have_key(:operation)
+      expect(result).to have_key(:state)
+      expect(result).to have_key(:content_type)
+    end
+  end
+
+  describe '#add_batch' do
+    let(:invalid_session_id) do
+      %Q{<?xml version="1.0" encoding="UTF-8"?>
+        <error xmlns="http://www.force.com/2009/06/asyncapi/dataload">
+          <exceptionCode>InvalidSessionId</exceptionCode>
+          <exceptionMessage>Invalid session id</exceptionMessage>
+        </error>}
+    end
+
+    it 'should raise an exception on faulty authorization' do
+      Executrix::Http.should_receive(:process_http_request).
+        and_return(invalid_session_id)
+      expect{Executrix::Http.query_batch('a','b','c','d','e')}.
+        to raise_error(RuntimeError, 'InvalidSessionId: Invalid session id')
+    end
+  end
+
+  describe '#query_batch_result_id' do
+    let(:batch_result_success) do
+      %Q{<result-list xmlns="http://www.force.com/2009/06/asyncapi/dataload">
+          <result>750D0000002jIAA</result>
+        </result-list>}
+    end
+
+    it 'should return hash including the result id' do
+      Executrix::Http.should_receive(:process_http_request).
+        and_return(batch_result_success)
+      result = Executrix::Http.query_batch_result_id('a','b','c','d','e')
+      expect(result).to be_a(Hash)
+      expect(result).to have_key(:result)
+    end
+  end
+
+  describe '#query_batch_result_data' do
+    let(:batch_result_data_success) do
+      %Q{"Id","my_external_id__c"
+        "003M000057GH39aIAD","K-00J799"
+        "003M001200KO82cIAD","K-015699"}
+    end
+
+    let(:batch_result_data_with_spaces_success) do
+      %Q{"Id","Name"
+        "003K000057GH39aIAD","Master of Disaster"
+        "003K001200KO82cIAD","King of the  Hill"}
+    end
+
+    it 'should return array of arrays for data' do
+      Executrix::Http.should_receive(:process_http_request).
+        and_return(batch_result_data_success)
+      result = Executrix::Http.query_batch_result_data('a','b','c','d','e','f')
+      expect(result).to eq([
+        {'Id' => '003M000057GH39aIAD', 'my_external_id__c' => 'K-00J799'},
+        {'Id' => '003M001200KO82cIAD', 'my_external_id__c' => 'K-015699'}])
+    end
+
+    it 'should return correct array with spaces' do
+      Executrix::Http.should_receive(:process_http_request).
+        and_return(batch_result_data_with_spaces_success)
+      result = Executrix::Http.query_batch_result_data('a','b','c','d','e','f')
+      expect(result).to eq([
+        {'Id' => '003K000057GH39aIAD', 'Name' => 'Master of Disaster'},
+        {'Id' => '003K001200KO82cIAD', 'Name' => 'King of the  Hill'}])
+    end
+  end
+end