epsilon 0.0.0

data/README

@@ -0,0 +1,21 @@
+  Epsilon
+  =======
+
+  Interface to Real-Time Messaging (RTM) of DREAMmail’s high-volume email
+  solution.
+
+  Please configure like this (if you're using this within an Rails-application,
+  you can place this to config/initializers/epsilon.rb):
+    ::Epsilon::Api.url           = 'http://rtm.us.epidm.net/weblet/weblet.dll'
+    ::Epsilon::Api.servername    = 'YSN1'
+    ::Epsilon::Api.username      = 'Username'
+    ::Epsilon::Api.password      = 'Password'
+    ::Epsilon::Api.configuration = { :client_name   => 'ClientName' }
+    #::Epsilon::Api.logger        = ::Rails.logger
+    ::Epsilon::Api.enabled       = true
+    #::Epsilon::Api.proxy_url     = 'http://proxy:8080/'
+
+  To send a email, use this call:
+    ::Epsilon::Api.deliver('some@email.com', 'Campaign', 'TemplateName',
+        { 'param1' => 'value1', 'param2' => 'value2', ... })
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/init.rb

@@ -0,0 +1,2 @@
+$:.unshift "#{File.dirname(__FILE__)}/lib"
+require 'epsilon'

data/lib/epsilon/api.rb

@@ -0,0 +1,147 @@
+require 'builder'
+require 'net/https'
+require 'uri'
+require 'rexml/document'
+
+module Epsilon
+  module Api
+    class << self
+
+      # These values need to be set with each request in the HTTP-Header.
+      attr_accessor :servername, :username, :password, :enabled, :logger, :message
+
+      # Retrieving the configuration.
+      attr_accessor :configuration
+
+      def deliver(email, campaign, template, attributes = {}, configuration = {})
+        if enabled
+          handle_result(post(xml(email, campaign, template, attributes, configuration)))
+        else
+          logger && logger.info("Sending email [#{campaign}/#{template}] via Epsilon::Api to #{email}")
+        end
+      end
+
+      def url=(url)
+        @uri = URI.parse(url)
+      end
+
+      def url
+        @uri ||= nil
+      end
+
+      def proxy_url=(url)
+        @proxy_uri = URI.parse(url)
+      end
+
+      def proxy_uri
+        @proxy_uri ||= ENV['http_proxy'] ? URI.parse(ENV['http_proxy']) : nil
+      end
+
+      def proxy_url=(url)
+        @@proxy_uri = URI.parse(url)
+      end
+
+      def proxy_uri
+        @@proxy_uri ||= ENV['http_proxy'] ? URI.parse(ENV['http_proxy']) : nil
+      end
+
+      private
+
+      def http
+        @http ||= proxy_uri ?
+          Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port) :
+          Net::HTTP
+      end
+
+      def post(xml)
+        http.start(uri.host, uri.port) do |agent|
+          agent.use_ssl = (uri.scheme == 'https') # SSL?
+          agent.post(uri.path, xml, {'Content-type' => 'text/xml',
+                                     'Accept'       => 'text/xml',
+                                     'ServerName'   => servername,
+                                     'UserName'     => username,
+                                     'Password'     => password})
+        end
+      end
+
+      def handle_result(result)
+        if(Net::HTTPOK === result)
+          doc = REXML::Document.new(result.body)
+          # Is there a better way than using REXML::Xpath.match to find text-node within XML?
+          case REXML::XPath.match(doc, '//DMResponse/Code/text()').first.to_s
+          when '1' # Success
+            self.message = result.message
+            REXML::XPath.match(doc, '//DMResponse/ResultData/TransactionID//text()').map(&:to_s)
+          else # Raise using Description
+            self.message = REXML::XPath.match(doc, '//DMResponse/Description/text()').first.to_s
+            false
+          end
+        else # resulting in HTTP-Message
+          self.message = result.message
+          false
+        end
+      end
+
+      # Retrieving the XML for the POST-Request
+      def xml(email, campaign, template, attributes = {}, configuration = {})
+        xml = Builder::XmlMarkup.new
+        xml.instruct!
+        xml.comment!('Created by Epsilon::Api')
+        xml.RTMWeblet do |weblet|
+          weblet.RTMEmailToEmailAddress do |email_to_email_address|
+            # XXX Acknowledgements yet disabled
+            #acknowledgements_to(email_to_email_address, configuration)
+            template_info(email_to_email_address, campaign, template, configuration)
+            email_to_email_address.ToEmailAddress do |to_email_address|
+              to_email_address.EventEmailAddress do |event_email_address|
+                event_email_address.EmailAddress(email)
+                event_variables(event_email_address, attributes)
+              end
+            end
+          end
+        end
+      end
+
+      # Creates XML for Acknowledgements
+      def acknowledgements_to(xml, configuration)
+        if(acknowledgements_email = configuration.delete('acknowledgements_to'))
+          xml.AcknowledgementsTo do |acknowledgements_to|
+            acknowledgements_to.mailAddress(acknowledgements_email)
+          end
+        end
+      end
+
+      def template_info(xml, campaign, template, configuration)
+        conf = self.configuration.merge(configuration).merge({ :campaign_name => campaign })
+        # Handle non-symbolic hash-keys
+        conf.keys.each do |key|
+          if key.is_a?(String)
+            conf[key.to_sym] = conf.delete(key)
+          end
+        end
+        { :client_name   => 'ClientName',
+          :site_name     => 'SiteName',
+          :campaign_name => 'CampaignName' }.each do |key,value|
+          if(var = conf[key])
+            xml.tag!(value, var)
+          end
+        end
+        xml.MailingName(template)
+      end
+
+      def event_variables(xml, variables)
+        unless variables.empty?
+          xml.EventVariables do |event_variables|
+            variables.each do |key, value|
+              event_variables.Variable do |variable|
+                variable.Name("eventvar:#{key.to_s}")
+                variable.Value(value.to_s)
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/epsilon.rb

