postmark 1.18.0 → 1.19.0

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

data/spec/unit/postmark/inflector_spec.rb

@@ -1,35 +1,33 @@
 require 'spec_helper'
 
 describe Postmark::Inflector do
-
   describe ".to_postmark" do
     it 'converts rubyish underscored format to camel cased symbols accepted by the Postmark API' do
-      subject.to_postmark(:foo_bar).should == 'FooBar'
-      subject.to_postmark(:_bar).should == 'Bar'
-      subject.to_postmark(:really_long_long_long_long_symbol).should == 'ReallyLongLongLongLongSymbol'
-      subject.to_postmark(:foo_bar_1).should == 'FooBar1'
+      expect(subject.to_postmark(:foo_bar)).to eq 'FooBar'
+      expect(subject.to_postmark(:_bar)).to eq 'Bar'
+      expect(subject.to_postmark(:really_long_long_long_long_symbol)).to eq 'ReallyLongLongLongLongSymbol'
+      expect(subject.to_postmark(:foo_bar_1)).to eq 'FooBar1'
     end
 
     it 'accepts strings as well' do
-      subject.to_postmark('foo_bar').should == 'FooBar'
+      expect(subject.to_postmark('foo_bar')).to eq 'FooBar'
     end
 
     it 'acts idempotentely' do
-      subject.to_postmark('FooBar').should == 'FooBar'
+      expect(subject.to_postmark('FooBar')).to eq 'FooBar'
     end
   end
 
   describe ".to_ruby" do
     it 'converts camel cased symbols returned by the Postmark API to underscored Ruby symbols' do
-      subject.to_ruby('FooBar').should == :foo_bar
-      subject.to_ruby('LongTimeAgoInAFarFarGalaxy').should == :long_time_ago_in_a_far_far_galaxy
-      subject.to_ruby('MessageID').should == :message_id
+      expect(subject.to_ruby('FooBar')).to eq :foo_bar
+      expect(subject.to_ruby('LongTimeAgoInAFarFarGalaxy')).to eq :long_time_ago_in_a_far_far_galaxy
+      expect(subject.to_ruby('MessageID')).to eq :message_id
     end
 
     it 'acts idempotentely' do
-      subject.to_ruby(:foo_bar).should == :foo_bar
-      subject.to_ruby(:foo_bar_1).should == :foo_bar_1
+      expect(subject.to_ruby(:foo_bar)).to eq :foo_bar
+      expect(subject.to_ruby(:foo_bar_1)).to eq :foo_bar_1
     end
   end
-
 end

data/spec/unit/postmark/json_spec.rb

@@ -6,8 +6,8 @@ describe Postmark::Json do
   shared_examples "json parser" do
     it 'encodes and decodes data correctly' do
       hash = Postmark::Json.decode(Postmark::Json.encode(data))
-      hash.should have_key("bar")
-      hash.should have_key("foo")
+      expect(hash).to have_key("bar")
+      expect(hash).to have_key("foo")
     end
   end
 

data/spec/unit/postmark/mail_message_converter_spec.rb

@@ -2,23 +2,22 @@
 require 'spec_helper'
 
 describe Postmark::MailMessageConverter do
-
-  subject { Postmark::MailMessageConverter }
+  subject {Postmark::MailMessageConverter}
 
   let(:mail_message) do
     Mail.new do
-      from    "sheldon@bigbangtheory.com"
-      to      "lenard@bigbangtheory.com"
+      from "sheldon@bigbangtheory.com"
+      to "lenard@bigbangtheory.com"
       subject "Hello!"
-      body    "Hello Sheldon!"
+      body "Hello Sheldon!"
     end
   end
 
   let(:mail_html_message) do
     Mail.new do
-      from          "sheldon@bigbangtheory.com"
-      to            "lenard@bigbangtheory.com"
-      subject       "Hello!"
+      from "sheldon@bigbangtheory.com"
+      to "lenard@bigbangtheory.com"
+      subject "Hello!"
       content_type 'text/html; charset=UTF-8'
       body "<b>Hello Sheldon!</b>"
     end
