MattHall-campaign_monitor 1.3.2.2

data/support/faster-xml-simple/lib/faster_xml_simple.rb

@@ -0,0 +1,187 @@
+# 
+# Copyright (c) 2006 Michael Koziarski
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in the
+# Software without restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+# Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'rubygems'
+require 'xml/libxml'
+
+class FasterXmlSimple
+  Version = '0.5.0'
+  class << self
+    # Take an string containing XML, and returns a hash representing that 
+    # XML document.  For example:
+    # 
+    #   FasterXmlSimple.xml_in("<root><something>1</something></root>")
+    #   {"root"=>{"something"=>{"__content__"=>"1"}}}
+    #
+    # Faster XML Simple is designed to be a drop in replacement for the xml_in
+    # functionality of http://xml-simple.rubyforge.org
+    #
+    # The following options are supported:
+    # 
+    # * <tt>contentkey</tt>: The key to use for the content of text elements,
+    #   defaults to '\_\_content__'
+    # * <tt>forcearray</tt>: The list of elements which should always be returned
+    #   as arrays.  Under normal circumstances single element arrays are inlined.
+    # * <tt>suppressempty</tt>: The value to return for empty elements, pass +true+
+    #   to remove empty elements entirely.
+    # * <tt>keeproot</tt>:  By default the hash returned has a single key with the
+    #   name of the root element.  If the name of the root element isn't 
+    #   interesting to you, pass +false+. 
+    # * <tt>forcecontent</tt>:  By default a text element with no attributes, will 
+    #   be collapsed to just a string instead of a hash with a single key.  
+    #   Pass +true+ to prevent this.
+    #
+    #
+    def xml_in(string, options={})
+      new(string, options).out
+    end
+  end
+  
+  def initialize(string, options) #:nodoc:
+    @doc     = parse(string)
+    @options = default_options.merge options
+  end
+  
+  def out #:nodoc:
+    if @options['keeproot']
+      {@doc.root.name => collapse(@doc.root)}
+    else
+      collapse(@doc.root)
+    end
+  end
+  
+  private
+    def default_options
+      {'contentkey' => '__content__', 'forcearray' => [], 'keeproot'=>true}
+    end
+  
+    def collapse(element)
+      result = hash_of_attributes(element) 
+      if text_node? element
+        text = collapse_text(element)
+        result[content_key] = text if text =~ /\S/
+      elsif element.children?
+        element.inject(result) do |hash, child|
+          unless child.text?
+            child_result = collapse(child) 
+            (hash[child.name] ||= []) << child_result
+          end
+          hash
+        end
+      end
+      if result.empty?
+        return empty_element
+      end
+      # Compact them to ensure it complies with the user's requests
+      inline_single_element_arrays(result) 
+      remove_empty_elements(result) if suppress_empty?
+      if content_only?(result) && !force_content?
+        result[content_key]
+      else
+        result
+      end
+    end
+    
+    def content_only?(result)
+      result.keys == [content_key]
+    end
+  
+    def content_key
+      @options['contentkey']
+    end
+  
+    def force_array?(key_name)
+      Array(@options['forcearray']).include?(key_name)
+    end
+  
+    def inline_single_element_arrays(result)
+      result.each do |key, value|
+        if value.size == 1 && value.is_a?(Array) && !force_array?(key)
+          result[key] = value.first
+        end
+      end    
+    end
+  
+    def remove_empty_elements(result)
+      result.each do |key, value|
+        if value == empty_element
+          result.delete key
+        end
+      end
+    end
+    
+    def suppress_empty?
+      @options['suppressempty'] == true
+    end
+     
+    def empty_element
+      if !@options.has_key? 'suppressempty'
+        {}
+      else
+        @options['suppressempty']
+      end
+    end
+
+    # removes the content if it's nothing but blanks,  prevents
+    # the hash being polluted with lots of content like "\n\t\t\t" 
+    def suppress_empty_content(result)
+      result.delete content_key if result[content_key] !~ /\S/ 
+    end
+  
+    def force_content?
+      @options['forcecontent']
+    end
+  
+    # a text node is one with 1 or more child nodes which are
+    # text nodes, and no non-text children, there's no sensible
+    # way to support nodes which are text and markup like:
+    # <p>Something <b>Bold</b> </p>
+    def text_node?(element)
+      !element.text? && element.all? {|c| c.text?}
+    end
+  
+    # takes a text node, and collapses it into a string
+    def collapse_text(element)
+      element.map {|c| c.content } * ''
+    end
+  
+    def hash_of_attributes(element)
+      result = {}
+      element.each_attr do |attribute| 
+        name = attribute.name
+        name = [attribute.ns, attribute.name].join(':') if attribute.ns?
+        result[name] = attribute.value 
+      end
+      result
+    end
+  
+    def parse(string)
+      if string == ''
+        string = ' '
+      end
+      XML::Parser.string(string).parse
+    end
+end
+
+class XmlSimple # :nodoc:
+  def self.xml_in(*args)
+    FasterXmlSimple.xml_in *args
+  end
+end

