expertsender_api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38a52cdaf7f8d15625b76d4fa4032729a903b341
+  data.tar.gz: a3a9ff5795c99eb610e10977d5e3996ce0ff3bb7
+SHA512:
+  metadata.gz: 5d995b6cafc6e7208646554f105861909c3401e160cb1e80ecfe28079415881374e64ac1a61a6b05bd6e8fbd010bcbed0e8d6bfb9adadc8babb861e8905e7878
+  data.tar.gz: 68e2f8414cf3d93a119c8f93ac8d5941df52d9c7b6acd147812dd7086c1b240849e94005d01a4f9ecd562c79aa0b963f5ad8b4b6b8366c03e57613b26fa27d47

data/.gitignore

@@ -0,0 +1,14 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+/Gemfile.lock
+/gems
+/tags
+
+*.swp
+.ruby-version

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,3 @@
+# ExpertSenderApi
+
+ExpertSenderApi is an API wrapper for ExpertSender's [API](https://sites.google.com/a/expertsender.com/api-documentation-russian).

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'rspec/core/rake_task'
+require 'rubygems/specification'
+require 'bundler/gem_tasks'
+
+task :default => :spec
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = FileList['spec/**/*_spec.rb']
+  t.rspec_opts = %w(-fs --color)
+end

data/expertsender_api.gemspec

@@ -0,0 +1,26 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "expertsender_api"
+  s.version = "0.0.1"
+  s.authors = ["kinderly"]
+  s.email = ["beorc@httplab.ru"]
+  s.homepage = "http://github.com/kinderly/expertsender_api"
+
+  s.summary = %q{A wrapper for ExpertSender API}
+  s.description = %q{A wrapper for  ExpertSender API}
+  s.license = "MIT"
+
+  s.rubyforge_project = "expertsender_api"
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('httparty')
+  s.add_dependency('nokogiri')
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency "rspec"
+end

data/lib/expertsender_api.rb

@@ -0,0 +1,22 @@
+require 'httparty'
+require 'nokogiri'
+require 'cgi'
+
+require 'expertsender_api/email'
+require 'expertsender_api/concerns/serializeable'
+
+require 'expertsender_api/subscriber'
+require 'expertsender_api/subscriber/tag'
+require 'expertsender_api/subscriber/property'
+require 'expertsender_api/email/recipients'
+require 'expertsender_api/email/receiver'
+require 'expertsender_api/email/content'
+require 'expertsender_api/email/snippet'
+require 'expertsender_api/result'
+require 'expertsender_api/expertsender_error'
+
+require 'expertsender_api/api'
+
+
+module ExpertSenderApi
+end

data/lib/expertsender_api/api.rb

