postmark 0.9.19 → 1.0.0

data/spec/integration/api_client_hashes_spec.rb

@@ -0,0 +1,101 @@
+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') }
+
+  let(:message) {
+    {
+      :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."
+    }
+  }
+
+  let(:message_with_no_body) {
+    {
+      :from => "sender@postmarkapp.com",
+      :to => "recipient@postmarkapp.com",
+    }
+  }
+
+  let(:message_with_attachment) {
+    message.tap do |m|
+      m[:attachments] = [File.open(empty_gif_path)]
+    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] }
+
+  context "message by message" do
+    it 'delivers a plain text message' do
+      api_client.deliver(message).should 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
+    end
+
+    it 'returns full Postmark response' do
+      api_client.deliver(message).should be_a Hash
+    end
+
+    it 'delivers a message with attachment' do
+      api_client.deliver(message_with_attachment).
+          should have_key(:message_id)
+    end
+
+    it 'fails to deliver a message without body' do
+      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)
+    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
+    end
+
+    context "given 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
+      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 }
+    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] } }
+    end
+  end
+
+
+
+end

data/spec/integration/api_client_messages_spec.rb

@@ -0,0 +1,127 @@
+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') }
+
+  let(:message) {
+    Mail.new do
+      from "sender@postmarkapp.com"
+      to "recipient@postmarkapp.com"
+      subject "Mail::Message object"
+      body "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do "
+           "eiusmod tempor incididunt ut labore et dolore magna aliqua."
+    end
+  }
+
+  let(:message_with_no_body) {
+    Mail.new do
+      from "sender@postmarkapp.com"
+      to "recipient@postmarkapp.com"
+    end
+  }
+
+  let(:message_with_attachment) {
+    message.tap do |msg|
+      msg.attachments["test.gif"] = File.read(empty_gif_path)
+    end
+  }
+
+  let(:message_with_invalid_to) {
+    Mail.new do
+      from "sender@postmarkapp.com"
+      to "@postmarkapp.com"
+    end
+  }
+
+  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(message).should 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
+    end
+
+    it 'returns full Postmark response' do
+      api_client.deliver_message(message).should be_a Hash
+    end
+
+    it 'delivers a message with attachment' do
+      api_client.deliver_message(message_with_attachment).
+          should have_key(:message_id)
+    end
+
+    it 'fails to deliver a message without body' do
+      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)
+    end
+  end
+
+  context "in batches" do
+    it 'delivers a batch of valid Mail::Message objects' do
+      expect { api_client.deliver_messages(valid_messages) }.
+          to change{valid_messages.all? { |m| m.delivered? }}.
+             to true
+    end
+
+    it 'updates delivered messages with Message-IDs' do
+      api_client.deliver_messages(valid_messages)
+
+      expect(valid_messages.all? { |m| m.message_id =~ postmark_message_id_format }).
+          to be_true
+    end
+
+    it 'updates delivered messages with related Postmark responses' do
+      api_client.deliver_messages(valid_messages)
+
+      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
+    end
+
+    context "given custom max_batch_size" do
+      before do
+        api_client.max_batch_size = 1
+      end
+
+      it 'updates delivered messages with related Postmark responses' do
+        api_client.deliver_messages(valid_messages)
+
+        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
+      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
+    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
+
+      invalid_messages.should satisfy { |ms| ms.all? { |m| !!m.postmark_response }}
+    end
+  end
+end