data/support/faster-xml-simple/test/regression_test.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RegressionTest < FasterXSTest #:nodoc: all
+  def test_content_nil_regressions
+    expected = {"asdf"=>{"jklsemicolon"=>{}}}
+    assert_equal expected, FasterXmlSimple.xml_in("<asdf><jklsemicolon /></asdf>")
+    assert_equal expected, FasterXmlSimple.xml_in("<asdf><jklsemicolon /></asdf>", 'forcearray'=>['asdf'])
+  end
+  
+  def test_s3_regression
+    str = File.read("test/fixtures/test-7.xml")
+    assert_nil FasterXmlSimple.xml_in(str)["AccessControlPolicy"]["AccessControlList"]["__content__"]
+  end
+  
+  def test_xml_simple_transparency
+    assert_equal XmlSimple.xml_in("<asdf />"), FasterXmlSimple.xml_in("<asdf />")
+  end
+  
+  def test_suppress_empty_variations
+    str = "<asdf><fdsa /></asdf>"
+    
+    assert_equal Hash.new, FasterXmlSimple.xml_in(str)["asdf"]["fdsa"]
+    assert_nil FasterXmlSimple.xml_in(str, 'suppressempty'=>nil)["asdf"]["fdsa"]
+    assert_equal '', FasterXmlSimple.xml_in(str, 'suppressempty'=>'')["asdf"]["fdsa"]
+    assert !FasterXmlSimple.xml_in(str, 'suppressempty'=>true)["asdf"].has_key?("fdsa")
+  end
+
+  def test_empty_string_doesnt_crash
+    assert_raise(XML::Parser::ParseError) do
+      silence_stderr do 
+        FasterXmlSimple.xml_in('')
+      end
+    end
+  end
+  
+  def test_keeproot_false
+    str = "<asdf><fdsa>1</fdsa></asdf>"
+    expected = {"fdsa"=>"1"}
+    assert_equal expected, FasterXmlSimple.xml_in(str, 'keeproot'=>false)
+  end
+  
+  def test_keeproot_false_with_force_content
+    str = "<asdf><fdsa>1</fdsa></asdf>"
+    expected = {"fdsa"=>{"__content__"=>"1"}}
+    assert_equal expected, FasterXmlSimple.xml_in(str, 'keeproot'=>false, 'forcecontent'=>true)
+  end
+end

data/support/faster-xml-simple/test/test_helper.rb

@@ -0,0 +1,17 @@
+
+require 'test/unit'
+require 'faster_xml_simple'
+
+class FasterXSTest < Test::Unit::TestCase
+  def default_test
+  end
+  
+  def silence_stderr
+    str = STDERR.dup
+    STDERR.reopen("/dev/null")
+    STDERR.sync=true
+    yield
+  ensure
+    STDERR.reopen(str)
+  end
+end