@@ -0,0 +1,190 @@
+module ExpertSenderApi
+  class API
+    include HTTParty
+
+    class << self
+      attr_accessor :api_key, :api_endpoint, :throws_exceptions
+    end
+
+    attr_accessor :api_key, :api_endpoint, :throws_exceptions
+
+    SUBSCRIBER_INFO_OPTION_SHORT = 1
+    SUBSCRIBER_INFO_OPTION_MEDIUM = 2
+    SUBSCRIBER_INFO_OPTION_FULL = 3
+
+    XML_NAMESPACES = { 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+                       'xmlns:xs' => 'http://www.w3.org/2001/XMLSchema' }
+
+    def initialize(key: nil, **parameters)
+      @api_key = key || self.class.api_key || ENV['EXPERTSENDER_API_KEY']
+      @api_key = @api_key.strip if @api_key
+
+      @throws_exceptions = parameters.has_key?(:throws_exceptions) ? parameters.delete(:throws_exceptions) : self.class.throws_exceptions
+      @api_endpoint = parameters.delete(:api_endpoint) || self.class.api_endpoint
+
+      unless api_endpoint.nil?
+        @subscribers_url = api_endpoint + '/Api/Subscribers'
+        @removed_subscribers_url = api_endpoint + '/Api/RemovedSubscribers'
+        @newsletters_url = api_endpoint + '/Api/Newsletters'
+        @transactionals_url = api_endpoint + '/Api/Transactionals'
+      end
+    end
+
+    def add_subscriber_to_list(subscriber)
+      add_subscribers_to_list([subscriber])
+    end
+
+    def add_subscribers_to_list(subscribers)
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.ApiRequest(XML_NAMESPACES) {
+          xml.ApiKey api_key
+          xml.MultiData {
+            subscribers.each { |subscriber| subscriber.insert_to(xml) }
+          }
+        }
+      end
+
+      xml = builder.to_xml save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+      response = self.class.post(@subscribers_url, body: xml)
+
+      handle_response(response)
+    end
+
+    def remove_subscriber_from_list(options)
+      email = options.delete :email
+      id = options.delete :id
+
+      response = id.nil? ? remove_subscriber_by_email(email, options) : remove_subscriber_by_id(id, options)
+
+      handle_response(response)
+    end
+
+    def get_subscriber_info(option: SUBSCRIBER_INFO_OPTION_FULL, email: nil)
+      params = { apiKey: api_key, email: email, option: option }
+
+      response = self.class.get(@subscribers_url, query: params)
+
+      handle_response(response)
+    end
+
+    def update_subscriber(email, subscriber)
+      result = get_subscriber_info(email: email)
+
+      return result if result.failed?
+
+      expertsender_id = result.parsed_response.xpath('//Data/Id').text
+      list_ids = result.parsed_response.xpath('//StateOnList/ListId').map(&:text)
+
+      subscriber.id = expertsender_id
+
+      list_ids.each do |list_id|
+        subscriber.list_id = list_id
+        res = add_subscriber_to_list(subscriber)
+      end
+
+      result
+    end
+
+    def add_or_update_subscriber(email, subscriber)
+      result = update_subscriber(email, subscriber)
+
+      return add_subscriber_to_list(subscriber) if result.failed?
+
+      result
+    end
+
+    def create_and_send_email(options)
+      recipients = options.delete :recipients
+      content = options.delete :content
+
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.ApiRequest(XML_NAMESPACES) {
+          xml.ApiKey api_key
+          xml.Data {
+            recipients.insert_to xml
+            content.insert_to xml
+          }
+        }
+      end
+
+      xml = builder.to_xml save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+      response = self.class.post(@newsletters_url, body: xml)
+
+      handle_response(response)
+    end
+
+    def send_transaction_email(options)
+      letter_id = options.delete :letter_id
+      receiver = options.delete :receiver
+      snippets = options.delete :snippets
+
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.ApiRequest(XML_NAMESPACES) {
+          xml.ApiKey api_key
+          xml.Data {
+            receiver.insert_to xml
+            if snippets.any?
+              xml.Snippets {
+                snippets.each { |snippet| snippet.insert_to(xml) }
+              }
+            end
+          }
+        }
+      end
+
+      xml = builder.to_xml save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+      response = self.class.post("#{@transactionals_url}/#{letter_id}", body: xml)
+
+      handle_response(response)
+    end
+
+    def get_deleted_subscribers(options = {})
+      params = { apiKey: api_key }
+
+      list_ids =  options[:list_ids]
+      remove_types =  options[:remove_types]
+      start_date = options[:start_date]
+      end_date = options[:end_date]
+
+      params[:listIds] = list_ids.join(',') if list_ids.respond_to?(:any?)
+      params[:removeTypes] = remove_types.join(',') if remove_types.respond_to?(:any?)
+      params[:startDate] = start_date.to_s unless start_date.nil?
+      params[:endDate] = end_date.to_s unless end_date.nil?
+
+      response = self.class.get(@removed_subscribers_url, query: params)
+
+      handle_response(response)
+    end
+
+    private
+
+    def handle_response(response)
+      result = Result.new(response)
+
+      if should_raise_for_response?(result)
+        error = ExpertSenderError.new("ExpertSender API Error: #{result.error_message} (code #{result.error_code})")
+        error.code = result.error_code
+        raise error
+      end
+
+      result
+    end
+
+    def should_raise_for_response?(result)
+      @throws_exceptions and result.failed?
+    end
+
+    def remove_subscriber_by_email(email, options = {})
+      params = options.merge({ apiKey: api_key, email: email })
+
+      self.class.delete(@subscribers_url, query: params)
+    end
+
+    def remove_subscriber_by_id(id, options = {})
+      params = options.merge({ apiKey: api_key })
+
+      self.class.delete("#{@subscribers_url}/#{id}", query: params)
+    end
+  end
+end
+

data/lib/expertsender_api/concerns/serializeable.rb

@@ -0,0 +1,21 @@
+module ExpertSenderApi
+  module Serializeable
+
+    private
+
+    def attributes
+      variables_to_serialize.map do |ivar|
+        { name: camel_case(ivar.to_s[1..-1]), value: instance_variable_get(ivar) }
+      end
+    end
+
+    def camel_case(str)
+      str.split(/[\W_]/).map {|c| c.capitalize}.join
+    end
+
+    def variables_to_serialize
+      instance_variables
+    end
+  end
+end
+

