postmark 1.8.1 → 1.21.3

data/lib/postmark/version.rb

@@ -1,3 +1,3 @@
 module Postmark
-  VERSION = '1.8.1'
+  VERSION = '1.21.3'
 end

data/postmark.gemspec

@@ -33,8 +33,8 @@ Gem::Specification.new do |s|
 
   s.required_rubygems_version = ">= 1.3.7"
 
-  s.add_dependency "rake"
   s.add_dependency "json"
 
   s.add_development_dependency "mail"
+  s.add_development_dependency "rake"
 end

data/spec/integration/account_api_client_spec.rb

@@ -8,12 +8,9 @@ describe 'Account API client usage' do
   let(:unique_token) { rand(36**32).to_s(36) }
   let(:unique_from_email) { ENV['POSTMARK_CI_SENDER'].gsub(/(\+.+)?@/, "+#{unique_token}@") }
 
-  it 'can be used to manage senders' do
-    new_sender = nil
-
+  it 'manage senders' do
     # create & count
-    new_sender = subject.create_sender(:name => 'Integration Test',
-                                       :from_email => unique_from_email)
+    new_sender = subject.create_sender(:name => 'Integration Test', :from_email => unique_from_email)
     expect(subject.get_senders_count).to be > 0
 
     # get
@@ -31,8 +28,9 @@ describe 'Account API client usage' do
     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_true
+    expect(subject.verified_sender_spf?(new_sender[:id])).to be true
 
     # resend
     expect { subject.resend_sender_confirmation(new_sender[:id]) }.not_to raise_error
@@ -46,9 +44,44 @@ describe 'Account API client usage' do
     expect { subject.delete_sender(new_sender[:id]) }.not_to raise_error
   end
 
-  it 'can be used to manage servers' do
-    new_server = nil
+  it 'manage domains' do
+    domain_name = "#{unique_token}-gem-integration.test"
+    return_path = "return.#{domain_name}"
+    updated_return_path = "updated-return.#{domain_name}"
+
+    # create & count
+    new_domain = subject.create_domain(:name => domain_name,
+                                       :return_path_domain => return_path)
+    expect(subject.get_domains_count).to be > 0
+
+    # get
+    expect(subject.get_domain(new_domain[:id])[:id]).to eq(new_domain[:id])
+
+    # list
+    domains = subject.get_domains(:count => 50)
+    expect(domains.map { |d| d[:id] }).to include(new_domain[:id])
+
+    # collection
+    expect(subject.domains.map { |d| d[:id] }).to include(new_domain[:id])
+
+    # update
+    updated_domain = subject.update_domain(new_domain[:id], :return_path_domain => updated_return_path)
+    expect(updated_domain[:return_path_domain]).to eq(updated_return_path)
+    expect(updated_domain[:id]).to eq(new_domain[:id])
+
+    # spf
+    expect(subject.verified_domain_spf?(new_domain[:id])).to be true
 
+    # dkim
+    expect { subject.rotate_domain_dkim(new_domain[:id]) }.
+        to raise_error(Postmark::InvalidMessageError,
+                       'This DKIM is already being renewed.')
+
+    # delete
+    expect { subject.delete_domain(new_domain[:id]) }.not_to raise_error
+  end
+
+  it 'manage servers' do
     # create & count
     new_server = subject.create_server(:name => "server-#{unique_token}",
                                        :color => 'red')
@@ -72,5 +105,4 @@ describe 'Account API client usage' do
     # delete
     expect { subject.delete_server(new_server[:id]) }.not_to raise_error
   end
-
-end
+end

data/spec/integration/api_client_hashes_spec.rb

@@ -1,19 +1,16 @@
 require 'spec_helper'
 
 describe "Sending messages as Ruby hashes with Postmark::ApiClient" do
-  let(:postmark_message_id_format) { /\w{8}\-\w{4}-\w{4}-\w{4}-\w{12}/ }
-  let(:api_client) {
-    Postmark::ApiClient.new('POSTMARK_API_TEST',
-                            :http_open_timeout => 15,
-                            :http_read_timeout => 15)
-  }
+  let(:message_id_format) {/<.+@.+>/}
+  let(:postmark_message_id_format) {/\w{8}\-\w{4}-\w{4}-\w{4}-\w{12}/}
+  let(:api_client) {Postmark::ApiClient.new('POSTMARK_API_TEST', :http_open_timeout => 15, :http_read_timeout => 15)}
 
   let(:message) {
     {
-      :from => "sender@postmarkapp.com",
-      :to => "recipient@postmarkapp.com",
-      :subject => "Mail::Message object",
-      :text_body => "Lorem ipsum dolor sit amet, consectetur adipisicing elit, " \
+        :from => "sender@postmarkapp.com",
+        :to => "recipient@postmarkapp.com",
+        :subject => "Mail::Message object",
+        :text_body => "Lorem ipsum dolor sit amet, consectetur adipisicing elit, " \
                     "sed do eiusmod tempor incididunt ut labore et dolore " \
                     "magna aliqua."
     }
@@ -21,8 +18,8 @@ describe "Sending messages as Ruby hashes with Postmark::ApiClient" do
 
   let(:message_with_no_body) {
     {
-      :from => "sender@postmarkapp.com",
-      :to => "recipient@postmarkapp.com",
+        :from => "sender@postmarkapp.com",
+        :to => "recipient@postmarkapp.com",
     }
   }
 
@@ -32,74 +29,60 @@ describe "Sending messages as Ruby hashes with Postmark::ApiClient" do
     end
   }
 
