postmark 1.8.1 → 1.21.3

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Mail::Message do
   before do
-    Kernel.stub(:warn)
+    allow(Kernel).to receive(:warn)
   end
 
   let(:mail_message) do
@@ -15,7 +15,7 @@ describe Mail::Message do
   end
 
   let(:mail_html_message) do
-    mail = Mail.new do
+    Mail.new do
       from          "sheldon@bigbangtheory.com"
       to            "lenard@bigbangtheory.com"
       subject       "Hello!"
@@ -24,38 +24,112 @@ describe Mail::Message do
     end
   end
 
-  let(:mail_message_with_bogus_headers) do
-    mail_message.header['Return-Path'] = 'bounce@wildbit.com'
-    mail_message.header['From'] = 'info@wildbit.com'
-    mail_message.header['Sender'] = 'info@wildbit.com'
-    mail_message.header['Received'] = 'from mta.pstmrk.it ([72.14.252.155]:54907)'
-    mail_message.header['Date'] = 'January 25, 2013 3:30:58 PM PDT'
-    mail_message.header['Content-Type'] = 'application/json'
-    mail_message.header['To'] = 'lenard@bigbangtheory.com'
-    mail_message.header['Cc'] = 'sheldon@bigbangtheory.com'
-    mail_message.header['Bcc'] = 'penny@bigbangtheory.com'
-    mail_message.header['Subject'] = 'You want not to use a bogus header'
-    mail_message.header['Tag'] = 'bogus-tag'
-    mail_message.header['Attachment'] = 'anydatahere'
-    mail_message.header['Allowed-Header'] = 'value'
-    mail_message
+  let(:templated_message) do
+    Mail.new do
+      from           "sheldon@bigbangtheory.com"
+      to             "lenard@bigbangtheory.com"
+      template_alias "Hello!"
+      template_model :name => "Sheldon"
+    end
+  end
+
+  describe '#tag' do
+
+    it 'value set on tag=' do
+      mail_message.tag='value'
+      expect(mail_message.tag).to eq 'value'
+    end
+
+    it 'value set on tag()' do
+      mail_message.tag('value')
+      expect(mail_message.tag).to eq 'value'
+    end
+
+  end
+
+  describe '#track_opens' do
+    it 'returns nil if unset' do
+      expect(mail_message.track_opens).to eq ''
+    end
+
+    context 'when assigned via #track_opens=' do
+      it 'returns assigned value to track opens' do
+        mail_message.track_opens = true
+        expect(mail_message.track_opens).to eq 'true'
+      end
+
+      it 'returns assigned value to not track opens' do
+        mail_message.track_opens = false
+        expect(mail_message.track_opens).to eq 'false'
+      end
+    end
+
+    context 'flag set on track_opens()' do
+      it 'true' do
+        mail_message.track_opens(true)
+        expect(mail_message.track_opens).to eq 'true'
+      end
+
+      it 'false' do
+        mail_message.track_opens(false)
+        expect(mail_message.track_opens).to eq 'false'
+      end
+    end
+  end
+
+  describe '#metadata' do
+    let(:metadata) { { :test => 'test' } }
+
+    it 'returns a mutable empty hash if unset' do
+      expect(mail_message.metadata).to eq({})
+      expect(mail_message.metadata.equal?(mail_message.metadata)).to be true
+    end
+
+    it 'supports assigning non-null values (for the builder DSL)' do
+      expect { mail_message.metadata(metadata) }.to change { mail_message.metadata }.to(metadata)
+      expect { mail_message.metadata(nil) }.to_not change { mail_message.metadata }
+    end
+
+    it 'returns value assigned via metadata=' do
+      expect { mail_message.metadata = metadata }.to change { mail_message.metadata }.to(metadata)
+    end
+  end
+
+  describe '#track_links' do
+    it 'return empty string when if unset' do
+      expect(mail_message.track_links).to eq ''
+    end
+
+    context 'when assigned via #track_links=' do
+      it 'returns track html only body value in Postmark format' do
+        mail_message.track_links=:html_only
+        expect(mail_message.track_links).to eq 'HtmlOnly'
+      end
+    end
+
+    context 'when assigned via track_links()' do
+      it 'returns track html only body value in Postmark format' do
+        mail_message.track_links(:html_only)
+        expect(mail_message.track_links).to eq 'HtmlOnly'
+      end
+    end
   end
 
   describe "#html?" do
     it 'is true for html only email' do
