njones-marketo 1.2.5

data/lib/marketo/authentication_header.rb

@@ -0,0 +1,48 @@
+module Rapleaf
+  module Marketo
+    # This class exists only to encapsulate the authentication header part of a soap request to marketo
+    # Marketo requires a somewhat complex calculation of an encrypted signature and so it seemed sensible to pull this code out here
+    class AuthenticationHeader
+      DIGEST = OpenSSL::Digest::Digest.new('sha1')
+
+      def initialize(access_key, secret_key, time = DateTime.now)
+        @access_key = access_key
+        @secret_key = secret_key
+        @time       = time
+      end
+
+      public
+      # time should be a DateTime instance
+      def set_time(time)
+        @time = time
+      end
+
+      def get_mktows_user_id
+        @access_key
+      end
+
+      def get_request_signature
+        calculate_signature
+      end
+
+      def get_request_timestamp
+        @time.to_s
+      end
+
+      def to_hash
+        {
+            "mktowsUserId"     => get_mktows_user_id,
+            "requestSignature" => get_request_signature,
+            "requestTimestamp" => get_request_timestamp
+        }
+      end
+
+      private
+      def calculate_signature
+        request_timestamp = get_request_timestamp
+        string_to_encrypt = request_timestamp + @access_key
+        OpenSSL::HMAC.hexdigest(DIGEST, @secret_key, string_to_encrypt)
+      end
+    end
+  end
+end

data/lib/marketo/client.rb