-  let(:message_with_invalid_to) {
-    {
-      :from => "sender@postmarkapp.com",
-      :to => "@postmarkapp.com"
-    }
-  }
-
-  let(:valid_messages) { [message, message.dup] }
-  let(:partially_valid_messages) { [message, message.dup, message_with_no_body] }
-  let(:invalid_messages) { [message_with_no_body, message_with_no_body.dup] }
+  let(:message_with_invalid_to) {{:from => "sender@postmarkapp.com", :to => "@postmarkapp.com"}}
+  let(:valid_messages) {[message, message.dup]}
+  let(:partially_valid_messages) {[message, message.dup, message_with_no_body]}
+  let(:invalid_messages) {[message_with_no_body, message_with_no_body.dup]}
 
-  context "message by message" do
-    it 'delivers a plain text message' do
-      api_client.deliver(message).should have_key(:message_id)
+  context "single message" do
+    it 'plain text message' do
+      expect(api_client.deliver(message)).to have_key(:message_id)
     end
 
-    it 'updates a message object with Message-ID' do
-      api_client.deliver(message)[:message_id].
-          should =~ postmark_message_id_format
+    it 'message with attachment' do
+      expect(api_client.deliver(message_with_attachment)).to have_key(:message_id)
     end
 
-    it 'returns full Postmark response' do
-      api_client.deliver(message).should be_a Hash
+    it 'response Message-ID' do
+      expect(api_client.deliver(message)[:message_id]).to be =~ postmark_message_id_format
     end
 
-    it 'delivers a message with attachment' do
-      api_client.deliver(message_with_attachment).
-          should have_key(:message_id)
+    it 'response is Hash' do
+      expect(api_client.deliver(message)).to be_a Hash
     end
 
     it 'fails to deliver a message without body' do
-      expect { api_client.deliver(message_with_no_body) }.
-          to raise_error(Postmark::InvalidMessageError)
+      expect {api_client.deliver(message_with_no_body)}.to raise_error(Postmark::InvalidMessageError)
     end
 
     it 'fails to deliver a message with invalid To address' do
-      expect { api_client.deliver(message_with_invalid_to) }.
-          to raise_error(Postmark::InvalidMessageError)
+      expect {api_client.deliver(message_with_invalid_to)}.to raise_error(Postmark::InvalidMessageError)
     end
   end
 
-  context "in batches" do
-    it 'returns as many responses as many messages were sent' do
-      api_client.deliver_in_batches(valid_messages).count.should == valid_messages.count
+  context "batch message" do
+    it 'response messages count' do
+      expect(api_client.deliver_in_batches(valid_messages).count).to eq valid_messages.count
     end
 
-    context "given custom max_batch_size" do
+    context "custom max_batch_size" do
       before do
         api_client.max_batch_size = 1
       end
 
-      it 'returns as many responses as many messages were sent' do
-        api_client.deliver_in_batches(valid_messages).count.should == valid_messages.count
+      it 'response message count' do
+        expect(api_client.deliver_in_batches(valid_messages).count).to eq valid_messages.count
       end
     end
 
     it 'partially delivers a batch of partially valid Mail::Message objects' do
       response = api_client.deliver_in_batches(partially_valid_messages)
-      expect(response).to satisfy { |r| r.count { |mr| mr[:error_code].to_i.zero? } == 2 }
+      expect(response).to satisfy {|r| r.count {|mr| mr[:error_code].to_i.zero?} == 2}
     end
 
     it "doesn't deliver a batch of invalid Mail::Message objects" do
       response = api_client.deliver_in_batches(invalid_messages)
-
-      expect(response).to satisfy { |r| r.all? { |mr| !!mr[:error_code] } }
+      expect(response).to satisfy {|r| r.all? {|mr| !!mr[:error_code]}}
     end
   end
-
-
-
 end

data/spec/integration/api_client_messages_spec.rb