-      mail_html_message.should be_html
+      expect(mail_html_message).to be_html
     end
   end
 
   describe "#body_html" do
     it 'returns html body if present' do
-      mail_html_message.body_html.should == "<b>Hello Sheldon!</b>"
+      expect(mail_html_message.body_html).to eq "<b>Hello Sheldon!</b>"
     end
   end
 
   describe "#body_text" do
     it 'returns text body if present' do
-      mail_message.body_text.should == "Hello Sheldon!"
+      expect(mail_message.body_text).to eq "Hello Sheldon!"
     end
   end
 
@@ -65,11 +139,11 @@ describe Mail::Message do
 
     it "stores attachments as an array" do
       mail_message.postmark_attachments = attached_hash
-      mail_message.instance_variable_get(:@_attachments).should include(attached_hash)
+      expect(mail_message.instance_variable_get(:@_attachments)).to include(attached_hash)
     end
 
     it "is deprecated" do
-      Kernel.should_receive(:warn).with(/deprecated/)
+      expect(Kernel).to receive(:warn).with(/deprecated/)
       mail_message.postmark_attachments = attached_hash
     end
   end
@@ -83,23 +157,23 @@ describe Mail::Message do
                            'Content' => ''} }
 
     before do
-      attached_file.stub(:is_a?) { |arg| arg == File ? true : false }
-      attached_file.stub(:path) { '/tmp/file.jpeg' }
+      allow(attached_file).to receive(:is_a?) { |arg| arg == File ? true : false }
+      allow(attached_file).to receive(:path) { '/tmp/file.jpeg' }
     end
 
     it "supports multiple attachment formats" do
-      IO.should_receive(:read).with("/tmp/file.jpeg").and_return("")
+      expect(IO).to receive(:read).with("/tmp/file.jpeg").and_return("")
 
       mail_message.postmark_attachments = [attached_hash, attached_file]
       attachments = mail_message.export_attachments
 
-      attachments.should include(attached_hash)
-      attachments.should include(exported_file)
+      expect(attachments).to include(attached_hash)
+      expect(attachments).to include(exported_file)
     end
 
     it "is deprecated" do
       mail_message.postmark_attachments = attached_hash
-      Kernel.should_receive(:warn).with(/deprecated/)
+      expect(Kernel).to receive(:warn).with(/deprecated/)
       mail_message.postmark_attachments
     end
   end
@@ -116,13 +190,13 @@ describe Mail::Message do
 
       it "exports native attachments" do
         mail_message.attachments["face.jpeg"] = file_data
-        mail_message.export_attachments.should include(exported_data)
+        expect(mail_message.export_attachments).to include(exported_data)
       end
 
       it "still supports the deprecated attachments API" do
         mail_message.attachments["face.jpeg"] = file_data
         mail_message.postmark_attachments = exported_data
-        mail_message.export_attachments.should == [exported_data, exported_data]
+        expect(mail_message.export_attachments).to eq [exported_data, exported_data]
       end
 
     end
@@ -132,10 +206,11 @@ describe Mail::Message do
       it "exports the attachment with related content id" do
         mail_message.attachments.inline["face.jpeg"] = file_data
         attachments = mail_message.export_attachments
-        attachments.count.should_not be_zero
-        attachments.first.should include(exported_data)
-        attachments.first.should have_key('ContentID')
-        attachments.first['ContentID'].should start_with('cid:')
+
+        expect(attachments.count).to_not be_zero
+        expect(attachments.first).to include(exported_data)
+        expect(attachments.first).to have_key('ContentID')
+        expect(attachments.first['ContentID']).to start_with('cid:')
       end
 
     end
@@ -143,15 +218,151 @@ describe Mail::Message do
   end
 
   describe "#export_headers" do
