postmark 1.8.1 → 1.21.3

data/spec/unit/postmark/bounce_spec.rb

@@ -15,49 +15,46 @@ describe Postmark::Bounce do
                        :subject => "Hello from our app!"} }
   let(:bounce_data_postmark) { Postmark::HashHelper.to_postmark(bounce_data) }
   let(:bounces_data) { [bounce_data, bounce_data, bounce_data] }
-
   let(:bounce) { Postmark::Bounce.new(bounce_data) }
 
   subject { bounce }
 
   context "attr readers" do
-
-    it { should respond_to(:email) }
-    it { should respond_to(:bounced_at) }
-    it { should respond_to(:type) }
-    it { should respond_to(:description) }
-    it { should respond_to(:details) }
-    it { should respond_to(:name) }
-    it { should respond_to(:id) }
-    it { should respond_to(:server_id) }
-    it { should respond_to(:tag) }
-    it { should respond_to(:message_id) }
-    it { should respond_to(:subject) }
-
+    it { expect(subject).to respond_to(:email) }
+    it { expect(subject).to respond_to(:bounced_at) }
+    it { expect(subject).to respond_to(:type) }
+    it { expect(subject).to respond_to(:description) }
+    it { expect(subject).to respond_to(:details) }
+    it { expect(subject).to respond_to(:name) }
+    it { expect(subject).to respond_to(:id) }
+    it { expect(subject).to respond_to(:server_id) }
+    it { expect(subject).to respond_to(:tag) }
+    it { expect(subject).to respond_to(:message_id) }
+    it { expect(subject).to respond_to(:subject) }
   end
 
   context "given a bounce created from bounce_data" do
 
     it 'is not inactive' do
-      should_not be_inactive
+      expect(subject).not_to be_inactive
     end
 
     it 'allows to activate the bounce' do
-      subject.can_activate?.should be_true
+      expect(subject.can_activate?).to be true
     end
 
     it 'has an available dump' do
-      subject.dump_available?.should be_true
+      expect(subject.dump_available?).to be true
     end
 
-    its(:type) { should eq bounce_data[:type] }
-    its(:message_id) { should eq bounce_data[:message_id] }
-    its(:description) { should eq bounce_data[:description] }
-    its(:details) { should eq bounce_data[:details] }
-    its(:email) { should eq bounce_data[:email] }
-    its(:bounced_at) { should == Time.parse(bounce_data[:bounced_at]) }
-    its(:id) { should eq bounce_data[:id] }
-    its(:subject) { should eq bounce_data[:subject] }
+    its(:type) { is_expected.to eq bounce_data[:type] }
+    its(:message_id) { is_expected.to eq bounce_data[:message_id] }
+    its(:description) { is_expected.to eq bounce_data[:description] }
+    its(:details) { is_expected.to eq bounce_data[:details] }
+    its(:email) { is_expected.to eq bounce_data[:email] }
+    its(:bounced_at) { is_expected.to eq Time.parse(bounce_data[:bounced_at]) }
+    its(:id) { is_expected.to eq bounce_data[:id] }
+    its(:subject) { is_expected.to eq bounce_data[:subject] }
 
   end
 
@@ -65,81 +62,62 @@ describe Postmark::Bounce do
     subject { Postmark::Bounce.new(bounce_data_postmark) }
 
     it 'is not inactive' do
-      should_not be_inactive
+      expect(subject).not_to be_inactive
     end
 
     it 'allows to activate the bounce' do
-      subject.can_activate?.should be_true
+      expect(subject.can_activate?).to be true
     end
 
     it 'has an available dump' do
-      subject.dump_available?.should be_true
+      expect(subject.dump_available?).to be true
     end
 
-    its(:type) { should eq bounce_data[:type] }
-    its(:message_id) { should eq bounce_data[:message_id] }
-    its(:details) { should eq bounce_data[:details] }
-    its(:email) { should eq bounce_data[:email] }
-    its(:bounced_at) { should == Time.parse(bounce_data[:bounced_at]) }
-    its(:id) { should eq bounce_data[:id] }
-    its(:subject) { should eq bounce_data[:subject] }
-
+    its(:type) { is_expected.to eq bounce_data[:type] }
+    its(:message_id) { is_expected.to eq bounce_data[:message_id] }
+    its(:details) { is_expected.to eq bounce_data[:details] }
+    its(:email) { is_expected.to eq bounce_data[:email] }
+    its(:bounced_at) { is_expected.to eq Time.parse(bounce_data[:bounced_at]) }
+    its(:id) { is_expected.to eq bounce_data[:id] }
+    its(:subject) { is_expected.to eq bounce_data[:subject] }
   end
 
   describe "#dump" do