data/support/faster-xml-simple/test/xml_simple_comparison_test.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'yaml'
+
+class XmlSimpleComparisonTest < FasterXSTest
+  
+  # Define test methods
+  
+  Dir["test/fixtures/test-*.xml"].each do |file_name|
+    xml_file_name = file_name
+    method_name = File.basename(file_name, ".xml").gsub('-', '_')
+    yml_file_name = file_name.gsub('xml', 'yml')
+    rails_yml_file_name = file_name.gsub('xml', 'rails.yml')
+    class_eval <<-EOV, __FILE__, __LINE__
+      def #{method_name}
+        assert_equal YAML.load(File.read('#{yml_file_name}')), 
+              FasterXmlSimple.xml_in(File.read('#{xml_file_name}'), default_options )
+      end
+      
+      def #{method_name}_rails
+        assert_equal YAML.load(File.read('#{rails_yml_file_name}')), 
+              FasterXmlSimple.xml_in(File.read('#{xml_file_name}'), rails_options)
+      end
+    EOV
+  end
+  
+  def default_options
+    {
+       'keeproot'      => true, 
+       'contentkey'    => '__content__', 
+       'forcecontent'  => true, 
+       'suppressempty' => nil,
+       'forcearray'    => ['something-else']
+    }
+  end
+  
+  def rails_options
+    {
+      'forcearray'   => false,
+      'forcecontent' => true,
+      'keeproot'     => true,
+      'contentkey'   => '__content__'
+    }
+  end
+  
+
+end

data/test/campaign_monitor_test.rb

@@ -0,0 +1,90 @@
+require 'rubygems'
+require 'lib/campaign_monitor'
+require 'test/unit'
+require 'test/test_helper'
+
+CLIENT_NAME               = 'Spacely Space Sprockets'
+LIST_NAME                 = 'List #1'
+
+class CampaignMonitorTest < Test::Unit::TestCase
+  
+  def setup
+    @cm = CampaignMonitor.new(ENV["API_KEY"])   
+    # find an existing client
+    @client=find_test_client
+    assert_not_nil @client, "Please create a '#{CLIENT_NAME}' (company name) client so tests can run."
+  end
+  
+  
+  # def test_create_and_delete_client
+  #   before=@cm.clients.size
+  #   response = @cm.Client_Create(build_new_client)
+  #   puts response.inspect
+  #   assert_equal before+1, @cm.clients.size 
+  #   @client_id=response["__content__"]
+  #   reponse = @cm.Client_Delete("ClientID" => @client_id)
+  #   assert_equal before, @cm.clients.size
+  # end
+  
+  def test_find_existing_client_by_name
+    clients = @cm.clients
+    assert clients.size > 0
+    
+    assert clients.map {|c| c.name}.include?(CLIENT_NAME), "could not find client named: #{CLIENT_NAME}"
+  end
+  
+  def test_invalid_key
+    @cm=CampaignMonitor.new("12345")
+    assert_raises (CampaignMonitor::InvalidAPIKey) { @cm.clients }
+  end
+  
+  # we should not get confused here
+  def test_can_access_two_accounts_at_once
+    @cm=CampaignMonitor.new("12345")
+    @cm2=CampaignMonitor.new("abcdef")
+    @client=@cm.new_client
+    @client2=@cm.new_client
+    assert_equal "12345", @client.cm_client.api_key
+    assert_equal "abcdef", @client2.cm_client.api_key
+  end
+  
+  def test_timezones
+    assert_equal 90, @cm.timezones.length
+  end
+
+  def test_countries
+    countries=@cm.countries
+    assert_equal 246, countries.length
+    assert countries.include?("United States of America")
+  end
+  
+  
+  # campaigns
+  
+  # def test_campaigns
+  #   client = find_test_client
+  #   assert client.campaigns.size > 0, "should have one campaign"
+  # end
+  
+  
+  protected
+    def build_new_client(options={})
+      {"CompanyName" => "Spacely Space Sprockets", "ContactName" => "George Jetson", 
+        "EmailAddress" => "george@sss.com", "Country" => "United States of America",
+        "TimeZone" => "(GMT-05:00) Indiana (East)"
+        }.merge(options)
+    end
+  
+
+    def assert_success(result)
+      assert result.succeeded?, result.message      
+    end
+    
+    def find_test_client(clients=@cm.clients)
+      clients.detect { |c| c.name == CLIENT_NAME }
+    end
+    
+    def find_test_list(lists=find_test_client.lists)
+      lists.detect { |l| l.name == LIST_NAME }
+    end
+end

data/test/campaign_test.rb