data/lib/expertsender_api/email.rb

@@ -0,0 +1,5 @@
+module ExpertSenderApi
+  module Email
+  end
+end
+

data/lib/expertsender_api/email/content.rb

@@ -0,0 +1,23 @@
+module ExpertSenderApi::Email
+  class Content
+    include ::ExpertSenderApi::Serializeable
+
+    attr_accessor :from_name, :from_email, :reply_to_name, :reply_to_email,
+                  :subject, :html, :plain
+
+    def initialize(parameters = {})
+      parameters.each { |key, value| send("#{key}=", value) }
+    end
+
+    def insert_to(xml)
+      xml.Content {
+        attributes.each do |attr|
+          xml.send(attr[:name], attr[:value]) unless attr[:value].nil?
+        end
+      }
+    end
+  end
+end
+
+
+

data/lib/expertsender_api/email/receiver.rb

@@ -0,0 +1,22 @@
+module ExpertSenderApi::Email
+  class Receiver
+    include ::ExpertSenderApi::Serializeable
+    attr_accessor :id, :email, :list_id
+
+    def initialize(parameters = {})
+      parameters.each { |key, value| send("#{key}=", value) }
+    end
+
+    def insert_to(xml)
+      xml.Receiver {
+        attributes.each do |attr|
+          xml.send(attr[:name], attr[:value]) unless attr[:value].nil?
+        end
+      }
+    end
+  end
+end
+
+
+
+

data/lib/expertsender_api/email/recipients.rb

@@ -0,0 +1,23 @@
+module ExpertSenderApi::Email
+  class Recipients
+    attr_accessor :subscriber_lists
+
+    def initialize(subscriber_lists: [])
+      @subscriber_lists = subscriber_lists
+    end
+
+    def insert_to(xml)
+      xml.Recipients {
+        if subscriber_lists.any?
+          xml.SubscriberLists {
+            subscriber_lists.each do |list_id|
+              xml.SubscriberList list_id
+            end
+          }
+        end
+      }
+    end
+  end
+end
+
+

data/lib/expertsender_api/email/snippet.rb

@@ -0,0 +1,27 @@
+module ExpertSenderApi::Email
+  class Snippet
+    attr_accessor :name, :value, :cdata
+
+    def initialize(name: nil, value: nil, cdata: true)
+      @name = name
+      @value = value
+      @cdata = cdata
+    end
+
+    def insert_to(xml)
+      if !name.empty? and !value.empty?
+        xml.Snippet {
+          xml.Name name
+          if cdata
+            xml.Value { xml.cdata value }
+          else
+            xml.Value value
+          end
+        }
+      end
+    end
+  end
+end
+
+
+

data/lib/expertsender_api/expertsender_error.rb

@@ -0,0 +1,5 @@
+module ExpertSenderApi
+  class ExpertSenderError < StandardError
+    attr_accessor :code
+  end
+end

data/lib/expertsender_api/result.rb

@@ -0,0 +1,64 @@
+module ExpertSenderApi
+  class Result
+    attr_reader :response, :parsed_response, :error_code, :error_message
+
+    def initialize(response)
+      @response = response
+
+      if (@response.body)
+        @parsed_response = Nokogiri::XML(@response.body)
+
+        if @parsed_response.xpath('//ErrorMessage').any?
+          @error_message = @parsed_response.xpath('//ErrorMessage/Message').text
+          @error_code = @parsed_response.xpath('//ErrorMessage/Code').text
+        end
+      end
+
+      freeze
+    end
+
+    def success?
+      status_success? and
+      error_code.nil? and
+      error_message.nil?
+    end
+
+    def failed?
+      not success?
+    end
+
+    def status_success?
+      response.code == 200 or
+      response.code == 201 or
+      response.code == 202
+    end
+  end
+end
+
+
+clients=Client.joins(:childs).
+  where("clients.created_at > '2014-01-13 00:00:00.000000' and clients.created_at < '2014-01-13 23:59:59.999999'").
+  where(synchronized: false).
+  where('children.client_id is not null')
+not_subscribed_clients = []
+clients.each do |c|
+  si = account.expertsender.get_subscriber_info email: c.email
+  subscribed = si.parsed_response.css('StateOnList').
+    select { |e| e.css('ListId').text.to_i == 2 && e.css('Status').text == 'Active' }.size == 1
+    p "Client: #{c.email}, sync: #{c.synchronized}, uns: #{c.unsubscribed}, registered: #{c.registered}, MainList: #{subscribed}"
+    not_subscribed_clients.push c unless subscribed
+end;nil
+p "Subscribed: #{clients.count - not_subscribed_clients.size}/#{clients.count}"
+
+orders = OrderChange.where("created_at > '2014-01-13 00:00:00.000000' and created_at < '2014-01-13 23:59:59.999999'").map(&:order)
+ios = []
+no_ios = []
+orders.each do |o|
+begin
+  io = InsalesApi::Order.find o.insales_order_id
+  ios << io
+rescue => e
+  p e
+  no_ios << o
+end
+end