-
     let(:bounce_body) { double }
     let(:response) { {:body => bounce_body} }
     let(:api_client) { Postmark.api_client }
 
     it "calls #dump_bounce on shared api_client instance" do
-      Postmark.api_client.should_receive(:dump_bounce).with(bounce.id) { response }
-      bounce.dump.should == bounce_body
+      expect(Postmark.api_client).to receive(:dump_bounce).with(bounce.id) { response }
+      expect(bounce.dump).to eq bounce_body
     end
-
   end
 
   describe "#activate" do
-
     let(:api_client) { Postmark.api_client }
 
     it "calls #activate_bounce on shared api_client instance" do
-      api_client.should_receive(:activate_bounce).with(bounce.id) { bounce_data }
-      bounce.activate.should be_a Postmark::Bounce
+      expect(api_client).to receive(:activate_bounce).with(bounce.id) { bounce_data }
+      expect(bounce.activate).to be_a Postmark::Bounce
     end
-
   end
 
   describe ".find" do
     let(:api_client) { Postmark.api_client }
 
     it "calls #get_bounce on shared api_client instance" do
-      api_client.should_receive(:get_bounce).with(42) { bounce_data }
-      Postmark::Bounce.find(42).should be_a Postmark::Bounce
+      expect(api_client).to receive(:get_bounce).with(42) { bounce_data }
+      expect(Postmark::Bounce.find(42)).to be_a Postmark::Bounce
     end
   end
 
   describe ".all" do
-
     let(:response) { bounces_data }
     let(:api_client) { Postmark.api_client }
 
     it "calls #get_bounces on shared api_client instance" do
-      api_client.should_receive(:get_bounces) { response }
-      Postmark::Bounce.all.should have(3).bounces
-    end
-
-  end
-
-  describe ".tags" do
-
-    let(:api_client) { Postmark.api_client }
-    let(:tags) { ["tag1", "tag2"] }
-
-    it "calls #get_bounced_tags on shared api_client instance" do
-      api_client.should_receive(:get_bounced_tags) { tags }
-      Postmark::Bounce.tags.should == tags
+      expect(api_client).to receive(:get_bounces) { response }
+      expect(Postmark::Bounce.all.count).to eq(3)
     end
   end
-
 end

data/spec/unit/postmark/client_spec.rb

@@ -1,13 +1,10 @@
 require 'spec_helper'
 
 describe Postmark::Client do
-
   subject { Postmark::Client.new('abcd-efgh') }
 
   describe 'instance' do
-
     describe '#find_each' do