@@ -0,0 +1,202 @@
+require File.expand_path('authentication_header', File.dirname(__FILE__))
+
+module Rapleaf
+  module Marketo
+    
+    def self.new_client(access_key, secret_key, api_version='1.7', api_subdomain='na-c')
+      
+      api_version = api_version.sub(".", "_")
+      client = Savon::Client.new do
+        wsdl.endpoint     = "https://#{api_subdomain}.marketo.com/soap/mktows/#{api_version}"
+        wsdl.document     = "http://app.marketo.com/soap/mktows/#{api_version}?WSDL"
+        http.read_timeout = 90
+        http.open_timeout = 90
+        http.headers      = {"Connection" => "Keep-Alive"}
+      end
+
+      Client.new(client, Rapleaf::Marketo::AuthenticationHeader.new(access_key, secret_key))
+    end
+
+    # = The client for talking to marketo
+    # based on the SOAP wsdl file: <i>http://app.marketo.com/soap/mktows/1_4?WSDL</i>
+    #
+    # Usage:
+    #
+    # client = Rapleaf::Marketo.new_client(<access_key>, <secret_key>)
+    #
+    # == get_lead_by_email:
+    #
+    # lead_record = client.get_lead_by_email('sombody@examnple.com')
+    #
+    # puts lead_record.idnum
+    #
+    # puts lead_record.get_attribute('FirstName')
+    #
+    # puts lead_record.get_attribute('LastName')
+    #
+    # == sync_lead: (update)
+    #
+    # lead_record = client.sync_lead('example@rapleaf.com', 'Joe', 'Smith', 'Company 1', '415 911')
+    #
+    # == sync_lead_record: (update with custom fields)
+    #
+    # lead_record = Rapleaf::Marketo::LeadRecord.new('harry@rapleaf.com')
+    #
+    # lead_record.set_attribute('FirstName', 'harry')
+    #
+    # lead_record.set_attribute('LastName', 'smith')
+    #
+    # lead_record.set_attribute('Email', 'harry@somesite.com')
+    #
+    # lead_record.set_attribute('Company', 'Rapleaf')
+    #
+    # lead_record.set_attribute('MobilePhone', '123 456')
+    #
+    # response = client.sync_lead_record(lead_record)
+    class Client
+      # This constructor is used internally, create your client with *Rapleaf::Marketo.new_client(<access_key>, <secret_key>)*
+      def initialize(savon_client, authentication_header)
+        @client = savon_client
+        @header = authentication_header
+      end
+
+      public
+
+      def get_lead_by_idnum(idnum)
+        get_lead(LeadKey.new(LeadKeyType::IDNUM, idnum))
+      end
+
+
+      def get_lead_by_email(email)
+        get_lead(LeadKey.new(LeadKeyType::EMAIL, email))
+      end
+
+      def set_logger(logger)
+        @logger = logger
+      end
+
+      # create (if new) or update (if existing) a lead
+      #
+      # * email - email address of lead
+      # * first - first name of lead
+      # * last - surname/last name of lead
+      # * company - company the lead is associated with
+      # * mobile - mobile/cell phone number
+      #
+      # returns the LeadRecord instance on success otherwise nil
+      def sync_lead(email, first, last, company, mobile)
+        lead_record = LeadRecord.new(email)
+        lead_record.set_attribute('FirstName', first)
+        lead_record.set_attribute('LastName', last)
+        lead_record.set_attribute('Email', email)
+        lead_record.set_attribute('Company', company)
+        lead_record.set_attribute('MobilePhone', mobile)
+        sync_lead_record(lead_record)
+      end
+
+      def sync_lead_record(lead_record)
+        begin
+          attributes = []
+          lead_record.each_attribute_pair do |name, value|
+            attributes << {:attr_name => name, :attr_type => 'string', :attr_value => value}
+          end
+
+          response = send_request("ns1:paramsSyncLead", {
+              :return_lead => true,
+              :lead_record =>
+                  {:email               => lead_record.email,
+                   :lead_attribute_list => {
+                       :attribute => attributes}}})
+          return LeadRecord.from_hash(response[:success_sync_lead][:result][:lead_record])
+        rescue Exception => e
+          @logger.log(e) if @logger
+          return nil
+        end
+      end
+      
+      def sync_multi_lead_records(lead_records)
+        send_records = []
+        begin
+          lead_records.each do |lead_record|
+            attributes = []
+            lead_record.each_attribute_pair do |name, value|
+              attributes << {:attr_name => name, :attr_type => 'string', :attr_value => value}
+            end
+            
+            send_records << {:lead_record => 
+              { "Email" => lead_record.email, 
+                :lead_attribute_list => 
+                  { :attribute => attributes }
+              }
+            }
+          end
+          
+          response = send_request("ns1:paramsSyncMultipleLeads", {
+                :lead_record_list => send_records }) # an array of lead records
+          
+          return response
+        rescue Exception => e
+          @logger.log(e) if @logger
+          return @client.http
+          #return nil
+        end
+      end
+
+      def add_to_list(list_key, email)
+        list_operation(list_key, ListOperationType::ADD_TO, email)
+      end
+
+      def remove_from_list(list_key, email)
+        list_operation(list_key, ListOperationType::REMOVE_FROM, email)
+      end
+
+      def is_member_of_list?(list_key, email)
+        list_operation(list_key, ListOperationType::IS_MEMBER_OF, email)
+      end
+
+      private
+      def list_operation(list_key, list_operation_type, email)
+        begin
+          response = send_request("ns1:paramsListOperation", {
+              :list_operation   => list_operation_type,
+              :list_key         => list_key,
+              :strict           => 'false',
+              :list_member_list => {
+                  :lead_key => [
+                      {:key_type => 'EMAIL', :key_value => email}
+                  ]
+              }
+          })
+          return response
+        rescue Exception => e
+          @logger.log(e) if @logger
+          return nil
+        end
+      end
+
+      def get_lead(lead_key)
+        begin
+          response = send_request("ns1:paramsGetLead", {:lead_key => lead_key.to_hash})
+          return LeadRecord.from_hash(response[:success_get_lead][:result][:lead_record_list][:lead_record])
+        rescue Exception => e
+          @logger.log(e) if @logger
+          return nil
+        end
+      end
+
+      def send_request(namespace, body)
+        @header.set_time(DateTime.now)
+        response = request(namespace, body, @header.to_hash)
+        response.to_hash
+      end
+
+      def request(namespace, body, header)
+        @client.request namespace do |soap|
+          soap.namespaces["xmlns:ns1"]            = "http://www.marketo.com/mktows/"
+          soap.body                               = body
+          soap.header["ns1:AuthenticationHeader"] = header
+        end
+      end
+    end
+  end
+end

data/lib/marketo/enums.rb

@@ -0,0 +1,23 @@
+module Rapleaf
+  module Marketo
+    # Types of operations you can do on a marketo list
+    module ListOperationType
+      ADD_TO       = 'ADDTOLIST'
+      REMOVE_FROM  = 'REMOVEFROMLIST'
+      IS_MEMBER_OF = 'ISMEMBEROFLIST'
+    end
+
+    # Types of keys that can be used to look up a lead
+    module LeadKeyType
+      IDNUM           = "IDNUM"
+      COOKIE          = "COOKIE"
+      EMAIL           = "EMAIL"
+      LEADOWNEREMAIL  = "LEADOWNEREMAIL"
+      SFDCACCOUNTID   = "SFDCACCOUNTID"
+      SFDCCONTACTID   = "SFDCCONTACTID"
+      SFDCLEADID      = "SFDCLEADID"
+      SFDCLEADOWNERID = "SFDCLEADOWNERID"
+      SFDCOPPTYID     = "SFDCOPPTYID"
+    end
+  end
+end