-    let(:headers) { mail_message_with_bogus_headers.export_headers }
-    let(:header_names) { headers.map { |h| h['Name'] } }
+    let(:mail_message_with_reserved_headers) do
+      mail_message.header['Return-Path'] = 'bounce@wildbit.com'
+      mail_message.header['From'] = 'info@wildbit.com'
+      mail_message.header['Sender'] = 'info@wildbit.com'
+      mail_message.header['Received'] = 'from mta.pstmrk.it ([72.14.252.155]:54907)'
+      mail_message.header['Date'] = 'January 25, 2013 3:30:58 PM PDT'
+      mail_message.header['Content-Type'] = 'application/json'
+      mail_message.header['To'] = 'lenard@bigbangtheory.com'
+      mail_message.header['Cc'] = 'sheldon@bigbangtheory.com'
+      mail_message.header['Bcc'] = 'penny@bigbangtheory.com'
+      mail_message.header['Subject'] = 'You want not to use a bogus header'
+      mail_message.header['Tag'] = 'bogus-tag'
+      mail_message.header['Attachment'] = 'anydatahere'
+      mail_message.header['Allowed-Header'] = 'value'
+      mail_message.header['TRACK-OPENS'] = 'true'
+      mail_message.header['TRACK-LINKS'] = 'HtmlOnly'
+      mail_message
+    end
+
+
+    it 'only allowed headers' do
+      headers = mail_message_with_reserved_headers.export_headers
+      header_names = headers.map { |h| h['Name'] }
 
-    specify { header_names.should include('Allowed-Header') }
-    specify { header_names.count.should == 1 }
+      aggregate_failures do
+        expect(header_names).to include('Allowed-Header')
+        expect(header_names.count).to eq 1
+      end
+    end
+
+    it 'custom header character case preserved' do
+      custom_header = {"Name"=>"custom-Header", "Value"=>"cUsTomHeaderValue"}
+      mail_message.header[custom_header['Name']] = custom_header['Value']
+
+      expect(mail_message.export_headers.first).to match(custom_header)
+    end
   end
 
   describe "#to_postmark_hash" do
     # See mail_message_converter_spec.rb
   end
 
+  describe '#templated?' do
+    it { expect(mail_message).to_not be_templated }
+    it { expect(templated_message).to be_templated }
+  end
+
+  describe '#prerender' do
+    let(:model) { templated_message.template_model }
+    let(:model_text) { model[:name] }
+
+    let(:template_response) do
+      {
+        :html_body => '<html><body>{{ name }}</body></html>',
+        :text_body => '{{ name }}'
+      }
+    end
+
+    let(:successful_render_response) do
+      {
+        :all_content_is_valid => true,
+        :subject => {
+          :rendered_content => 'Subject'
+        },
+        :text_body => {
+          :rendered_content => model_text
+        },
+        :html_body => {
+          :rendered_content => "<html><body>#{model_text}</body></html>"
+        }
+      }
+    end
+
+    let(:failed_render_response) do
+      {
+        :all_content_is_valid => false,
+        :subject => {
+          :rendered_content => 'Subject'
+        },
+        :text_body => {
+          :rendered_content => model_text
+        },
+        :html_body => {
+          :rendered_content => nil,
+          :validation_errors => [
+            { :message => 'The syntax for this template is invalid.', :line => 1, :character_position => 1 }
+          ]
+        }
+      }
+    end
+
+    subject(:rendering) { message.prerender }
+
+    context 'when called on a non-templated message' do
+      let(:message) { mail_message }
+
+      it 'raises a Postmark::Error' do
+        expect { rendering }.to raise_error(Postmark::Error, /Cannot prerender/)
+      end
+    end
+
+    context 'when called on a templated message' do
+      let(:message) { templated_message }
+
+      before do
+        message.delivery_method delivery_method
+      end
+
+      context 'and using a non-Postmark delivery method' do
+        let(:delivery_method) { Mail::SMTP }
+
+        it { expect { rendering }.to raise_error(Postmark::MailAdapterError) }
+      end
+
+      context 'and using a Postmark delivery method' do
+        let(:delivery_method) { Mail::Postmark }
+
+        before do
+          expect_any_instance_of(Postmark::ApiClient).
+            to receive(:get_template).with(message.template_alias).
+            and_return(template_response)
+          expect_any_instance_of(Postmark::ApiClient).
+            to receive(:validate_template).with(template_response.merge(:test_render_model => model)).
+            and_return(render_response)
+        end
+
+        context 'and rendering succeeds' do
+          let(:render_response) { successful_render_response }
+
+          it 'sets HTML and Text parts to rendered values' do
+            expect { rendering }.
+              to change { message.subject }.to(render_response[:subject][:rendered_content]).
+              and change { message.body_text }.to(render_response[:text_body][:rendered_content]).
+              and change { message.body_html }.to(render_response[:html_body][:rendered_content])
+          end
+        end
+
+        context 'and rendering fails' do
+          let(:render_response) { failed_render_response }
+
+          it 'raises Postmark::InvalidTemplateError' do
+            expect { rendering }.to raise_error(Postmark::InvalidTemplateError)
+          end
+        end
+      end
+    end
+  end
 end