@@ -0,0 +1,110 @@
+require 'rubygems'
+require 'lib/campaign_monitor'
+require 'test/unit'
+require 'test/test_helper'
+
+CLIENT_NAME               = 'Spacely Space Sprockets'
+CLIENT_CONTACT_NAME       = 'George Jetson'
+LIST_NAME                 = 'List #1'
+
+class CampaignMonitorTest < Test::Unit::TestCase
+
+  def setup
+    @cm = CampaignMonitor.new(ENV["API_KEY"])   
+    # find an existing client and make sure we know it's values
+    @client=find_test_client(@cm.clients)
+    assert_not_nil @client, "Please create a '#{CLIENT_NAME}' (company name) client so tests can run."
+
+    @campaign=@client.campaigns.detect { |x| x["Subject"] == "Big Deal" }
+    assert_not_nil @campaign, "Please create a campaign named 'Big Deal' so tests can run."
+    
+    # delete all existing lists
+    @client.lists.each { |l| l.Delete }
+    @list = @client.lists.build.defaults
+  end
+  
+  def teardown
+  end
+
+  def test_finds_named_campaign
+    assert_equal 1, @campaign["TotalRecipients"]
+    assert_equal 1, @campaign.lists.size
+    assert_equal Hash.new, @campaign.lists.first["Title"]
+  end
+  
+  def test_bracket_lookup_for_nonexistant
+    @campaign=CampaignMonitor::Campaign[12345]
+    assert_not_nil @campaign
+    assert_equal 12345, @campaign.id
+    assert_raises( CampaignMonitor::ApiError ) { @campaign.lists }
+    assert_raises( CampaignMonitor::ApiError ) { @campaign.GetSummary }
+  end
+  
+  def test_bracket_lookup_for_existing
+    camp=CampaignMonitor::Campaign[@campaign.id]
+    assert_not_nil camp
+    camp.lists
+  end
+  
+  def test_summary_interface
+    # old
+    assert_equal 1, @campaign.number_recipients
+    assert_equal 0, @campaign.number_opened
+    assert_equal 0, @campaign.number_clicks
+    assert_equal 0, @campaign.number_unsubscribed
+    assert_equal 0, @campaign.number_bounced
+    # new
+    assert_equal 1, @campaign.summary["Recipients"]
+    assert_equal 0, @campaign.summary["TotalOpened"]
+    assert_equal 0, @campaign.summary["Clicks"]
+    assert_equal 0, @campaign.summary["Unsubscribed"]
+    assert_equal 0, @campaign.summary["Bounced"]
+  end
+  
+  def test_creating_a_campaign
+    return
+    @campaign=@client.new_campaign
+    # create two lists
+    @beef=@client.lists.build.defaults
+    @beef["Title"]="Beef"
+    @beef.Create
+    assert_success @beef.result
+    @chicken=@client.lists.build.defaults
+    @chicken["Title"]="Chicken"
+    @chicken.Create
+    assert_success @chicken.result
+
+    @campaign.lists << @beef
+    @campaign.lists << @chicken
+    @campaign["CampaignName"]="Noodles #{secure_digest(Time.now.to_s)}"
+    @campaign["CampaignSubject"]="Noodly #{secure_digest(Time.now.to_s)}"
+    @campaign["FromName"] = "George Bush"
+    @campaign["FromEmail"] = "george@aol.com"
+    @campaign["ReplyTo"] = "george@aol.com"
+    @campaign["HtmlUrl"] = "http://www.google.com/robots.txt"
+    @campaign["TextUrl"] = "http://www.google.com/robots.txt"
+    @campaign.Create
+    assert_success @campaign.result
+    assert_not_nil @campaign.id
+    assert_equal 32, @campaign.id.length
+    # test GetLists
+    @campaign.instance_variable_set("@lists",nil)
+    assert_equal 2, @campaign.lists.size
+    # test sending
+    @campaign.Send("ConfirmationEmail" => "george@aol.com", "SendDate" => "Immediately")
+    assert_success @campaign.result
+  end
+  
+  def test_GetSummary
+    @campaign.GetSummary
+    assert @campaign.result.success?
+  end
+
+  
+  protected
+    
+    def find_test_client(clients)
+      clients.detect { |c| c.name == CLIENT_NAME }
+    end
+    
+end

data/test/client_test.rb

