postmark 1.8.1 → 1.21.3

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/helpers/message_helper_spec.rb

@@ -80,48 +80,97 @@ describe Postmark::MessageHelper do
       message.merge(:track_opens => true)
     }
 
+    let(:message_with_open_tracking_false) {
+      message.merge(:track_opens => false)
+    }
+
     let(:postmark_message_with_open_tracking) {
       postmark_message.merge("TrackOpens" => true)
     }
 
+    let(:postmark_message_with_open_tracking_false) {
+      postmark_message.merge("TrackOpens" => false)
+    }
+
     it 'converts messages without custom headers and attachments correctly' do
-      subject.to_postmark(message).should == postmark_message
+      expect(subject.to_postmark(message)).to eq postmark_message
     end
 
     it 'converts messages with custom headers and without attachments correctly' do
-      subject.to_postmark(message_with_headers).should == postmark_message_with_headers
+      expect(subject.to_postmark(message_with_headers)).to eq postmark_message_with_headers
     end
 
     it 'converts messages with custom headers and attachments correctly' do
-      subject.to_postmark(message_with_headers_and_attachments).should == postmark_message_with_headers_and_attachments
+      expect(subject.to_postmark(message_with_headers_and_attachments)).to eq postmark_message_with_headers_and_attachments
+    end
+
+    context 'open tracking' do
+
+      it 'converts messages with open tracking flag set to true correctly' do
+        expect(subject.to_postmark(message_with_open_tracking)).to eq(postmark_message_with_open_tracking)
+      end
+
+      it 'converts messages with open tracking flag set to false correctly' do
+        expect(subject.to_postmark(message_with_open_tracking_false)).to eq(postmark_message_with_open_tracking_false)
+      end
+
     end
 
-    it 'includes open tracking flag when specified' do
-      expect(subject.to_postmark(message_with_open_tracking)).to eq(postmark_message_with_open_tracking)
+    context 'metadata' do
+      it 'converts messages with metadata correctly' do
+        metadata = {"test" => "value"}
+        data= message.merge(:metadata => metadata)
+        expect(subject.to_postmark(data)).to include(postmark_message.merge("Metadata" => metadata))
+      end
     end
 
+    context 'link tracking' do
+      let(:message_with_link_tracking_html) { message.merge(:track_links => :html_only) }
+      let(:message_with_link_tracking_text) { message.merge(:track_links => :text_only) }
+      let(:message_with_link_tracking_all) { message.merge(:track_links => :html_and_text) }
+      let(:message_with_link_tracking_none) { message.merge(:track_links => :none) }
+
+      let(:postmark_message_with_link_tracking_html) { postmark_message.merge("TrackLinks" => 'HtmlOnly') }
+      let(:postmark_message_with_link_tracking_text) { postmark_message.merge("TrackLinks" => 'TextOnly') }
+      let(:postmark_message_with_link_tracking_all) { postmark_message.merge("TrackLinks" => 'HtmlAndText') }
+      let(:postmark_message_with_link_tracking_none) { postmark_message.merge("TrackLinks" => 'None') }
+
+      it 'converts html body link tracking to Postmark format' do
+        expect(subject.to_postmark(message_with_link_tracking_html)).to eq(postmark_message_with_link_tracking_html)
+      end
+
+      it 'converts text body link tracking to Postmark format' do
+        expect(subject.to_postmark(message_with_link_tracking_text)).to eq(postmark_message_with_link_tracking_text)
+      end
+
+      it 'converts html and text body link tracking to Postmark format' do
+        expect(subject.to_postmark(message_with_link_tracking_all)).to eq(postmark_message_with_link_tracking_all)
+      end
+
+      it 'converts no link tracking to Postmark format' do
+        expect(subject.to_postmark(message_with_link_tracking_none)).to eq(postmark_message_with_link_tracking_none)
+      end
+    end
   end
 
   describe ".headers_to_postmark" do
     it 'converts headers to Postmark format' do
-      subject.headers_to_postmark(headers).should == postmark_headers
+      expect(subject.headers_to_postmark(headers)).to eq postmark_headers
     end
 
     it 'accepts single header as a non-array' do
-      subject.headers_to_postmark(headers.first).should == [postmark_headers.first]
+      expect(subject.headers_to_postmark(headers.first)).to eq [postmark_headers.first]
     end
   end
 
   describe ".attachments_to_postmark" do
