postmark 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dea79dd86f6f199d56c6d3845f164961be3950c5
-  data.tar.gz: 0b112a7f4412ccc38276947f4513ffbaaee4164a
+  metadata.gz: 2bdedf5c9c85549872f00c732d6415a597f40267
+  data.tar.gz: fb1aa95ee6adedf96a0a39c91223cfb54ce804a2
 SHA512:
-  metadata.gz: a578a7aede0e3dd604b67bbe4ea922cf3459b52fc10ee46cf80dcdf681283bd8a09f0d17927e261ee9c17c3070dc8251788fd01c537b1975c1e230a4bb4083e9
-  data.tar.gz: 933f64251c5bd09c29ee044c23ea84637e589ceb060155d0da2cfd9d75590cab622ace4e140a89956a1b908762fe284119fb09b2eaf4a8337324549402c16516
+  metadata.gz: 03e03d105cfc7dbcea13c2f3c5966af5d1e8519a30eba3473da82e46b59bdb48e7599e3cd294e0c576f1f4f0f6d01e6f245b52e087e4b51e2dec04bd7029027f
+  data.tar.gz: e5bb214b73f426f7dae362ac16a44976097e6c878033b6b58ff6718093b67cef2b60c39788940d7fc51760e34f38d9c3aca1fd3bc444acd9f8e7db3f6b333c36

data/.travis.yml

@@ -1,6 +1,8 @@
 env:
   global:
-    secure: MV+nKlzuLJ5CEoEfCmzwRMlnBOudgB1fTxBYI6aDV9vUkwYRzkcpCPS+Ik6jdCzNEFK+L2dTfv/IfDOvxnK3cZpMi1sp0po04m3Pg+ZhzYoANS1KY6V4sFIFaPtx+x2DVStxjFch4WQV8ktzdoUI0POlCdJrD6GYXLh1aTgbAGU=
+    - secure: "fo5ce1ABn12rZODstLzMnM14Ma21CUpYkcn9EnRtsPlvpFt/71hTPtP5pYrhnTTGUxVk6JPYGSUC58fXMa9zJKyMZv1PKokiGuGw4ktcsn+fX/pvEYxmsuQx0e+GbZ6psCHneIbaADEjUeqR/XJUBJDFpDoXKGwZuJW05b8Hxbc="
+    - secure: "YGu/kwvIbTKQ9/ox2MGJ3qVLU78ccqi+HLgkXYBxhjfOFTgTemFizMgZYRDmwGKnOB1XVnKj0mZUOuMb66DjZjRn9MK6ifxp6NjPb82AKkLALFkMKUm0rUqz2PeiUYSPDyta3pQfyTZTvN/XjFXjKvInVz9onKsoPUmPGh2AxNw="
+    - secure: "Cb54rQW9L8XAOPLe8x+DNTsF0g13QjSRhzCUq3U8vHlM7UmsHzIRA0GvAomFCq5bp5wrUVVQKD+6rQpqGLBdTG6VxKvPbomS+nVIukjQiOqnqtjaZHcSuK5RnJ+4mJSKHV/W1Wq7NbdvmQxpzURXTJuuLqib5Lwd4Jt5cWqX05w="
 language: ruby
 rvm:
 - 1.8.7

data/CHANGELOG.rdoc

@@ -1,5 +1,10 @@
 = Changelog
 
+== 1.2.0
+
+* Added support for the Postmark Account API.
+* Added #bounces and #messages methods to Postmark::ApiClient returning Ruby enumerators.
+
 == 1.1.2
 
 * Fixed HTTP verb used to update server info from POST to PUT to support the breaking change in the API.

data/Gemfile

@@ -4,7 +4,7 @@ source "http://rubygems.org"
 gemspec
 
 group :test do
-  gem 'rspec', '~> 2.13.0'
+  gem 'rspec', '~> 2.14.0'
   gem 'fakeweb'
   gem 'fakeweb-matcher'
 end

data/README.md