@@ -0,0 +1,129 @@
+require 'rubygems'
+require 'lib/campaign_monitor'
+require 'test/unit'
+require 'test/test_helper'
+
+CLIENT_NAME               = 'Spacely Space Sprockets'
+CLIENT_CONTACT_NAME       = 'George Jetson'
+LIST_NAME                 = 'List #1'
+
+class CampaignMonitorTest < Test::Unit::TestCase
+  
+  def setup
+    @cm = CampaignMonitor.new(ENV["API_KEY"])   
+    # find an existing client and make sure we know it's values
+    @client=find_test_client
+    assert_not_nil @client, "Please create a '#{CLIENT_NAME}' (company name) client so tests can run."
+  end
+  
+  
+  def teardown
+    # revert it back
+    @client["ContactName"]="George Jetson"
+    @client["EmailAddress"]="george@sss.com"
+    
+    @client["Username"]=""
+    @client["Password"]=""
+    @client["AccessLevel"]=0
+    
+    assert @client.update
+    assert_success @client.result
+  end
+  
+  # def test_create_and_delete_client
+  #   before=@cm.clients.size
+  #   client=CampaignMonitor::Client.new(build_new_client)
+  #   client.Create
+  #   assert_success client.result
+  #   assert_equal before+1, @cm.clients.size 
+  #   client.Delete
+  #   assert_success client.result
+  #   assert_equal before, @cm.clients.size
+  # end
+  
+  def test_find_existing_client_by_name
+    clients = @cm.clients
+    assert clients.size > 0
+    
+    assert clients.map {|c| c.name}.include?(CLIENT_NAME), "could not find client named: #{CLIENT_NAME}"
+  end
+  
+  def test_client_attributes
+    assert_equal CLIENT_NAME, @client["CompanyName"]
+    assert_nil @client["ContactName"]
+    assert @client.GetDetail
+    assert_not_empty @client["ContactName"]
+    assert_not_empty @client["EmailAddress"]
+    assert_not_empty @client["Country"]
+    assert_not_empty @client["Timezone"]
+    
+    assert_nil @client["Username"]
+    assert_nil @client["Password"]
+    assert_equal 0, @client["AccessLevel"]
+  end
+  
+  def test_update_client_basics
+    # only update the name
+    @client["ContactName"]="Bob Watson"
+    assert @client.UpdateBasics
+    assert_success @client.result
+    client=@cm.clients.detect {|x| x.name==CLIENT_NAME}
+    client.GetDetail
+    assert_equal "Bob Watson", client["ContactName"]
+    # make sure e-mail has remained unchanged
+    assert_equal "george@sss.com", client["EmailAddress"]
+  end
+  
+  def test_update_access_and_billing
+    @client["Username"]="login"
+    @client["Password"]="secret"
+    @client["AccessLevel"]=63
+    @client["BillingType"]="ClientPaysAtStandardRate"
+    @client["Currency"]="USD"
+    @client.UpdateAccessAndBilling
+    assert_success @client.result
+    # load it up again
+    client=@cm.clients.detect {|x| x.name==CLIENT_NAME}
+    client.GetDetail
+    assert_equal "login", client["Username"]
+    assert_equal "secret", client["Password"]
+    assert_equal "ClientPaysAtStandardRate", client["BillingType"]
+    assert_equal 63, client["AccessLevel"]
+    assert_equal "USD", client["Currency"]
+  end
+  
+  def test_update_both
+    @client["ContactName"]="Bob Watson"
+    @client["Username"]="login"
+    @client["Password"]="secret"
+    @client["AccessLevel"]=63
+    @client["BillingType"]="ClientPaysAtStandardRate"
+    @client["Currency"]="USD"
+    @client.update
+    assert_success @client.result
+    assert_equal "login", @client["Username"]
+    assert_equal "Bob Watson", @client["ContactName"]
+  end
+  
+  
+  protected
+    def build_new_client(options={})
+      {"CompanyName" => "Lick More Enterprises", "ContactName" => "George Jetson", 
+        "EmailAddress" => "george@jetson.com", "Country" => "United States of America",
+        "TimeZone" => "(GMT-05:00) Indiana (East)"
+        }.merge(options)
+    end
+  
+
+    def assert_success(result)
+      assert result.succeeded?, result.message      
+    end
+    
+    def find_test_client(clients=@cm.clients)
+      clients.detect { |c| c.name == CLIENT_NAME }
+    end
+    
+    def find_test_list(lists=find_test_client.lists)
+      lists.detect { |l| l.name == LIST_NAME }
+    end
+end