marketo-api-ruby 0.8

data/spec/marketo/lead_key_spec.rb

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

data/spec/marketo/lead_record_spec.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require "rubygems"
+require "rspec"
+
+require File.expand_path('../lib/marketo', File.dirname(__FILE__))

data/test/marketo_api/test_campaigns.rb

@@ -0,0 +1,173 @@
+require "minitest_helper"
+
+class TestMarketoAPICampaigns < Minitest::Test
+  include MarketoTestHelper
+
+  def setup
+    super
+    @subject = @client.campaigns
+  end
+
+  def test_for_marketo
+    assert subject.respond_to? :for_marketo
+    stub_specialized :for_source do
+      assert_equal :MKTOWS, subject.for_marketo.first
+    end
+    stub_soap_call do
+      method, options = subject.for_marketo
+      assert_equal :get_campaigns_for_source, method
+      assert_equal({ source: :MKTOWS }, options)
+    end
+  end
+
+  def test_for_sales
+    assert subject.respond_to? :for_sales
+    stub_specialized :for_source do
+      assert_equal :SALES, subject.for_sales.first
+    end
+    stub_soap_call do
+      method, options = subject.for_sales
+      assert_equal :get_campaigns_for_source, method
+      assert_equal({ source: :SALES }, options)
+    end
+  end
+
+  def test_for_source_bad_source
+    assert_raises(ArgumentError) { subject.for_source :bad_source }
+  end
+
+  def test_for_source_marketo_name
+    stub_soap_call do
+      method, options = subject.for_source :marketo, 'John'
+      assert_equal :get_campaigns_for_source, method
+      assert_equal({ source: :MKTOWS, name: 'John' }, options)
+    end
+  end
+
+  def test_for_source_sales_name_exact
+    stub_soap_call do
+      method, options = subject.for_source :marketo, 'John', true
+      assert_equal :get_campaigns_for_source, method
+      assert_equal({ source: :MKTOWS, name: 'John', exact_name: true },
+                   options)
+    end
+  end
+
+  def test_request_marketo
+    assert subject.respond_to? :request_marketo
+    stub_specialized :request do
+      options = subject.request_marketo.first
+      assert_equal({ source: :MKTOWS }, options)
+    end
+  end
+
+  def test_request_sales
+    assert subject.respond_to? :request_sales
+    stub_specialized :request do
+      options = subject.request_sales.first
+      assert_equal({ source: :SALES }, options)
+    end
+  end
+
+  def test_request_missing_leads
+    assert_raises(ArgumentError) {
+      subject.request
+    }
+  end
+
+  def test_request_missing_campaign_or_program
+    assert_raises(ArgumentError) {
+      subject.request(lead: :foo)
+    }
+  end
+
+  def test_request_program_token_with_no_program_name
+    assert_raises(KeyError) {
+      subject.request(lead: :foo, campaign_id: 5, program_tokens: [ 3 ])
+    }
+  end
+
+  def test_request_with_campaign_id_and_name
+    assert_raises(ArgumentError) {
+      subject.request(lead: :foo, campaign_id: 5, campaign_name: 'Five')
+    }
+  end
+
+  def test_request_bad_source
+    assert_raises(ArgumentError) {
+      subject.request(lead: :foo, campaign_id: 5, source: :bad_source)
+    }
+  end
+
+  def test_request_merged_leads_campaign_id_default_source
+    stub_soap_call do
+      method, options = subject.request(lead:        lead_key(3),
+                                        leads:       lead_keys(4, 5),
+                                        campaign_id: 3)
+      assert_equal :request_campaign, method
+      assert_equal :MKTOWS, options[:source]
+      assert_equal lead_keys(4, 5, 3), options[:lead_list]
+      assert_equal 3, options[:campaign_id]
+      assert_missing_keys options, :campaign_name, :program_name,
+        :program_tokens
+    end
+  end
+
+  def test_request_using_campaign_name
+    stub_soap_call do
+      method, options = subject.request(lead:          lead_key(3),
+                                        campaign_name: 'earthday')
+      assert_equal :request_campaign, method
+      assert_equal :MKTOWS, options[:source]
+      assert_equal [ lead_key(3) ], options[:lead_list]
+      assert_equal 'earthday', options[:campaign_name]
+      assert_missing_keys options, :campaign_id, :program_name,
+        :program_tokens
+    end
+  end
+
+  def test_request_using_program_name
+    stub_soap_call do
+      method, options = subject.request(lead:         lead_key(3),
+                                        program_name: 'earthday')
+      assert_equal :request_campaign, method
+      assert_equal :MKTOWS, options[:source]
+      assert_equal [ lead_key(3) ], options[:lead_list]
+      assert_equal 'earthday', options[:program_name]
+      assert_missing_keys options, :campaign_name, :campaign_id,
+        :program_tokens
+    end
+  end
+
+  def test_schedule
+    stub_soap_call do
+      method, options = subject.schedule('program', 'campaign')
+      assert_equal :schedule_campaign, method
+      assert_equal({ program_name: 'program', campaign_name: 'campaign' }, options)
+    end
+  end
+
+  def test_schedule_with_run_at
+    stub_soap_call do
+      method, options = subject.schedule('program', 'campaign', run_at: 3)
+      assert_equal :schedule_campaign, method
+      assert_equal({
+        program_name:    'program',
+        campaign_name:   'campaign',
+        campaign_run_at: 3
+      }, options)
+    end
+  end
+
+  def test_schedule_with_program_tokens
+    stub_soap_call do
+      method, options = subject.schedule('program', 'campaign', program_tokens: [ :x ])
+      assert_equal :schedule_campaign, method
+      assert_equal({
+        program_name:       'program',
+        campaign_name:      'campaign',
+        program_token_list: [ :x ]
+      }, options)
+    end
+  end
+end