data/lib/marketo/lead_key.rb

@@ -0,0 +1,31 @@
+module Rapleaf
+  module Marketo
+    # Encapsulates a key used to look up or describe a specific marketo lead.
+    class LeadKey
+      # - *key_type* the type of key to use see LeadKeyType
+      # - *key_value* normally a string value for the given type
+      def initialize(key_type, key_value)
+        @key_type = key_type
+        @key_value = key_value
+      end
+
+      # get the key type
+      def key_type
+        @key_type
+      end
+
+      # get the key value
+      def key_value
+        @key_value
+      end
+
+      # create a hash from this instance, for sending this object to marketo using savon
+      def to_hash
+        {
+            :key_type => @key_type,
+            :key_value => @key_value
+        }
+      end
+    end
+  end
+end

data/lib/marketo/lead_record.rb

@@ -0,0 +1,59 @@
+module Rapleaf
+  module Marketo
+    # Represents a record of the data known about a lead within marketo
+    class LeadRecord
+      def initialize(email, idnum = nil)
+        @email      = email
+        @idnum      = idnum
+        @attributes = {}
+        set_attribute('Email', @email)
+      end
+
+      # hydrates an instance from a savon hash returned form the marketo API
+      def self.from_hash(savon_hash)
+        lead_record = LeadRecord.new(savon_hash[:email], savon_hash[:id].to_i)
+        savon_hash[:lead_attribute_list][:attribute].each do |attribute|
+          lead_record.set_attribute(attribute[:attr_name], attribute[:attr_value])
+        end
+        lead_record
+      end
+
+      # get the record idnum
+      def idnum
+        @idnum
+      end
+
+      # get the record email
+      def email
+        @email
+      end
+
+      def attributes
+        @attributes
+      end
+
+      # update the value of the named attribute
+      def set_attribute(name, value)
+        @attributes[name] = value
+      end
+
+      # get the value for the named attribute
+      def get_attribute(name)
+        @attributes[name]
+      end
+
+      # will yield pairs of |attribute_name, attribute_value|
+      def each_attribute_pair(&block)
+        @attributes.each_pair do |name, value|
+          block.call(name, value)
+        end
+      end
+
+      def ==(other)
+        @attributes == other.attributes &&
+        @idnum == other.idnum &&
+        @email == other.email
+      end
+    end
+  end
+end

data/lib/njones-marketo.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'savon'
+
+Savon.configure do |config|
+  config.log = false # disable logging
+end
+
+require File.expand_path('marketo/client', File.dirname(__FILE__))
+require File.expand_path('marketo/authentication_header', File.dirname(__FILE__))
+require File.expand_path('marketo/enums', File.dirname(__FILE__))
+require File.expand_path('marketo/lead_key', File.dirname(__FILE__))
+require File.expand_path('marketo/lead_record', File.dirname(__FILE__))
+
+
+
+