@@ -252,6 +252,13 @@ client.dump_message('41f03342-xxxx-xxxx-xxxx-558caedb5e82')
 # => {:body=>"..."}
 ```
 
+There is also a handy `#messages` enumerator allowing you to easily manipulate big data arrays.
+
+``` ruby
+client.messages.lazy.select { |m| DateTime.parse(m[:received_at]).day.even? }.first(5)
+# => [{...}, {...}]
+```
+
 You can get more details about the underlying endpoints and parameters they
 accept in [Postmark Developer Docs](http://developer.postmarkapp.com/developer-messages.html).
 
@@ -286,6 +293,13 @@ client.dump_bounce(654714902)
 # => {:body=>"Return-Path: <>\r\nReceived: from m1.mtasv.net (74.205.19.136) by sc-ord-mail2.mtasv.net id hcjov61jk5ko for <pm_bounces@pm.mtasv.net>; Wed, 10 Apr 2013 01:00:35 -0400 (envelope-from <>)\r\nDate: Wed, 10 Apr 2013 01:00:48 -0400\r\nFrom: postmaster@m1.mtasv.net\r\n..."}
 ```
 
+There is a `#bounces` enumerator to take the underlying complexity off of your shoulders. Use it to iterate over all of your bounces.
+
+``` ruby
+client.bounces.first(5)
+# => [{...}, {...}]
+```
+
 You can activate email addresses that were disabled due to a hard bounce by using `#activate_bounce`:
 
 ``` ruby
@@ -547,7 +561,13 @@ message.message_id
 
 # Exploring Other Gem Features
 
-To provide an interface similar to ActiveRecord for bounces, the Postmark gem adds
+## The Account API Support
+
+Postmark allows you to automatically scale your sending infrastructure with the Account API. Learn how in the [Account API Support](https://github.com/wildbit/postmark-gem/wiki/The-Account-API-Support) guide.
+
+## ActiveModel-like Interface For Bounces
+
+To provide an interface similar to ActiveModel for bounces, the Postmark gem adds
 `Postmark::Bounce` class. This class uses the shared `Postmark::ApiClient` instance
 configured through the Postmark module.
 
@@ -595,8 +615,7 @@ Postmark.response_parser_class = :Json # :ActiveSupport or :Yajl are also suppor
 
 * Fork the project.
 * Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
 * Commit, do not mess with rakefile, version, or history.
 * Send me a pull request. Bonus points for topic branches.
 

data/VERSION

@@ -1 +1 @@
-1.1.2
+1.2.0

data/lib/postmark/account_api_client.rb

@@ -0,0 +1,96 @@
+module Postmark
+
+  class AccountApiClient < Client
+
+    def initialize(api_key, options = {})
+      options[:auth_header_name] = 'X-Postmark-Account-Token'
+      super
+    end
+
+    def senders(options = {})
+      find_each('senders', 'SenderSignatures', options)
+    end
+    alias_method :signatures, :senders
+
+    def get_senders(options = {})
+      load_batch('senders', 'SenderSignatures', options).last
+    end
+    alias_method :get_signatures, :get_senders
+
+    def get_senders_count(options = {})
+      get_resource_count('senders', options)
+    end
+    alias_method :get_signatures_count, :get_senders_count
+
+    def get_sender(id)
+      format_response http_client.get("senders/#{id.to_i}")
+    end
+    alias_method :get_signature, :get_sender
+
+    def create_sender(attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+
+      format_response http_client.post('senders', data)
+    end
+    alias_method :create_signature, :create_sender
+
+    def update_sender(id, attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+
+      format_response http_client.put("senders/#{id.to_i}", data)
+    end
+    alias_method :update_signature, :update_sender
+
+    def resend_sender_confirmation(id)
+      format_response http_client.post("senders/#{id.to_i}/resend")
+    end
+    alias_method :resend_signature_confirmation, :resend_sender_confirmation
+
+    def verified_sender_spf?(id)
+      !!http_client.post("senders/#{id.to_i}/verifyspf")['SPFVerified']
+    end
+    alias_method :verified_signature_spf?, :verified_sender_spf?
+
+    def request_new_sender_dkim(id)
+      format_response http_client.post("senders/#{id.to_i}/requestnewdkim")
+    end
+    alias_method :request_new_signature_dkim, :request_new_sender_dkim
+
+    def delete_sender(id)
+      format_response http_client.delete("senders/#{id.to_i}")
+    end
+    alias_method :delete_signature, :delete_sender
+
+    def servers(options = {})
+      find_each('servers', 'Servers', options)
+    end
+
+    def get_servers(options = {})
+      load_batch('servers', 'Servers', options).last
+    end
+
+    def get_servers_count(options = {})
+      get_resource_count('servers', options)
+    end
+
+    def get_server(id)
+      format_response http_client.get("servers/#{id.to_i}")
+    end
+
+    def create_server(attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+      format_response http_client.post('servers', data)
+    end
+
+    def update_server(id, attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+      format_response http_client.put("servers/#{id.to_i}", data)
+    end
+
+    def delete_server(id)
+      format_response http_client.delete("servers/#{id.to_i}")
+    end
+
+  end
+
+end

data/lib/postmark/api_client.rb

@@ -1,15 +1,11 @@
 module Postmark
-  class ApiClient
-    attr_reader :http_client, :max_retries
-    attr_writer :max_batch_size
+  class ApiClient < Client
+    attr_accessor :max_batch_size
 
     def initialize(api_key, options = {})
-      @max_retries = options.delete(:max_retries) || 3
-      @http_client = HttpClient.new(api_key, options)
-    end
-
-    def api_key=(api_key)
-      http_client.api_key = api_key
+      options = options.dup
+      @max_batch_size = options.delete(:max_batch_size) || 500
+      super
     end
 
     def deliver(message_hash = {})
@@ -65,12 +61,19 @@ module Postmark
       response
     end
 
+    def messages(options = {})
+      path, name, params = extract_messages_path_and_params(options)
+      find_each(path, name, params)
+    end
+
     def get_messages(options = {})
-      path, params = extract_messages_path_and_params(options)
-      params[:offset] ||= 0
-      params[:count] ||= 50
-      messages_key = options[:inbound] ? 'InboundMessages' : 'Messages'
-      format_response http_client.get(path, params)[messages_key]
+      path, name, params = extract_messages_path_and_params(options)
+      load_batch(path, name, params).last
+    end
+
+    def get_messages_count(options = {})
+      path, _, params = extract_messages_path_and_params(options)
+      get_resource_count(path, params)
     end
 
     def get_message(id, options = {})
@@ -81,8 +84,12 @@ module Postmark
       get_for_message('dump', id, options)
     end
 
+    def bounces(options = {})
+      find_each('bounces', 'Bounces', options)
+    end
+
     def get_bounces(options = {})
-      format_response http_client.get("bounces", options)["Bounces"]
+      load_batch('bounces', 'Bounces', options)
     end
 
     def get_bounced_tags
@@ -110,23 +117,8 @@ module Postmark
       format_response http_client.put("server", serialize(data))
     end
 
-    def max_batch_size
-      @max_batch_size ||= 500
-    end
-
     protected
 
-    def with_retries
-      yield
-    rescue DeliveryError
-      retries = retries ? retries + 1 : 1
-      if retries < self.max_retries
-        retry
-      else
-        raise
-      end
-    end
-
     def in_batches(messages)
       r = messages.each_slice(max_batch_size).each_with_index.map do |batch, i|
         yield batch, i * max_batch_size
@@ -142,35 +134,16 @@ module Postmark
       message.postmark_response = response
     end
 
-    def serialize(data)
-      Postmark::Json.encode(data)
-    end
-
-    def take_response_of
-      [yield, nil]
-    rescue DeliveryError => e
-      [e.full_response || {}, e]
-    end
-
     def get_for_message(action, id, options = {})
-      path, params = extract_messages_path_and_params(options)
+      path, _, params = extract_messages_path_and_params(options)
       format_response http_client.get("#{path}/#{id}/#{action}", params)
     end
 
-    def format_response(response, compatible = false)
-      return {} unless response
-
-      if response.kind_of? Array
-        response.map { |entry| Postmark::HashHelper.to_ruby(entry, compatible) }
-      else
-        Postmark::HashHelper.to_ruby(response, compatible)
-      end
-    end
-
     def extract_messages_path_and_params(options = {})
       options = options.dup
+      messages_key = options[:inbound] ? 'InboundMessages' : 'Messages'
       path = options.delete(:inbound) ? 'messages/inbound' : 'messages/outbound'
-      [path, options]
+      [path, messages_key, options]
     end
 
   end

data/lib/postmark/client.rb

@@ -0,0 +1,82 @@
+require 'enumerator'
+
+module Postmark
+  class Client
+    attr_reader :http_client, :max_retries
+
+    def initialize(api_key, options = {})
+      options = options.dup
+      @max_retries = options.delete(:max_retries) || 3
+      @http_client = HttpClient.new(api_key, options)
+    end
+
+    def api_key=(api_key)
+      http_client.api_key = api_key
+    end
+
+    def find_each(path, name, options = {})
+      if block_given?
+        options = options.dup
+        i, total_count = [0, 1]
+
+        while i < total_count
+          options[:offset] = i
+          total_count, collection = load_batch(path, name, options)
+          collection.each { |e| yield e }
+          i += collection.size
+        end
+      else
+        enum_for(:find_each, path, name, options) do
+          get_resource_count(path, options)
+        end
+      end
+    end
+
+    protected
+
+    def with_retries
+      yield
+    rescue DeliveryError
+      retries = retries ? retries + 1 : 1
+      if retries < self.max_retries
+        retry
+      else
+        raise
+      end
+    end
+
+    def serialize(data)
+      Postmark::Json.encode(data)
+    end
+
+    def take_response_of
+      [yield, nil]
+    rescue DeliveryError => e
+      [e.full_response || {}, e]
+    end
+
+    def format_response(response, compatible = false)
+      return {} unless response
+
+      if response.kind_of? Array
+        response.map { |entry| Postmark::HashHelper.to_ruby(entry, compatible) }
+      else
+        Postmark::HashHelper.to_ruby(response, compatible)
+      end
+    end
+
+    def get_resource_count(path, options = {})
+      # At this point Postmark API returns 0 as total if you request 0 documents
+      total_count, _ = load_batch(path, nil, options.merge(:count => 1))
+      total_count
+    end
+
+    def load_batch(path, name, options)
+      options[:offset] ||= 0
+      options[:count] ||= 30
+      response = http_client.get(path, options)
+      [response['TotalCount'], format_response(response[name])]
+    end
+
+  end
+end

data/lib/postmark/http_client.rb

@@ -6,9 +6,10 @@ module Postmark
     attr_accessor :api_key
     attr_reader :http, :secure, :proxy_host, :proxy_port, :proxy_user,
                 :proxy_pass, :host, :port, :path_prefix,
-                :http_open_timeout, :http_read_timeout
+                :http_open_timeout, :http_read_timeout, :auth_header_name
 
     DEFAULTS = {
+      :auth_header_name => 'X-Postmark-Server-Token',
       :host => 'api.postmarkapp.com',
       :secure => false,
       :path_prefix => '/',
@@ -35,6 +36,10 @@ module Postmark
       do_request { |client| client.get(url_path(path + to_query_string(query)), headers) }
     end
 
+    def delete(path, query = {})
+      do_request { |client| client.delete(url_path(path + to_query_string(query)), headers) }
+    end
+
     protected
 
     def apply_options(options = {})
@@ -74,7 +79,7 @@ module Postmark
     end
 
     def headers
-      HEADERS.merge({ "X-Postmark-Server-Token" => self.api_key.to_s })
+      HEADERS.merge(self.auth_header_name => self.api_key.to_s)
     end
 
     def url_path(path)

data/lib/postmark/version.rb

@@ -1,3 +1,3 @@
 module Postmark
-  VERSION = "1.1.2"
+  VERSION = "1.2.0"
 end

data/lib/postmark.rb

@@ -10,7 +10,9 @@ require 'postmark/bounce'
 require 'postmark/inbound'
 require 'postmark/json'
 require 'postmark/http_client'
+require 'postmark/client'
 require 'postmark/api_client'
+require 'postmark/account_api_client'
 require 'postmark/message_extensions/shared'
 require 'postmark/message_extensions/mail'
 require 'postmark/handlers/mail'

data/spec/integration/account_api_client_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe 'Account API client usage' do
+
+  subject { Postmark::AccountApiClient.new(ENV['POSTMARK_ACCOUNT_API_KEY'],
+                                           :http_open_timeout => 15,
+                                           :http_read_timeout => 15) }
+  let(:unique_token) { rand(36**32).to_s(36) }
+  let(:unique_from_email) { ENV['POSTMARK_CI_RECIPIENT'].gsub(/(\+.+)?@/, "+#{unique_token}@") }
+
+  it 'can be used to manage senders' do
+    new_sender = nil
+
+    # create & count
+    expect {
+      new_sender = subject.create_sender(:name => 'Integration Test',
+                                         :from_email => unique_from_email)
+    }.to change { subject.get_senders_count }.by(1)
+
+    # get
+    expect(subject.get_sender(new_sender[:id])[:id]).to eq(new_sender[:id])
+
+    # list
+    senders = subject.get_senders(:count => 50)
+    expect(senders.map { |s| s[:id] }).to include(new_sender[:id])
+
+    # collection
+    expect(subject.senders.map { |s| s[:id] }).to include(new_sender[:id])
+
+    # update
+    updated_sender = subject.update_sender(new_sender[:id], :name => 'New Name')
+    expect(updated_sender[:name]).to eq('New Name')
+    expect(updated_sender[:id]).to eq(new_sender[:id])
+
+    # spf
+    expect(subject.verified_sender_spf?(new_sender[:id])).to be_false
+
+    # resend
+    expect { subject.resend_sender_confirmation(new_sender[:id]) }.not_to raise_error
+
+    # dkim
+    expect { subject.request_new_sender_dkim(new_sender[:id]) }.
+        to raise_error(Postmark::InvalidMessageError,
+                       'This DKIM is already being renewed.')
+
+    # delete
+    expect { subject.delete_sender(new_sender[:id]) }.not_to raise_error
+  end
+
+  it 'can be used to manage servers' do
+    new_server = nil
+
+    # create & count
+    expect {
+      new_server = subject.create_server(:name => "server-#{unique_token}",
+                                         :color => 'red')
+    }.to change { subject.get_servers_count }.by(1)
+
+    # get
+    expect(subject.get_server(new_server[:id])[:id]).to eq(new_server[:id])
+
+    # list
+    servers = subject.get_servers(:count => 50)
+    expect(servers.map { |s| s[:id] }).to include(new_server[:id])
+
+    # collection
+    expect(subject.servers.map { |s| s[:id] }).to include(new_server[:id])
+
+    # update
+    updated_server = subject.update_server(new_server[:id], :color => 'blue')
+    expect(updated_server[:color]).to eq('blue')
+    expect(updated_server[:id]).to eq(new_server[:id])
+
+    # delete
+    expect { subject.delete_server(new_server[:id]) }.not_to raise_error
+  end
+
+end

data/spec/spec_helper.rb

@@ -27,6 +27,16 @@ RSpec.configure do |config|
     RUBY_PLATFORM.to_s =~ /^#{platform.to_s}/
   }
 
+  config.filter_run_excluding :skip_ruby_version => lambda { |version|
+    versions = [*version]
+    versions.any? { |v| RUBY_VERSION.to_s =~ /^#{v.to_s}/ }
+  }
+
+  config.filter_run_excluding :exclusive_for_ruby_version => lambda { |version|
+    versions = [*version]
+    versions.all? { |v| !(RUBY_VERSION.to_s =~ /^#{v.to_s}/) }
+  }
+
   config.before(:each) do
     %w(api_client response_parser_class secure api_key proxy_host proxy_port
        proxy_user proxy_pass host port path_prefix http_open_timeout