-
       let(:path) { 'resources' }
       let(:name) { 'Resources' }
       let(:response) {
@@ -44,9 +41,6 @@ describe Postmark::Client do
             to receive(:get).exactly(5).times.and_return(response)
         expect(subject.find_each(path, name, :count => 2).count).to eq(10)
       end
-
     end
-
   end
-
 end

data/spec/unit/postmark/error_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe(Postmark::Error) do
+  it {is_expected.to be_a(StandardError)}
+end
+
+describe(Postmark::HttpClientError) do
+  it {is_expected.to be_a(Postmark::Error)}
+  it {expect(subject.retry?).to be true}
+end
+
+describe(Postmark::HttpServerError) do
+  it {is_expected.to be_a(Postmark::Error)}
+
+  describe '.build' do
+    context 'picks an appropriate subclass for code' do
+      subject {Postmark::HttpServerError.build(code, Postmark::Json.encode({}))}
+
+      context '401' do
+        let(:code) {'401'}
+
+        it {is_expected.to be_a(Postmark::InvalidApiKeyError)}
+        its(:status_code) {is_expected.to eq 401}
+      end
+
+      context '422' do
+        let(:code) {'422'}
+
+        it {is_expected.to be_a(Postmark::ApiInputError)}
+        its(:status_code) {is_expected.to eq 422}
+      end
+
+      context '500' do
+        let(:code) {'500'}
+
+        it {is_expected.to be_a(Postmark::InternalServerError)}
+        its(:status_code) {is_expected.to eq 500}
+      end
+
+      context 'others' do
+        let(:code) {'999'}
+
+        it {is_expected.to be_a(Postmark::UnexpectedHttpResponseError)}
+        its(:status_code) {is_expected.to eq code.to_i}
+      end
+    end
+  end
+
+  describe '#retry?' do
+    it 'is true for 5XX status codes' do
+      (500...600).each do |code|
+        expect(Postmark::HttpServerError.new(code).retry?).to be true
+      end
+    end
+
+    it 'is false for other codes except 5XX' do
+      [200, 300, 400].each do |code|
+        expect(Postmark::HttpServerError.new(code).retry?).to be false
+      end
+    end
+  end
+
+  describe '#message ' do
+    it 'uses "Message" field on postmark response if available' do
+      data = {'Message' => 'Postmark error message'}
+      error = Postmark::HttpServerError.new(502, Postmark::Json.encode(data), data)
+      expect(error.message).to eq data['Message']
+    end
+
+    it 'falls back to a message generated from status code' do
+      error = Postmark::HttpServerError.new(502, '<html>')
+      expect(error.message).to match(/The Postmark API responded with HTTP status \d+/)
+    end
+  end
+end
+
+describe(Postmark::ApiInputError) do
+  describe '.build' do
+    context 'picks an appropriate subclass for error code' do
+      let(:response) {{'ErrorCode' => code}}
+
+      subject do
+        Postmark::ApiInputError.build(Postmark::Json.encode(response), response)
+      end
+
+      shared_examples_for 'api input error' do
+        its(:status_code) {is_expected.to eq 422}
+        it {expect(subject.retry?).to be false}
+        it {is_expected.to be_a(Postmark::ApiInputError)}
+        it {is_expected.to be_a(Postmark::HttpServerError)}
+      end
+
+      context '406' do
+        let(:code) {Postmark::ApiInputError::INACTIVE_RECIPIENT}
+
+        it {is_expected.to be_a(Postmark::InactiveRecipientError)}
+        it_behaves_like 'api input error'
+      end
+
+      context 'others' do
+        let(:code) {'9999'}
+
+        it_behaves_like 'api input error'
+      end
+    end
+  end
+end
+
+describe Postmark::InvalidTemplateError do
+  subject(:error) {Postmark::InvalidTemplateError.new(:foo => 'bar')}
+
+  it 'is created with a response' do
+    expect(error.message).to start_with('Failed to render the template.')
+    expect(error.postmark_response).to eq(:foo => 'bar')
+  end
+end
+
+describe(Postmark::TimeoutError) do
+  it {is_expected.to be_a(Postmark::Error)}
+  it {expect(subject.retry?).to be true}
+end
+
+describe(Postmark::UnknownMessageType) do
+  it 'exists for backward compatibility' do
+    is_expected.to be_a(Postmark::Error)
+  end
+end
+
+describe(Postmark::InvalidApiKeyError) do
+  it {is_expected.to be_a(Postmark::Error)}
+end
+
+describe(Postmark::InternalServerError) do
+  it {is_expected.to be_a(Postmark::Error)}
+end
+
+describe(Postmark::UnexpectedHttpResponseError) do
+  it {is_expected.to be_a(Postmark::Error)}
+end
+
+describe(Postmark::MailAdapterError) do
+  it {is_expected.to be_a(Postmark::Error)}
+end
+
+describe(Postmark::InactiveRecipientError) do
+  describe '.parse_recipients' do
+    let(:recipients) do
+      %w(nothing@wildbit.com noth.ing+2@wildbit.com noth.ing+2-1@wildbit.com)
+    end
+
+    subject {Postmark::InactiveRecipientError.parse_recipients(message)}
+
+    context '1/1 inactive' do
+      let(:message) do
+        'You tried to send to a recipient that has been marked as ' \
+        "inactive.\nFound inactive addresses: #{recipients[0]}.\n" \
+        'Inactive recipients are ones that have generated a hard ' \
+        'bounce or a spam complaint.'
+      end
+
+      it {is_expected.to eq(recipients.take(1))}
+    end
+
+    context 'i/n inactive, n > 1, i < n' do
+      let(:message) do
+        'Message OK, but will not deliver to these inactive addresses: ' \
+        "#{recipients[0...2].join(', ')}. Inactive recipients are ones that " \
+        'have generated a hard bounce or a spam complaint.'
+      end
+
+      it {is_expected.to eq(recipients.take(2))}
+    end
+
+    context 'n/n inactive, n > 1' do
+      let(:message) do
+        'You tried to send to recipients that have all been marked as ' \
+        "inactive.\nFound inactive addresses: #{recipients.join(', ')}.\n" \
+        'Inactive recipients are ones that have generated a hard bounce or a spam complaint.'
+      end
+
+      it {is_expected.to eq(recipients)}
+    end
+
+    context 'unknown error format' do
+      let(:message) {recipients.join(', ')}
+
+      it {is_expected.to eq([])}
+    end
+  end
+
+  describe '.new' do
+    let(:address) {'user@example.org'}
+    let(:response) {{'Message' => message}}
+
+    subject do
+      Postmark::InactiveRecipientError.new(
+          Postmark::ApiInputError::INACTIVE_RECIPIENT,
+          Postmark::Json.encode(response),
+          response)
+    end
+
+    let(:message) do
+      'You tried to send to a recipient that has been marked as ' \
+      "inactive.\nFound inactive addresses: #{address}.\n" \
+      'Inactive recipients are ones that have generated a hard ' \
+      'bounce or a spam complaint.'
+    end
+
+    it 'parses recipients from json payload' do
+      expect(subject.recipients).to eq([address])
+    end
+  end
+end
+
+describe(Postmark::DeliveryError) do
+  it 'is an alias to Error for backwards compatibility' do
+    expect(subject.class).to eq(Postmark::Error)
+  end
+end
+
+describe(Postmark::InvalidMessageError) do
+  it 'is an alias to Error for backwards compatibility' do
+    expect(subject.class).to eq(Postmark::ApiInputError)
+  end
+end
+
+describe(Postmark::UnknownError) do
+  it 'is an alias for backwards compatibility' do
+    expect(subject.class).to eq(Postmark::UnexpectedHttpResponseError)
+  end
+end

data/spec/unit/postmark/handlers/mail_spec.rb

@@ -10,42 +10,74 @@ describe Mail::Postmark do
     end
   end
 
-  it "can be set as delivery_method" do
+  before do
     message.delivery_method Mail::Postmark
   end
 
-  it "wraps Postmark.send_through_postmark" do
-    Postmark::ApiClient.any_instance.should_receive(:deliver_message).with(message)
-    message.delivery_method Mail::Postmark
-    message.deliver
-  end
+  subject(:handler) { message.delivery_method }
 
-  it "returns self by default" do
-    Postmark::ApiClient.any_instance.should_receive(:deliver_message).with(message)
+  it "can be set as delivery_method" do
     message.delivery_method Mail::Postmark
-    message.deliver.should eq message
-  end
 
-  it "returns the actual response if :return_response setting is present" do
-    Postmark::ApiClient.any_instance.should_receive(:deliver_message).with(message)
-    message.delivery_method Mail::Postmark, :return_response => true
-    message.deliver.should eq message
+    is_expected.to be_a(Mail::Postmark)
   end
 
-  it "allows setting the api token" do
-    message.delivery_method Mail::Postmark, :api_token => 'api-token'
-    message.delivery_method.settings[:api_token].should == 'api-token'
-  end
+  describe '#deliver!' do
+    it "returns self by default" do
+      expect_any_instance_of(Postmark::ApiClient).to receive(:deliver_message).with(message)
+      expect(message.deliver).to eq message
+    end
+
+    it "returns the actual response if :return_response setting is present" do
+      expect_any_instance_of(Postmark::ApiClient).to receive(:deliver_message).with(message)
+      message.delivery_method Mail::Postmark, :return_response => true
+      expect(message.deliver).to eq message
+    end
+
+    it "allows setting the api token" do
+      message.delivery_method Mail::Postmark, :api_token => 'api-token'
+      expect(message.delivery_method.settings[:api_token]).to eq 'api-token'
+    end
+
+    it 'uses provided API token' do
+      message.delivery_method Mail::Postmark, :api_token => 'api-token'
+      expect(Postmark::ApiClient).to receive(:new).with('api-token', {}).and_return(double(:deliver_message => true))
+      message.deliver
+    end
+
+    it 'uses API token provided as legacy api_key' do
+      message.delivery_method Mail::Postmark, :api_key => 'api-token'
+      expect(Postmark::ApiClient).to receive(:new).with('api-token', {}).and_return(double(:deliver_message => true))
+      message.deliver
+    end
 
-  it 'uses provided API token' do
-    message.delivery_method Mail::Postmark, :api_token => 'api-token'
-    Postmark::ApiClient.should_receive(:new).with('api-token', {}).and_return(double(:deliver_message => true))
-    message.deliver
+    context 'when sending a pre-rendered message' do
+      it "uses ApiClient#deliver_message to send the message" do
+        expect_any_instance_of(Postmark::ApiClient).to receive(:deliver_message).with(message)
+        message.deliver
+      end
+    end
+
+    context 'when sending a Postmark template' do
+      let(:message) do
+        Mail.new do
+          from            "sheldon@bigbangtheory.com"
+          to              "lenard@bigbangtheory.com"
+          template_alias  "hello"
+          template_model  :name => "Sheldon"
+        end
+      end
+
+      it 'uses ApiClient#deliver_message_with_template to send the message' do
+        expect_any_instance_of(Postmark::ApiClient).to receive(:deliver_message_with_template).with(message)
+        message.deliver
+      end
+    end
   end
 
-  it 'uses API token provided as legacy api_key' do
-    message.delivery_method Mail::Postmark, :api_key => 'api-token'
-    Postmark::ApiClient.should_receive(:new).with('api-token', {}).and_return(double(:deliver_message => true))
-    message.deliver
+  describe '#api_client' do
+    subject { handler.api_client }
+
+    it { is_expected.to be_a(Postmark::ApiClient) }
   end
-end
+end