email_vision-neopoly 0.3.0

data/Gemfile

@@ -0,0 +1,9 @@
+source 'http://rubygems.org'
+
+gem 'savon', '>=0.8.2'
+
+group :dev do
+  gem 'rake'
+  gem 'rspec', '~>2'
+  gem 'jeweler'
+end

data/Gemfile.lock

@@ -0,0 +1,43 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    gyoku (0.4.4)
+      builder (>= 2.1.2)
+    httpi (0.9.4)
+      pyu-ntlm-http (>= 0.1.3.1)
+      rack
+    jeweler (1.6.2)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    nokogiri (1.4.4)
+    nori (0.2.3)
+    pyu-ntlm-http (0.1.3.1)
+    rack (1.3.0)
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    savon (0.9.2)
+      builder (>= 2.1.2)
+      gyoku (>= 0.4.0)
+      httpi (>= 0.7.8)
+      nokogiri (>= 1.4.0)
+      nori (>= 0.2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler
+  rake
+  rspec (~> 2)
+  savon (>= 0.8.2)

data/Rakefile

@@ -0,0 +1,56 @@
+task :default => :spec
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--backtrace --color'
+end
+
+def account
+  YAML.load(File.read('spec/account.yml')) rescue {}
+end
+
+def email_vision
+  @email_vision ||= begin
+    $LOAD_PATH << 'lib'
+    require 'email_vision'
+    require 'yaml'
+    EmailVision.new(account)
+  end
+end
+
+desc 'possible actions'
+task :actions do
+  unnecessary_actions = [:open_api_connection, :close_api_connection]
+  actions = email_vision.send(:connection).wsdl.soap_actions
+  puts (actions - unnecessary_actions).map{|x|" - #{x}"}.sort.join("\n")
+end
+
+desc 'test update here, since it takes forever to be processed'
+task :test_update do
+  user = account[:changeable_user]
+  value = rand(1111111)
+  email_vision.update(user[:email], :firstname => value)
+  start = Time.now
+  loop do
+    sleep 5
+    puts (Time.now - start).to_i
+    data = email_vision.find(user[:email])
+    break if data[:firstname] == value.to_s
+  end
+  puts "SUCCESS!!!!!! #{(Time.now - start).to_i}"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name =  'email_vision-neopoly'
+    gem.summary = "Ruby SOAP Api Client for EmailVision / CampaignCommander"
+    gem.email = "ps@neopoly.de"
+    gem.homepage = "http://github.com/neopoly/#{gem.name}"
+    gem.authors = ["Michael Grosser", "Peter Suschlik"]
+    gem.add_dependency 'savon'
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
+end

data/Readme.md

@@ -0,0 +1,82 @@
+EmailVision SOAP Api Client
+
+    gem install email_vision
+
+Usage
+=====
+
+Member API
+----------
+
+    emv = EmailVision::Member.new(:password => 'foo', :login => 'bar', :key => 'token')
+    emv.find 'me@host.com'
+    emv.create_or_update :email => 'me@host.com', :foo => 1
+
+    emv.create :email => 'me@host.com', :foo => 1
+    emv.update :email => 'me@host.com', :foo => 1
+    emv.update :email_was => 'me@host.com', :email => 'you@host.com'
+
+    emv.columns
+
+    emv.unjoin 'me@host.com'
+    emv.rejoin 'me@host.com'
+
+    # create, create_or_update, update, change_email return a job-id
+    # it can be used to wait for the job or fetch its status
+    job_id = emv.update :email => 'me@host.com', :foo => 1
+    puts "Status is #{emv.job_status job_id}"
+    emv.wait_for_job_to_finish job_id # raises when job failed
+
+
+    # :dateunjoin cannot be set via update, use a separate rejoin / unjoin request
+    class User < ActiveRecord::Base
+      after_save :update_email_vision
+
+      def update_email_vision
+        case receive_newsletter_change
+        when [false, true]
+          emv.rejoin(email)
+          emv.update(...data for emailv vision...)
+        when [true, false]
+          emv.unjoin(email)
+        end
+      end
+    end
+
+
+Message API
+-----------
+
+    emv = EmailVision::Message.new(:password => 'foo', :login => 'bar', :key => 'token')
+
+    # create
+    message_id = emv.create(:name => "test message", :body => "[EMV TEXTPART] hello world", :reply_to_email => "reply@example.com")
+
+    # find single message
+    message = emv.find(message_id)
+
+    # updating
+    message[:subject] = "cool subject"
+    emv.update(message) # => true || false
+
+    # sending a test message
+    emv.test(message_id, member_id)
+
+    # cloning and deleting
+    cloned_id = emv.clone(message_id, "test message clone")
+    cloned = emv.find(cloned_id)
+    emv.delete(cloned_id)
+
+    # find messages by period
+    message_ids = emv.find_all_by_period(2.days.ago, Time.now)
+
+
+Docs
+====
+ - [EmailVision api](https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=1FLFs3Jautozs6-ZNcT34oSXJbH6K7szw1wD8cU5i9jpEWjA4p64StquqYa6P&hl=de&authkey=CO383_EP)
+
+Author
+======
+[Michael Grosser](http://grosser.it)<br/>
+michael@grosser.it<br/>
+Hereby placed under public domain, do what you want, just do not hold me accountable...

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/email_vision-neopoly.gemspec

@@ -0,0 +1,52 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "email_vision-neopoly"
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Grosser", "Peter Suschlik"]
+  s.date = "2012-05-04"
+  s.email = "ps@neopoly.de"
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "Rakefile",
+    "Readme.md",
+    "VERSION",
+    "email_vision-neopoly.gemspec",
+    "lib/email_vision.rb",
+    "lib/email_vision/base_client.rb",
+    "lib/email_vision/campaign.rb",
+    "lib/email_vision/member.rb",
+    "lib/email_vision/message.rb",
+    "spec/account.yml.example",
+    "spec/email_vision_campaign_spec.rb",
+    "spec/email_vision_member_spec.rb",
+    "spec/email_vision_message_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/neopoly/email_vision-neopoly"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.17"
+  s.summary = "Ruby SOAP Api Client for EmailVision / CampaignCommander"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<savon>, [">= 0.8.2"])
+      s.add_runtime_dependency(%q<savon>, [">= 0"])
+    else
+      s.add_dependency(%q<savon>, [">= 0.8.2"])
+      s.add_dependency(%q<savon>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<savon>, [">= 0.8.2"])
+    s.add_dependency(%q<savon>, [">= 0"])
+  end
+end
+

data/lib/email_vision/base_client.rb

@@ -0,0 +1,78 @@
+module EmailVision
+  class BaseClient
+    SESSION_TIMEOUT = 10*60
+
+    attr_accessor :options
+
+    def initialize(options)
+      self.options  = options
+      @wsdl         = options.delete(:wsdl)
+      @namespace    = options.delete(:namespace)
+    end
+
+    def connection
+      connect! unless connected?
+      client
+    end
+
+    def client
+      @client ||= Savon::Client.new(@wsdl)
+    end
+
+    def connected?
+      @token and @token_requested > (Time.now.to_i - SESSION_TIMEOUT)
+    end
+
+    def connect!
+      @token = request_without_protection(:open_api_connection,
+        :login => options[:login],
+        :pwd => options[:password],
+        :key => options[:key],
+        :soap_client => client
+      )
+      @token_requested = Time.now.to_i
+    end
+
+    def execute(method, options={})
+      request_without_protection(method, options.merge(:token => true))
+    rescue Object => e
+      if e.respond_to?(:http) and e.http.respond_to?(:body)
+        retries ||= -1
+        retries += 1
+        session_error = (e.http.body =~ /status>(SESSION_RETRIEVING_FAILED|CHECK_SESSION_FAILED)</)
+        if session_error
+          if retries < 1
+            connect!
+            retry
+          else
+            e.message << " -- retried #{retries}"
+          end
+        end
+      end
+      raise e
+    end
+
+    def request_without_protection(method, options)
+      client = options.delete(:soap_client) || connection
+      response = client.request(api_namespaced(method)) do |r|
+        r.namespaces['xmlns:api'] = @namespace
+        options[:token] = @token if options[:token] # token first is generated via connection method
+        r.body = options
+      end
+      response.to_hash["#{method}_response".to_sym][:return]
+    end
+
+    def api_namespaced(method)
+      "api:#{method.to_s.gsub(/_./){|x| x.slice(1,1).upcase }}"
+    end
+
+    def check_server_status!(e, status)
+      fault = e.to_hash[:fault]
+      if fault && fault[:faultcode] == "soap:Server" && status === fault[:detail].first.last[:status]
+        block_given? ? yield(fault[:detail][:status]) : true
+      else
+        raise e
+      end
+    end
+  end
+end

data/lib/email_vision/campaign.rb

@@ -0,0 +1,35 @@
+module EmailVision
+  class Campaign < BaseClient
+    def find(id)
+      execute(:get_campaign, :id => id)
+    rescue Savon::SOAP::Fault => e
+      check_server_status!(e, "GET_CAMPAIGN_FAILED") { nil }
+    end
+
+    def create(attributes)
+      execute(:create_campaign, format_attributes(attributes))
+    rescue Savon::SOAP::Fault => e
+      nil
+    end
+
+    def delete(id)
+      execute(:delete_campaign, :id => id)
+    rescue Savon::SOAP::Fault => e
+      check_server_status!(e, "GET_CAMPAIGN_FAILED") { false }
+    end
+
+    private
+
+    def format_attributes(attributes)
+      Hash[attributes.map do |k, v|
+        v = Time.parse(v.to_s) if v.is_a?(Date)
+        v = format_date(v) if v.is_a?(Time)
+        [ k, v ]
+      end]
+    end
+
+    def format_date(date)
+      date.strftime("%Y-%m-%d %H:%M:%S")
+    end
+  end
+end

data/lib/email_vision/member.rb

@@ -0,0 +1,94 @@
+module EmailVision
+  class Member < BaseClient
+    JOB_STATUS = {
+      :finished => 'Job_Done_Or_Does_Not_Exist',
+      :error => 'Error'
+    }
+
+    def find(email_or_id)
+      result = execute_by_email_or_id(:get_member, email_or_id)
+      result = result.first if result.is_a?(Array) # may return multiple users if they have the same email -> return first
+      return unless result.is_a?(Hash)
+      result = convert_to_hash(result[:attributes][:entry], :key, :value)
+      result.reject{|k,v| v.nil? }
+    end
+
+    def unjoin(email_or_id)
+      execute_by_email_or_id(:unjoin_member, email_or_id)
+    end
+
+    def rejoin(email_or_id)
+      execute_by_email_or_id(:rejoin_member, email_or_id)
+    end
+
+    def update(attributes)
+      execute_by_obj(:update_member_by_obj, attributes)
+    end
+
+    def create(attributes)
+      execute_by_obj(:insert_member_by_obj, attributes)
+    end
+
+    def create_or_update(attributes)
+      execute_by_obj(:insert_or_update_member_by_obj, attributes)
+    end
+
+    # should be one of: Insert, Processing, Processed, Error, Job_Done_Or_Does_Not_Exist
+    def job_status(job_id)
+      execute(:get_member_job_status, :synchro_id => job_id)[:status]
+    end
+
+    def wait_for_job_to_finish(job_id, options={})
+      interval = options[:interval] || 5
+      times = options[:times] || 20
+
+      times.times do
+        current_status = job_status(job_id)
+        raise "Job failed" if current_status == JOB_STATUS[:error]
+        return true if current_status == JOB_STATUS[:finished]
+        sleep interval
+      end
+
+      raise "Job not finished in time! #{current_status}"
+    end
+
+    def columns
+      result = execute(:desc_member_table)
+      result = convert_to_hash(result[:fields], :name, :type)
+      result.each{|k,v| result[k] = to_ruby_style(v)}
+      result
+    end
+
+    private
+
+    def execute_by_email_or_id(method, email_or_id)
+      if email_or_id.to_s.include?('@')
+        execute("#{method}_by_email", :email => email_or_id)
+      else
+        execute("#{method}_by_id", :id => email_or_id)
+      end
+    end
+
+    def to_ruby_style(name)
+      name.downcase.to_sym
+    end
+
+    def execute_by_obj(method, attributes)
+      existing_email = attributes.delete(:email_was) || attributes[:email]
+      entries = attributes.map do |k,v|
+        v = Time.parse(v.to_s) if v.is_a?(Date)
+        v = v.strftime('%Y-%m-%d %H:%M:%S') if v.is_a?(Time)
+        {:key => k, :value => v}
+      end
+
+      execute(method, :member => {:email => existing_email, :dynContent => {:entry => entries}})
+    end
+
+    def convert_to_hash(entries, key, value)
+      entries.inject({}) do |hash, part|
+        hash[to_ruby_style(part[key])] = part[value]
+        hash
+      end
+    end
+  end
+end

data/lib/email_vision/message.rb

@@ -0,0 +1,49 @@
+module EmailVision
+  class Message < BaseClient
+    def find(id)
+      execute(:get_message, :id => id)
+    rescue Savon::SOAP::Fault => e
+      check_server_status!(e, "GET_MESSAGE_FAILED") { nil }
+    end
+
+    def find_all_by_period(from, to)
+      execute(:get_messages_by_period, :date_begin => format_date(from), :date_end => format_date(to)) || []
+    end
+
+    def create(attributes)
+      defaults = { :encoding => "UTF-8" }
+      execute(:create_email_message_by_obj, :message => defaults.merge(attributes))
+    rescue Savon::SOAP::Fault => e
+      check_server_status!(e, "CEM_MESSAGE_FAILED") { nil }
+    end
+
+    def clone(id, new_name)
+      execute(:clone_message, :id => id, :new_name => new_name)
+    end
+
+    def delete(id)
+      execute(:delete_message, :id => id)
+    rescue Savon::SOAP::Fault => e
+      check_server_status!(e, "GET_MESSAGE_FAILED") { false }
+    end
+
+    def update(attributes)
+      execute(:update_message_by_obj, :message => attributes)
+    rescue Savon::SOAP::Fault => e
+      check_server_status!(e, "GET_MESSAGE_FAILED") { false }
+    end
+
+    def test(id, member_id, options={})
+      options = { :id => id, :member_id => member_id }.merge(options)
+      execute(:test_email_message_by_member, options)
+    rescue Savon::SOAP::Fault => e
+      check_server_status!(e, "TEM_MESSAGE_FAILED") { false }
+    end
+
+    private
+
+    def format_date(date)
+      date.strftime("%Y-%m-%d %H:%M:%S")
+    end
+  end
+end

data/lib/email_vision.rb

@@ -0,0 +1,10 @@
+require 'savon'
+
+module EmailVision
+  VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
+end
+
+require 'email_vision/base_client'
+require 'email_vision/member'
+require 'email_vision/message'
+require 'email_vision/campaign'

data/spec/account.yml.example

@@ -0,0 +1,47 @@
+:member:
+  :login: api_your_host
+  :password: your_password
+  :key: your_api_key
+  :wsdl: 'http://emvapi.emv3.com/apimember/services/MemberService?wsdl'
+  :namespace: 'http://api.service.apimember.emailvision.com/'
+  :findable_user:
+    :country: "DE"
+    :gender: "0"
+    :email: test@test.de
+    :datejoin: 2009-12-07T13:36:15+01:00
+    :dateunjoin: 2010-09-17T11:03:01+02:00
+    :firstname: First
+    :firstname: Last
+    :member_id: "1014086935042"
+  :changeable_user: # must have firstname, lastname, country columns
+    :email: testaccount@testaccount.de
+    :member_id: "1021531859844"
+    :lastname: "account"
+    :country: "DE"
+    :member_id: "1021531859844"
+
+:message:
+  :login: api_your_host
+  :password: your_password
+  :key: your_api_key
+  :wsdl: 'http://emvapi.emv3.com/apiccmd/services/CcmdService?wsdl'
+  :namespace: 'http://api.service.apiccmd.emailvision.com/'
+  :findable_user:
+    :member_id: "1014086935042"
+  :findable_email_message:
+    :body: "Hello world"
+    :description: "test message"
+    :message_id: "1014086935042"
+
+:campaign:
+  :login: api_your_host
+  :password: your_password
+  :key: your_api_key
+  :wsdl: 'http://emvapi.emv3.com/apiccmd/services/CcmdService?wsdl'
+  :namespace: 'http://api.service.apiccmd.emailvision.com/'
+  :findable_campaign:
+    :id: "325685"
+  :cloneable_email_message:
+    :id: "1300231"
+  :findable_segment:
+    :id: "228909"

data/spec/email_vision_campaign_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe "EmailVision" do
+  describe "Campgain" do
+    let(:config) { YAML.load(File.read('spec/account.yml'))[:campaign] }
+    let(:client) { EmailVision::Campaign.new(config) }
+    let(:message_config) { YAML.load(File.read('spec/account.yml'))[:message] }
+    let(:message_client) { EmailVision::Message.new(message_config) }
+    let(:findable_campaign) { config[:findable_campaign] }
+    let(:findable_id) { findable_campaign[:id] }
+    let(:cloneable_message_id) { config[:cloneable_email_message][:id] }
+    let(:findable_segment_id) { config[:findable_segment][:id] }
+
+    context :find do
+      it "by id" do
+        campaign = client.find(findable_id)
+        campaign.should_not be_nil
+      end
+
+      it "by id again and again" do
+        campaign = client.find(findable_id)
+        campaign.should == client.find(findable_id)
+      end
+
+      it "returns nil for unknown campaigns" do
+        client.find("-123").should be_nil
+      end
+
+      it "raises a soap fault for invalid input" do
+        lambda { client.find("invalid input") }.should raise_error Savon::SOAP::Fault, /Unmarshalling Error/
+      end
+    end
+
+    context "creating and deleting" do
+      before { @message_id = message_client.clone(cloneable_message_id, "test message clone #{Time.now}") }
+      let(:attributes) do
+        {
+          :name             => "test campaign #{Time.now}",
+          :send_date        => Time.now + 86400,
+          :message_id       => message_id,
+          :mailing_list_id  => findable_segment_id
+        }
+      end
+      let(:message_id) { @message_id }
+      after { message_client.delete(@message_id) }
+
+      it "creates a campaign" do
+        campaign_id = client.create(attributes)
+        campaign_id.should_not be_nil
+        campaign = client.find(campaign_id)
+        campaign[:name].should == attributes[:name]
+        campaign[:message_id].should == attributes[:message_id]
+        campaign[:mailinglist_id].should == attributes[:mailing_list_id]
+        client.delete(campaign_id)
+      end
+
+      it "needs attributes for creation" do
+        client.create(attributes.merge(:name => nil)).should be_nil
+        client.create(attributes.merge(:send_date => nil)).should be_nil
+        client.create(attributes.merge(:message_id => nil)).should be_nil
+        client.create(attributes.merge(:mailing_list_id => nil)).should be_nil
+      end
+
+      it "deletes a campaign" do
+        campaign_id = client.create(attributes)
+        campaign_id.should_not be_nil
+        client.delete(campaign_id).should == true
+      end
+
+      it "cannot delete unknown campaign" do
+        client.delete("-123").should == false
+      end
+    end
+  end
+end

data/spec/email_vision_member_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe "EmailVision" do
+  describe "Member" do
+    let(:email){"#{rand(1111111)}.foo@justatest.com"}
+    let(:random_value){rand(11111111111).to_s}
+    let(:expired_token){'Duy-M5FktALawBJ7dZN94s6hLEgLGKXC_j7cCqlDUMXRGw2shqHYbR9Zud_19EBtFkSCbJ0ZmrZ_d0ieBqgR'}
+
+    def error_with_status(status)
+      # mock / stub did not work...
+      $the_status = status
+      http = ""
+      def http.error?; true; end
+      def http.body; "<status>#{$the_status}</status>"; end
+      def http.code; 500; end
+      Savon::HTTP::Error.new(http)
+    end
+
+    # updates need some time to finish on the server...
+    def wait_for_job_to_finish
+      client.wait_for_job_to_finish yield
+    end
+
+    def reset_email
+      email = client.find(changeable_user[:member_id])[:email]
+      wait_for_job_to_finish do
+        client.update(:email_was => email, :email => changeable_user[:email])
+      end
+      email = client.find(changeable_user[:member_id])[:email]
+      email.should == changeable_user[:email]
+    end
+
+    def steady_fields(hash)
+      hash.select{|k,v| [:email, :member_id, :firstname, :lastname].include?(k) }
+    end
+
+    let(:config){YAML.load(File.read('spec/account.yml'))[:member]}
+    let(:client){EmailVision::Member.new(config)}
+    let(:findable_user) do
+      data = config[:findable_user]
+      [:datejoin, :dateunjoin].each do |field|
+        data[field] = DateTime.parse(data[field].to_s) if data[field]
+      end
+      data
+    end
+    let(:changeable_user){config[:changeable_user]}
+
+    it "has a VERSION" do
+      EmailVision::VERSION.should =~ /^\d+\.\d+\.\d+$/
+    end
+
+    it "can call more than one method" do
+      first = client.find(findable_user[:email])
+      first.should == client.find(findable_user[:email])
+    end
+
+    it "can reconnect when token is expired" do
+      client.instance_variable_set('@token', expired_token)
+      client.instance_variable_set('@token_requested', Time.now.to_i - EmailVision::BaseClient::SESSION_TIMEOUT - 10)
+      client.find(findable_user[:email])[:email].should == findable_user[:email]
+    end
+
+    describe :find do
+      it "can find by email" do
+        response = client.find(findable_user[:email])
+        steady_fields(response).should == steady_fields(findable_user)
+      end
+
+      it "can find by id" do
+        response = client.find(findable_user[:member_id])
+        steady_fields(response).should == steady_fields(findable_user)
+      end
+
+      it "can find first users of multiple that have the same email" do
+        client.should_receive(:execute_by_email_or_id).and_return [{:attributes=>{:entry=>[{:key=>"firstname",:value=>'yyy'}]}},{:attributes=>{:entry=>[{:key=>"firstname",:value=>'zzz'}]}}]
+        response = client.find('foo@bar.com')
+        steady_fields(response).should == {:firstname => 'yyy'}
+      end
+
+      it "is nil when nothing was found" do
+        client.find('foo@bar.baz').should == nil
+      end
+    end
+
+    describe 'error handling' do
+      before do
+        @connection = client.send(:connection)
+        client.stub!(:connection).and_return @connection
+      end
+
+      it "retries if it failed due to session timeout" do
+        error = error_with_status("CHECK_SESSION_FAILED")
+        @connection.should_receive(:request).exactly(2).and_raise(error)
+        lambda{
+          client.find('aaaa')
+        }.should raise_error#(error)
+      end
+
+      it "retries if it failed due to maximum request per session" do
+        error = error_with_status("SESSION_RETRIEVING_FAILED")
+        @connection.should_receive(:request).exactly(2).and_raise(error)
+        lambda{
+          client.find('aaaa')
+        }.should raise_error#(error)
+      end
+
+      it "does not retry if it failed otherwise" do
+        error = error_with_status("FOO_BAR")
+        @connection.should_receive(:request).exactly(1).and_raise(error)
+        lambda{
+          client.find('aaaa')
+        }.should raise_error#(error)
+      end
+    end
+
+    describe :update do
+      it "can update an attribute" do
+        wait_for_job_to_finish do
+          client.update(
+            :email => changeable_user[:email],
+            :firstname => random_value,
+            :lastname => random_value
+          )
+        end
+
+        data = client.find(changeable_user[:email])
+        data[:firstname].should == random_value
+        data[:lastname].should == random_value
+
+        # it does not overwrite other attributes
+        data[:country].should == changeable_user[:country]
+      end
+
+      it "can update a Time" do
+        time = Time.now
+        wait_for_job_to_finish do
+          client.update(:email => changeable_user[:email], :dateofbirth => time)
+        end
+        data = client.find(changeable_user[:email])
+        data[:dateofbirth].strftime('%s').to_i.should == time.to_i
+      end
+
+      it "can update a Date" do
+        time = Date.new(2010, 5,1)
+        wait_for_job_to_finish do
+          client.update(:email => changeable_user[:email], :dateofbirth => time)
+        end
+        data = client.find(changeable_user[:email])
+        data[:dateofbirth].strftime('%s').to_i.should == 1272664800
+      end
+
+      it "can remove dateunjoin" do
+        pending
+        wait_for_job_to_finish do
+          client.unjoin(changeable_user[:email])
+        end
+        wait_for_job_to_finish do
+          client.update(:email => changeable_user[:email], :dateunjoin => 'NULL')
+        end
+        data = client.find(changeable_user[:email])
+        data[:dateunjoin].should == nil
+      end
+
+      it "returns a job id" do
+        job_id = client.update(:email => changeable_user[:email], :firstname => random_value)
+        client.job_status(job_id).should == 'Insert'
+      end
+
+      it "updates the email" do
+        begin
+          wait_for_job_to_finish do
+            client.update(:email_was => changeable_user[:email], :email => email)
+          end
+          client.find(email)[:email].should == email
+        ensure
+          reset_email
+        end
+      end
+    end
+
+    describe :create_or_update do
+      it "can create a record" do
+        wait_for_job_to_finish do
+          client.create_or_update(:email => email, :firstname => 'first-name')
+        end
+        data = client.find(email)
+        data[:firstname].should == 'first-name'
+      end
+
+      it "can update a record" do
+        wait_for_job_to_finish do
+          client.create_or_update(:email => changeable_user[:email], :firstname => random_value)
+        end
+        data = client.find(changeable_user[:email])
+        data[:firstname].should == random_value
+      end
+    end
+
+    describe :create do
+      it "can create a record" do
+        wait_for_job_to_finish do
+          client.create(:email => email, :firstname => 'first-name')
+        end
+        data = client.find(email)
+        data[:firstname].should == 'first-name'
+      end
+    end
+
+    describe :columns do
+      it "can read them" do
+        data = client.columns
+        data[:dateunjoin].should == :date
+      end
+    end
+
+    describe :unjoin do
+      it "can unjoin a member" do
+        wait_for_job_to_finish do
+          client.unjoin(changeable_user[:email])
+        end
+        date = client.find(changeable_user[:email])[:dateunjoin]
+        date.is_a?(DateTime).should == true
+        Time.parse(date.to_s).should be_within(40).of(Time.now)
+      end
+    end
+
+    describe :rejoin do
+      it "can rejoin a member" do
+        wait_for_job_to_finish do
+          client.rejoin(changeable_user[:email])
+        end
+        date = client.find(changeable_user[:email])[:datejoin]
+        date.is_a?(DateTime).should == true
+        Time.parse(date.to_s).should be_within(40).of(Time.now)
+      end
+    end
+  end
+end

data/spec/email_vision_message_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+describe "EmailVision" do
+  describe "Message" do
+    let(:config) { YAML.load(File.read('spec/account.yml'))[:message] }
+    let(:client) { EmailVision::Message.new(config) }
+    let(:findable_message) { config[:findable_email_message] }
+    let(:findable_id) { findable_message[:id] }
+
+    context "finding message" do
+      it "finds by id" do
+        message = client.find(findable_message[:id])
+        message.should_not be_nil
+      end
+
+      it "finds serveral times" do
+        message = client.find(findable_id)
+        message.should == client.find(findable_id)
+      end
+
+      it "returns nil for message not found" do
+        client.find("-123").should be_nil
+      end
+
+      it "raises soap fault for invalid input" do
+        lambda { client.find("invalid input") }.should raise_error Savon::SOAP::Fault, /Unmarshalling Error/
+      end
+    end
+
+    context "finding messages by period" do
+      let(:message) { client.find(findable_id) }
+
+      it "finds findable message" do
+        from = message[:create_date]
+        to = message[:create_date] + 1
+        client.find_all_by_period(from, to).should include(findable_id)
+      end
+
+      it "no messages found in future" do
+        from = Time.now + 1
+        to = Time.now + 2
+        client.find_all_by_period(from, to).should == []
+      end
+    end
+
+    context "creating message" do
+      let(:attributes) do
+        {
+          :name           => "test message #{Time.now}",
+          :body           => "[EMV TEXTPART]test body",
+          :reply_to_email => "reply@example.com"
+        }
+      end
+
+      context "successfully" do
+        before(:all) { @message_id = client.create(attributes) }
+        let(:message_id) { @message_id }
+        let(:message) { client.find(message_id) }
+        after(:all) { client.delete(message_id) }
+
+        it "has attributes set" do
+          message[:name].should == attributes[:name]
+          message[:body].should == attributes[:body]
+          message[:reply_to_email].should == attributes[:reply_to_email]
+        end
+
+        it "has UTF-8 by default" do
+          attributes[:encoding].should be_nil
+          message[:encoding].should == "UTF-8"
+        end
+
+        it "overrides encoding" do
+          message_id = client.create(attributes.merge(:encoding => "iso-8859-15"))
+          message = client.find(message_id)
+          message[:encoding].should == "iso-8859-15"
+        end
+
+        it "uses HTML only" do
+          body = "[EMV HTMLPART]<b>bold</b>"
+          message_id = client.create(attributes.merge(:body => body))
+          message = client.find(message_id)
+          message[:body].should == body
+        end
+
+        it "is an email" do
+          message[:type].should == "email"
+        end
+      end
+
+      it "needs a name" do
+        client.create(attributes.merge(:name => nil)).should be_nil
+      end
+
+      it "needs a body" do
+        client.create(attributes.merge(:body => nil)).should be_nil
+      end
+
+      it "needs a body with emv tag" do
+        client.create(attributes.merge(:body => "no emv tag")).should be_nil
+      end
+
+      it "needs a reply_to_email" do
+        client.create(attributes.merge(:reply_to_email => nil)).should be_nil
+      end
+    end
+
+    context "cloning message" do
+      let(:uniq_attributes) { [:id, :name, :create_date] }
+      let(:message) { client.find(findable_id) }
+      let(:clone_name) { "clone of #{message[:name]}" }
+
+      before(:all) { @clone = client.find(client.clone(message[:id], clone_name)) }
+      let(:clone) { @clone }
+      after(:all) { client.delete(@clone[:id]) }
+
+      it "has different id" do
+        clone[:id].should_not == message[:id]
+      end
+
+      it "has different name" do
+        clone[:name].should == clone_name
+      end
+
+      it "has different create date" do
+        clone[:create_date].should_not == message[:create_date]
+      end
+
+      it "has cloned non-uniq attributes" do
+        (clone.keys - uniq_attributes).each do |attr|
+          clone[attr].should == message[attr]
+        end
+      end
+    end
+
+    context "deleting message" do
+      it "returns true for successful delete" do
+        clone_id = client.clone(findable_message[:id], "delete me")
+        client.delete(clone_id).should == true
+        client.find(clone_id).should be_nil
+      end
+
+      it "returns false for undeletable message" do
+        client.delete("-123").should == false
+      end
+    end
+
+    context "updating message" do
+      before(:all) { @message = client.find(client.clone(findable_id, "test update")) }
+      let(:message) { @message }
+      after(:all) { client.delete(@message[:id]) }
+
+      let(:random_name) { "test update #{Time.now.to_f}" }
+
+      it "updates name passing message hash" do
+        message[:name] = random_name
+        client.update(message).should == true
+        client.find(message[:id])[:name].should == random_name
+      end
+
+      it "updates name passing only id and name" do
+        client.update(:id => message[:id], :name => random_name).should == true
+        client.find(message[:id])[:name].should == random_name
+      end
+
+      it "fails for invalid id" do
+        client.update(:id => "-123").should == false
+      end
+    end
+
+    context "testing message" do
+      let(:member_id) { config[:findable_user][:member_id] }
+
+      it "sends a test message to member" do
+        client.test(findable_id, member_id, :subject => subject).should == true
+      end
+
+      it "refuses to send a test message for invalid message" do
+        client.test("-123", member_id).should == false
+      end
+
+      it "returns true even for an invalid member_id" do
+        client.test(findable_id, "-123").should == true
+      end
+
+      it "sends a test message with an empty subject" do
+        client.test(findable_id, member_id, :subject => nil).should == true
+      end
+
+      it "sends a test html message" do
+        client.test(findable_id, member_id, :subject => subject("pure html"), :part => "HTML").should == true
+      end
+
+      it "sends a test text message" do
+        client.test(findable_id, member_id, :subject => subject("pure text"), :part => "TEXT").should == true
+      end
+
+      it "sends a test multipart message" do
+        client.test(findable_id, member_id, :subject => subject("multipart test"), :part => "MULTIPART").should == true
+      end
+
+      private
+
+      def subject(addon="")
+        "[TEST] spec run on #{Time.now} #{addon}"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH << 'lib'
+
+require 'rubygems'
+require 'yaml'
+require 'email_vision'

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: email_vision-neopoly
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Michael Grosser
+- Peter Suschlik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: savon
+  requirement: &18651300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *18651300
+- !ruby/object:Gem::Dependency
+  name: savon
+  requirement: &18650760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *18650760
+description: 
+email: ps@neopoly.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- Readme.md
+- VERSION
+- email_vision-neopoly.gemspec
+- lib/email_vision.rb
+- lib/email_vision/base_client.rb
+- lib/email_vision/campaign.rb
+- lib/email_vision/member.rb
+- lib/email_vision/message.rb
+- spec/account.yml.example
+- spec/email_vision_campaign_spec.rb
+- spec/email_vision_member_spec.rb
+- spec/email_vision_message_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/neopoly/email_vision-neopoly
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Ruby SOAP Api Client for EmailVision / CampaignCommander
+test_files: []