@@ -26,41 +25,41 @@ describe Postmark::MailMessageConverter do
 
   let(:mail_message_with_open_tracking) do
     Mail.new do
-      from          "sheldon@bigbangtheory.com"
-      to            "lenard@bigbangtheory.com"
-      subject       "Hello!"
-      content_type  'text/html; charset=UTF-8'
-      body          "<b>Hello Sheldon!</b>"
-      track_opens   true
+      from "sheldon@bigbangtheory.com"
+      to "lenard@bigbangtheory.com"
+      subject "Hello!"
+      content_type 'text/html; charset=UTF-8'
+      body "<b>Hello Sheldon!</b>"
+      track_opens true
     end
   end
 
   let(:mail_message_with_open_tracking_disabled) do
     Mail.new do
-      from          "sheldon@bigbangtheory.com"
-      to            "lenard@bigbangtheory.com"
-      subject       "Hello!"
-      content_type  'text/html; charset=UTF-8'
-      body          "<b>Hello Sheldon!</b>"
-      track_opens   false
+      from "sheldon@bigbangtheory.com"
+      to "lenard@bigbangtheory.com"
+      subject "Hello!"
+      content_type 'text/html; charset=UTF-8'
+      body "<b>Hello Sheldon!</b>"
+      track_opens false
     end
   end
 
   let(:mail_message_with_open_tracking_set_variable) do
     mail = mail_html_message
-    mail.track_opens=true
+    mail.track_opens = true
     mail
   end
 
   let(:mail_message_with_open_tracking_disabled_set_variable) do
     mail = mail_html_message
-    mail.track_opens=false
+    mail.track_opens = false
     mail
   end
 
   let(:mail_message_with_link_tracking_all) do
     mail = mail_html_message
-    mail.track_links   :html_and_text
+    mail.track_links :html_and_text
     mail
   end
 
@@ -84,73 +83,73 @@ describe Postmark::MailMessageConverter do
 
   let(:tagged_mail_message) do
     Mail.new do
-      from    "sheldon@bigbangtheory.com"
-      to      "lenard@bigbangtheory.com"
+      from "sheldon@bigbangtheory.com"
+      to "lenard@bigbangtheory.com"
       subject "Hello!"
-      body    "Hello Sheldon!"
-      tag     "sheldon"
+      body "Hello Sheldon!"
+      tag "sheldon"
     end
   end
 
   let(:mail_message_without_body) do
     Mail.new do
-      from    "sheldon@bigbangtheory.com"
-      to      "lenard@bigbangtheory.com"
+      from "sheldon@bigbangtheory.com"
+      to "lenard@bigbangtheory.com"
       subject "Hello!"
     end
   end
 
   let(:mail_multipart_message) do
     Mail.new do
-      from          "sheldon@bigbangtheory.com"
-      to            "lenard@bigbangtheory.com"
-      subject       "Hello!"
+      from "sheldon@bigbangtheory.com"
+      to "lenard@bigbangtheory.com"
+      subject "Hello!"
       text_part do
-        body        "Hello Sheldon!"
+        body "Hello Sheldon!"
       end
       html_part do
-        body        "<b>Hello Sheldon!</b>"
+        body "<b>Hello Sheldon!</b>"
       end
     end
   end
 
   let(:mail_message_with_attachment) do
     Mail.new do
-      from    "sheldon@bigbangtheory.com"
-      to      "lenard@bigbangtheory.com"
+      from "sheldon@bigbangtheory.com"
+      to "lenard@bigbangtheory.com"
       subject "Hello!"
-      body    "Hello Sheldon!"
+      body "Hello Sheldon!"
       add_file empty_gif_path
     end
   end
 
   let(:mail_message_with_named_addresses) do
     Mail.new do
-      from    "Sheldon <sheldon@bigbangtheory.com>"
-      to      "\"Leonard Hofstadter\" <leonard@bigbangtheory.com>"
+      from "Sheldon <sheldon@bigbangtheory.com>"
+      to "\"Leonard Hofstadter\" <leonard@bigbangtheory.com>"
       subject "Hello!"
