marketo2 1.4.0

data/lib/marketo2.rb

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

data/lib/marketo2/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/marketo2/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_subdomain = '207-XLI-813', api_version = '2_2', document_version = '2_2')
+      client = Savon::Client.new do
+        wsdl.endpoint     = "https://#{api_subdomain}.mktoapi.com/soap/mktows/#{api_version}"
+        wsdl.document     = "http://app.marketo.com/soap/mktows/#{document_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>, api_subdomain = 'na-i', api_version = '1_5', document_version = '1_4')
+    #
+    # == 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)
+    #
+    # == sync_lead_record_on_id: (update with custom fields, ensuring the sync is id based)
+    #
+    # similarly, you can force a sync via id instead of email by calling client.sync_lead_record_on_id(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_lead_record_on_id(lead_record)
+        idnum = lead_record.idnum
+        raise 'lead record id not set' if idnum.nil?
+
+        begin
+          attributes = []
+          lead_record.each_attribute_pair do |name, value|
+              attributes << {:attr_name => name, :attr_type => 'string', :attr_value => value}
+          end
+
+          attributes << {:attr_name => 'Id', :attr_type => 'string', :attr_value => idnum.to_s}
+
+          response = send_request("ns1:paramsSyncLead", {
+              :return_lead => true,
+              :lead_record =>
+                  {
+                    :lead_attribute_list => { :attribute => attributes},
+                    :id => idnum
+                  }})
+          return LeadRecord.from_hash(response[:success_sync_lead][:result][:lead_record])
+        rescue Exception => e
+          @logger.log(e) if @logger
+          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/marketo2/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/marketo2/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/marketo2/lead_record.rb

@@ -0,0 +1,62 @@
+module Rapleaf
+  module Marketo
+    # Represents a record of the data known about a lead within marketo
+    class LeadRecord
+      def initialize(email, idnum = nil)
+        @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
+        get_attribute('Email')
+      end
+
+      def attributes
+        @attributes
+      end
+
+      # update the value of the named attribute
+      def set_attribute(name, value)
+        @attributes[name] = value
+      end
+      
+      # update the value of the named attribute, only if blank
+      def set_attribute_if_blank(name, value)
+        set_attribute(name, value) if get_attribute(name).blank?
+      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
+      end
+    end
+  end
+end

data/spec/marketo2/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/marketo2/client_spec.rb

@@ -0,0 +1,363 @@
+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,
+                         (Proc.new do |actual|
+                             retval = true
+                             retval = false unless actual[:return_lead]
+                             retval = false unless actual[:lead_record][:email].equal?(EMAIL)
+                             retval = false unless actual[:lead_record][:lead_attribute_list][:attribute].size == 5
+                             retval = false unless actual[:lead_record][:lead_attribute_list][:attribute].include?({:attr_value => EMAIL, :attr_name => "Email", :attr_type => "string"})
+                             retval = false unless actual[:lead_record][:lead_attribute_list][:attribute].include?({:attr_value => "val1", :attr_name => "name1", :attr_type => "string"})
+                             retval = false unless actual[:lead_record][:lead_attribute_list][:attribute].include?({:attr_value => "val2", :attr_name => "name2", :attr_type => "string"})
+                             retval = false unless actual[:lead_record][:lead_attribute_list][:attribute].include?({:attr_value => "val3", :attr_name => "name3", :attr_type => "string"})
+                             retval = false unless actual[:lead_record][:lead_attribute_list][:attribute].include?({:attr_value => "val4", :attr_name => "name4", :attr_type => "string"})
+                             retval.should == true
+                         end),
+                         'ns1:paramsSyncLead',
+                         response_hash)
+          lead_record = LeadRecord.new(EMAIL, IDNUM)
+          lead_record.set_attribute('name1', 'val1')
+          lead_record.set_attribute('name2', 'val2')
+          lead_record.set_attribute('name3', 'val3')
+          lead_record.set_attribute('name4', 'val4')
+
+          client.sync_lead_record(lead_record).should == 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/marketo2/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/marketo2/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,90 @@
+--- !ruby/object:Gem::Specification
+name: marketo2
+version: !ruby/object:Gem::Version
+  version: 1.4.0
+  prerelease: 
+platform: ruby
+authors:
+- Maxime Domain
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-09 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70357517664720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *70357517664720
+- !ruby/object:Gem::Dependency
+  name: savon
+  requirement: &70357517664120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70357517664120
+description: ! "     Allows easy integration with marketo from ruby (v2 and up). You
+  can synchronize leads and fetch them back by email.\n     By default this is configured
+  for the SOAP wsdl file: http://app.marketo.com/soap/mktows/1_4?WSDL but this is\n
+  \    configurable when you construct the client, e.g.\n     client = Rapleaf::Marketo.new_client(<access_key>,
+  <secret_key>, (api_subdomain = 'na-i'), (api_version = '1_5'), (document_version
+  = '1_4'))\n     More information at https://www.rapleaf.com/developers/marketo.\n
+  \    Forked from James O'Brien's marketo gem.\n"
+email: hanaiapa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/marketo2/authentication_header.rb
+- lib/marketo2/client.rb
+- lib/marketo2/enums.rb
+- lib/marketo2/lead_key.rb
+- lib/marketo2/lead_record.rb
+- lib/marketo2.rb
+- spec/marketo2/authentication_header_spec.rb
+- spec/marketo2/client_spec.rb
+- spec/marketo2/lead_key_spec.rb
+- spec/marketo2/lead_record_spec.rb
+homepage: https://github.com/hanaiapa/marketo2
+licenses: []
+post_install_message: 
+rdoc_options:
+- --title
+- Marketo Client Gem
+- --main
+- Rapleaf::Marketo::Client
+require_paths:
+- - lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A client for the marketo API
+test_files:
+- spec/marketo2/authentication_header_spec.rb
+- spec/marketo2/client_spec.rb
+- spec/marketo2/lead_key_spec.rb
+- spec/marketo2/lead_record_spec.rb