data/spec/integration/mail_delivery_method_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe "Sending Mail::Messages with delivery_method Mail::Postmark" do
+  let(:postmark_message_id_format) { /\w{8}\-\w{4}-\w{4}-\w{4}-\w{12}/ }
+
+  let(:message) {
+    Mail.new do
+      from "sender@postmarkapp.com"
+      to "recipient@postmarkapp.com"
+      subject "Mail::Message object"
+      body "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do "
+           "eiusmod tempor incididunt ut labore et dolore magna aliqua."
+      delivery_method Mail::Postmark, :api_key => "POSTMARK_API_TEST"
+    end
+  }
+
+  let(:tagged_message) {
+    message.tap do |m|
+      m.tag "postmark-gem"
+    end
+  }
+
+  let(:message_with_no_body) {
+    Mail.new do
+      from "sender@postmarkapp.com"
+      to "recipient@postmarkapp.com"
+      delivery_method Mail::Postmark, :api_key => "POSTMARK_API_TEST"
+    end
+  }
+
+  let(:message_with_attachment) {
+    message.tap do |msg|
+      msg.attachments["test.gif"] = File.read(File.join(File.dirname(__FILE__), '..', 'data', 'empty.gif'))
+    end
+  }
+
+  let(:message_with_invalid_to) {
+    Mail.new do
+      from "sender@postmarkapp.com"
+      to "@postmarkapp.com"
+      delivery_method Mail::Postmark, :api_key => "POSTMARK_API_TEST"
+    end
+  }
+
+  it 'delivers a plain text message' do
+    expect { message.deliver }.to change{message.delivered?}.to(true)
+  end
+
+  it 'updates a message object with Message-ID' do
+    expect { message.deliver }.
+        to change{message['Message-ID'].to_s}.to(postmark_message_id_format)
+  end
+
+  it 'updates a message object with full postmark response' do
+    expect { message.deliver }.
+        to change{message.postmark_response}.from(nil)
+  end
+
+  it 'delivers a tagged message' do
+    expect { tagged_message.deliver }.
+        to change{message.delivered?}.to(true)
+  end
+
+  it 'delivers a message with attachment' do
+    expect { message_with_attachment.deliver }.
+        to change{message_with_attachment.delivered?}.to(true)
+  end
+
+  it 'fails to deliver a message without body' do
+    expect { message_with_no_body.deliver! }.
+        to raise_error(Postmark::InvalidMessageError)
+    message_with_no_body.should_not be_delivered
+  end
+
+  it 'fails to deliver a message with invalid To address' do
+    expect { message_with_invalid_to.deliver! }.
+        to raise_error(Postmark::InvalidMessageError)
+    message_with_invalid_to.should_not be_delivered
+  end
+end

data/spec/spec_helper.rb

@@ -4,16 +4,15 @@ require 'rubygems'
 require 'bundler'
 Bundler.setup(:development)
 require 'mail'
-#require 'tmail'
 require 'postmark'
 require 'active_support'
 require 'json'
 require 'fakeweb'
 require 'fakeweb_matcher'
-require 'timecop'
 require 'rspec'
 require 'rspec/autorun'
-require File.join(File.expand_path(File.dirname(__FILE__)), 'shared_examples.rb')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'support', 'shared_examples.rb')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'support', 'helpers.rb')
 
 if ENV['JSONGEM']
   # `JSONGEM=Yajl rake spec`
@@ -22,9 +21,20 @@ if ENV['JSONGEM']
 end
 
 RSpec.configure do |config|