data/spec/marketo/authentication_header_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+module Rapleaf
+  module Marketo
+    ACCESS_KEY = 'ACCESS_KEY'
+    SECRET_KEY = 'SECRET_KEY'
+
+    describe AuthenticationHeader do
+      it "should set mktowsUserId to access key" do
+        header = Rapleaf::Marketo::AuthenticationHeader.new(ACCESS_KEY, SECRET_KEY)
+        header.get_mktows_user_id.should == ACCESS_KEY
+      end
+
+      it "should set requestSignature" do
+        header = Rapleaf::Marketo::AuthenticationHeader.new(ACCESS_KEY, SECRET_KEY)
+        header.get_request_signature.should_not be_nil
+        header.get_request_signature.should_not == ''
+      end
+
+      it "should set requestTimestamp in correct format" do
+        header = Rapleaf::Marketo::AuthenticationHeader.new(ACCESS_KEY, SECRET_KEY)
+        time   = DateTime.new(1998, 1, 17, 20, 15, 1)
+        header.set_time(time)
+        header.get_request_timestamp().should == '1998-01-17T20:15:01+00:00'
+      end
+
+      it "should calculate encrypted signature" do
+        # I got this example of the marketo API docs
+
+        access_key = 'bigcorp1_461839624B16E06BA2D663'
+        secret_key = '899756834129871744AAEE88DDCC77CDEEDEC1AAAD66'
+
+        header     = Rapleaf::Marketo::AuthenticationHeader.new(access_key, secret_key)
+        header.set_time(DateTime.new(2010, 4, 9, 14, 4, 55, -7/24.0))
+
+        header.get_request_timestamp.should == '2010-04-09T14:04:54-07:00'
+        header.get_request_signature.should == 'ffbff4d4bef354807481e66dc7540f7890523a87'
+      end
+
+      it "should cope if no date is given" do
+        header   = Rapleaf::Marketo::AuthenticationHeader.new(ACCESS_KEY, SECRET_KEY)
+        expected = DateTime.now
+        actual   = DateTime.parse(header.get_request_timestamp)
+
+        expected.year.should == actual.year
+        expected.hour.should == actual.hour
+      end
+
+      it "should to_hash correctly" do
+        # I got this example from the marketo API docs
+
+        access_key = 'bigcorp1_461839624B16E06BA2D663'
+        secret_key = '899756834129871744AAEE88DDCC77CDEEDEC1AAAD66'
+
+        header     = Rapleaf::Marketo::AuthenticationHeader.new(access_key, secret_key)
+        header.set_time(DateTime.new(2010, 4, 9, 14, 4, 55, -7/24.0))
+
+        header.to_hash.should == {
+            'mktowsUserId'     => header.get_mktows_user_id,
+            'requestSignature' => header.get_request_signature,
+            'requestTimestamp' => header.get_request_timestamp,
+        }
+      end
+    end
+  end
+end

data/spec/marketo/client_spec.rb

