postmark 1.18.0 → 1.19.0

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

@@ -1,47 +1,47 @@
 require 'spec_helper'
 
 describe(Postmark::Error) do
-  it { is_expected.to be_a(StandardError) }
+  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 }
+  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) }
+  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({})) }
+      subject {Postmark::HttpServerError.build(code, Postmark::Json.encode({}))}
 
       context '401' do
-        let(:code) { '401' }
+        let(:code) {'401'}
 
-        it { is_expected.to be_a(Postmark::InvalidApiKeyError) }
-        its(:status_code) { is_expected.to eq 401 }
+        it {is_expected.to be_a(Postmark::InvalidApiKeyError)}
+        its(:status_code) {is_expected.to eq 401}
       end
 
       context '422' do
-        let(:code) { '422' }
+        let(:code) {'422'}
 
-        it { is_expected.to be_a(Postmark::ApiInputError) }
-        its(:status_code) { is_expected.to eq 422 }
+        it {is_expected.to be_a(Postmark::ApiInputError)}
+        its(:status_code) {is_expected.to eq 422}
       end
 
       context '500' do
-        let(:code) { '500' }
+        let(:code) {'500'}
 
-        it { is_expected.to be_a(Postmark::InternalServerError) }
-        its(:status_code) { is_expected.to eq 500 }
+        it {is_expected.to be_a(Postmark::InternalServerError)}
+        its(:status_code) {is_expected.to eq 500}
       end
 
       context 'others' do
-        let(:code) { '999' }
+        let(:code) {'999'}
 
-        it { is_expected.to be_a(Postmark::UnexpectedHttpResponseError) }
-        its(:status_code) { is_expected.to eq code.to_i }
+        it {is_expected.to be_a(Postmark::UnexpectedHttpResponseError)}
+        its(:status_code) {is_expected.to eq code.to_i}
       end
     end
   end
@@ -62,7 +62,7 @@ describe(Postmark::HttpServerError) do
 
   describe '#message ' do
     it 'uses "Message" field on postmark response if available' do
-      data = { 'Message' => 'Postmark error message' }
+      data = {'Message' => 'Postmark error message'}
       error = Postmark::HttpServerError.new(502, Postmark::Json.encode(data), data)
       expect(error.message).to eq data['Message']
     end
@@ -77,28 +77,28 @@ end
 describe(Postmark::ApiInputError) do
   describe '.build' do
     context 'picks an appropriate subclass for error code' do
-      let(:response) { { 'ErrorCode' => code } }
+      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) }
+        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 }
+        let(:code) {Postmark::ApiInputError::INACTIVE_RECIPIENT}
 
-        it { is_expected.to be_a(Postmark::InactiveRecipientError) }
+        it {is_expected.to be_a(Postmark::InactiveRecipientError)}
         it_behaves_like 'api input error'
       end
 
       context 'others' do
-        let(:code) { '9999' }
+        let(:code) {'9999'}
 
         it_behaves_like 'api input error'
       end
@@ -107,7 +107,7 @@ describe(Postmark::ApiInputError) do
 end
 
 describe Postmark::InvalidTemplateError do
-  subject(:error) { Postmark::InvalidTemplateError.new(:foo => 'bar') }
+  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.')
@@ -116,8 +116,8 @@ describe Postmark::InvalidTemplateError do
 end
 
 describe(Postmark::TimeoutError) do
-  it { is_expected.to be_a(Postmark::Error) }
-  it { expect(subject.retry?).to be true }
+  it {is_expected.to be_a(Postmark::Error)}
+  it {expect(subject.retry?).to be true}
 end
 
 describe(Postmark::UnknownMessageType) do
@@ -127,19 +127,19 @@ describe(Postmark::UnknownMessageType) do
 end
 
 describe(Postmark::InvalidApiKeyError) do
-  it { is_expected.to be_a(Postmark::Error) }
+  it {is_expected.to be_a(Postmark::Error)}
 end
 
 describe(Postmark::InternalServerError) do
-  it { is_expected.to be_a(Postmark::Error) }
+  it {is_expected.to be_a(Postmark::Error)}
 end
 
 describe(Postmark::UnexpectedHttpResponseError) do