data/lib/expertsender_api/subscriber.rb

@@ -0,0 +1,5 @@
+module ExpertSenderApi
+  module Subscriber
+  end
+end
+

data/lib/expertsender_api/subscriber/property.rb

@@ -0,0 +1,27 @@
+module ExpertSenderApi::Subscriber
+  class Property
+    attr_accessor :id, :value, :type
+
+    TYPE_INTEGER = 'int'
+    TYPE_STRING = 'string'
+    TYPE_DATE = 'date'
+    TYPE_DATE_TIME = 'dateTime'
+
+    def initialize(id: nil, value: nil, type: TYPE_STRING)
+      @id = id
+      @value = value
+      @type = type
+    end
+
+    def insert_to(xml)
+      xml.Property {
+        xml.Id id
+        xml.Value value, 'xsi:type' => "xs:#{type}"
+      }
+    end
+  end
+end
+
+
+
+

data/lib/expertsender_api/subscriber/tag.rb

@@ -0,0 +1,47 @@
+module ExpertSenderApi::Subscriber
+  class Tag
+    include ::ExpertSenderApi::Serializeable
+
+    MODE_ADD_AND_UPDATE = 'AddAndUpdate'
+    MODE_ADD_AND_REPLACE = 'AddAndReplace'
+    MODE_ADD_AND_IGNORE = 'AddAndIgnore'
+    MODE_IGNORE_AND_UPDATE = 'IgnoreAndUpdate'
+    MODE_IGNORE_AND_REPLACE = 'IgnoreAndReplace'
+
+    class << self
+      attr_accessor :mode, :force, :list_id
+    end
+
+    attr_accessor :mode, :force, :list_id, :id, :email, :firstname, :lastname,
+                  :tracking_code, :name, :vendor, :ip, :properties
+
+    def initialize(mode: MODE_ADD_AND_UPDATE, **parameters)
+      @mode = mode || self.class.mode
+      @force = parameters[:force] || self.class.force
+      @list_id = parameters[:list_id] || self.class.list_id
+      @properties = parameters.delete(:properties) || []
+
+      parameters.each { |key, value| send("#{key}=", value) }
+    end
+
+    def insert_to(xml)
+      xml.Subscriber {
+        attributes.each do |attr|
+          xml.send(attr[:name], attr[:value]) unless attr[:value].nil?
+        end
+        if properties.any?
+          xml.Properties {
+            properties.each { |property| property.insert_to(xml) }
+          }
+        end
+      }
+    end
+
+    private
+
+    def variables_to_serialize
+      instance_variables.select { |var| var != :@properties }
+    end
+  end
+end
+

data/spec/expertsender_api/api_spec.rb