@@ -0,0 +1,372 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+module Rapleaf
+  module Marketo
+
+    describe Client do
+      EMAIL   = "some@email.com"
+      IDNUM   = 29
+      FIRST   = 'Joe'
+      LAST    = 'Smith'
+      COMPANY = 'Rapleaf'
+      MOBILE  = '415 123 456'
+      API_KEY = 'API123KEY'
+
+      context 'Exception handling' do
+        it "should return nil if any exception is raised on get_lead request" do
+          savon_client          = mock('savon_client').as_null_object
+          authentication_header = mock('authentication_header').as_null_object
+          client                = Rapleaf::Marketo::Client.new(savon_client, authentication_header)
+          savon_client.should_receive(:request).and_raise Exception
+          client.get_lead_by_email(EMAIL).should be_nil
+        end
+
+        it "should return nil if any exception is raised on sync_lead request" do
+          savon_client          = mock('savon_client').as_null_object
+          authentication_header = mock('authentication_header').as_null_object
+          client                = Rapleaf::Marketo::Client.new(savon_client, authentication_header)
+          savon_client.should_receive(:request).and_raise Exception
+          client.sync_lead(EMAIL, FIRST, LAST, COMPANY, MOBILE).should be_nil
+        end
+      end
+
+      context 'Client interaction' do
+        it "should have the correct body format on get_lead_by_idnum" do
+          savon_client          = mock('savon_client')
+          authentication_header = mock('authentication_header')
+          client                = Rapleaf::Marketo::Client.new(savon_client, authentication_header)
+          response_hash         = {
+              :success_get_lead => {
+                  :result => {
+                      :count            => 1,
+                      :lead_record_list => {
+                          :lead_record => {
+                              :email                 => EMAIL,
+                              :lead_attribute_list   => {
+                                  :attribute => [
+                                      {:attr_name => 'name1', :attr_type => 'string', :attr_value => 'val1'},
+                                      {:attr_name => 'name2', :attr_type => 'string', :attr_value => 'val2'},
+                                      {:attr_name => 'name3', :attr_type => 'string', :attr_value => 'val3'},
+                                      {:attr_name => 'name4', :attr_type => 'string', :attr_value => 'val4'}
+                                  ]
+                              },
+                              :foreign_sys_type      => nil,
+                              :foreign_sys_person_id => nil,
+                              :id                    => IDNUM.to_s
+                          }
+                      }
+                  }
+              }
+          }
+          expect_request(savon_client,
+                         authentication_header,
+                         equals_matcher(:lead_key => {
+                             :key_value => IDNUM,
+                             :key_type  => LeadKeyType::IDNUM
+                         }),
+                         'ns1:paramsGetLead',
+                         response_hash)
+          expected_lead_record = LeadRecord.new(EMAIL, IDNUM)
+          expected_lead_record.set_attribute('name1', 'val1')
+          expected_lead_record.set_attribute('name2', 'val2')
+          expected_lead_record.set_attribute('name3', 'val3')
+          expected_lead_record.set_attribute('name4', 'val4')
+          client.get_lead_by_idnum(IDNUM).should == expected_lead_record
+        end
+
+        it "should have the correct body format on get_lead_by_email" do
+          savon_client          = mock('savon_client')
+          authentication_header = mock('authentication_header')
+          client                = Rapleaf::Marketo::Client.new(savon_client, authentication_header)
+          response_hash         = {
+              :success_get_lead => {
+                  :result => {
+                      :count            => 1,
+                      :lead_record_list => {
+                          :lead_record => {
+                              :email                 => EMAIL,
+                              :lead_attribute_list   => {
+                                  :attribute => [
+                                      {:attr_name => 'name1', :attr_type => 'string', :attr_value => 'val1'},
+                                      {:attr_name => 'name2', :attr_type => 'string', :attr_value => 'val2'},
+                                      {:attr_name => 'name3', :attr_type => 'string', :attr_value => 'val3'},
+                                      {:attr_name => 'name4', :attr_type => 'string', :attr_value => 'val4'}
+                                  ]
+                              },
+                              :foreign_sys_type      => nil,
+                              :foreign_sys_person_id => nil,
+                              :id                    => IDNUM.to_s
+                          }
+                      }
+                  }
+              }
+          }
+          expect_request(savon_client,
+                         authentication_header,
+                         equals_matcher({:lead_key => {
+                             :key_value => EMAIL,
+                             :key_type  => LeadKeyType::EMAIL}}),
+                         'ns1:paramsGetLead',
+                         response_hash)
+          expected_lead_record = LeadRecord.new(EMAIL, IDNUM)
+          expected_lead_record.set_attribute('name1', 'val1')
+          expected_lead_record.set_attribute('name2', 'val2')
+          expected_lead_record.set_attribute('name3', 'val3')
+          expected_lead_record.set_attribute('name4', 'val4')
+          client.get_lead_by_email(EMAIL).should == expected_lead_record
+        end
+
+        it "should have the correct body format on sync_lead_record" do
+          savon_client          = mock('savon_client')
+          authentication_header = mock('authentication_header')
+          client                = Rapleaf::Marketo::Client.new(savon_client, authentication_header)
+          response_hash         = {
+              :success_sync_lead => {
+                  :result => {
+                      :lead_id     => IDNUM,
+                      :sync_status => {
+                          :error   => nil,
+                          :status  => 'UPDATED',
+                          :lead_id => IDNUM
+                      },
+                      :lead_record => {
+                          :email                 => EMAIL,
+                          :lead_attribute_list   => {
+                              :attribute => [
+                                  {:attr_name => 'name1', :attr_type => 'string', :attr_value => 'val1'},
+                                  {:attr_name => 'name2', :attr_type => 'string', :attr_value => 'val2'},
+                                  {:attr_name => 'name3', :attr_type => 'string', :attr_value => 'val3'},
+                                  {:attr_name => 'name4', :attr_type => 'string', :attr_value => 'val4'}
+                              ]
+                          },
+                          :foreign_sys_type      => nil,
+                          :foreign_sys_person_id => nil,
+                          :id                    => IDNUM.to_s
+                      }
+                  }
+              }
+          }
+          expect_request(savon_client,
+                         authentication_header,
+                         equals_matcher({
+                                            :return_lead => true,
+                                            :lead_record => {
+                                                :email               => EMAIL,
+                                                :lead_attribute_list =>
+                                                    {
+                                                        :attribute => [
+                                                            {:attr_value => "val1",
+                                                             :attr_name  => "name1",
+                                                             :attr_type  => "string"},
+                                                            {:attr_value => "val2",
+                                                             :attr_name  => "name2",
+                                                             :attr_type  => "string"},
+                                                            {:attr_value => EMAIL,
+                                                             :attr_name  => "Email",
+                                                             :attr_type  => "string"}
+                                                        ]}}}),
+                         'ns1:paramsSyncLead',
+                         response_hash)
+          lead_record = LeadRecord.new(EMAIL)
+          lead_record.set_attribute('name1', 'val1')
+          lead_record.set_attribute('name2', 'val2')
+
+          expected_lead_record = LeadRecord.new(EMAIL, IDNUM)
+          expected_lead_record.set_attribute('Email', EMAIL)
+          expected_lead_record.set_attribute('name1', 'val1')
+          expected_lead_record.set_attribute('name2', 'val2')
+          expected_lead_record.set_attribute('name3', 'val3')
+          expected_lead_record.set_attribute('name4', 'val4')
+          client.sync_lead_record(lead_record).should == expected_lead_record
+        end
+
+        it "should have the correct body format on sync_lead" do
+          savon_client          = mock('savon_client')
+          authentication_header = mock('authentication_header')
+          client                = Rapleaf::Marketo::Client.new(savon_client, authentication_header)
+          response_hash         = {
+              :success_sync_lead => {
+                  :result => {
+                      :lead_id     => IDNUM,
+                      :sync_status => {
+                          :error   => nil,
+                          :status  => 'UPDATED',
+                          :lead_id => IDNUM
+                      },
+                      :lead_record => {
+                          :email                 => EMAIL,
+                          :lead_attribute_list   => {
+                              :attribute => [
+                                  {:attr_name => 'name1', :attr_type => 'string', :attr_value => 'val1'},
+                                  {:attr_name => 'name2', :attr_type => 'string', :attr_value => 'val2'},
+                                  {:attr_name => 'name3', :attr_type => 'string', :attr_value => 'val3'},
+                                  {:attr_name => 'name4', :attr_type => 'string', :attr_value => 'val4'}
+                              ]
+                          },
+                          :foreign_sys_type      => nil,
+                          :foreign_sys_person_id => nil,
+                          :id                    => IDNUM.to_s
+                      }
+                  }
+              }
+          }
+
+          expect_request(savon_client,
+                         authentication_header,
+                         Proc.new { |actual|
+                           actual_attribute_list                                  = actual[:lead_record][:lead_attribute_list][:attribute]
+                           actual[:lead_record][:lead_attribute_list][:attribute] = nil
+                           expected                                               = {
+                               :return_lead => true,
+                               :lead_record => {
+                                   :email               => "some@email.com",
+                                   :lead_attribute_list =>
+                                       {
+                                           :attribute => nil}}
+                           }
+                           actual.should == expected
+                           actual_attribute_list.should =~ [
+                               {:attr_value => FIRST,
+                                :attr_name  => "FirstName",
+                                :attr_type  => "string"},
+                               {:attr_value => LAST,
+                                :attr_name  => "LastName",
+                                :attr_type  => "string"},
+                               {:attr_value => EMAIL,
+                                :attr_name  =>"Email",
+                                :attr_type  => "string"},
+                               {:attr_value => COMPANY,
+                                :attr_name  => "Company",
+                                :attr_type  => "string"},
+                               {:attr_value => MOBILE,
+                                :attr_name  => "MobilePhone",
+                                :attr_type  => "string"}
+                           ]
+                         },
+                         'ns1:paramsSyncLead',
+                         response_hash)
+          expected_lead_record = LeadRecord.new(EMAIL, IDNUM)
+          expected_lead_record.set_attribute('name1', 'val1')
+          expected_lead_record.set_attribute('name2', 'val2')
+          expected_lead_record.set_attribute('name3', 'val3')
+          expected_lead_record.set_attribute('name4', 'val4')
+          client.sync_lead(EMAIL, FIRST, LAST, COMPANY, MOBILE).should == expected_lead_record
+        end
+
+        context "list operations" do
+          LIST_KEY = 'awesome leads list'
+
+          before(:each) do
+            @savon_client          = mock('savon_client')
+            @authentication_header = mock('authentication_header')
+            @client                = Rapleaf::Marketo::Client.new(@savon_client, @authentication_header)
+          end
+
+          it "should have the correct body format on add_to_list" do
+            response_hash = {} # TODO
+            expect_request(@savon_client,
+                           @authentication_header,
+                           equals_matcher({
+                                              :list_operation   => ListOperationType::ADD_TO,
+                                              :list_key         => LIST_KEY,
+                                              :strict           => 'false',
+                                              :list_member_list => {
+                                                  :lead_key => [
+                                                      {
+                                                          :key_type  => 'EMAIL',
+                                                          :key_value => EMAIL
+                                                      }
+                                                  ]
+                                              }
+                                          }),
+                           'ns1:paramsListOperation',
+                           response_hash)
+
+            @client.add_to_list(LIST_KEY, EMAIL).should == response_hash
+          end
+
+          it "should have the correct body format on remove_from_list" do
+            response_hash = {} # TODO
+            expect_request(@savon_client,
+                           @authentication_header,
+                           equals_matcher({
+                                              :list_operation   => ListOperationType::REMOVE_FROM,
+                                              :list_key         => LIST_KEY,
+                                              :strict           => 'false',
+                                              :list_member_list => {
+                                                  :lead_key => [
+                                                      {
+                                                          :key_type  => 'EMAIL',
+                                                          :key_value => EMAIL
+                                                      }
+                                                  ]
+                                              }
+                                          }),
+                           'ns1:paramsListOperation',
+                           response_hash)
+
+            @client.remove_from_list(LIST_KEY, EMAIL).should == response_hash
+          end
+
+          it "should have the correct body format on is_member_of_list?" do
+            response_hash = {} # TODO
+            expect_request(@savon_client,
+                           @authentication_header,
+                           equals_matcher({
+                                              :list_operation   => ListOperationType::IS_MEMBER_OF,
+                                              :list_key         => LIST_KEY,
+                                              :strict           => 'false',
+                                              :list_member_list => {
+                                                  :lead_key => [
+                                                      {
+                                                          :key_type  => 'EMAIL',
+                                                          :key_value => EMAIL
+                                                      }
+                                                  ]
+                                              }
+                                          }),
+                           'ns1:paramsListOperation',
+                           response_hash)
+
+            @client.is_member_of_list?(LIST_KEY, EMAIL).should == response_hash
+          end
+        end
+      end
+
+      private
+
+      def equals_matcher(expected)
+        Proc.new { |actual|
+          actual.should == expected
+        }
+      end
+
+      def expect_request(savon_client, authentication_header, expected_body_matcher, expected_namespace, response_hash)
+        header_hash       = stub('header_hash')
+        soap_response     = stub('soap_response')
+        request_namespace = mock('namespace')
+        request_header    = mock('request_header')
+        soap_request      = mock('soap_request')
+        authentication_header.should_receive(:set_time)
+        authentication_header.should_receive(:to_hash).and_return(header_hash)
+        request_namespace.should_receive(:[]=).with("xmlns:ns1", "http://www.marketo.com/mktows/")
+        request_header.should_receive(:[]=).with("ns1:AuthenticationHeader", header_hash)
+        soap_request.should_receive(:namespaces).and_return(request_namespace)
+        soap_request.should_receive(:header).and_return(request_header)
+        soap_request.should_receive(:body=) do |actual_body|
+          expected_body_matcher.call(actual_body)
+        end
+        soap_response.should_receive(:to_hash).and_return(response_hash)
+        savon_client.should_receive(:request).with(expected_namespace).and_yield(soap_request).and_return(soap_response)
+      end
+    end
+
+    describe ListOperationType do
+      it 'should define the correct types' do
+        ListOperationType::ADD_TO.should == 'ADDTOLIST'
+        ListOperationType::IS_MEMBER_OF.should == 'ISMEMBEROFLIST'
+        ListOperationType::REMOVE_FROM.should == 'REMOVEFROMLIST'
+      end
+    end
+  end
+end