-  it { is_expected.to be_a(Postmark::Error) }
+  it {is_expected.to be_a(Postmark::Error)}
 end
 
 describe(Postmark::MailAdapterError) do
-  it { is_expected.to be_a(Postmark::Error) }
+  it {is_expected.to be_a(Postmark::Error)}
 end
 
 describe(Postmark::InactiveRecipientError) do
@@ -148,7 +148,7 @@ describe(Postmark::InactiveRecipientError) do
       %w(nothing@wildbit.com noth.ing+2@wildbit.com noth.ing+2-1@wildbit.com)
     end
 
-    subject { Postmark::InactiveRecipientError.parse_recipients(message) }
+    subject {Postmark::InactiveRecipientError.parse_recipients(message)}
 
     context '1/1 inactive' do
       let(:message) do
@@ -158,7 +158,7 @@ describe(Postmark::InactiveRecipientError) do
         'bounce or a spam complaint.'
       end
 
-      it { is_expected.to eq(recipients.take(1)) }
+      it {is_expected.to eq(recipients.take(1))}
     end
 
     context 'i/n inactive, n > 1, i < n' do
@@ -168,7 +168,7 @@ describe(Postmark::InactiveRecipientError) do
         'have generated a hard bounce or a spam complaint.'
       end
 
-      it { is_expected.to eq(recipients.take(2)) }
+      it {is_expected.to eq(recipients.take(2))}
     end
 
     context 'n/n inactive, n > 1' do
@@ -178,25 +178,25 @@ describe(Postmark::InactiveRecipientError) do
         'Inactive recipients are ones that have generated a hard bounce or a spam complaint.'
       end
 
-      it { is_expected.to eq(recipients) }
+      it {is_expected.to eq(recipients)}
     end
 
     context 'unknown error format' do
-      let(:message) { recipients.join(', ') }
+      let(:message) {recipients.join(', ')}
 
-      it { is_expected.to eq([]) }
+      it {is_expected.to eq([])}
     end
   end
 
   describe '.new' do
-    let(:address) { 'user@example.org' }
-    let(:response) { { 'Message' => message } }
+    let(:address) {'user@example.org'}
+    let(:response) {{'Message' => message}}
 
     subject do
       Postmark::InactiveRecipientError.new(
-        Postmark::ApiInputError::INACTIVE_RECIPIENT,
-        Postmark::Json.encode(response),
-        response)
+          Postmark::ApiInputError::INACTIVE_RECIPIENT,
+          Postmark::Json.encode(response),
+          response)
     end
 
     let(:message) do

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

@@ -25,18 +25,18 @@ describe Mail::Postmark do
   describe '#deliver!' do
     it "returns self by default" do
       expect_any_instance_of(Postmark::ApiClient).to receive(:deliver_message).with(message)
-      message.deliver.should eq 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
-      message.deliver.should eq message
+      expect(message.deliver).to eq message
     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'
+      expect(message.delivery_method.settings[:api_token]).to eq 'api-token'
     end
 
     it 'uses provided API token' do

data/spec/unit/postmark/helpers/hash_helper_spec.rb

@@ -6,11 +6,11 @@ describe Postmark::HashHelper do
     let(:target) { {"From" => "support@postmarkapp.com", "ReplyTo" => "contact@wildbit.com"} }
 
     it 'converts Hash keys to Postmark format' do
-      subject.to_postmark(source).should == target
+      expect(subject.to_postmark(source)).to eq target
     end
 
     it 'acts idempotentely' do
-      subject.to_postmark(target).should == target
+      expect(subject.to_postmark(target)).to eq target
     end
   end
 
@@ -19,16 +19,15 @@ describe Postmark::HashHelper do
     let(:target) { {:from => "support@postmarkapp.com", :reply_to => "contact@wildbit.com"} }
 
     it 'converts Hash keys to Ruby format' do
-      subject.to_ruby(source).should == target
+      expect(subject.to_ruby(source)).to eq target
     end
 
     it 'has compatible mode' do
-      subject.to_ruby(source, true).should == target.merge(source)
+      expect(subject.to_ruby(source, true)).to eq target.merge(source)
     end
 
     it 'acts idempotentely' do