@@ -0,0 +1,232 @@
+require 'spec_helper'
+
+describe ExpertSenderApi::API do
+  let(:api_key) { "123-us1" }
+  let(:api_endpoint) { 'https://api2.esv2.com' }
+
+  let(:subscribers) { [ExpertSenderApi::Subscriber::Tag.new(subscriber_attributes)] }
+  let(:subscriber_attributes) { { id: 1, list_id: 52, email: "test@httplab.ru" } }
+  let(:subscribers_url) { "#{api_endpoint}/Api/Subscribers" }
+
+  let(:recipients) { ExpertSenderApi::Email::Recipients.new(recipients_attributes) }
+  let(:recipients_attributes) { { subscriber_lists: [52, 53] } }
+
+  let(:content) { ExpertSenderApi::Email::Content.new(content_attributes) }
+  let(:content_attributes) { { from_name: 'From Name Test',
+                               from_email: 'test@httplab.ru',
+                               reply_to_name: 'Reply To Name Test',
+                               reply_to_email: 'Reply To Email Test',
+                               subject: 'Subject test',
+                               plain: 'Plain Test Content' } }
+
+  let(:receiver) { ExpertSenderApi::Email::Receiver.new(receiver_attributes) }
+  let(:receiver_attributes) { { id: 123,
+                                email: 'test@test.ru',
+                                list_id: 53 } }
+
+  let(:snippets) { [ExpertSenderApi::Email::Snippet.new(snippet_attributes)] }
+  let(:snippet_attributes) { { name: 'Test snippet name',
+                               value: 'Test snippet value' } }
+  describe "attributes" do
+    it "have no API key by default" do
+      having_env('EXPERTSENDER_API_KEY', nil) { @expertsender = ExpertSenderApi::API.new }
+      expect(@expertsender.api_key).to be_nil
+    end
+
+    it "set an API key in constructor" do
+      @expertsender = ExpertSenderApi::API.new(key: api_key)
+      expect(@expertsender.api_key).to eq(api_key)
+    end
+
+    it "set an API key from the 'EXPERTSENDER_API_KEY' ENV variable" do
+      having_env('EXPERTSENDER_API_KEY', api_key) { @expertsender = ExpertSenderApi::API.new }
+      expect(@expertsender.api_key).to eq(api_key)
+    end
+
+    it "set an API key via setter" do
+      @expertsender = ExpertSenderApi::API.new
+      @expertsender.api_key = api_key
+      expect(@expertsender.api_key).to eq(api_key)
+    end
+
+    it "detect api endpoint from initializer parameters" do
+      @expertsender = ExpertSenderApi::API.new(key: api_key, api_endpoint: api_endpoint)
+      expect(api_endpoint).to eq(@expertsender.api_endpoint)
+    end
+
+    it "sets the 'throws_exceptions' option from initializer parameters" do
+      @expertsender = ExpertSenderApi::API.new(key: api_key, throws_exceptions: false)
+      expect(false).to eq(@expertsender.throws_exceptions)
+    end
+  end
+
+  describe "ExpertSenderApi class variables" do
+    before do
+      ExpertSenderApi::API.api_key = "123-us1"
+      ExpertSenderApi::API.throws_exceptions = false
+      ExpertSenderApi::API.api_endpoint = api_endpoint
+    end
+
+    after do
+      ExpertSenderApi::API.api_key = nil
+      ExpertSenderApi::API.throws_exceptions = nil
+      ExpertSenderApi::API.api_endpoint = nil
+    end
+
+    it "set api key on new instances" do
+      expect(ExpertSenderApi::API.new.api_key).to eq(ExpertSenderApi::API.api_key)
+    end
+
+    it "set throws_exceptions on new instances" do
+      expect(ExpertSenderApi::API.new.throws_exceptions).to eq(ExpertSenderApi::API.throws_exceptions)
+    end
+
+    it "set api_endpoint on new instances" do
+      expect(ExpertSenderApi::API.api_endpoint).not_to be_nil
+      expect(ExpertSenderApi::API.new.api_endpoint).to eq(ExpertSenderApi::API.api_endpoint)
+    end
+  end
+
+  context 'when configured properly' do
+    subject { ExpertSenderApi::API.new key: api_key, api_endpoint: api_endpoint }
+
+    its '#add_subscribers_to_list calls post with correct body' do
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.ApiRequest {
+          xml.ApiKey api_key
+          xml.MultiData {
+            subscribers.each { |subscriber| subscriber.insert_to(xml) }
+          }
+        }
+      end
+
+      xml = builder.to_xml save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+
+      expect_post(subscribers_url, xml)
+      subject.add_subscribers_to_list(subscribers)
+    end
+
+    its '#remove_subscriber_from_list by id calls delete with correct parameters' do
+      expected_params = { apiKey: api_key,
+                          listId: subscriber_attributes[:list_id] }
+      expect_delete("#{subscribers_url}/#{subscriber_attributes[:id]}", expected_params)
+
+      subject.remove_subscriber_from_list(id: subscriber_attributes[:id], listId: subscriber_attributes[:list_id])
+    end
+
+    its '#remove_subscriber_from_list by email returns success response' do
+      expected_params = { apiKey: api_key,
+                          email: subscriber_attributes[:email],
+                          listId: subscriber_attributes[:list_id] }
+      expect_delete(subscribers_url, expected_params)
+
+      subject.remove_subscriber_from_list(email: subscriber_attributes[:email], listId: subscriber_attributes[:list_id])
+    end
+
+    its '#get_subscriber_info calls get with correct parameters' do
+      expected_params = { apiKey: api_key,
+                          email: subscriber_attributes[:email],
+                          option: ExpertSenderApi::API::SUBSCRIBER_INFO_OPTION_FULL }
+      expect_get(subscribers_url, expected_params)
+
+      subject.get_subscriber_info(email: subscriber_attributes[:email])
+    end
+
+    its '#create_and_send_email calls post with correct body' do
+
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.ApiRequest {
+          xml.ApiKey api_key
+          xml.Data {
+            recipients.insert_to xml
+            content.insert_to xml
+          }
+        }
+      end
+
+      xml = builder.to_xml save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+
+      expect_post("#{api_endpoint}/Api/Newsletters", xml)
+      subject.create_and_send_email(recipients: recipients, content: content)
+    end
+
+    its '#send_transaction_email' do
+      letter_id = 93
+
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.ApiRequest {
+          xml.ApiKey api_key
+          xml.Data {
+            receiver.insert_to xml
+            if snippets.any?
+              xml.Snippets {
+                snippets.each { |snippet| snippet.insert_to(xml) }
+              }
+            end
+          }
+        }
+      end
+
+      xml = builder.to_xml save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+
+      expect_post("#{api_endpoint}/Api/Transactionals/#{letter_id}", xml)
+      subject.send_transaction_email(letter_id: letter_id,
+                                     receiver: receiver,
+                                     snippets: snippets)
+    end
+
+    its '#get_deleted_subscribers calls get with correct parameters' do
+      expected_params = { apiKey: api_key,
+                          listIds: '52,53',
+                          removeTypes: 'OptOutLink,Compliant,Ui',
+                          startDate: Date.today.to_s,
+                          endDate: Date.new(2090, 1, 1).to_s }
+
+      expect_get("#{api_endpoint}/Api/RemovedSubscribers", expected_params)
+
+      subject.get_deleted_subscribers(list_ids: [52, 53],
+                                      remove_types: ['OptOutLink', 'Compliant', 'Ui'],
+                                      start_date: Date.today,
+                                      end_date: Date.new(2090, 1, 1))
+    end
+  end
+
+  context 'when has wrong api key' do
+    subject { ExpertSenderApi::API.new key: 'wrong', api_endpoint: api_endpoint, throws_exceptions: true }
+
+    its '#add_subscribers_to_list raises exception' do
+      expect { subject.add_subscribers_to_list(subscribers) }.to raise_error(ExpertSenderApi::ExpertSenderError)
+    end
+  end
+
+  private
+
+  def having_env(key, value)
+    prev_value = ENV[key]
+    ENV[key] = value
+    yield
+    ENV[key] = prev_value
+  end
+
+  def expect_get(expected_url, expected_params)
+    ExpertSenderApi::API.should_receive(:get).with do |url, opts|
+      expect(url).to eq expected_url
+      expect(expected_params).to eq opts[:query]
+    end.and_return(Struct.new(:body).new(nil))
+  end
+
+  def expect_post(expected_url, expected_body)
+    ExpertSenderApi::API.should_receive(:post).with do |url, opts|
+      expect(url).to eq expected_url
+      expect(expected_body).to eq opts[:body]
+    end.and_return(Struct.new(:body).new(nil))
+  end
+
+  def expect_delete(expected_url, expected_params)
+    ExpertSenderApi::API.should_receive(:delete).with do |url, opts|
+      expect(url).to eq expected_url
+      expect(expected_params).to eq opts[:query]
+    end.and_return(Struct.new(:body).new(nil))
+  end
+end
+