data/spec/marketo/lead_key_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+module Rapleaf
+  module Marketo
+    describe LeadKeyType do
+      it "should define the correct types" do
+        LeadKeyType::IDNUM.should == 'IDNUM'
+        LeadKeyType::COOKIE.should == 'COOKIE'
+        LeadKeyType::EMAIL.should == 'EMAIL'
+        LeadKeyType::LEADOWNEREMAIL.should == 'LEADOWNEREMAIL'
+        LeadKeyType::SFDCACCOUNTID.should == 'SFDCACCOUNTID'
+        LeadKeyType::SFDCCONTACTID.should == 'SFDCCONTACTID'
+        LeadKeyType::SFDCLEADID.should == 'SFDCLEADID'
+        LeadKeyType::SFDCLEADOWNERID.should == 'SFDCLEADOWNERID'
+        LeadKeyType::SFDCOPPTYID.should == 'SFDCOPPTYID'
+      end
+    end
+
+    describe LeadKey do
+      it "should store type and value on construction" do
+        KEY_VALUE = 'a value'
+        KEY_TYPE = LeadKeyType::IDNUM
+        lead_key = LeadKey.new(KEY_TYPE, KEY_VALUE)
+        lead_key.key_type.should == KEY_TYPE
+        lead_key.key_value.should == KEY_VALUE
+      end
+
+      it "should to_hash correctly" do
+        KEY_VALUE = 'a value'
+        KEY_TYPE = LeadKeyType::IDNUM
+        lead_key = LeadKey.new(KEY_TYPE, KEY_VALUE)
+
+        lead_key.to_hash.should == {
+            :key_type => KEY_TYPE,
+            :key_value => KEY_VALUE
+        }
+      end
+    end
+  end
+end