@@ -2,11 +2,7 @@ require 'spec_helper'
 
 describe "Sending Mail::Messages with Postmark::ApiClient" do
   let(:postmark_message_id_format) { /\w{8}\-\w{4}-\w{4}-\w{4}-\w{12}/ }
-  let(:api_client) {
-    Postmark::ApiClient.new('POSTMARK_API_TEST',
-                            :http_open_timeout => 15,
-                            :http_read_timeout => 15)
-  }
+  let(:api_client) { Postmark::ApiClient.new('POSTMARK_API_TEST', :http_open_timeout => 15, :http_read_timeout => 15) }
 
   let(:message) {
     Mail.new do
@@ -25,11 +21,7 @@ describe "Sending Mail::Messages with Postmark::ApiClient" do
     end
   }
 
-  let(:message_with_attachment) {
-    message.tap do |msg|
-      msg.attachments["test.gif"] = File.read(empty_gif_path)
-    end
-  }
+  let(:message_with_attachment) { message.tap { |msg| msg.attachments["test.gif"] = File.read(empty_gif_path) } }
 
   let(:message_with_invalid_to) {
     Mail.new do
@@ -50,90 +42,79 @@ describe "Sending Mail::Messages with Postmark::ApiClient" do
     end
   end
 
-  context "message by message" do
-    it 'delivers a plain text message' do
-      api_client.deliver_message(message).should have_key(:message_id)
+  context "single message" do
+    it 'plain text message' do
+      expect(api_client.deliver_message(message)).to have_key(:message_id)
     end
 
-    it 'updates a message object with Message-ID' do
-      api_client.deliver_message(message)[:message_id].
-          should =~ postmark_message_id_format
+    it 'message with attachment' do
+      expect(api_client.deliver_message(message_with_attachment)).to have_key(:message_id)
     end
 
-    it 'returns full Postmark response' do
-      api_client.deliver_message(message).should be_a Hash
+    it 'response Message-ID' do
+      expect(api_client.deliver_message(message)[:message_id]).to be =~ postmark_message_id_format
     end
 
-    it 'delivers a message with attachment' do
-      api_client.deliver_message(message_with_attachment).
-          should have_key(:message_id)
+    it 'response is Hash' do
+      expect(api_client.deliver_message(message)).to be_a Hash
     end
 
     it 'fails to deliver a message without body' do
-      expect { api_client.deliver_message(message_with_no_body) }.
-          to raise_error(Postmark::InvalidMessageError)
+      expect { api_client.deliver_message(message_with_no_body) }.to raise_error(Postmark::InvalidMessageError)
     end
 
     it 'fails to deliver a message with invalid To address' do
-      expect { api_client.deliver_message(message_with_invalid_to) }.
-          to raise_error(Postmark::InvalidMessageError)
+      expect { api_client.deliver_message(message_with_invalid_to) }.to raise_error(Postmark::InvalidMessageError)
     end
   end
 
-  context "in batches" do
-    it 'delivers a batch of valid Mail::Message objects' do
+  context "batch message" do
+    it 'response - valid Mail::Message objects' do
       expect { api_client.deliver_messages(valid_messages) }.
-          to change{valid_messages.all? { |m| m.delivered? }}.
-             to true
+          to change{valid_messages.all? { |m| m.delivered? }}.to true
     end
 
-    it 'updates delivered messages with Message-IDs' do
+    it 'response - valid X-PM-Message-Ids' do
       api_client.deliver_messages(valid_messages)
-
-      expect(valid_messages.all? { |m| m.message_id =~ postmark_message_id_format }).
-          to be_true
+      expect(valid_messages.all? { |m| m['X-PM-Message-Id'].to_s =~ postmark_message_id_format }).to be true
     end
 
-    it 'updates delivered messages with related Postmark responses' do
+    it 'response - valid response objects' do
       api_client.deliver_messages(valid_messages)
-
-      expect(valid_messages.all? { |m| m.postmark_response["To"] == m.to[0] }).
-          to be_true
+      expect(valid_messages.all? { |m| m.postmark_response["To"] == m.to[0] }).to be true
     end
 
-    it 'returns as many responses as many messages were sent' do
-      api_client.deliver_messages(valid_messages).count.should == valid_messages.count
+    it 'response - message responses count' do
+      expect(api_client.deliver_messages(valid_messages).count).to eq valid_messages.count
     end
 
-    context "given custom max_batch_size" do
+    context "custom max_batch_size" do
       before do
         api_client.max_batch_size = 1
       end
 
-      it 'updates delivered messages with related Postmark responses' do
+      it 'response - valid response objects' do
         api_client.deliver_messages(valid_messages)
-
-        expect(valid_messages.all? { |m| m.postmark_response["To"] == m.to[0] }).
-            to be_true
+        expect(valid_messages.all? { |m| m.postmark_response["To"] == m.to[0] }).to be true
       end
 
-      it 'returns as many responses as many messages were sent' do
-        api_client.deliver_messages(valid_messages).count.should == valid_messages.count
+      it 'response - message responses count' do
+        expect(api_client.deliver_messages(valid_messages).count).to eq valid_messages.count
       end
     end
 
     it 'partially delivers a batch of partially valid Mail::Message objects' do
       expect { api_client.deliver_messages(partially_valid_messages) }.
-          to change{partially_valid_messages.select { |m| m.delivered? }.count}.
-             to 2
+          to change{partially_valid_messages.select { |m| m.delivered? }.count}.to 2
     end
 
     it "doesn't deliver a batch of invalid Mail::Message objects" do
-      expect { api_client.deliver_messages(invalid_messages) }.
-          to change{invalid_messages.all? { |m| m.delivered? == false }}.
-             to true
+      aggregate_failures do
+        expect { api_client.deliver_messages(invalid_messages) }.
+            to change{invalid_messages.all? { |m| m.delivered? == false }}.to true
 
-      invalid_messages.should satisfy { |ms| ms.all? { |m| !!m.postmark_response }}
+        expect(invalid_messages).to satisfy { |ms| ms.all? { |m| !!m.postmark_response }}
+      end
     end
   end
 end

data/spec/integration/api_client_resources_spec.rb

@@ -1,46 +1,20 @@
 require 'spec_helper'
 
 describe 'Accessing server resources using the API' do
-
-  let(:api_client) {
-    Postmark::ApiClient.new(ENV['POSTMARK_API_KEY'], :http_open_timeout => 15)
-  }
-  let(:recipient) { ENV['POSTMARK_CI_RECIPIENT'] }
+  let(:api_client) {Postmark::ApiClient.new(ENV['POSTMARK_API_KEY'], :http_open_timeout => 15)}
+  let(:recipient) {ENV['POSTMARK_CI_RECIPIENT']}
   let(:message) {
     {
-      :from => "tema+ci@wildbit.com",
-      :to => recipient,
-      :subject => "Mail::Message object",
-      :text_body => "Lorem ipsum dolor sit amet, consectetur adipisicing elit, " \
+        :from => ENV['POSTMARK_CI_SENDER'],
+        :to => recipient,
+        :subject => "Mail::Message object",
+        :text_body => "Lorem ipsum dolor sit amet, consectetur adipisicing elit, " \
                     "sed do eiusmod tempor incididunt ut labore et dolore " \
                     "magna aliqua."
     }
   }
 
-  context 'Triggers API' do
-
-    let(:unique_token) { rand(36**32).to_s(36) }
-
-    it 'can be used to manage tag triggers via the API' do
-      trigger = api_client.create_trigger(:tags,
-                                          :match_name => "gemtest_#{unique_token}",
-                                          :track_opens => true)
-      api_client.update_trigger(:tags,
-                                trigger[:id],
-                                :match_name => "pre_#{trigger[:match_name]}")
-      updated = api_client.get_trigger(:tags, trigger[:id])
-
-      expect(updated[:id]).to eq(trigger[:id])
-      expect(updated[:match_name]).not_to eq(trigger[:id])
-      expect(api_client.triggers(:tags).map { |t| t[:id] }).to include(trigger[:id])
-
-      api_client.delete_trigger(:tags, trigger[:id])
-    end
-
-  end
-
   context 'Messages API' do
-
     def with_retries(max_retries = 20, wait_seconds = 3)
       yield
     rescue => e
@@ -55,17 +29,13 @@ describe 'Accessing server resources using the API' do
 
     it 'is possible to send a message and access its details via the Messages API' do
       response = api_client.deliver(message)
-      message = with_retries {
-        api_client.get_message(response[:message_id])
-      }
+      message = with_retries {api_client.get_message(response[:message_id])}
       expect(message[:recipients]).to include(recipient)
     end
 
     it 'is possible to send a message and dump it via the Messages API' do
       response = api_client.deliver(message)
-      dump = with_retries {
-        api_client.dump_message(response[:message_id])
-      }
+      dump = with_retries {api_client.dump_message(response[:message_id])}
       expect(dump[:body]).to include('Mail::Message object')
     end
 
@@ -74,15 +44,13 @@ describe 'Accessing server resources using the API' do
       expect {
         with_retries {
           messages = api_client.get_messages(:recipient => recipient,
-                                  :fromemail => message[:from],
-                                  :subject => message[:subject])
-          unless messages.map { |m| m[:message_id] }.include?(response[:message_id])
+                                             :fromemail => message[:from],
+                                             :subject => message[:subject])
+          unless messages.map {|m| m[:message_id]}.include?(response[:message_id])
             raise 'Message not found'
           end
         }
       }.not_to raise_error
     end
-
   end
-
-end
+end