data/spec/expertsender_api/email/content_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe ExpertSenderApi::Email::Content do
+  context :with_valid_attributes do
+    let(:valid_attributes) { { from_name: 'From Name Test',
+                               from_email: 'test@httplab.ru',
+                               reply_to_name: 'Reply To Name Test',
+                               reply_to_email: 'Reply To Email Test',
+                               subject: 'Subject test',
+                               html: 'Html Test Content',
+                               plain: 'Plain Test Content' } }
+
+    subject do
+      ExpertSenderApi::Email::Content.new valid_attributes
+    end
+
+    it 'has proper attributes' do
+      valid_attributes.each do |key, value|
+        subject.send(key).should eq value
+      end
+    end
+
+    it 'generates proper markup' do
+      builder = Nokogiri::XML::Builder.new do |xml|
+        subject.insert_to(xml)
+      end
+
+      xml = Nokogiri::XML(builder.to_xml)
+
+      xml.xpath('//FromName').text.should eq valid_attributes[:from_name]
+      xml.xpath('//FromEmail').text.should eq valid_attributes[:from_email]
+      xml.xpath('//ReplyToName').text.should eq valid_attributes[:reply_to_name]
+      xml.xpath('//ReplyToEmail').text.should eq valid_attributes[:reply_to_email]
+      xml.xpath('//Subject').text.should eq valid_attributes[:subject]
+      xml.xpath('//Html').text.should eq valid_attributes[:html]
+      xml.xpath('//Plain').text.should eq valid_attributes[:plain]
+    end
+  end
+end
+
+