data/spec/marketo/lead_record_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+module Rapleaf
+  module Marketo
+    EMAIL = 'some@email.com'
+    IDNUM    = 93480938
+
+    describe LeadRecord do
+      it "should store the idnum" do
+        lead_record = LeadRecord.new(EMAIL, IDNUM)
+        lead_record.idnum.should == IDNUM
+      end
+
+      it "should store the email" do
+        LeadRecord.new(EMAIL, IDNUM).email.should == EMAIL
+      end
+
+      it "should implement == sensibly" do
+        lead_record1 = LeadRecord.new(EMAIL, IDNUM)
+        lead_record1.set_attribute('favourite color', 'red')
+        lead_record1.set_attribute('age', '100')
+
+        lead_record2 = LeadRecord.new(EMAIL, IDNUM)
+        lead_record2.set_attribute('favourite color', 'red')
+        lead_record2.set_attribute('age', '100')
+
+        lead_record1.should == lead_record2
+      end
+
+      it "should store when attributes are set" do
+        lead_record = LeadRecord.new(EMAIL, IDNUM)
+        lead_record.set_attribute('favourite color', 'red')
+        lead_record.get_attribute('favourite color').should == 'red'
+      end
+
+      it "should store when attributes are updated" do
+        lead_record = LeadRecord.new(EMAIL, IDNUM)
+        lead_record.set_attribute('favourite color', 'red')
+        lead_record.set_attribute('favourite color', 'green')
+        lead_record.get_attribute('favourite color').should == 'green'
+      end
+
+      it "should yield all attributes through each_attribute_pair" do
+        lead_record = LeadRecord.new(EMAIL, IDNUM)
+        lead_record.set_attribute('favourite color', 'red')
+        lead_record.set_attribute('favourite color', 'green')
+        lead_record.set_attribute('age', '99')
+
+        pairs       = []
+        lead_record.each_attribute_pair do |attribute_name, attribute_value|
+          pairs << [attribute_name, attribute_value]
+        end
+
+        pairs.size.should == 3
+        pairs.should include(['favourite color', 'green'])
+        pairs.should include(['age', '99'])
+        pairs.should include(['Email', EMAIL])
+      end
+
+      it "should be instantiable from a savon hash" do
+        savon_hash = {
+            :email => EMAIL,
+            :foreign_sys_type => nil,
+            :lead_attribute_list => {
+                :attribute => [
+                  { :attr_name => 'Company', :attr_type => 'string', :attr_value => 'Rapleaf'},
+                  { :attr_name => 'FirstName', :attr_type => 'string', :attr_value => 'James'},
+                  { :attr_name => 'LastName', :attr_type => 'string', :attr_value => 'O\'Brien'}
+                ]
+            },
+            :foreign_sys_person_id => nil,
+            :id => IDNUM
+        }
+
+        actual = LeadRecord.from_hash(savon_hash)
+
+        expected = LeadRecord.new(EMAIL, IDNUM)
+        expected.set_attribute('Company', 'Rapleaf')
+        expected.set_attribute('FirstName', 'James')
+        expected.set_attribute('LastName', 'O\'Brien')
+
+        actual.should == expected
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: njones-marketo
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 2
+  - 5
+  version: 1.2.5
+platform: ruby
+authors: 
+- James O'Brien (orginal author)
+- Nika Jones
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-29 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: savon
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 3
+        version: 0.8.3
+  type: :runtime
+  version_requirements: *id002
+description: "     A Fork of the Rapleaf marketo-gem. Once the updates in the gem are merged into that one, you should use that.\n\n    Allows easy integration with marketo from ruby. You can synchronize leads (multiple leads too) and fetch them back by email. This is based on the SOAP wsdl file: http://app.marketo.com/soap/mktows/1_7?WSDL (by default, but you can change on the fly). More information at https://www.rapleaf.com/developers/marketo. And look to https://github.com/njones/marketo_gem/tree/njones-marketo for updates.\n"
+email: njones@appcelerator.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/marketo/authentication_header.rb
+- lib/marketo/client.rb
+- lib/marketo/enums.rb
+- lib/marketo/lead_key.rb
+- lib/marketo/lead_record.rb
+- lib/njones-marketo.rb
+has_rdoc: true
+homepage: https://github.com/njones/marketo_gem
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Marketo Client Gem
+- --main
+- Rapleaf::Marketo::Client
+require_paths: 
+- - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A client for using the marketo API
+test_files: 
+- spec/marketo/authentication_header_spec.rb
+- spec/marketo/client_spec.rb
+- spec/marketo/lead_key_spec.rb
+- spec/marketo/lead_record_spec.rb