-
     it 'converts attachments to Postmark format' do
-      subject.attachments_to_postmark(attachments).should == postmark_attachments
+      expect(subject.attachments_to_postmark(attachments)).to eq postmark_attachments
     end
 
     it 'accepts single attachment as a non-array' do
-      subject.attachments_to_postmark(attachments.first).should == [postmark_attachments.first]
+      expect(subject.attachments_to_postmark(attachments.first)).to eq [postmark_attachments.first]
     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,40 @@ 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) }
+    it { expect(subject).to respond_to(:http_ssl_version) }
   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 }
-
-    it 'uses TLS encryption', :skip_ruby_version => ['1.8.7'] do
+    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 'does not provide a default which utilizes the Net::HTTP default', :skip_ruby_version => ['1.8.7'] do
       http_client = subject.http
-      http_client.ssl_version.should == :TLSv1
+      expect(http_client.ssl_version).to eq nil
     end
   end
 
@@ -54,10 +55,11 @@ describe Postmark::HttpClient do
     let(:proxy_user) { "provided proxy user" }
     let(:proxy_pass) { "provided proxy pass" }
     let(:host) { "providedhostname.org" }
-    let(:port) { 443 }
+    let(:port) { 4443 }
     let(:path_prefix) { "/provided/path/prefix" }
     let(:http_open_timeout) { 42 }
     let(:http_read_timeout) { 42 }
+    let(:http_ssl_version) { :TLSv1_2}
 
     subject { Postmark::HttpClient.new(api_token,
                                        :secure => secure,
@@ -69,20 +71,36 @@ describe Postmark::HttpClient do
                                        :port => port,
                                        :path_prefix => path_prefix,
                                        :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 }
+                                       :http_read_timeout => http_read_timeout,
+                                       :http_ssl_version => http_ssl_version) }
+
+    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 }
+    its(:http_ssl_version) { is_expected.to eq http_ssl_version }
+
+    it 'uses port 80 for plain HTTP connections' do
+      expect(Postmark::HttpClient.new(api_token, :secure => false).port).to eq(80)
+    end
+
+    it 'uses port 443 for secure HTTP connections' do
+      expect(Postmark::HttpClient.new(api_token, :secure => true).port).to eq(443)
+    end
+
+    it 'respects port over secure option' do
+      client = Postmark::HttpClient.new(api_token, :port => 80, :secure => true)
+      expect(client.port).to eq(80)
+      expect(client.protocol).to eq('https')
+    end
   end
 
   describe "#post" do
@@ -92,18 +110,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
 
@@ -114,8 +131,7 @@ describe Postmark::HttpClient do
     end
 
     it "raises a custom error when the request times out" do
-      subject.http.should_receive(:post).at_least(:once).
-                                             and_raise(Timeout::Error)
+      expect(subject.http).to receive(:post).at_least(:once).and_raise(Timeout::Error)
       expect { subject.post(target_path) }.to raise_error Postmark::TimeoutError
     end
 
@@ -124,7 +140,7 @@ describe Postmark::HttpClient do
                                               :status => [ "485", "Custom HTTP response status" ])
       expect { subject.post(target_path) }.to raise_error Postmark::UnknownError
     end
-    
+
   end
 
   describe "#get" do
@@ -134,18 +150,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
 
@@ -156,7 +171,7 @@ describe Postmark::HttpClient do
     end
 
     it "raises a custom error when the request times out" do
-      subject.http.should_receive(:get).at_least(:once).and_raise(Timeout::Error)
+      expect(subject.http).to receive(:get).at_least(:once).and_raise(Timeout::Error)
       expect { subject.get(target_path) }.to raise_error Postmark::TimeoutError
     end
 
@@ -165,7 +180,7 @@ describe Postmark::HttpClient do
                                              :status => [ "485", "Custom HTTP response status" ])
       expect { subject.get(target_path) }.to raise_error Postmark::UnknownError
     end
-    
+
   end
 
   describe "#put" do
@@ -175,7 +190,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
@@ -197,7 +213,7 @@ describe Postmark::HttpClient do
     end
 
     it "raises a custom error when the request times out" do
-      subject.http.should_receive(:put).at_least(:once).and_raise(Timeout::Error)
+      expect(subject.http).to receive(:put).at_least(:once).and_raise(Timeout::Error)
       expect { subject.put(target_path) }.to raise_error Postmark::TimeoutError
     end
 