data/spec/expertsender_api/email/receiver_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe ExpertSenderApi::Email::Receiver do
+  context :with_valid_attributes do
+    let(:valid_attributes) { { id: '777',
+                               email: 'test@test.com',
+                               list_id: '53' } }
+
+    subject do
+      ExpertSenderApi::Email::Receiver.new valid_attributes
+    end
+
+    it 'has proper attributes' do
+      subject.id.should eq valid_attributes[:id]
+      subject.email.should eq valid_attributes[:email]
+      subject.list_id.should eq valid_attributes[:list_id]
+    end
+
+    it 'generates proper markup' do
+      builder = Nokogiri::XML::Builder.new do |xml|
+        subject.insert_to(xml)
+      end
+
+      xml = Nokogiri::XML(builder.to_xml)
+
+      xml.xpath('//Receiver/Id').text.should eq valid_attributes[:id]
+      xml.xpath('//Receiver/Email').text.should eq valid_attributes[:email]
+      xml.xpath('//Receiver/ListId').text.should eq valid_attributes[:list_id]
+    end
+  end
+end
+
+

data/spec/expertsender_api/email/recipients_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe ExpertSenderApi::Email::Recipients do
+  context :with_valid_attributes do
+    let(:valid_attributes) { { subscriber_lists: [53, 53] } }
+
+    subject do
+      ExpertSenderApi::Email::Recipients.new valid_attributes
+    end
+
+    it 'has proper attributes' do
+      valid_attributes.each do |key, value|
+        subject.send(key).should eq value
+      end
+    end
+
+    it 'generates proper markup' do
+      builder = Nokogiri::XML::Builder.new do |xml|
+        subject.insert_to(xml)
+      end
+
+      xml = Nokogiri::XML(builder.to_xml)
+
+      xml.xpath('//SubscriberLists/SubscriberList').map(&:text).should eq valid_attributes[:subscriber_lists].map(&:to_s)
+    end
+  end
+end
+
+
+

data/spec/expertsender_api/email/snippet_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe ExpertSenderApi::Email::Snippet do
+  context :with_valid_attributes do
+    let(:valid_attributes) { { name: 'TestSnippetName',
+                               value: 'TestSnippetValue' } }
+
+    subject do
+      ExpertSenderApi::Email::Snippet.new valid_attributes
+    end
+
+    it 'has proper attributes' do
+      subject.name.should eq valid_attributes[:name]
+      subject.value.should eq valid_attributes[:value]
+    end
+
+    it 'generates proper markup' do
+      builder = Nokogiri::XML::Builder.new do |xml|
+        subject.insert_to(xml)
+      end
+
+      xml = Nokogiri::XML(builder.to_xml)
+
+      xml.xpath('//Name').text.should eq valid_attributes[:name]
+      xml.xpath('//Value').text.should eq valid_attributes[:value]
+    end
+  end
+end
+
+

data/spec/expertsender_api/subscriber/property_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe ExpertSenderApi::Subscriber::Property do
+  context :with_valid_attributes do
+    let(:valid_attributes) { { id: 123,
+                               type: 'string',
+                               value: 'Test Property Value' } }
+
+    subject do
+      ExpertSenderApi::Subscriber::Property.new valid_attributes
+    end
+
+    it 'has proper attributes' do
+      subject.id.should eq valid_attributes[:id]
+      subject.type.should eq valid_attributes[:type]
+      subject.value.should eq valid_attributes[:value]
+    end
+
+    it 'generates proper markup' do
+      builder = Nokogiri::XML::Builder.new do |xml|
+        subject.insert_to(xml)
+      end
+
+      xml = Nokogiri::XML(builder.to_xml)
+
+      xml.xpath('//Property/Id').text.to_i.should eq valid_attributes[:id]
+      xml.xpath('//Property/Value').attribute('xsi:type').value.should eq "xs:#{valid_attributes[:type]}"
+      xml.xpath('//Property/Value').text.should eq valid_attributes[:value]
+    end
+  end
+end
+
+