-      body    "Hello Sheldon!"
+      body "Hello Sheldon!"
       reply_to '"Penny The Neighbor" <penny@bigbangtheory.com>'
     end
   end
 
   let(:mail_message_quoted_printable) do
     Mail.new do
-      from    "Sheldon <sheldon@bigbangtheory.com>"
-      to      "\"Leonard Hofstadter\" <leonard@bigbangtheory.com>"
+      from "Sheldon <sheldon@bigbangtheory.com>"
+      to "\"Leonard Hofstadter\" <leonard@bigbangtheory.com>"
       subject "Hello!"
       content_type 'text/plain; charset=utf-8'
       content_transfer_encoding 'quoted-printable'
-      body    'Он здесь бывал: еще не в галифе.'
+      body 'Он здесь бывал: еще не в галифе.'
       reply_to '"Penny The Neighbor" <penny@bigbangtheory.com>'
     end
   end
 
   let(:multipart_message_quoted_printable) do
     Mail.new do
-      from          "sheldon@bigbangtheory.com"
-      to            "lenard@bigbangtheory.com"
-      subject       "Hello!"
+      from "sheldon@bigbangtheory.com"
+      to "lenard@bigbangtheory.com"
+      subject "Hello!"
       text_part do
         content_type 'text/plain; charset=utf-8'
         content_transfer_encoding 'quoted-printable'
@@ -166,80 +165,80 @@ describe Postmark::MailMessageConverter do
 
   let(:templated_message) do
     Mail.new do
-      from            "sheldon@bigbangtheory.com"
-      to              "lenard@bigbangtheory.com"
-      template_alias  "hello"
-      template_model  :name => "Sheldon"
+      from "sheldon@bigbangtheory.com"
+      to "lenard@bigbangtheory.com"
+      template_alias "hello"
+      template_model :name => "Sheldon"
     end
   end
 
   it 'converts plain text messages correctly' do
-    subject.new(mail_message).run.should == {
+    expect(subject.new(mail_message).run).to eq ({
         "From" => "sheldon@bigbangtheory.com",
         "Subject" => "Hello!",
         "TextBody" => "Hello Sheldon!",
-        "To" => "lenard@bigbangtheory.com"}
+        "To" => "lenard@bigbangtheory.com"})
   end
 
   it 'converts tagged text messages correctly' do
-    subject.new(tagged_mail_message).run.should == {
+    expect(subject.new(tagged_mail_message).run).to eq ({
         "From" => "sheldon@bigbangtheory.com",
         "Subject" => "Hello!",
         "TextBody" => "Hello Sheldon!",
         "Tag" => "sheldon",
-        "To"=>"lenard@bigbangtheory.com"}
+        "To" => "lenard@bigbangtheory.com"})
   end
 
   it 'converts plain text messages without body correctly' do
-    subject.new(mail_message_without_body).run.should == {
+    expect(subject.new(mail_message_without_body).run).to eq ({
         "From" => "sheldon@bigbangtheory.com",
         "Subject" => "Hello!",
-        "To" => "lenard@bigbangtheory.com"}
+        "To" => "lenard@bigbangtheory.com"})
   end
 
   it 'converts html messages correctly' do
-    subject.new(mail_html_message).run.should == {
+    expect(subject.new(mail_html_message).run).to eq ({
         "From" => "sheldon@bigbangtheory.com",
         "Subject" => "Hello!",
         "HtmlBody" => "<b>Hello Sheldon!</b>",
-        "To" => "lenard@bigbangtheory.com"}
+        "To" => "lenard@bigbangtheory.com"})
   end
 
   it 'converts multipart messages correctly' do
-    subject.new(mail_multipart_message).run.should == {
+    expect(subject.new(mail_multipart_message).run).to eq ({
         "From" => "sheldon@bigbangtheory.com",
         "Subject" => "Hello!",
         "HtmlBody" => "<b>Hello Sheldon!</b>",
         "TextBody" => "Hello Sheldon!",
-        "To" => "lenard@bigbangtheory.com"}
+        "To" => "lenard@bigbangtheory.com"})
   end
 
   it 'converts messages with attachments correctly' do