@@ -206,6 +222,5 @@ describe Postmark::HttpClient do
                                              :status => [ "485", "Custom HTTP response status" ])
       expect { subject.put(target_path) }.to raise_error Postmark::UnknownError
     end
-    
   end
-end
+end

data/spec/unit/postmark/inbound_spec.rb

@@ -7,81 +7,81 @@ describe Postmark::Inbound do
   context "given a serialized inbound document" do
     subject { Postmark::Inbound.to_ruby_hash(example_inbound) }
 
-    it { should have_key(:from) }
-    it { should have_key(:from_full) }
-    it { should have_key(:to) }
-    it { should have_key(:to_full) } 
-    it { should have_key(:cc) }
-    it { should have_key(:cc_full) }
-    it { should have_key(:reply_to) }
-    it { should have_key(:subject) }
-    it { should have_key(:message_id) }
-    it { should have_key(:date) }
-    it { should have_key(:mailbox_hash) }
-    it { should have_key(:text_body) }
-    it { should have_key(:html_body) }
-    it { should have_key(:tag) }
-    it { should have_key(:headers) }
-    it { should have_key(:attachments) }
+    it { expect(subject).to have_key(:from) }
+    it { expect(subject).to have_key(:from_full) }
+    it { expect(subject).to have_key(:to) }
+    it { expect(subject).to have_key(:to_full) }
+    it { expect(subject).to have_key(:cc) }
+    it { expect(subject).to have_key(:cc_full) }
+    it { expect(subject).to have_key(:reply_to) }
+    it { expect(subject).to have_key(:subject) }
+    it { expect(subject).to have_key(:message_id) }
+    it { expect(subject).to have_key(:date) }
+    it { expect(subject).to have_key(:mailbox_hash) }
+    it { expect(subject).to have_key(:text_body) }
+    it { expect(subject).to have_key(:html_body) }
+    it { expect(subject).to have_key(:tag) }
+    it { expect(subject).to have_key(:headers) }
+    it { expect(subject).to have_key(:attachments) }
 
     context "cc" do
       it 'has 2 CCs' do
-        subject[:cc_full].count.should == 2
+        expect(subject[:cc_full].count).to eq 2
       end
 
       it 'stores CCs as an array of Ruby hashes' do
         cc = subject[:cc_full].last
-        cc.should have_key(:email)
-        cc.should have_key(:name)
+        expect(cc).to have_key(:email)
+        expect(cc).to have_key(:name)
       end
     end
 
     context "to" do
       it 'has 1 recipients' do
-        subject[:to_full].count.should == 1
+        expect(subject[:to_full].count).to eq 1
       end
 
       it 'stores TOs as an array of Ruby hashes' do
         cc = subject[:to_full].last
-        cc.should have_key(:email)
-        cc.should have_key(:name)
+        expect(cc).to have_key(:email)
+        expect(cc).to have_key(:name)
       end
     end
 
     context "from" do
       it 'is a hash' do
-        subject[:from_full].should be_a Hash
+        expect(subject[:from_full]).to be_a Hash
       end
 
-      it 'should have all required fields' do
-        subject[:from_full].should have_key(:email)
-        subject[:from_full].should have_key(:name)
+      it 'has all required fields' do
+        expect(subject[:from_full]).to have_key(:email)
+        expect(subject[:from_full]).to have_key(:name)
       end
     end
 
     context "headers" do
       it 'has 8 headers' do
-        subject[:headers].count.should == 8
+        expect(subject[:headers].count).to eq 8
       end
 
       it 'stores headers as an array of Ruby hashes' do
         header = subject[:headers].last
-        header.should have_key(:name)
-        header.should have_key(:value)
+        expect(header).to have_key(:name)
+        expect(header).to have_key(:value)
       end
     end
 
     context "attachments" do
       it 'has 2 attachments' do
-        subject[:attachments].count.should == 2
+        expect(subject[:attachments].count).to eq 2
       end
 
       it 'stores attachemnts as an array of Ruby hashes' do
         attachment = subject[:attachments].last
-        attachment.should have_key(:name)
-        attachment.should have_key(:content)
-        attachment.should have_key(:content_type)
-        attachment.should have_key(:content_length)
+        expect(attachment).to have_key(:name)
+        expect(attachment).to have_key(:content)
+        expect(attachment).to have_key(:content_type)
+        expect(attachment).to have_key(:content_length)
       end
     end
   end