activeforce 1.5.0

data/lib/salesforce/connection.rb

@@ -0,0 +1,33 @@
+require 'salesforce/connection/soap_api'
+require 'salesforce/connection/rest_api'
+require 'salesforce/connection/http_methods'
+require 'salesforce/connection/conversion'
+require 'salesforce/connection/async'
+
+module Salesforce
+  module Connection
+    include SoapApi
+    include RestApi
+    include HttpMethods
+    include Conversion
+    include Async
+    
+    def self.as_logged_in_user(&block)
+      count = 0 
+      begin
+        Salesforce::Authentication.session_id
+        block.call
+      rescue RestClient::Request::Unauthorized, Savon::SOAP::Fault => e
+        if count < 1 && (e.message.downcase.include?("unauthorized") || e.message.downcase.include?("invalid_login"))
+          count += 1
+          Salesforce::Config.on_login_failure
+          Salesforce::Authentication.logout
+          retry
+        else
+          raise e
+        end
+      end
+    
+    end
+  end
+end

data/lib/salesforce/connection/async.rb

@@ -0,0 +1,36 @@
+module Salesforce
+  module Connection
+    module Async
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+        def async_post(path, body, options = {})
+          url = async_api_url(path)
+          as_logged_in_user do
+            convert_body(RestClient.post(url, body, async_headers(options)), options)
+          end
+        rescue RestClient::ResourceNotFound, RestClient::BadRequest => e
+          convert_error(e, url, options)
+        end
+
+        def async_get(path, options = {})
+          url = async_api_url(path)
+          as_logged_in_user do
+            convert_body RestClient.get(url, async_headers(options)), options
+          end
+        rescue RestClient::ResourceNotFound, RestClient::BadRequest => e
+          convert_error(e, url, options)
+        end
+        
+        def async_api_url(path)
+          ::Salesforce::Config.async_url + "/" + path
+        end
+        
+        def async_headers(options)
+          { 'X-SFDC-Session' => Salesforce::Authentication.session_id }.merge(content_type_headers(options))
+        end 
+
+      end
+    end
+  end
+end

data/lib/salesforce/connection/conversion.rb

@@ -0,0 +1,37 @@
+module Salesforce
+  module Connection
+    module Conversion
+      extend ActiveSupport::Concern
+      module ClassMethods
+        
+        def convert_body(response, options)
+          convert(response.body, options)
+        end
+        
+        def convert_error(error, url, options)
+          error_message = convert(error.http_body, options)
+          error_message = error_message.first if error_message.is_a?(Array)
+          error_message = error_message["Error"] if error_message.is_a?(Hash) && error_message["Error"]
+          raise InvalidRequest.new(error_message, url)
+        end
+        
+        def convert(body, options)
+          if options[:format] == :json
+            ActiveSupport::JSON.decode(body)
+          elsif options[:format] == :xml
+            result = Hash.from_xml(body)
+            if result.is_a?(Hash) && result.keys.size == 1
+              result[result.keys.first].with_indifferent_access
+            else
+              result.with_indifferent_access
+            end
+          else
+            body
+          end
+        end
+        
+      end #ClassMethods
+    end
+  end
+end
+

data/lib/salesforce/connection/http_methods.rb

@@ -0,0 +1,72 @@
+module Salesforce
+  module Connection
+    module HttpMethods
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def headers(options = {})
+          {'Authorization' => "OAuth #{::Salesforce::Authentication.session_id}"}.merge(content_type_headers(options))
+        end
+
+        def get(path, options = {})
+          http(:get, path, nil, options)
+        end
+
+        def patch(path, body, options = {})
+          http(:patch, path, body, options)
+        end
+
+        def post(path, body, options = {})
+          http(:post, path, body, options)
+        end
+        
+        def delete(path)
+          true if http(:delete, path, nil, :format => :xml)
+        end
+        
+        def salesforce_url(path)
+          if path.include?("services/data")
+            ::Salesforce::Config.server_host + path
+          else
+            ::Salesforce::Config.server_url + "/" + path
+          end
+        end
+        
+        def http(action, path, body, options)
+          as_logged_in_user do
+            begin
+              response = if body
+                RestClient.send(action, salesforce_url(path), body, headers(options))
+              else
+                RestClient.send(action, salesforce_url(path), headers(options))
+              end
+
+              if response.body.present?
+                convert_body(response, options) 
+              else
+                response
+              end
+            rescue RestClient::ResourceNotFound, RestClient::BadRequest => e
+              convert_error(e, salesforce_url(path), options)
+            end
+          end
+        end
+        
+        def content_type_headers(options)
+          {}.tap do |hash|
+            hash[:content_type] = if options[:content_type]
+               options[:content_type]
+            elsif options[:format].to_s == 'json'
+              "application/json"
+            elsif options[:format].to_s == 'xml'
+              "application/xml"
+            end
+          end
+        end
+        
+      end #ClassMethods
+    end
+  end
+end
+