-    subject.new(mail_message_with_attachment).run.should == {
+    expect(subject.new(mail_message_with_attachment).run).to eq ({
         "From" => "sheldon@bigbangtheory.com",
         "Subject" => "Hello!",
-        "Attachments" => [{"Name"=>"empty.gif",
-                           "Content"=>encoded_empty_gif_data,
-                           "ContentType"=>"image/gif"}],
-        "TextBody"=>"Hello Sheldon!",
-        "To"=>"lenard@bigbangtheory.com"}
+        "Attachments" => [{"Name" => "empty.gif",
+                           "Content" => encoded_empty_gif_data,
+                           "ContentType" => "image/gif"}],
+        "TextBody" => "Hello Sheldon!",
+        "To" => "lenard@bigbangtheory.com"})
   end
 
   it 'converts messages with named addresses correctly' do
-    subject.new(mail_message_with_named_addresses).run.should == {
+    expect(subject.new(mail_message_with_named_addresses).run).to eq ({
         "From" => "Sheldon <sheldon@bigbangtheory.com>",
         "Subject" => "Hello!",
         "TextBody" => "Hello Sheldon!",
         "To" => "Leonard Hofstadter <leonard@bigbangtheory.com>",
-        "ReplyTo" => 'Penny The Neighbor <penny@bigbangtheory.com>'}
+        "ReplyTo" => 'Penny The Neighbor <penny@bigbangtheory.com>'})
   end
 
   it 'convertes templated messages correctly' do
-    expect(subject.new(templated_message).run).
-      to eq("From" => "sheldon@bigbangtheory.com",
-            "TemplateAlias" => "hello",
-            "TemplateModel" => { :name => "Sheldon" },
-            "To" => "lenard@bigbangtheory.com")
+    expect(subject.new(templated_message).run).to eq({
+                                                         "From" => "sheldon@bigbangtheory.com",
+                                                         "TemplateAlias" => "hello",
+                                                         "TemplateModel" => {:name => "Sheldon"},
+                                                         "To" => "lenard@bigbangtheory.com"})
   end
 
   context 'open tracking' do
@@ -345,7 +344,7 @@ describe Postmark::MailMessageConverter do
 
     it 'converts multiple metadata fields' do
       metadata = {}
-      10.times { |i| metadata["test#{i+1}"] = "t"*80 }
+      10.times {|i| metadata["test#{i + 1}"] = "t" * 80}
       msg = mail_html_message
       msg.metadata = metadata
       expect(subject.new(msg).run).to include('Metadata' => metadata)
@@ -353,28 +352,26 @@ describe Postmark::MailMessageConverter do
   end
 
   it 'correctly decodes unicode in messages transfered as quoted-printable' do
-    subject.new(mail_message_quoted_printable).run.should \
-      include('TextBody' => 'Он здесь бывал: еще не в галифе.')
+    expect(subject.new(mail_message_quoted_printable).run).to include('TextBody' => 'Он здесь бывал: еще не в галифе.')
   end
 
   it 'correctly decodes unicode in multipart quoted-printable messages' do
-    subject.new(multipart_message_quoted_printable).run.should \
-      include('TextBody' => 'Загадочное послание.',
-              'HtmlBody' => '<b>Загадочное послание.</b>')
+    expect(subject.new(multipart_message_quoted_printable).run).to include(
+                                                                       'TextBody' => 'Загадочное послание.',
+                                                                       'HtmlBody' => '<b>Загадочное послание.</b>')
   end
 
   context 'when bcc is empty' do
     it 'excludes bcc from message' do
       mail_message.bcc = nil
-      mail_message.to_postmark_hash.keys.should_not include('Bcc')
+      expect(mail_message.to_postmark_hash.keys).not_to include('Bcc')
     end
   end
 
   context 'when cc is empty' do
     it 'excludes cc from message' do
       mail_message.cc = nil
-      mail_message.to_postmark_hash.keys.should_not include('Cc')
+      expect(mail_message.to_postmark_hash.keys).not_to include('Cc')
     end
   end
-
 end