data/spec/unit/postmark_spec.rb

@@ -26,37 +26,37 @@ describe Postmark do
   end
 
   context "attr readers" do
-    it { should respond_to(:secure) }
-    it { should respond_to(:api_key) }
-    it { should respond_to(:api_token) }
-    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 { should respond_to(:max_retries) }
+    it { expect(subject).to respond_to(:secure) }
+    it { expect(subject).to respond_to(:api_key) }
+    it { expect(subject).to respond_to(:api_token) }
+    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(:max_retries) }
   end
 
   context "attr writers" do
-    it { should respond_to(:secure=) }
-    it { should respond_to(:api_key=) }
-    it { should respond_to(:api_token=) }
-    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 { should respond_to(:max_retries=) }
-    it { should respond_to(:response_parser_class=) }
-    it { should respond_to(:api_client=) }
+    it { expect(subject).to respond_to(:secure=) }
+    it { expect(subject).to respond_to(:api_key=) }
+    it { expect(subject).to respond_to(:api_token=) }
+    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(:max_retries=) }
+    it { expect(subject).to respond_to(:response_parser_class=) }
+    it { expect(subject).to respond_to(:api_client=) }
   end
 
   describe ".response_parser_class" do
@@ -66,12 +66,12 @@ describe Postmark do
     end
 
     it "returns :ActiveSupport when ActiveSupport::JSON is available" do
-      subject.response_parser_class.should == :ActiveSupport
+      expect(subject.response_parser_class).to eq :ActiveSupport
     end
 
     it "returns :Json when ActiveSupport::JSON is not available" do
       hide_const("ActiveSupport::JSON")
-      subject.response_parser_class.should == :Json
+      expect(subject.response_parser_class).to eq :Json
     end
 
   end
@@ -91,7 +91,7 @@ describe Postmark do
 
       it 'returns the existing instance' do
         subject.instance_variable_set(:@api_client, api_client)
-        subject.api_client.should == api_client
+        expect(subject.api_client).to eq api_client
       end
 
     end
@@ -99,7 +99,7 @@ describe Postmark do
     context "when shared client instance does not exist" do
 
       it 'creates a new instance of Postmark::ApiClient' do
-        Postmark::ApiClient.should_receive(:new).
+        allow(Postmark::ApiClient).to receive(:new).
                             with(api_token,
                                  :secure => secure,
                                  :proxy_host => proxy_host,
@@ -111,7 +111,7 @@ describe Postmark do
                                  :path_prefix => path_prefix,
                                  :max_retries => max_retries).
                             and_return(api_client)
-        subject.api_client.should == api_client
+        expect(subject.api_client).to eq api_client
       end
 
     end
@@ -127,12 +127,12 @@ describe Postmark do
     end
 
     it 'delegates the method to the shared api client instance' do
-      api_client.should_receive(:deliver_message).with(message)
+      allow(api_client).to receive(:deliver_message).with(message)
       subject.deliver_message(message)
     end
 
     it 'is also accessible as .send_through_postmark' do
-      api_client.should_receive(:deliver_message).with(message)
+      allow(api_client).to receive(:deliver_message).with(message)
       subject.send_through_postmark(message)
     end
   end
@@ -146,7 +146,7 @@ describe Postmark do
     end
 
     it 'delegates the method to the shared api client instance' do
-      api_client.should_receive(:deliver_messages).with(message)
+      allow(api_client).to receive(:deliver_messages).with(message)
       subject.deliver_messages(message)
     end
   end
@@ -159,7 +159,7 @@ describe Postmark do
     end
 
     it 'delegates the method to the shared api client instance' do
-      api_client.should_receive(:delivery_stats)
+      allow(api_client).to receive(:delivery_stats)
       subject.delivery_stats
     end
   end