data/lib/salesforce/connection/rest_api.rb

@@ -0,0 +1,52 @@
+module Salesforce
+  module Connection
+    module RestApi
+      extend ActiveSupport::Concern
+      module ClassMethods
+
+        def supported_objects
+          get("sobjects.json", :format => :json)["sobjects"].map { |hash| hash["name"] }
+        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 find_object_by_id(object_name, object_id, fields)
+          get("sobjects/#{object_name}/#{object_id}.json?fields=#{URI.encode(fields)}", :format => :json)
+        end
+
+        def soql(query_string)
+          records = []
+          response = get "query.json?q=#{CGI.escape(query_string)}", :format => :json
+          records += response["records"].each { |r| r.delete("attributes")}
+          while(!response["done"])
+            response = get((response["nextRecordsUrl"] + '.json'), :format => :json)
+            records += response["records"].each { |r| r.delete("attributes")}
+          end
+          records
+        end
+
+        def update(object_name, object_id, fields)
+          response = patch("sobjects/#{object_name}/#{object_id}.json", fields.to_json, :format => :json)
+          response.code == 204
+        end
+
+        def create(object_name, fields)
+          result = post("sobjects/#{object_name}.json", fields.to_json, :format => :json)
+          if result["success"]
+            return result["id"]
+          else
+            raise RecordInvalid.new(object_name, result["errors"])
+          end
+        end
+
+        def destroy(object_name, object_id)
+          delete("sobjects/#{object_name}/#{object_id}")
+        end
+        
+      end
+    end
+  end
+end

data/lib/salesforce/connection/soap_api.rb

@@ -0,0 +1,74 @@
+module Salesforce
+  module Connection
+    module SoapApi
+      extend ActiveSupport::Concern
+
+      class Error < RuntimeError; end
+
+      module ClassMethods
+
+        def login
+          options = { 
+            :endpoint_url => Config.login_url,
+            :body         => { 
+              :username => Config.username, 
+              :password => Config.password, 
+              :order!   => [ :username, :password ] 
+            } 
+          }
+          
+          invoke_soap(:login, options)
+        end
+        
+        def convert_lead(lead_converts)
+          options = { :body => { :leadConverts => lead_converts } }
+          
+          as_logged_in_user do
+            invoke_soap(:convertLead, options)
+          end
+        end
+        
+        protected
+        
+        def invoke_soap(method_name, options)
+          options[:namespace]    ||= Config.soap_enterprise_namespace
+          options[:endpoint_url] ||= Config.soap_endpoint_url
+          
+          result = soap_client(options).request :wsdl, method_name do |soap|
+            soap.body = options[:body]
+
+            unless method_name.to_sym == :login
+              soap.namespaces["xmlns:ns1"] = Config.soap_enterprise_namespace
+              soap.header = { "ns1:SessionHeader" => { "ns1:sessionId" => Config.session_id }}
+            end
+          end
+          
+          result.to_hash[:"#{method_name.to_s.underscore}_response"][:result].tap do |result|
+            unless result[:success] || method_name.to_sym == :login
+              raise_error(method_name, options, result[:errors])
+            end
+          end
+        end
+        
+        def soap_client(options)
+          Savon::Client.new do
+            wsdl.namespace = options[:namespace]
+            wsdl.endpoint  = options[:endpoint_url]
+          end          
+        end
+        
+        def raise_error(method_name, options, errors)
+          message = <<-MSG
+\n
+  METHOD_NAME: #{method_name}
+  OPTIONS: #{options.inspect}
+  ERRORS: #{errors.inspect}
+MSG
+          
+          raise Error.new(message)
+        end
+      end
+      
+    end
+  end
+end