-	config.filter_run_excluding :ruby => lambda { |version|
-    RUBY_VERSION.to_s !~ /^#{version.to_s}/
+  include Postmark::RSpecHelpers
+
+	config.filter_run_excluding :skip_for_platform => lambda { |platform|
+    RUBY_PLATFORM.to_s =~ /^#{platform.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
+       http_read_timeout max_retries).each do |var|
+      Postmark.instance_variable_set(:"@#{var}", nil)
+    end
+    Postmark.response_parser_class = nil
+  end
 end
 
 RSpec::Matchers.define :be_serialized_to do |json|

data/spec/support/helpers.rb

@@ -0,0 +1,11 @@
+module Postmark
+  module RSpecHelpers
+    def empty_gif_path
+      File.join(File.dirname(__FILE__), '..', 'data', 'empty.gif')
+    end
+
+    def encoded_empty_gif_data
+      Postmark::MessageHelper.encode_in_base64(File.read(empty_gif_path))
+    end
+  end
+end

data/spec/unit/postmark/api_client_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+describe Postmark::ApiClient do
+
+  let(:api_key) { "provided-api-key" }
+  let(:max_retries) { 42 }
+  let(:message_hash) {
+    {
+      :from => "support@postmarkapp.com"
+    }
+  }
+  let(:message) {
+    Mail.new do
+      from "support@postmarkapp.com"
+      delivery_method Mail::Postmark
+    end
+  }
+
+  let(:api_client) { Postmark::ApiClient.new(api_key) }
+  subject { api_client }
+
+  context "attr readers" do
+    it { should respond_to(:http_client) }
+    it { should respond_to(:max_retries) }
+  end
+
+  context "when it's created without options" do
+
+    its(:max_retries) { should eq 3 }
+
+  end
+
+  context "when it's created with user options" do
+
+    subject { Postmark::ApiClient.new(api_key, :max_retries => max_retries,
+                                               :foo => :bar)}
+
+    its(:max_retries) { should eq max_retries }
+
+    it 'passes other options to HttpClient instance' do
+      Postmark::HttpClient.should_receive(:new).with(api_key, :foo => :bar)
+      subject.should be
+    end
+
+  end
+
+  describe "#api_key=" do
+
+    let(:api_key) { "new-api-key-value" }
+
+    it 'assigns the api key to the http client instance' do
+      subject.api_key = api_key
+      subject.http_client.api_key.should == api_key
+    end
+
+  end
+
+  describe "#deliver" do
+    let(:email) { Postmark::MessageHelper.to_postmark(message_hash) }
+    let(:email_json) { Postmark::Json.encode(email) }
+    let(:http_client) { subject.http_client }
+    let(:response) { {"MessageID" => 42} }
+
+    it 'converts message hash to Postmark format and posts it to /email' do
+      http_client.should_receive(:post).with('email', email_json) { response }
+      subject.deliver(message_hash)
+    end
+
+    it 'retries 3 times' do
+      2.times do
+        http_client.should_receive(:post).and_raise(Postmark::InternalServerError)
+      end
+      http_client.should_receive(:post) { response }
+      expect { subject.deliver(message_hash) }.not_to raise_error
+    end
+
+    it 'converts response to ruby format' do
+      http_client.should_receive(:post).with('email', email_json) { response }
+      r = subject.deliver(message_hash)
+      r.should have_key(:message_id)
+    end
+  end
+
+  describe "#deliver_in_batches" do
+    let(:email) { Postmark::MessageHelper.to_postmark(message_hash) }
+    let(:emails) { [email, email, email] }
+    let(:emails_json) { Postmark::Json.encode(emails) }
+    let(:http_client) { subject.http_client }
+    let(:response) { [{'ErrorCode' => 0}, {'ErrorCode' => 0}, {'ErrorCode' => 0}] }
+
+    it 'turns array of messages into a JSON document and posts it to /email/batch' do
+      http_client.should_receive(:post).with('email/batch', emails_json) { response }
+      subject.deliver_in_batches([message_hash, message_hash, message_hash])
+    end
+
+    it 'converts response to ruby format' do
+      http_client.should_receive(:post).with('email/batch', emails_json) { response }
+      response = subject.deliver_in_batches([message_hash, message_hash, message_hash])
+      response.first.should have_key(:error_code)
+    end
+  end
+
+  describe "#deliver_message" do
+    let(:email) { message.to_postmark_hash }
+    let(:email_json) { JSON.dump(email) }
+    let(:http_client) { subject.http_client }
+
+    it 'turns message into a JSON document and posts it to /email' do
+      http_client.should_receive(:post).with('email', email_json)
+      subject.deliver_message(message)
+    end
+
+    it "should retry 3 times" do
+      2.times do
+        http_client.should_receive(:post).and_raise(Postmark::InternalServerError)
+      end
+      http_client.should_receive(:post)
+      expect { subject.deliver_message(message) }.not_to raise_error
+    end
+
+    it "should retry on timeout" do
+      http_client.should_receive(:post).and_raise(Postmark::TimeoutError)
+      http_client.should_receive(:post)
+      expect { subject.deliver_message(message) }.not_to raise_error
+    end
+
+  end
+
+  describe "#deliver_messages" do
+
+    let(:email) { message.to_postmark_hash }
+    let(:emails) { [email, email, email] }
+    let(:emails_json) { JSON.dump(emails) }
+    let(:http_client) { subject.http_client }
+    let(:response) { [{}, {}, {}] }
+
+    it 'turns array of messages into a JSON document and posts it to /email/batch' do
+      http_client.should_receive(:post).with('email/batch', emails_json) { response }
+      subject.deliver_messages([message, message, message])
+    end
+
+    it "should retry 3 times" do
+      2.times do
+        http_client.should_receive(:post).and_raise(Postmark::InternalServerError)
+      end
+      http_client.should_receive(:post) { response }
+      expect { subject.deliver_messages([message, message, message]) }.not_to raise_error
+    end
+
+    it "should retry on timeout" do
+      http_client.should_receive(:post).and_raise(Postmark::TimeoutError)
+      http_client.should_receive(:post) { response }
+      expect { subject.deliver_messages([message, message, message]) }.not_to raise_error
+    end
+
+  end
+
+  describe "#delivery_stats" do
+    let(:http_client) { subject.http_client }
+    let(:response) { {"Bounces" => [{"Foo" => "Bar"}]} }
+
+    it 'requests data at /deliverystats' do
+      http_client.should_receive(:get).with("deliverystats") { response }
+      subject.delivery_stats.should have_key(:bounces)
+    end
+  end
+
+  describe "#get_bounces" do
+    let(:http_client) { subject.http_client }
+    let(:options) { {:foo => :bar} }
+    let(:response) { {"Bounces" => []} }
+
+    it 'requests data at /bounces' do
+      http_client.should_receive(:get).with("bounces", options) { response }
+      subject.get_bounces(options).should be_an Array
+    end
+  end
+
+  describe "#get_bounced_tags" do
+    let(:http_client) { subject.http_client }
+
+    it 'requests data at /bounces/tags' do
+      http_client.should_receive(:get).with("bounces/tags")
+      subject.get_bounced_tags
+    end
+  end
+
+  describe "#get_bounce" do
+    let(:http_client) { subject.http_client }
+    let(:id) { 42 }
+
+    it 'requests a single bounce by ID at /bounces/:id' do
+      http_client.should_receive(:get).with("bounces/#{id}")
+      subject.get_bounce(id)
+    end
+  end
+
+  describe "#dump_bounce" do
+    let(:http_client) { subject.http_client }
+    let(:id) { 42 }
+
+    it 'requests a specific bounce data at /bounces/:id/dump' do
+      http_client.should_receive(:get).with("bounces/#{id}/dump")
+      subject.dump_bounce(id)
+    end
+  end
+
+  describe "#activate_bounce" do
+    let(:http_client) { subject.http_client }
+    let(:id) { 42 }
+    let(:response) { {"Bounce" => {}} }
+
+    it 'activates a specific bounce by sending a PUT request to /bounces/:id/activate' do
+      http_client.should_receive(:put).with("bounces/#{id}/activate") { response }
+      subject.activate_bounce(id)
+    end
+  end
+
+  describe "#server_info" do
+    let(:http_client) { subject.http_client }
+    let(:response) { {"Name" => "Testing",
+                      "Color" => "blue",
+                      "InboundHash" => "c2425d77f74f8643e5f6237438086c81",
+                      "SmtpApiActivated" => true} }
+
+    it 'requests server info from Postmark and converts it to ruby format' do
+      http_client.should_receive(:get).with('server') { response }
+      subject.server_info.should have_key(:inbound_hash)
+    end
+  end
+
+  describe "#update_server_info" do
+    let(:http_client) { subject.http_client }
+    let(:response) { {"Name" => "Testing",
+                      "Color" => "blue",
+                      "InboundHash" => "c2425d77f74f8643e5f6237438086c81",
+                      "SmtpApiActivated" => false} }
+    let(:update) { {:smtp_api_activated => false} }
+
+    it 'updates server info in Postmark and converts it to ruby format' do
+      http_client.should_receive(:post).with('server', anything) { response }
+      subject.update_server_info(update)[:smtp_api_activated].should be_false
+    end
+  end
+
+end