@@ -0,0 +1,4 @@
+require 'epsilon/api'
+
+module Epsilon
+end

data/test/epsilon_api_test.rb

@@ -0,0 +1,119 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+
+require "#{File.expand_path(File.dirname(__FILE__))}/../init.rb"
+
+class EpsilonApiTest < Test::Unit::TestCase
+
+  def setup
+    ::Epsilon::Api.servername = 'EpsilonServer'
+    ::Epsilon::Api.username   = 'EpsilonUser'
+    ::Epsilon::Api.password   = 'EpsilonSecret'
+    ::Epsilon::Api.url        = 'http://rtm.na.epidm.net/weblet/weblet.dll'
+  end
+
+  def test_classes_are_loaded
+    assert_nothing_raised do
+      ::Epsilon
+      ::Epsilon::Api
+    end
+  end
+
+  # PASSWORD
+  def test_can_set_and_retrieve_password
+    assert_nothing_raised do
+      ::Epsilon::Api.password = 'test.pass.word'
+      assert_equal 'test.pass.word', ::Epsilon::Api.password
+    end
+  end
+
+  # USERNAME
+  def test_can_set_and_retrieve_username
+    assert_nothing_raised do
+      ::Epsilon::Api.username = 'test.user.name'
+      assert_equal 'test.user.name', ::Epsilon::Api.username
+    end
+  end
+
+  # SERVERNAME
+  def test_can_set_and_retrieve_servername
+    assert_nothing_raised do
+      ::Epsilon::Api.servername = 'test.server.name'
+      assert_equal 'test.server.name', ::Epsilon::Api.servername
+    end
+  end
+
+  # CONFIGURATION
+
+  def test_default_configuration_is_hash
+    assert ::Epsilon::Api.configuration.is_a?(Hash)
+  end
+
+  # CONFIGURATION=
+
+  def test_configuration_takes_an_empty_hash
+    assert_nothing_raised do
+      ::Epsilon::Api.configuration = {}
+    end
+  end
+
+  # POST
+  #def test_post_does_succeed
+  #  puts ::Epsilon::Api.deliver('some@email.com')
+  #end
+
+  # URL
+
+  def test_url_fills_uri
+    ::Epsilon::Api.url = 'http://github.com/rjung/epsilon'
+    assert_equal 'github.com', ::Epsilon::Api.url.host
+    assert_equal '/rjung/epsilon', ::Epsilon::Api.url.path
+  end
+
+  # XML
+
+  def test_xml_does_contain_xml_instruction
+    # Need a better way to test this.
+    xml = ::Epsilon::Api.send(:xml, 'some@email.com', 'Campaign', 'Template')
+    assert /<\?xml/.match(xml), 'XML does not contain XML-Instructions'
+  end
+
+  def test_handle_results_false_when_result_is_not_200_OK
+    ::Epsilon::Api.expects(:post).with(anything).returns(Net::HTTPBadRequest.new(nil, 200, 'Bad Request'))
+    enable_epsilon do
+      assert_nothing_raised do
+        ::Epsilon::Api.deliver('some@email.com', 'Campaign', 'Template')
+      end
+    end
+  end
+
+  def test_handle_fills_message_when_result_is_not_200_OK
+    ::Epsilon::Api.expects(:post).with(anything).returns(Net::HTTPBadRequest.new(nil, 200, 'Bad Request'))
+    enable_epsilon do
+      ::Epsilon::Api.deliver('some@email.com', 'Campaign', 'Template')
+      assert_equal 'Bad Request', ::Epsilon::Api.message
+    end
+  end
+
+  def test_xml_does_contain_site_name_if_its_given_with_symbol
+    # Need a better way to test this.
+    xml = ::Epsilon::Api.send(:xml, 'some@email.com', 'Campaign', 'Template', {}, {:site_name => 'Bla'})
+    assert /<SiteName>/.match(xml), 'XML does not contain SiteName'
+  end
+
+  def test_xml_does_contain_site_name_if_its_given_with_string
+    xml = ::Epsilon::Api.send(:xml, 'some@email.com', 'Campaign', 'Template', {}, {'site_name' => 'Bla'})
+    assert /<SiteName>/.match(xml), "XML does not contain SiteName #{xml}"
+  end
+
+  private
+
+  def enable_epsilon(&block)
+    enabled_before = ::Epsilon::Api.enabled
+    ::Epsilon::Api.enabled = true
+    block.call
+    ::Epsilon::Api.enabled = enabled_before
+  end
+
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: epsilon
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: []
+
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-16 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 1
+        - 2
+        version: 2.1.2
+  type: :runtime
+  version_requirements: *id001
+description: API to DREAMmail Real Time Messaging
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- Rakefile
+- init.rb
+- lib/epsilon.rb
+- lib/epsilon/api.rb
+- test/epsilon_api_test.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: API to DREAMmail Real Time Messaging
+test_files: 
+- test/epsilon_api_test.rb