data/spec/expertsender_api/subscriber/tag_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe ExpertSenderApi::Subscriber::Tag do
+  context :with_valid_attributes do
+    let(:properties) { [ExpertSenderApi::Subscriber::Property.new(id: 123,
+                                                                  value: 'test',
+                                                                  type: 'string'),
+                        ExpertSenderApi::Subscriber::Property.new(id: 456,
+                                                                  value: 'test1',
+                                                                  type: 'string')] }
+    let(:valid_attributes) { { list_id: 52,
+                               email: 'test@httplab.ru',
+                               mode: ExpertSenderApi::Subscriber::Tag::MODE_ADD_AND_IGNORE,
+                               id: 777,
+                               firstname: 'Test1',
+                               lastname: 'Test2',
+                               name: 'Test3',
+                               tracking_code: '123',
+                               vendor: 'Vendor',
+                               ip: '127.0.0.1',
+                               properties: properties } }
+
+    subject do
+      ExpertSenderApi::Subscriber::Tag.new valid_attributes
+    end
+
+    it 'has proper attributes' do
+      valid_attributes.each do |key, value|
+        subject.send(key).should eq value
+      end
+    end
+
+    it 'generates proper markup' do
+      builder = Nokogiri::XML::Builder.new do |xml|
+        subject.insert_to(xml)
+      end
+
+      xml = Nokogiri::XML(builder.to_xml)
+
+      xml.xpath('//Subscriber/ListId').text.to_i.should eq valid_attributes[:list_id]
+      xml.xpath('//Subscriber/Email').text.should eq valid_attributes[:email]
+      xml.xpath('//Subscriber/Mode').text.should eq valid_attributes[:mode]
+      xml.xpath('//Subscriber/Id').text.to_i.should eq valid_attributes[:id]
+      xml.xpath('//Subscriber/Firstname').text.should eq valid_attributes[:firstname]
+      xml.xpath('//Subscriber/Lastname').text.should eq valid_attributes[:lastname]
+      xml.xpath('//Subscriber/Name').text.should eq valid_attributes[:name]
+      xml.xpath('//Subscriber/TrackingCode').text.should eq valid_attributes[:tracking_code]
+      xml.xpath('//Subscriber/Vendor').text.should eq valid_attributes[:vendor]
+      xml.xpath('//Subscriber/Ip').text.should eq valid_attributes[:ip]
+
+      properties.each_with_index do |property, i|
+        xml_prop = xml.xpath('//Subscriber/Properties/Property')[i]
+        xml_prop.xpath('Id').text.to_i.should eq property.id
+        xml_prop.xpath('Value').attribute('xsi:type').value.should eq "xs:#{property.type}"
+        xml_prop.xpath('Value').text.should eq property.value
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup(:default, :development)
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'expertsender_api'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: expertsender_api
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- kinderly
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A wrapper for  ExpertSender API
+email:
+- beorc@httplab.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- expertsender_api.gemspec
+- lib/expertsender_api.rb
+- lib/expertsender_api/api.rb
+- lib/expertsender_api/concerns/serializeable.rb
+- lib/expertsender_api/email.rb
+- lib/expertsender_api/email/content.rb
+- lib/expertsender_api/email/receiver.rb
+- lib/expertsender_api/email/recipients.rb
+- lib/expertsender_api/email/snippet.rb
+- lib/expertsender_api/expertsender_error.rb
+- lib/expertsender_api/result.rb
+- lib/expertsender_api/subscriber.rb
+- lib/expertsender_api/subscriber/property.rb
+- lib/expertsender_api/subscriber/tag.rb
+- spec/expertsender_api/api_spec.rb
+- spec/expertsender_api/email/content_spec.rb
+- spec/expertsender_api/email/receiver_spec.rb
+- spec/expertsender_api/email/recipients_spec.rb
+- spec/expertsender_api/email/snippet_spec.rb
+- spec/expertsender_api/subscriber/property_spec.rb
+- spec/expertsender_api/subscriber/tag_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/kinderly/expertsender_api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: expertsender_api
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A wrapper for ExpertSender API
+test_files:
+- spec/expertsender_api/api_spec.rb
+- spec/expertsender_api/email/content_spec.rb
+- spec/expertsender_api/email/receiver_spec.rb
+- spec/expertsender_api/email/recipients_spec.rb
+- spec/expertsender_api/email/snippet_spec.rb
+- spec/expertsender_api/subscriber/property_spec.rb
+- spec/expertsender_api/subscriber/tag_spec.rb
+- spec/spec_helper.rb