data/test/marketo_api/test_client.rb

@@ -0,0 +1,83 @@
+require "minitest_helper"
+
+class TestMarketoAPIClient < Minitest::Test
+  include MarketoTestHelper
+
+  def setup
+    super
+    @subject = @client
+  end
+
+  def test_api_version
+    assert_equal '2_3', subject.api_version
+    assert_equal '2_4', setup_client(api_version: '2_4').api_version
+  end
+
+  def test_subdomain
+    assert_equal '123-ABC-456', subject.subdomain
+    assert_equal 'testable', setup_client(api_subdomain: 'testable').subdomain
+  end
+
+  def test_wsdl
+    assert_equal "http://app.marketo.com/soap/mktows/2_3?WSDL",
+      subject.wsdl
+    assert_equal "http://app.marketo.com/soap/mktows/2_4?WSDL",
+      setup_client(api_version: '2_4').wsdl
+  end
+
+  def test_endpoint
+    assert_equal "https://123-ABC-456.mktoapi.com/soap/mktows/2_3",
+      subject.endpoint
+    assert_equal "https://testable.mktoapi.com/soap/mktows/2_4",
+      setup_client(api_subdomain: 'testable', api_version: '2_4').endpoint
+  end
+
+  def test_generated_methods
+    assert subject.respond_to? :campaigns
+    assert subject.respond_to? :leads
+    assert subject.respond_to? :lists
+    assert subject.respond_to? :mobjects
+    refute subject.respond_to? :customobjects
+  end
+
+  def stub_savon callable = nil, &block
+    callable ||= ARGS_STUB
+    subject.instance_variable_get(:@savon).stub :call, callable do
+      block.call if block
+    end
+  end
+
+  def test_call_exception_suppressed
+    stub_savon -> { raise ArgumentError } do
+      assert_nil subject.call(:web_method, {})
+      assert subject.error?
+      refute_nil subject.error
+      assert_instance_of ArgumentError, subject.error
+    end
+  end
+
+  def test_call_with_auth
+    time = Time.now.to_i
+
+    signature = {
+      mktowsUserId:      'user',
+      requestTimestamp:  time.to_s,
+      requestSignature:  OpenSSL::HMAC.hexdigest(
+        OpenSSL::Digest.new('sha1'),
+        'key',
+        "#{time}user"
+      )
+    }
+
+    Time.stub :now, -> { time } do
+      stub_savon do
+        method, params = subject.call(:web_method, {})
+        assert_equal :web_method, method
+        assert_equal({
+          message: {},
+          soap_header: { 'ns1:AuthenticationHeader' => signature }
+        }, params)
+      end
+    end
+  end
+end

data/test/marketo_api/test_lead.rb

