marketo-api-ruby 0.8

data/lib/marketo_api/mobjects.rb

@@ -0,0 +1,115 @@
+require_relative 'client_proxy'
+require_relative 'mobject'
+
+# MarketoAPI operations on Marketo objects (MObject).
+class MarketoAPI::MObjects < MarketoAPI::ClientProxy
+
+  # :call-seq:
+  #   delete(mobject, mobject, ...) -> status_list
+  #
+  # Implements
+  # {+deleteMObjects+}[http://developers.marketo.com/documentation/soap/deletemobjects/],
+  # returning the deletion success status for each object provided.
+  #
+  # Only works with Opportunity or OpportunityPersonRole MObjects.
+  #
+  # To delete an Opportunity:
+  #
+  #   marketo.mobjects.delete MarketoAPI::MObject.opportunity(75)
+  def delete(*mobjects)
+    if mobjects.empty?
+      raise ArgumentError, "must provide one or more MObjects to delete"
+    end
+    response = call(
+      :delete_m_objects,
+      m_object_list: transform_param_list(__method__, mobjects)
+    )
+    extract_mobject_status_list(response)
+  end
+
+  # Implements
+  # {+listMObjects+}[http://developers.marketo.com/documentation/soap/listmobjects/],
+  # returning the type names of the available Marketo objects. The type
+  # names can be passed to #describe.
+  def list
+    extract_from_response(
+      call(:list_m_objects, nil),
+      :objects
+    )
+  end
+
+  # Implements
+  # {+describeMObject+}[http://developers.marketo.com/documentation/soap/describemobject/],
+  # returning the description of the Marketo object.
+  def describe(name)
+    unless MarketoAPI::MObject::DESCRIBE_TYPES.include?(name.to_sym)
+      raise ArgumentError, "invalid type #{name} to describe"
+    end
+
+    extract_from_response(
+      call(:describe_m_object, object_name: name),
+      :metadata
+    )
+  end
+
+  # Implements
+  # {+getMObjects+}[http://developers.marketo.com/documentation/soap/getmobjects/],
+  # returning one or more Marketo objects, up to 100 in a page. It also
+  # returns the current current stream position to continue working with the
+  # pages on subsequent calls to #get.
+  #
+  # See MObject#criteria and MObject#association on how to build criteria
+  # and association filters for #get queries.
+  def get(mobject)
+    call(:get_m_objects, transform_param(__method__, mobject)) { |list|
+      Get.new(list)
+    }
+  end
+
+  def sync(operation, *mobjects) #:nodoc:
+    # http://developers.marketo.com/documentation/soap/sync-mobjects/
+    raise NotImplementedError,
+      ":sync_m_objects is not implemented in this version."
+    response = call(
+      :sync_m_objects,
+      transform_param_list(__method__, mobjects)
+    )
+    extract_mobject_status_list(response)
+  end
+
+  # A response object to MObjects#get that includes the return count, the
+  # new stream position, and the list of MObject records.
+  class Get
+    # The number of MObjects returned from MObjects#get.
+    attr_reader :return_count
+    # The stream position used for paging in MObjects#get.
+    # This may be shared with each MObject in #mobjects.
+    attr_reader :stream_position
+    # The list of Marketo objects.
+    attr_reader :mobjects
+
+    def initialize(hash)
+      @return_count = hash[:return_count].to_i
+      @more = hash[:has_more]
+      @stream_position = hash[:new_stream_position]
+      objects = MarketoAPI.array(hash[:m_object_list])
+
+      @mobjects = objects.map { |object|
+        MarketoAPI::MObject.from_soap_hash(object[:m_object])
+      }
+    end
+
+    # Returns +true+ if there are more objects to be returned.
+    def more?
+      !!@more
+    end
+  end
+
+  private
+  def extract_mobject_status_list(response)
+    response = extract_from_response(response, :m_obj_status_list) { |resp|
+      resp.map { |e| e[:m_object_status].values_at(:id, :status) }
+    }.flatten
+    Hash[*response]
+  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,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