activeforce 1.5.0

data/test/salesforce/connection/async_test.rb

@@ -0,0 +1,138 @@
+require 'test_helper'
+
+class Salesforce.connection::AsyncTest < ActiveSupport::TestCase
+  def async_post(path, body, options = {})
+    as_logged_in_user do
+      convert_body RestClient.post(async_api_url(path), body, async_headers(options)), options
+    end
+  rescue => e
+    raise e
+  end
+  
+  def test_async_post__json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    http_body = stub(:body => { :result => 'foo' }.to_json)
+    RestClient.expects(:post).with('https://.salesforce.com/services/async/22.0/path', :body, {'X-SFDC-Session' => 'session_id', :content_type => 'application/json'}).returns(http_body)
+    assert_equal({'result' => 'foo'}, Salesforce.connection.async_post('path', :body, :format => :json))
+  end
+  
+  def test_async_post__400_error_json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("[{\"message\":\"someproblem\",\"errorCode\":\"MALFORMED_QUERY\"}]")
+    RestClient.stubs(:post).raises(error)
+    begin
+      Salesforce.connection.async_post('path', :body, :format => :json)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/async/22.0/path", e.message
+    end
+  end
+  
+  def test_async_post__404_error_xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Errors><Error><errorCode>MALFORMED_QUERY</errorCode><message>someproblem</message></Error></Errors>" )
+    RestClient.expects(:post).with('https://.salesforce.com/services/async/22.0/path', :body, {'X-SFDC-Session' => 'session_id', :content_type => 'application/xml'}).raises(error)
+    
+    begin
+      Salesforce.connection.async_post('path', :body, :format => :xml)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/async/22.0/path", e.message
+    end
+  end
+  
+  def test_async_post__400_error_json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::ResourceNotFound.new
+    error.stubs(:http_body).returns("[{\"message\":\"someproblem\",\"errorCode\":\"MALFORMED_QUERY\"}]")
+    RestClient.expects(:post).with('https://.salesforce.com/services/async/22.0/path', :body, {'X-SFDC-Session' => 'session_id', :content_type => 'application/json'}).raises(error)
+    begin
+      Salesforce.connection.async_post('path', :body, :format => :json)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/async/22.0/path", e.message
+    end
+  end
+  
+  def test_async_post__400_error_xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::ResourceNotFound.new
+    error.stubs(:http_body).returns("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Errors><Error><errorCode>MALFORMED_QUERY</errorCode><message>someproblem</message></Error></Errors>" )
+    RestClient.expects(:post).with('https://.salesforce.com/services/async/22.0/path', :body, {'X-SFDC-Session' => 'session_id', :content_type => 'application/xml'}).raises(error)
+    
+    begin
+      Salesforce.connection.async_post('path', :body, :format => :xml)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/async/22.0/path", e.message
+    end
+  end
+  
+  def test_async_post__xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    http_body = stub(:body => { :result => 'foo' }.to_xml)
+    RestClient.expects(:post).with('https://.salesforce.com/services/async/22.0/path', :body, {'X-SFDC-Session' => 'session_id', :content_type => 'application/xml'}).returns(http_body)
+    assert_equal({'result' => 'foo'}, Salesforce.connection.async_post('path', :body, :format => :xml))
+  end
+  
+  def test_async_get__json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    http_body = stub(:body => { :result => 'foo' }.to_json)
+    RestClient.expects(:get).with('https://.salesforce.com/services/async/22.0/path', {'X-SFDC-Session' => 'session_id', :content_type => 'application/json'}).returns(http_body)
+    assert_equal({'result' => 'foo'}, Salesforce.connection.async_get('path', :format => :json))
+  end
+  
+  def test_async_get__error_json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("[{\"message\":\"someproblem\",\"errorCode\":\"MALFORMED_QUERY\"}]")
+    RestClient.expects(:get).with('https://.salesforce.com/services/async/22.0/path', {'X-SFDC-Session' => 'session_id', :content_type => 'application/json'}).raises(error)
+    
+    begin
+      Salesforce.connection.async_get('path', :format => :json)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/async/22.0/path", e.message
+    end
+  end
+  
+  def test_async_get__error_xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Errors><Error><errorCode>MALFORMED_QUERY</errorCode><message>someproblem</message></Error></Errors>" )
+    RestClient.expects(:get).with('https://.salesforce.com/services/async/22.0/path', {'X-SFDC-Session' => 'session_id', :content_type => 'application/xml'}).raises(error)
+    
+    begin
+      Salesforce.connection.async_get('path', :format => :xml)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/async/22.0/path", e.message
+    end
+  end
+  
+  def test_async_get__xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    http_body = stub(:body => { :result => 'foo' }.to_xml)
+    RestClient.expects(:get).with('https://.salesforce.com/services/async/22.0/path', {'X-SFDC-Session' => 'session_id', :content_type => 'application/xml'}).returns(http_body)
+    assert_equal({'result' => 'foo'}, Salesforce.connection.async_get('path', :format => :xml))
+  end
+  
+  def test_async_api_url
+    assert_equal 'https://.salesforce.com/services/async/22.0/path', Salesforce.connection.async_api_url('path')
+  end
+  
+  
+  
+  
+  
+  
+  
+end