-      subject.to_ruby(target).should == target
+      expect(subject.to_ruby(target)).to eq target
     end
   end
-
 end

data/spec/unit/postmark/http_client_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Postmark::HttpClient do
 
   def response_body(status, message = "")
-    body = {"ErrorCode" => status, "Message" => message}.to_json
+    {"ErrorCode" => status, "Message" => message}.to_json
   end
 
   let(:api_token) { "provided-postmark-api-token" }
@@ -11,39 +11,39 @@ describe Postmark::HttpClient do
   subject { http_client }
 
   context "attr writers" do
-    it { should respond_to(:api_token=) }
-    it { should respond_to(:api_key=) }
+    it { expect(subject).to respond_to(:api_token=) }
+    it { expect(subject).to respond_to(:api_key=) }
   end
 
   context "attr readers" do
-    it { should respond_to(:http) }
-    it { should respond_to(:secure) }
-    it { should respond_to(:api_token) }
-    it { should respond_to(:api_key) }
-    it { should respond_to(:proxy_host) }
-    it { should respond_to(:proxy_port) }
-    it { should respond_to(:proxy_user) }
-    it { should respond_to(:proxy_pass) }
-    it { should respond_to(:host) }
-    it { should respond_to(:port) }
-    it { should respond_to(:path_prefix) }
-    it { should respond_to(:http_open_timeout) }
-    it { should respond_to(:http_read_timeout) }
+    it { expect(subject).to respond_to(:http) }
+    it { expect(subject).to respond_to(:secure) }
+    it { expect(subject).to respond_to(:api_token) }
+    it { expect(subject).to respond_to(:api_key) }
+    it { expect(subject).to respond_to(:proxy_host) }
+    it { expect(subject).to respond_to(:proxy_port) }
+    it { expect(subject).to respond_to(:proxy_user) }
+    it { expect(subject).to respond_to(:proxy_pass) }
+    it { expect(subject).to respond_to(:host) }
+    it { expect(subject).to respond_to(:port) }
+    it { expect(subject).to respond_to(:path_prefix) }
+    it { expect(subject).to respond_to(:http_open_timeout) }
+    it { expect(subject).to respond_to(:http_read_timeout) }
   end
 
   context "when it is created without options" do
-    its(:api_token) { should eq api_token }
-    its(:api_key) { should eq api_token }
-    its(:host) { should eq 'api.postmarkapp.com' }
-    its(:port) { should eq 443 }
-    its(:secure) { should be true }
-    its(:path_prefix) { should eq '/' }
-    its(:http_read_timeout) { should eq 15 }
-    its(:http_open_timeout) { should eq 5 }
+    its(:api_token) { is_expected.to eq api_token }
+    its(:api_key) { is_expected.to eq api_token }
+    its(:host) { is_expected.to eq 'api.postmarkapp.com' }
+    its(:port) { is_expected.to eq 443 }
+    its(:secure) { is_expected.to be true }
+    its(:path_prefix) { is_expected.to eq '/' }
+    its(:http_read_timeout) { is_expected.to eq 15 }
+    its(:http_open_timeout) { is_expected.to eq 5 }
 
     it 'uses TLS encryption', :skip_ruby_version => ['1.8.7'] do
       http_client = subject.http
-      http_client.ssl_version.should == :TLSv1
+      expect(http_client.ssl_version).to eq :TLSv1
     end
   end
 
@@ -71,18 +71,18 @@ describe Postmark::HttpClient do
                                        :http_open_timeout => http_open_timeout,
                                        :http_read_timeout => http_read_timeout) }
 