data/lib/salesforce/engine.rb

@@ -0,0 +1,6 @@
+if Object.const_defined?(:Rails)
+  module Activeforce
+    class Engine < Rails::Engine
+    end
+  end
+end

data/lib/salesforce/errors.rb

@@ -0,0 +1,33 @@
+module Salesforce
+  class InvalidRequest < StandardError
+    attr_accessor :error_code
+    
+    def initialize(error_options, url)
+      @error_code = error_options['errorCode']
+      super("#{error_options["errorCode"]}: #{error_options["message"]} while accessing #{url}")
+    end
+  end
+  
+  class ObjectNotSupported < StandardError
+    def initialize(object_name)
+      super("The #{object_name} is not supported in SalesForce")
+    end
+  end
+  
+  class RecordInvalid < StandardError
+    def initialize(object_name, reason)
+      super("#{object_name} failed to be saved. #{reason}")
+    end
+  end
+  
+  class ColumnNotFound < StandardError
+    def initialize(name, table_name)
+      super("Column ''#{name}' not found for #{table_name}.")
+    end
+  end
+  
+  
+  class InvalidCredentials < StandardError; end
+  class ObjectDestroyed    < StandardError; end;
+  class UnrecognizedColumn < StandardError; end;
+end

data/test/salesforce/authentication_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class Salesforce::AuthenticationTest < ActiveSupport::TestCase
+  def test_session_id__exists
+    Salesforce.configure do
+      username "username"
+      password "password"
+    end
+    Salesforce::Authentication.expects(:generate_new_session_id).never
+    Salesforce::Config.instance.session_id "existingsessionid"
+    assert_equal "existingsessionid", Salesforce::Authentication.session_id
+  end
+  
+  def test_session_id__doesnotexist
+    Salesforce.configure do
+      username "username"
+      password "password"
+    end
+    Salesforce::Authentication.expects(:generate_new_session_id).returns("new_session_id")
+    assert_equal "new_session_id", Salesforce::Authentication.session_id
+  end
+  
+  def test_session_id__credentials_missing
+    Salesforce::Authentication.expects(:generate_new_session_id).never
+    assert_raises Salesforce::InvalidCredentials do
+      Salesforce::Authentication.session_id
+    end
+  end
+  
+  def test_logout
+    Salesforce::Config.instance.session_id = "session_id"
+    Salesforce::Authentication.logout
+    assert_equal nil, Salesforce::Config.session_id
+  end
+    
+  def test_generate_new_session_id__calls_connection_login
+    result = {
+      :session_id => "session_id",
+      :server_url => "https://cs99-api.salesforce.com/services/Soap/c/22.0/00DQ00000001LRX",
+      :user_id    => "user_id"
+    }
+
+    Salesforce.connection.expects(:login).returns(result)
+
+    assert_equal "session_id", Salesforce::Authentication.generate_new_session_id
+    assert_equal "https://cs99-api.salesforce.com/services/Soap/c/22.0/00DQ00000001LRX", Salesforce::Config.soap_endpoint_url
+    assert_equal "session_id", Salesforce::Config.session_id
+    assert_equal "cs99", Salesforce::Config.server_instance
+    assert_equal "user_id", Salesforce::Config.user_id
+  end
+  
+end

data/test/salesforce/base_test.rb