@@ -0,0 +1,158 @@
+require "minitest_helper"
+
+class TestMarketoAPILead < Minitest::Test
+  include MarketoTestHelper
+
+  def setup
+    super
+    @id = 99
+    @date = DateTime.new(2014, 01, 01)
+    @email = 'great@gretzky.com'
+    @attributes = {
+      String:  'string',
+      Int: 5,
+      Date:    @date
+    }
+    @subject = MarketoAPI::Lead.new(id: @id, email: @email) do |lead|
+      @attributes.each { |k, v| lead[k] = v }
+    end
+  end
+
+  def test_id
+    assert_equal 99, subject.id
+  end
+
+  def test_cookie
+    assert_nil subject.cookie
+    subject.cookie = 'cookie'
+    refute_nil subject.cookie
+    assert_equal 'cookie', subject.cookie
+  end
+
+  def test_attributes
+    assert_equal @attributes.merge(Email: @email), subject.attributes
+  end
+
+  def test_types
+    types = Hash[*@attributes.merge(Email: @email).map { |(k, v)|
+      [ k, subject.send(:infer_value_type, v) ]
+    }.flatten]
+    assert_equal types, subject.types
+  end
+
+  def test_proxy_bad_assignment
+    assert_raises(ArgumentError) { subject.proxy = :invalid }
+  end
+
+  def test_proxy_leads_assignment
+    assert_same @client.leads, subject.proxy = @client.leads
+  end
+
+  def test_proxy_proxy_assignment
+    subject.proxy = @client.campaigns
+    assert_same @client.leads, subject.proxy
+  end
+
+  def test_proxy_client_assignment
+    subject.proxy = @client
+    assert_same @client.leads, subject.proxy
+  end
+
+  def test_forwarded_methods
+    [
+      :[], :each, :each_pair, :each_key, :each_value, :keys, :values
+    ].each do |m|
+      assert subject.respond_to? m
+    end
+  end
+
+  def test_index_assignment
+    subject[:Test] = 33
+    assert subject.attributes.has_key? :Test
+    assert subject.types.has_key? :Test
+    assert_equal 33, subject.attributes[:Test]
+    assert_equal 'integer', subject.types[:Test]
+  end
+
+  def test_foreign
+    assert_equal({ type: :id, id: 3 }, subject.foreign('id', 3))
+  end
+
+  def test_sync_no_proxy
+    assert_raises(ArgumentError) { subject.sync }
+    assert_raises(ArgumentError) { subject.sync! }
+  end
+
+  def test_sync_with_proxy
+    @client.leads.stub :sync, ->(lead) { lead.dup } do
+      subject.proxy = @client.leads
+      assert_equal subject, subject.sync
+      refute_same subject, subject.sync
+    end
+  end
+
+  def test_sync_bang_failed
+    @client.leads.stub :sync, ->(lead) { nil } do
+      subject.proxy = @client.leads
+      assert_nil subject.sync!
+    end
+  end
+
+  def test_sync_bang_success
+    @client.leads.stub :sync, ->(lead) { lead.dup } do
+      subject.proxy = @client.leads
+      assert_same subject, subject.sync!
+    end
+  end
+
+  def test_params_for_get
+    assert_equal MarketoAPI::Lead.key(:IDNUM, @id), subject.params_for_get
+  end
+
+  def test_params_for_sync
+    result = {
+      return_lead: true,
+      lead_record: {
+        email: @email,
+        id: @id,
+        lead_attribute_list: {
+          attribute: [
+            { attr_name: 'Email', attr_type: 'string', attr_value: @email },
+            { attr_name: 'String', attr_type: 'string', attr_value: 'string' },
+            { attr_name: 'Int', attr_type: 'integer', attr_value: 5 },
+            { attr_name: 'Date', attr_type: 'datetime', attr_value: @date }
+          ]
+        }
+      }
+    }
+
+    assert_equal result, subject.params_for_sync
+  end
+
+  def test_class_key
+    subject.class::NAMED_KEYS.each { |k, v|
+      result = { lead_key: { key_type: v, key_value: 'value' } }
+
+      assert_equal result, subject.class.key(k, 'value')
+      assert_equal result, subject.class.key(v, 'value')
+    }
+
+    assert_raises(ArgumentError) { subject.class.key('invalid', 'value') }
+  end
+
+  def test_class_from_soap_hash
+    hash = {
+      id: @id.to_s,
+      email: @email,
+      lead_attribute_list: {
+        attribute: [
+          { attr_name: 'Email', attr_type: 'string', attr_value: @email },
+          { attr_name: 'String', attr_type: 'string', attr_value: 'string' },
+          { attr_name: 'Int', attr_type: 'integer', attr_value: 5 },
+          { attr_name: 'Date', attr_type: 'datetime', attr_value: @date }
+        ]
+      }
+    }
+    assert_equal subject, subject.class.from_soap_hash(hash)
+  end
+end