data/test/salesforce/connection/http_methods_test.rb

@@ -0,0 +1,242 @@
+require 'test_helper'
+
+class Salesforce.connection::HttpMethodsTest < ActiveSupport::TestCase
+  def test_content_type_headers
+    assert_equal({ :content_type => 'application/json'}, Salesforce.connection.content_type_headers(:format => :json))
+    assert_equal({ :content_type => 'application/json'}, Salesforce.connection.content_type_headers(:format => "json"))
+    assert_equal({ :content_type => 'application/xml'}, Salesforce.connection.content_type_headers(:format => :xml))
+    assert_equal({ :content_type => 'application/xml'}, Salesforce.connection.content_type_headers(:format => 'xml'))
+    assert_equal({ :content_type => 'foobar'}, Salesforce.connection.content_type_headers(:content_type => 'foobar'))
+    assert_equal({ :content_type => nil }, Salesforce.connection.content_type_headers(:format => 'foobar'))
+  end
+  
+  def test_get__json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    http_body = stub(:body => { :result => 'foo' }.to_json)
+    RestClient.expects(:get).with('https://.salesforce.com/services/data/v22.0/path', {'Authorization' => 'OAuth session_id', :content_type => 'application/json'}).returns(http_body)
+    assert_equal({'result' => 'foo'}, Salesforce.connection.get('path', :format => :json))
+  end
+  
+  def test_get__error_json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("[{\"message\":\"someproblem\",\"errorCode\":\"MALFORMED_QUERY\"}]")
+    RestClient.expects(:get).with('https://.salesforce.com/services/data/v22.0/path', {'Authorization' => 'OAuth session_id', :content_type => 'application/json'}).raises(error)
+    
+    begin
+      Salesforce.connection.get('path', :format => :json)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_get__error_xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Errors><Error><errorCode>MALFORMED_QUERY</errorCode><message>someproblem</message></Error></Errors>" )
+    RestClient.expects(:get).with('https://.salesforce.com/services/data/v22.0/path', {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).raises(error)
+    
+    begin
+      Salesforce.connection.get('path', :format => :xml)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_get__xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    http_body = stub(:body => { :result => 'foo' }.to_xml)
+    RestClient.expects(:get).with('https://.salesforce.com/services/data/v22.0/path', {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).returns(http_body)
+    assert_equal({'result' => 'foo'}, Salesforce.connection.get('path', :format => :xml))
+  end
+  
+  def test_patch__json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    http_body = stub(:code => 204, :body => '')
+    RestClient.expects(:patch).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/json'}).returns(http_body)
+    assert Salesforce.connection.patch('path', :body, :format => :json)
+  end
+  
+  def test_patch__400_error_json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("[{\"message\":\"someproblem\",\"errorCode\":\"MALFORMED_QUERY\"}]")
+    RestClient.expects(:patch).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/json'}).raises(error)
+    begin
+      Salesforce.connection.patch('path', :body, :format => :json)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_patch__400_error_xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Errors><Error><errorCode>MALFORMED_QUERY</errorCode><message>someproblem</message></Error></Errors>" )
+    RestClient.expects(:patch).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).raises(error)
+    
+    begin
+      Salesforce.connection.patch('path', :body, :format => :xml)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_patch__404_error_json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::ResourceNotFound.new
+    error.stubs(:http_body).returns("[{\"message\":\"someproblem\",\"errorCode\":\"MALFORMED_QUERY\"}]")
+    RestClient.expects(:patch).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/json'}).raises(error)
+    begin
+      Salesforce.connection.patch('path', :body, :format => :json)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_patch__404_error_xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::ResourceNotFound.new
+    error.stubs(:http_body).returns("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Errors><Error><errorCode>MALFORMED_QUERY</errorCode><message>someproblem</message></Error></Errors>" )
+    RestClient.expects(:patch).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).raises(error)
+    
+    begin
+      Salesforce.connection.patch('path', :body, :format => :xml)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_patch__xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    http_body = stub(:code => 204, :body => '')
+    RestClient.expects(:patch).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).returns(http_body)
+    assert Salesforce.connection.patch('path', :body, :format => :xml)
+  end
+  
+
+  def test_post__json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    http_body = stub(:body => { :result => 'foo' }.to_json)
+    RestClient.expects(:post).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/json'}).returns(http_body)
+    assert_equal({'result' => 'foo'}, Salesforce.connection.post('path', :body, :format => :json))
+  end
+  
+  def test_post__400_error_json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("[{\"message\":\"someproblem\",\"errorCode\":\"MALFORMED_QUERY\"}]")
+    RestClient.expects(:post).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/json'}).raises(error)
+    begin
+      Salesforce.connection.post('path', :body, :format => :json)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_post__404_error_xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Errors><Error><errorCode>MALFORMED_QUERY</errorCode><message>someproblem</message></Error></Errors>" )
+    RestClient.expects(:post).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).raises(error)
+    
+    begin
+      Salesforce.connection.post('path', :body, :format => :xml)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_post__400_error_json
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::ResourceNotFound.new
+    error.stubs(:http_body).returns("[{\"message\":\"someproblem\",\"errorCode\":\"MALFORMED_QUERY\"}]")
+    RestClient.expects(:post).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/json'}).raises(error)
+    begin
+      Salesforce.connection.post('path', :body, :format => :json)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_post__400_error_xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::ResourceNotFound.new
+    error.stubs(:http_body).returns("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Errors><Error><errorCode>MALFORMED_QUERY</errorCode><message>someproblem</message></Error></Errors>" )
+    RestClient.expects(:post).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).raises(error)
+    
+    begin
+      Salesforce.connection.post('path', :body, :format => :xml)
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_post__xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    http_body = stub(:body => { :result => 'foo' }.to_xml)
+    RestClient.expects(:post).with('https://.salesforce.com/services/data/v22.0/path', :body, {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).returns(http_body)
+    assert_equal({'result' => 'foo'}, Salesforce.connection.post('path', :body, :format => :xml))
+  end
+  
+  def test_delete__400_error_xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::BadRequest.new
+    error.stubs(:http_body).returns("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Errors><Error><errorCode>MALFORMED_QUERY</errorCode><message>someproblem</message></Error></Errors>" )
+    RestClient.expects(:delete).with('https://.salesforce.com/services/data/v22.0/path', {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).raises(error)
+    
+    begin
+      Salesforce.connection.delete('path')
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_delete__404_error_xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    error = RestClient::ResourceNotFound.new
+    error.stubs(:http_body).returns("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Errors><Error><errorCode>MALFORMED_QUERY</errorCode><message>someproblem</message></Error></Errors>" )
+    RestClient.expects(:delete).with('https://.salesforce.com/services/data/v22.0/path', {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).raises(error)
+    
+    begin
+      Salesforce.connection.delete('path')
+      assert false, "Shouldn't have gotten here"
+    rescue => e
+      assert_equal "Salesforce::InvalidRequest", e.class.name
+      assert_equal "MALFORMED_QUERY: someproblem while accessing https://.salesforce.com/services/data/v22.0/path", e.message
+    end
+  end
+  
+  def test_delete__xml
+    Salesforce::Authentication.stubs(:session_id).returns('session_id')
+    RestClient.expects(:delete).with('https://.salesforce.com/services/data/v22.0/path', {'Authorization' => 'OAuth session_id', :content_type => 'application/xml'}).returns(stub(:body => ''))
+    assert Salesforce.connection.delete('path')
+  end
+  
+  def test_salesforce_url
+    assert_equal 'https://.salesforce.com/services/data/v22.0/path', Salesforce.connection.salesforce_url("path")
+    assert_equal 'https://.salesforce.com/services/data/23.0/foo', Salesforce.connection.salesforce_url("/services/data/23.0/foo")
+  end  
+end

data/test/salesforce/connection/rest_api_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+class Salesforce.connection::RestApiTest < ActiveSupport::TestCase
+  def test_supported_objects
+    connection.expects(:get).with("sobjects.json", :format => :json).returns({ "sobjects" => [ { "name" => "Account"}, { "name" => "Contact"}]})
+    assert_equal [ "Account", "Contact" ], connection.supported_objects
+  end
+  
+  def fields(object_name)
+    raise ObjectNotSupported.new(object_name) unless supported_objects.include?(object_name)
+    get("sobjects/#{object_name}/describe.json", :format => :json)["fields"]
+  end
+  
+  def test_fields
+    connection.expects(:supported_objects).returns(["Account"])
+    connection.expects(:get).with("sobjects/Account/describe.json", :format => :json).returns("fields" => :fields)
+    assert_equal :fields, connection.fields("Account")
+  end
+
+  def test_fields__fails
+    connection.expects(:supported_objects).returns(["Account__c"])
+    connection.expects(:get).never
+    assert_raises Salesforce::ObjectNotSupported do
+      connection.fields("Account")
+    end
+  end
+  
+  def test_find_object_by_id
+    connection.expects(:get).with("sobjects/Bill__c/a123456789.json?fields=Account__c,Name,Due_Date__c", :format => :json).returns(:result)
+    assert_equal :result, connection.find_object_by_id('Bill__c', 'a123456789', 'Account__c,Name,Due_Date__c' )
+  end
+  
+  def test_update
+    fields = { "Account__c" => 'a4000', 'Due_Date__c' => "08/10/2029"}
+    connection.expects(:patch).with("sobjects/Bill__c/a123456789.json", fields.to_json, :format => :json).returns(stub(:code => 204))
+    assert connection.update('Bill__c', 'a123456789', fields)
+  end
+  
+  def test_create__succeeds
+    fields = { "Account__c" => 'a4000', 'Due_Date__c' => "08/10/2029"}
+    connection.expects(:post).with('sobjects/Bill__c.json', fields.to_json, :format => :json).returns({ "success" => true, "id" => "newid"})
+    assert_equal "newid", connection.create('Bill__c', fields)
+  end
+  
+  def test_create__fails
+    fields = { "Account__c" => 'a4000', 'Due_Date__c' => "08/10/2029"}
+    connection.expects(:post).with('sobjects/Bill__c.json', fields.to_json, :format => :json).returns({ "success" => false, "errors" => "something"})
+    assert_raises Salesforce::RecordInvalid do 
+      connection.create('Bill__c', fields)
+    end
+  end
+  
+  def test_delete
+    connection.expects(:delete).with("sobjects/Bill__c/a123456789")
+    connection.destroy("Bill__c", "a123456789")
+  end
+  
+  def connection
+    Salesforce.connection
+  end
+end

data/test/salesforce/connection/soap_api_test.rb

@@ -0,0 +1,148 @@
+require 'test_helper'
+
+class Salesforce::Connection::SoapApiTest < ActiveSupport::TestCase
+
+  def test_login
+    expected_options = { 
+      :endpoint_url => :soap_login_url,
+      :body         => { 
+        :username => :soap_username, 
+        :password => :soap_password, 
+        :order!   => [ :username, :password ] 
+      } 
+    }
+    
+    Salesforce::Config.expects(:login_url).returns(:soap_login_url)
+    Salesforce::Config.expects(:username).returns(:soap_username)
+    Salesforce::Config.expects(:password).returns(:soap_password)
+    
+    Salesforce.connection.expects(:invoke_soap).with(:login, expected_options).returns(:login_result)
+    
+    assert_equal :login_result, Salesforce.connection.login
+  end
+  
+  def test_convert_lead
+    expected_options = { 
+      :body         => { 
+        :leadConverts => :some_lead_converts
+      } 
+    }
+
+    Salesforce.connection.expects(:as_logged_in_user).yields.returns(:convert_lead_result)
+    Salesforce.connection.expects(:invoke_soap).with(:convertLead, expected_options)
+    
+    assert_equal :convert_lead_result, Salesforce.connection.convert_lead(:some_lead_converts)
+  end
+
+  def test_invoke_soap__not_login__success
+    options = {
+      :body => :soap_body,
+      :other_option => 'foo'
+    }
+
+    result = {
+      :not_login_response => {
+        :result => {
+          :stuff => "i like",
+          :success => true
+        }
+      }
+    }
+    
+    expected_result = result[:not_login_response][:result]
+    
+    soap_client_mock = mock
+    Salesforce.connection.expects(:soap_client).with(options).returns(soap_client_mock)
+
+    Salesforce::Config.stubs(:session_id).returns('boyahh_session_id')
+    Salesforce::Config.stubs(:soap_enterprise_namespace).returns('soap:enterprise:namespace')
+
+    soap_mock = mock
+    soap_mock.expects(:body=).with(:soap_body)
+    soap_mock.expects(:header=).with({ "ns1:SessionHeader" => { "ns1:sessionId" => 'boyahh_session_id' }})
+    
+    
+    namespaces_mock = mock
+    namespaces_mock.expects(:[]=).with("xmlns:ns1", 'soap:enterprise:namespace')
+    soap_mock.expects(:namespaces).returns(namespaces_mock)
+    
+    soap_client_mock.expects(:request).with(:wsdl, :notLogin).yields(soap_mock).returns(mock(:to_hash => result))
+    
+    assert_equal expected_result, Salesforce.connection.send(:invoke_soap, :notLogin, options)    
+  end
+
+  def test_invoke_soap__not_login__not_success
+    options = {
+      :body => :soap_body,
+      :other_option => 'foo'
+    }
+
+    result = {
+      :not_login_response => {
+        :result => {
+          :errors => { :inspect => :me },
+          :success => false
+        }
+      }
+    }
+    
+    soap_client_mock = mock
+    Salesforce.connection.expects(:soap_client).with(options).returns(soap_client_mock)
+
+    Salesforce::Config.stubs(:session_id).returns('boyahh_session_id')
+    Salesforce::Config.stubs(:soap_enterprise_namespace).returns('soap:enterprise:namespace')
+
+    soap_mock = mock
+    soap_mock.expects(:body=).with(:soap_body)
+    soap_mock.expects(:header=).with({ "ns1:SessionHeader" => { "ns1:sessionId" => 'boyahh_session_id' }})
+    
+    
+    namespaces_mock = mock
+    namespaces_mock.expects(:[]=).with("xmlns:ns1", 'soap:enterprise:namespace')
+    soap_mock.expects(:namespaces).returns(namespaces_mock)
+    
+    soap_client_mock.expects(:request).with(:wsdl, :notLogin).yields(soap_mock).returns(mock(:to_hash => result))
+    
+    assert_raises Salesforce::Connection::SoapApi::Error do
+      Salesforce.connection.send(:invoke_soap, :notLogin, options)
+    end
+  end
+
+  def test_invoke_soap__login
+    options = {
+      :body => :soap_body,
+      :other_option => 'foo'
+    }
+
+    result = {
+      :login_response => {
+        :result => {
+          :stuff => "i like"
+        }
+      }
+    }
+    
+    expected_result = result[:login_response][:result]
+    
+    soap_client_mock = mock
+    Salesforce.connection.expects(:soap_client).with(options).returns(soap_client_mock)
+
+    soap_mock = mock
+    soap_mock.expects(:body=).with(:soap_body)
+    soap_client_mock.expects(:request).with(:wsdl, :login).yields(soap_mock).returns(mock(:to_hash => result))
+    
+    assert_equal expected_result, Salesforce.connection.send(:invoke_soap, :login, options)
+  end
+
+  def test_soap_client
+    options = {
+      :namespace => 'my:name:space',
+      :endpoint_url => 'https://my.endpoint.url.com'
+    }
+    
+    client = Salesforce.connection.send(:soap_client, options)
+    assert_equal 'https://my.endpoint.url.com', client.wsdl.endpoint
+    assert_equal 'my:name:space', client.wsdl.namespace
+  end
+
+end