-    its(:api_token) { should eq api_token }
-    its(:api_key) { should eq api_token }
-    its(:secure) { should == secure }
-    its(:proxy_host) { should == proxy_host }
-    its(:proxy_port) { should == proxy_port }
-    its(:proxy_user) { should == proxy_user }
-    its(:proxy_pass) { should == proxy_pass }
-    its(:host) { should == host }
-    its(:port) { should == port }
-    its(:path_prefix) { should == path_prefix }
-    its(:http_open_timeout) { should == http_open_timeout }
-    its(:http_read_timeout) { should == http_read_timeout }
+    its(:api_token) { is_expected.to eq api_token }
+    its(:api_key) { is_expected.to eq api_token }
+    its(:secure) { is_expected.to eq secure }
+    its(:proxy_host) { is_expected.to eq proxy_host }
+    its(:proxy_port) { is_expected.to eq proxy_port }
+    its(:proxy_user) { is_expected.to eq proxy_user }
+    its(:proxy_pass) { is_expected.to eq proxy_pass }
+    its(:host) { is_expected.to eq host }
+    its(:port) { is_expected.to eq port }
+    its(:path_prefix) { is_expected.to eq path_prefix }
+    its(:http_open_timeout) { is_expected.to eq http_open_timeout }
+    its(:http_read_timeout) { is_expected.to eq http_read_timeout }
 
     it 'uses port 80 for plain HTTP connections' do
       expect(Postmark::HttpClient.new(api_token, :secure => false).port).to eq(80)
@@ -106,18 +106,17 @@ describe Postmark::HttpClient do
     it "sends a POST request to provided URI" do
       FakeWeb.register_uri(:post, target_url, :body => response_body(200))
       subject.post(target_path)
-      FakeWeb.should have_requested(:post, target_url)
+      expect(FakeWeb.last_request.method).to eq('POST')
+      expect(FakeWeb.last_request.path).to eq('/' + target_path)
     end
 
     it "raises a custom error when API token authorization fails" do
-      FakeWeb.register_uri(:post, target_url, :body => response_body(401),
-                                              :status => [ "401", "Unauthorized" ])
+      FakeWeb.register_uri(:post, target_url, :body => response_body(401), :status => [ "401", "Unauthorized" ])
       expect { subject.post(target_path) }.to raise_error Postmark::InvalidApiKeyError
     end
 
     it "raises a custom error when sent JSON was not valid" do
-      FakeWeb.register_uri(:post, target_url, :body => response_body(422),
-                                              :status => [ "422", "Invalid" ])
+      FakeWeb.register_uri(:post, target_url, :body => response_body(422), :status => [ "422", "Invalid" ])
       expect { subject.post(target_path) }.to raise_error Postmark::InvalidMessageError
     end
 
@@ -147,18 +146,17 @@ describe Postmark::HttpClient do
     it "sends a GET request to provided URI" do
       FakeWeb.register_uri(:get, target_url, :body => response_body(200))
       subject.get(target_path)
-      FakeWeb.should have_requested(:get, target_url)
+      expect(FakeWeb.last_request.method).to eq('GET')
+      expect(FakeWeb.last_request.path).to eq('/' + target_path)
     end
 
     it "raises a custom error when API token authorization fails" do
-      FakeWeb.register_uri(:get, target_url, :body => response_body(401),
-                                              :status => [ "401", "Unauthorized" ])
+      FakeWeb.register_uri(:get, target_url, :body => response_body(401), :status => [ "401", "Unauthorized" ])
       expect { subject.get(target_path) }.to raise_error Postmark::InvalidApiKeyError
     end
 
     it "raises a custom error when sent JSON was not valid" do
-      FakeWeb.register_uri(:get, target_url, :body => response_body(422),
-                                             :status => [ "422", "Invalid" ])
+      FakeWeb.register_uri(:get, target_url, :body => response_body(422), :status => [ "422", "Invalid" ])
       expect { subject.get(target_path) }.to raise_error Postmark::InvalidMessageError
     end
 
@@ -188,7 +186,8 @@ describe Postmark::HttpClient do
     it "sends a PUT request to provided URI" do
       FakeWeb.register_uri(:put, target_url, :body => response_body(200))
       subject.put(target_path)
-      FakeWeb.should have_requested(:put, target_url)
+      expect(FakeWeb.last_request.method).to eq('PUT')
+      expect(FakeWeb.last_request.path).to eq('/' + target_path)
     end
 
     it "raises a custom error when API token authorization fails" do
@@ -219,6 +218,5 @@ describe Postmark::HttpClient do
                                              :status => [ "485", "Custom HTTP response status" ])
       expect { subject.put(target_path) }.to raise_error Postmark::UnknownError
     end
-    
   end
 end