@@ -0,0 +1,440 @@
+require 'test_helper'
+
+class Salesforce::OriginalTable < Salesforce::Base
+end
+
+class Salesforce::CustomTable < Salesforce::Base
+  self.custom_object = true
+end
+
+class Salesforce::BaseTest < ActiveSupport::TestCase
+  
+  setup :clear_columns
+  
+  def test_table_name
+    assert_equal "OriginalTable", Salesforce::OriginalTable.table_name
+    assert_equal "CustomTable__c", Salesforce::CustomTable.table_name
+    Salesforce::CustomTable.custom_table_name = "this_is_your_name"
+    assert_equal "this_is_your_name", Salesforce::CustomTable.table_name
+  ensure
+    Salesforce::CustomTable.custom_table_name = nil
+  end
+  
+  def test_columns
+    setup_columns_for_custom_table    
+    obj = Salesforce::CustomTable.new(:name => "tushar", :account => "account")
+    assert_equal "tushar", obj.name
+    assert_equal "account", obj.account
+    
+    obj = Salesforce::CustomTable.new
+    obj.name = "tushar"
+    assert_equal "tushar", obj.name
+    
+    obj = Salesforce::CustomTable.new
+    obj.Name__c = "tushar"
+    obj.Car__c  = "Ferrari"
+    obj.Id   = "newid"
+    assert_equal "tushar", obj.name
+    assert_equal "Ferrari", obj.car
+    assert_equal "newid", obj.id
+  end
+  
+  def test_column_attr_createable_columns__new_record
+    setup_columns_for_custom_table
+    obj = Salesforce::CustomTable.new
+    assert_nothing_raised do
+      obj.account = "account"
+      obj.name = "foo"
+      obj.attributes = { :account => 'account2', :name => 'foo'}
+      assert_equal 'account2', obj.account
+      assert_equal 'foo', obj.name
+    end
+    
+    assert_raises ArgumentError do
+      obj.car = "car"
+    end
+    
+    assert_raises ArgumentError do
+      obj.attributes = { :car => 'car2'}
+    end
+    
+    assert_raises NoMethodError do
+      obj.id = "id"
+    end
+    
+    assert_raises NoMethodError do
+      obj.attributes = { :id => 'id2'}
+    end
+  end
+  
+  def test_attributes__creatable_and_updateable
+    setup_columns_for_custom_table
+    obj = Salesforce::CustomTable.new("Id"=> "id", "Account__c" => "account", "Car__c" => 'car', "Name__c" => 'name')
+    assert_equal({"name"=>"name", "account"=>"account", "id"=>"id", "car"=>"car"}, obj.attributes)
+    assert_equal({"Account__c"=>"account", "Name__c"=>"name"}, obj.createable_attributes)
+    assert_equal({"Car__c"=>"car", "Name__c"=>"name"}, obj.updateable_attributes)
+  end
+  
+  def test_column_attr_updateable_columns__existing_record
+    setup_columns_for_custom_table
+    obj = Salesforce::CustomTable.new("Id" => "id")
+    
+    assert_nothing_raised do
+      obj.name = "foo"
+      obj.car = "car"
+      obj.attributes = { :name => 'foo2', :car => 'car2' }
+      assert_equal 'foo2', obj.name
+      assert_equal 'car2', obj.car
+    end
+    
+    assert_raises ArgumentError do
+      obj.account = "account"
+    end
+    
+    assert_raises ArgumentError do
+      obj.attributes = { :account => 'account2' }
+    end
+    
+    
+    
+    assert_raises NoMethodError do
+      obj.id = "id"
+    end
+    
+    assert_raises NoMethodError do
+      obj.attributes = { :id => 'id' }
+    end
+  end
+  
+  def test_save__create
+    setup_columns_for_custom_table
+    Salesforce.connection.expects(:create).with('CustomTable__c', { 'Account__c' => 'account', "Name__c" => "name"}).returns("newid")
+    obj = Salesforce::CustomTable.new(:account => 'account', :name => 'name')
+    obj.save!
+    assert_equal 'newid', obj.id
+    assert_equal false, obj.new_record?
+  end
+  
+  def test_save__create_fails
+    setup_columns_for_custom_table
+    error = Salesforce::RecordInvalid.new('CustomTable__c', 'msg')
+    Salesforce.connection.expects(:create).raises(error)
+    obj = Salesforce::CustomTable.new(:account => 'account', :name => 'name')
+    assert_raises Salesforce::RecordInvalid do
+      obj.save!
+    end
+    assert obj.new_record?
+  end
+  
+  def test_save__update
+    setup_columns_for_custom_table
+    Salesforce.connection.expects(:update).with('CustomTable__c', 'oldid', {'Name__c' => 'newname', 'Car__c' => 'mycar'})
+    obj = Salesforce::CustomTable.new(:Account__c => 'account', :name => 'newname', :Id => "oldid", :Car__c => 'mycar')
+    assert_equal false, obj.new_record?
+    obj.save!
+  end
+  
+  def test_update__wrapped_by_with_invalid_column_handling
+    Salesforce::OriginalTable.stubs(:columns)
+    Salesforce::OriginalTable.expects(:with_invalid_column_handling).returns(:update_result)
+    assert_equal :update_result, Salesforce::OriginalTable.new.update
+  end  
+
+  def test_save__update_fails
+    setup_columns_for_custom_table
+    error = Salesforce::RecordInvalid.new('CustomTable__c', 'msg')
+    Salesforce.connection.expects(:update).raises(error)
+    obj = Salesforce::CustomTable.new(:Account__c => 'account', :name => 'newname', :Id => "oldid", :Car__c => 'mycar')
+    assert_raises Salesforce::RecordInvalid do
+      obj.save!
+    end
+  end
+  
+  def test_destroy
+    setup_columns_for_custom_table
+    Salesforce.connection.expects(:destroy).with('CustomTable__c', 'oldid')
+    obj = Salesforce::CustomTable.new(:Account__c => 'account', :name => 'newname', :Id => "oldid")
+    obj.destroy
+    assert obj.destroyed?
+    assert_raises Salesforce::ObjectDestroyed do
+      obj.save!
+    end
+    
+    assert_raises Salesforce::ObjectDestroyed do
+      obj.destroy
+    end
+    
+    assert_raises Salesforce::ObjectDestroyed do
+      obj.create
+    end
+    
+    assert_raises Salesforce::ObjectDestroyed do
+      obj.update
+    end
+  end
+  
+  def test_destroy__new_record
+    setup_columns_for_custom_table
+    Salesforce.connection.expects(:destroy).never
+    obj = Salesforce::CustomTable.new(:Account__c => 'account', :name => 'newname')
+    assert obj.new_record?
+    obj.destroy
+    assert obj.destroyed?
+    assert_raises Salesforce::ObjectDestroyed do
+      obj.save!
+    end
+    
+    assert_raises Salesforce::ObjectDestroyed do
+      obj.destroy
+    end
+    
+    assert_raises Salesforce::ObjectDestroyed do
+      obj.create
+    end
+    
+    assert_raises Salesforce::ObjectDestroyed do
+      obj.update
+    end
+  end
+  
+  
+  def test_find
+    Salesforce::OriginalTable.expects(:find_by_id).with("id")
+    Salesforce::OriginalTable.find("id")
+    
+    Salesforce::OriginalTable.expects(:find_all)
+    Salesforce::OriginalTable.find(:all)
+  end
+  
+  def test_find_by_id
+    setup_columns_for_original_table
+    Salesforce.connection.expects(:find_object_by_id).with("OriginalTable", "id", "Col1,Col2__c").returns({ "Col1" => 'col11', "Col2__c" => 'col21'})
+    result =  Salesforce::OriginalTable.find_by_id("id")
+    assert_equal "col11", result.col1
+    assert_equal "col21", result.col2
+  end
+  
+  def test_find_by_id__wrapped_by_with_invalid_column_handling
+    Salesforce::OriginalTable.expects(:with_invalid_column_handling).returns(:find_by_id_result)
+    
+    assert_equal :find_by_id_result, Salesforce::OriginalTable.find_by_id(anything)
+  end
+  
+  def test_find_by_id__columns_not_set
+    columns_hash = [{"name" => "Col1", "type" => "id"}, { "name" => "Col2__c", "type" => "string" } ]
+    columns      = columns_hash.map { |hash| Salesforce::Column.new(hash) }
+    Salesforce.connection.expects(:fields).with("CustomTable__c").returns(columns_hash)
+    Salesforce.connection.expects(:find_object_by_id).with("CustomTable__c", "id", "Col1,Col2__c").returns("Col1" => 'col11', "Col2__c" => 'col21')
+    result = Salesforce::CustomTable.find_by_id("id")
+    assert_equal "col11", result.col1
+    assert_equal "col21", result.col2
+  end
+  
+  def test_find_all
+    setup_columns_for_original_table
+    Salesforce.connection.expects(:soql).with("SELECT Col1,Col2__c FROM OriginalTable").returns([ { "Col1" => 'col11', "Col2__c" => 'col21'}, { "Col1" => 'col21', "Col2__c" => 'col22'}])
+    results =  Salesforce::OriginalTable.find(:all)
+    assert_equal 2, results.size
+    assert_equal "col11", results.first.col1
+    assert_equal "col21", results.first.col2
+    assert_equal "col21", results.last.col1
+    assert_equal "col22", results.last.col2
+  end
+  def test_find_all__wrapped_by_with_invalid_column_handling
+    Salesforce::OriginalTable.expects(:with_invalid_column_handling).returns(:find_all_result)
+    
+    assert_equal :find_all_result, Salesforce::OriginalTable.find_all
+  end
+  
+  def test_find_all__with_select
+    setup_columns_for_original_table
+    Salesforce.connection.expects(:soql).with("SELECT Col2__c FROM OriginalTable").returns([ { "Col2__c" => 'col21'}, { "Col2__c" => 'col22'}])
+    results =  Salesforce::OriginalTable.find(:all, :select => :col2)
+    assert_equal 2, results.size
+    assert_equal "col21", results.first.col2
+    assert_equal "col22", results.last.col2
+  end
+  
+  def test_find_all__with_conditions
+    setup_columns_for_original_table
+    Salesforce.connection.expects(:soql).with("SELECT Col1,Col2__c FROM OriginalTable WHERE Col2__c >= 2011-11-11").returns([ { "Col2__c" => 'col21'}, { "Col2__c" => 'col22'}])
+    results =  Salesforce::OriginalTable.find(:all, :conditions => ":col2 >= :date", :date => Date.parse("11/11/2011"))
+    assert_equal 2, results.size
+    assert_equal "col21", results.first.col2
+    assert_equal "col22", results.last.col2
+  end
+  
+  def test_query_string
+    Salesforce.connection.expects(:fields).with("OriginalTable").returns([ 
+      { "name" => "Col1", "type" => "id" }, 
+      {"name" => "Col2__c", "type" => "string"},
+      {"name" => "Col3__c", "type" => "datetime"},
+      {"name" => "ZCol4__c", "type" => "date"},
+      {"name" => "ACol5__c", "type" => "boolean"}
+    ])
+
+    Salesforce::OriginalTable.columns
+    
+    assert_equal "SELECT ACol5__c,Col1,Col2__c,Col3__c,ZCol4__c FROM OriginalTable", Salesforce::OriginalTable.query_string({})
+    assert_equal "SELECT ACol5__c FROM OriginalTable", Salesforce::OriginalTable.query_string({:select => :a_col5})
+    assert_equal "SELECT ZCol4__c,Col2__c FROM OriginalTable", Salesforce::OriginalTable.query_string({:select => [ :z_col4, :col2 ]})
+    
+    assert_equal "SELECT ACol5__c FROM OriginalTable WHERE Col1 > Col2__c", Salesforce::OriginalTable.query_string(:select => :a_col5, :conditions => ":col1 > :col2")
+    assert_equal "SELECT ACol5__c FROM OriginalTable WHERE Col1 > Col2__c", Salesforce::OriginalTable.query_string(:select => :a_col5, :conditions => ":col1 > :col2")
+    assert_equal "SELECT ACol5__c FROM OriginalTable WHERE Col1 > 2011-08-01", Salesforce::OriginalTable.query_string(:select => :a_col5, :conditions => ":col1 > :date", 
+                                                                                :date => Date.parse('08/01/2011') )
+    assert_equal "SELECT ACol5__c FROM OriginalTable WHERE Col1 > 2011-08-01 AND ACol5__c = 2011-08-01T09:30:00-07:00", 
+            Salesforce::OriginalTable.query_string(:select => :a_col5, 
+                      :conditions => ":col1 > :date AND :a_col5 = :time", :date => Date.parse('08/01/2011'), :time => Time.zone.parse("08/01/2011 09:30 AM"))
+    
+    assert_equal "SELECT ACol5__c FROM OriginalTable WHERE Col1 = TRUE AND Col2__c = FALSE AND Col3__c = NULL", 
+            Salesforce::OriginalTable.query_string(:select => :a_col5, 
+                      :conditions => ":col1 = :true AND :col2 = :false AND :col3 = :nil", :true => true, :false => false, :nil => nil)
+    
+    assert_equal "SELECT ACol5__c FROM OriginalTable WHERE Col1 = 'string'", 
+            Salesforce::OriginalTable.query_string(:select => :a_col5, :conditions => ":col1 = :string", :string => 'string' )
+            
+    assert_equal "SELECT ACol5__c FROM OriginalTable WHERE Col1 = 'string' ORDER BY Col1", 
+            Salesforce::OriginalTable.query_string(:select => :a_col5, :conditions => ":col1 = :string", :string => 'string', :order => :col1)
+            
+    assert_equal "SELECT ACol5__c FROM OriginalTable WHERE Col1 = 'string' ORDER BY Col1 ASC, Col3__c DESC", 
+            Salesforce::OriginalTable.query_string(:select => :a_col5, :conditions => ":col1 = :string", 
+            :string => 'string' , :order => ":col1 ASC, :col3 DESC")
+            
+    assert_equal "SELECT ACol5__c FROM OriginalTable WHERE Col1 = 'string' GROUP BY Col2__c HAVING Col3__c > 2009-08-01 ORDER BY Col1 ASC, Col3__c DESC", 
+            Salesforce::OriginalTable.query_string(:select => :a_col5, :conditions => ":col1 = :string", :group_by => :col2, :having => ":col3 > :date",
+            :string => 'string', :date => Date.parse('08/01/2009'), :order => ":col1 ASC, :col3 DESC")
+            
+    
+  
+    assert_raises Salesforce::ColumnNotFound do
+      Salesforce::OriginalTable.query_string({:select => [ :col4 ]})
+    end
+  end
+  
+  def test_find_all__columns_not_set
+    columns_hash = [{"name" => "Col1", "type" => "id"}, { "name" => "Col2__c", "type" => "string" } ]
+    columns      = columns_hash.map { |hash| Salesforce::Column.new(hash) }
+    Salesforce.connection.expects(:fields).with("CustomTable__c").returns(columns_hash)
+    Salesforce.connection.expects(:soql).with("SELECT Col1,Col2__c FROM CustomTable__c").returns([ { "Col1" => 'col11', "Col2__c" => 'col21'}, { "Col1" => 'col21', "Col2__c" => 'col22'} ])
+    results =  Salesforce::CustomTable.find(:all)
+    assert_equal 2, results.size
+    assert_equal "col11", results.first.col1
+    assert_equal "col21", results.first.col2
+    assert_equal "col21", results.last.col1
+    assert_equal "col22", results.last.col2
+  end
+  
+  def test_dynamic_finders
+    setup_columns_for_original_table
+    
+    Salesforce::OriginalTable.expects(:find_by_column).with do |col, value|
+      col.original_name == "Col1" && value == "col1value"
+    end.returns(:find_by_col1_result)
+
+    assert_equal :find_by_col1_result, Salesforce::OriginalTable.find_by_col1("col1value")
+    
+    Salesforce::OriginalTable.expects(:find_by_column).with do |col, value|
+      col.original_name == "Col2__c" && value == "col2value"
+    end.returns(:find_by_col2_result)
+
+    assert_equal :find_by_col2_result, Salesforce::OriginalTable.find_by_col2("col2value")
+    
+    Salesforce::OriginalTable.expects(:find_by_column).never
+
+    assert_raises NoMethodError do
+      Salesforce::OriginalTable.find_by_col3("col1value")
+    end
+  end
+  
+  def test_find_by_column
+    setup_columns_for_original_table
+    Salesforce.connection.expects(:soql).with("SELECT Col1,Col2__c FROM OriginalTable WHERE Col2__c='value'").returns([ { "Col1" => 'col11', "Col2__c" => 'col21'}, { "Col1" => 'col21', "Col2__c" => 'col22'} ])
+    results =  Salesforce::OriginalTable.find_by_column(Salesforce::OriginalTable.columns.all.last, "value")
+    assert_equal 2, results.size
+    assert_equal "col11", results.first.col1
+    assert_equal "col21", results.first.col2
+    assert_equal "col21", results.last.col1
+    assert_equal "col22", results.last.col2
+  end
+  
+  def test_select_values
+    setup_columns_for_original_table
+    Salesforce::OriginalTable.expects(:query_string).with(:select => [ :col1, :col2 ], :other => :options).returns("sql_query")
+    Salesforce.connection.expects(:soql).with("sql_query").returns([ { "Col1" => '123456789012345678', "Col2__c" => 'col21'}, { "Col1" => '123456789012345678', "Col2__c" => 'col22'} ])
+    results = Salesforce::OriginalTable.select_values(:select => [ :col1, :col2 ], :other => :options)
+    assert_equal 2, results.size
+    assert_equal({ :col1 => '123456789012345', :col2 => 'col21'}, results.first)
+    assert_equal({ :col1 => '123456789012345', :col2 => 'col22'}, results.last)
+  end
+  
+  def test_with_invalid_column_handling__succeeds_the_first_time
+    value = Salesforce::OriginalTable.with_invalid_column_handling do
+      :foo
+    end
+    
+    assert_equal :foo, value
+  end
+  
+  def test_with_invalid_column_handling__throws_invalid_fields_error__more_than_once
+    assert_raises Salesforce::InvalidRequest do
+      Salesforce::OriginalTable.with_invalid_column_handling do
+        raise Salesforce::InvalidRequest.new({ 'errorCode' => 'INVALID_FIELD'}, '/foo')
+      end
+    end
+  end
+  
+  def test_with_invalid_column_handling__throws_invalid_fields_error__more_than_once
+    error = RuntimeError.new
+    Salesforce::OriginalTable.expects(:clear_cached_columns!).never
+    
+    assert_raises error.class do
+      Salesforce::OriginalTable.with_invalid_column_handling do
+        raise error
+      end
+    end
+  end
+  
+  def test_with_invalid_column_handling__throws_invalid_fields_error__once__then_recovers
+    count = 0 
+
+    Salesforce::OriginalTable.expects(:clear_cached_columns!)
+    value = Salesforce::OriginalTable.with_invalid_column_handling do
+      if count < 1
+        count += 1
+        raise Salesforce::InvalidRequest.new({ 'errorCode' => 'INVALID_FIELD'}, '/foo') 
+      end
+      :bar
+    end
+    
+    assert_equal :bar, value
+  end
+  
+  private
+  
+  def clear_columns
+    Salesforce::CustomTable.cached_columns   = nil
+    Salesforce::OriginalTable.cached_columns = nil
+  end
+  
+  def setup_columns_for_original_table
+    Salesforce.connection.expects(:fields).with("OriginalTable").returns([ { "name" => "Col1", "type" => "id" }, {"name" => "Col2__c", "type" => "id"} ])
+    Salesforce::OriginalTable.columns
+  end
+  
+  def setup_columns_for_custom_table
+    columns_hash = [ 
+      { "name" => "Id", "type" => "id", "createable" => false, "updateable" => false}, 
+      { "name" => "Account__c", "type" => "reference", "createable" => true, "updateable" => false, "custom" => true }, 
+      { "name" => "Car__c", "type" => "reference", "createable" => false, "updateable" => true, "custom" => true},
+      { "name" => "Name__c", "type" => "string", "createable" => true, "updateable" => true, "custom" => true} 
+    ]
+    
+    Salesforce.connection.expects(:fields).with("CustomTable__c").returns(columns_hash).twice
+    columns      = Salesforce::Columns.new("CustomTable__c")
+    assert_equal columns, Salesforce::CustomTable.columns
+  end
+  
+  
+end
+