marketo 1.1.0

data/lib/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/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,126 @@
+require File.expand_path('authentication_header', File.dirname(__FILE__))
+
+module Rapleaf
+  module Marketo
+    def self.new_client(access_key, secret_key)
+      client = Savon::Client.new do
+        wsdl.endpoint     = "https://na-i.marketo.com/soap/mktows/1_5"
+        wsdl.document     = "http://app.marketo.com/soap/mktows/1_4?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>)
+    #
+    #  client.sync_lead('john@gmail.com', 'john', 'smith', 'rapleaf', '1122 334 455', 'api')
+    class Client
+      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
+
+      # 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
+      # * api_key - rapleaf API key
+      def sync_lead(email, first, last, company, mobile, api_key)
+        begin
+          response = send_request("ns1:paramsSyncLead", {
+              :return_lead => true,
+              :lead_record =>
+                  {:email               => email,
+                   :lead_attribute_list => {
+                       :attribute => [
+                           {:attr_name => 'FirstName', :attr_type => 'string', :attr_value => first},
+                           {:attr_name => 'LastName', :attr_type => 'string', :attr_value => last},
+                           {:attr_name => 'Email', :attr_type => 'string', :attr_value => email},
+                           {:attr_name => 'Company', :attr_type => 'string', :attr_value => company},
+                           {:attr_name => 'MobilePhone', :attr_type => 'string', :attr_value => mobile},
+                           {:attr_name => 'API_Key__c', :attr_type => 'string', :attr_value => api_key}
+                       ]}}})
+          return response
+        rescue Exception => e
+          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
+          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
+          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,58 @@
+module Rapleaf
+  module Marketo
+    # Represents a record of the data known about a lead within marketo
+    class LeadRecord
+      def initialize(email, idnum)
+        @email      = email
+        @idnum      = idnum
+        @attributes = {}
+      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/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,263 @@
+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, API_KEY).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,
+                         {: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,
+                         {: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" do
+          savon_client          = mock('savon_client')
+          authentication_header = mock('authentication_header')
+          client                = Rapleaf::Marketo::Client.new(savon_client, authentication_header)
+          response_hash         = {} # TODO
+          expect_request(savon_client,
+                         authentication_header,
+                         {
+                             :return_lead => true,
+                             :lead_record => {
+                                 :email               => "some@email.com",
+                                 :lead_attribute_list =>
+                                     {
+                                         :attribute => [
+                                             {:attr_value => "Joe",
+                                              :attr_name  => "FirstName",
+                                              :attr_type  => "string"},
+                                             {:attr_value => "Smith",
+                                              :attr_name  => "LastName",
+                                              :attr_type  => "string"},
+                                             {:attr_value => "some@email.com",
+                                              :attr_name  =>"Email",
+                                              :attr_type  => "string"},
+                                             {:attr_value => "Rapleaf",
+                                              :attr_name  =>"Company",
+                                              :attr_type  =>"string"},
+                                             {:attr_value =>"415 123 456",
+                                              :attr_name  =>"MobilePhone",
+                                              :attr_type  =>"string"},
+                                             {:attr_value =>"API123KEY",
+                                              :attr_name  =>"API_Key__c",
+                                              :attr_type  =>"string"}
+                                         ]}}},
+                         'ns1:paramsSyncLead',
+                         response_hash)
+          client.sync_lead(EMAIL, FIRST, LAST, COMPANY, MOBILE, API_KEY).should == response_hash
+        end
+
+        context "list operations" do
+          before(:each) do
+            LIST_KEY               = 'awesome leads list'
+            @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,
+                           {
+                               :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,
+                           {
+                               :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,
+                           {
+                               :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 expect_request(savon_client, authentication_header, expected_body, 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=).with(expected_body)
+        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,88 @@
+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
+        LeadRecord.new(EMAIL, IDNUM).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 == 2
+        pairs.should include(['favourite color', 'green'])
+        pairs.should include(['age', '99'])
+      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)
+
+        actual.email.should == EMAIL
+        actual.idnum.should == IDNUM
+        pairs = []
+        actual.each_attribute_pair do |attribute_name, attribute_value|
+          pairs << [attribute_name, attribute_value]
+        end
+        pairs.size.should == 3
+        pairs.should include(['Company', 'Rapleaf'])
+        pairs.should include(['FirstName', 'James'])
+        pairs.should include(['LastName', 'O\'Brien'])
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: marketo
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 1
+  - 1
+  - 0
+  version: 1.1.0
+platform: ruby
+authors: 
+- James O'Brien
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-31 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: savon
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Allows easy integration with marketo from ruby. You can synchronize leads and fetch them back by email.
+email: james@rapleaf.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/marketo.rb
+- spec/marketo/authentication_header_spec.rb
+- spec/marketo/client_spec.rb
+- spec/marketo/lead_key_spec.rb
+- spec/marketo/lead_record_spec.rb
+has_rdoc: true
+homepage: http://www.rapleaf.com
+licenses: 
+- - Rapleaf internal - do not use without permission
+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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A client for using the marketo API within Rapleaf
+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