letter_opener 1.0.0 → 1.7.0

data/spec/letter_opener/delivery_method_spec.rb

@@ -1,10 +1,13 @@
 require "spec_helper"
 
 describe LetterOpener::DeliveryMethod do
-  let(:location) { File.expand_path('../../../tmp/letter_opener', __FILE__) }
+  let(:location)   { File.expand_path('../../../tmp/letter_opener', __FILE__) }
+
+  let(:plain_file) { Dir["#{location}/*/plain.html"].first }
+  let(:plain)      { CGI.unescape_html(File.read(plain_file)) }
 
   before do
-    Launchy.stub(:open)
+    allow(Launchy).to receive(:open)
     FileUtils.rm_rf(location)
     context = self
 
@@ -14,58 +17,97 @@ describe LetterOpener::DeliveryMethod do
   end
 
   it 'raises an exception if no location passed' do
-    lambda { LetterOpener::DeliveryMethod.new }.should raise_exception(LetterOpener::DeliveryMethod::InvalidOption)
-    lambda { LetterOpener::DeliveryMethod.new(location: "foo") }.should_not raise_exception
+    expect { LetterOpener::DeliveryMethod.new }.to raise_exception(LetterOpener::DeliveryMethod::InvalidOption)
+    expect { LetterOpener::DeliveryMethod.new(location: "foo") }.to_not raise_exception
   end
 
-  context 'content' do
-    let(:plain_file) { Dir["#{location}/*/plain.html"].first }
-    let(:plain) { File.read(plain_file) }
+  context 'integration' do
+    before do
+      expect(Launchy).to receive(:open).and_call_original
+      ENV['LAUNCHY_DRY_RUN'] = 'true'
+    end
+
+    context 'normal location path' do
+      it 'opens email' do
+        expect($stdout).to receive(:puts)
+        expect {
+          Mail.deliver do
+            to   'Bar bar@example.com'
+            from 'Foo foo@example.com'
+            body 'World! http://example.com'
+          end
+        }.not_to raise_error
+      end
+    end
+
+    context 'with spaces in location path' do
+      let(:location) { File.expand_path('../../../tmp/letter_opener with space', __FILE__) }
+
+      it 'opens email' do
+        expect($stdout).to receive(:puts)
+        expect {
+          Mail.deliver do
+            to   'Bar bar@example.com'
+            from 'Foo foo@example.com'
+            body 'World! http://example.com'
+          end
+        }.not_to raise_error
+      end
+    end
+  end
 
+  context 'content' do
     context 'plain' do
       before do
-        Launchy.should_receive(:open)
+        expect(Launchy).to receive(:open)
 
         Mail.deliver do
-          from     'Foo foo@example.com'
-          reply_to 'No Reply no-reply@example.com'
-          to       'Bar bar@example.com'
+          from     'Foo <foo@example.com>'
+          sender   'Baz <baz@example.com>'
+          reply_to 'No Reply <no-reply@example.com>'
+          to       'Bar <bar@example.com>'
+          cc       'Qux <qux@example.com>'
+          bcc      'Qux <qux@example.com>'
           subject  'Hello'
           body     'World! http://example.com'
         end
       end
 
       it 'creates plain html document' do
-        File.exist?(plain_file).should be_true
+        expect(File.exist?(plain_file)).to be_truthy
       end
 
       it 'saves From field' do
-        plain.should include("Foo foo@example.com")
+        expect(plain).to include("Foo <foo@example.com>")
+      end
+
+      it 'saves Sender field' do
+        expect(plain).to include("Baz <baz@example.com>")
       end
 
       it 'saves Reply-to field' do
-        plain.should include("No Reply no-reply@example.com")
+        expect(plain).to include("No Reply <no-reply@example.com>")
       end
 
       it 'saves To field' do
-        plain.should include("Bar bar@example.com")
+        expect(plain).to include("Bar <bar@example.com>")
       end
 
       it 'saves Subject field' do
-        plain.should include("Hello")
+        expect(plain).to include("Hello")
       end
 
       it 'saves Body with autolink' do
-        plain.should include('World! <a href="http://example.com">http://example.com</a>')
+        expect(plain).to include('World! <a href="http://example.com">http://example.com</a>')
       end
     end
 
     context 'multipart' do
       let(:rich_file) { Dir["#{location}/*/rich.html"].first }
-      let(:rich) { File.read(rich_file) }
+      let(:rich) { CGI.unescape_html(File.read(rich_file)) }
 
       before do
-        Launchy.should_receive(:open)
+        expect(Launchy).to receive(:open)
 
         Mail.deliver do
           from    'foo@example.com'
@@ -82,41 +124,43 @@ describe LetterOpener::DeliveryMethod do
       end
 
       it 'creates plain html document' do
-        File.exist?(plain_file).should be_true
+        expect(File.exist?(plain_file)).to be_truthy
       end
 
       it 'creates rich html document' do
-        File.exist?(rich_file).should be_true
+        expect(File.exist?(rich_file)).to be_truthy
       end
 
       it 'shows link to rich html version' do
-        plain.should include("View HTML version")
+        expect(plain).to include("View HTML version")
       end
 
       it 'saves text part' do
-        plain.should include("This is &lt;plain&gt; text")
+        expect(plain).to include("This is <plain> text")
       end
 
       it 'saves html part' do
-        rich.should include("<h1>This is HTML</h1>")
+        expect(rich).to include("<h1>This is HTML</h1>")
       end
 
       it 'saves escaped Subject field' do
-        plain.should include("Many parts with &lt;html&gt;")
+        expect(plain).to include("Many parts with <html>")
+      end
+
+      it 'shows subject as title' do
+        expect(rich).to include("<title>Many parts with <html></title>")
       end
     end
   end
 
   context 'document with spaces in name' do
     let(:location) { File.expand_path('../../../tmp/letter_opener with space', __FILE__) }
-    let(:file)     { Dir["#{location}/*/plain.html"].first }
-    let(:plain)    { File.read(file) }
 
     before do
-      Launchy.should_receive(:open)
+      expect(Launchy).to receive(:open)
 
       Mail.deliver do
-        from     'Foo foo@example.com'
+        from     'Foo <foo@example.com>'
         to       'bar@example.com'
         subject  'Hello'
         body     'World!'
@@ -124,20 +168,17 @@ describe LetterOpener::DeliveryMethod do
     end
 
     it 'creates plain html document' do
-      File.exist?(file)
+      File.exist?(plain_file)
     end
 
     it 'saves From filed' do
-      plain.should include("Foo foo@example.com")
+      expect(plain).to include("Foo <foo@example.com>")
     end
   end
 
   context 'using deliver! method' do
-    let(:plain_file) { Dir["#{location}/*/plain.html"].first }
-    let(:plain) { File.read(plain_file) }
-
     before do
-      Launchy.should_receive(:open)
+      expect(Launchy).to receive(:open)
       Mail.new do
         from    'foo@example.com'
         to      'bar@example.com'
@@ -147,23 +188,23 @@ describe LetterOpener::DeliveryMethod do
     end
 
     it 'creates plain html document' do
-      File.exist?(plain_file).should be_true
+      expect(File.exist?(plain_file)).to be_truthy
     end
 
     it 'saves From field' do
-      plain.should include("foo@example.com")
+      expect(plain).to include("foo@example.com")
     end
 
     it 'saves To field' do
-      plain.should include("bar@example.com")
+      expect(plain).to include("bar@example.com")
     end
 
     it 'saves Subject field' do
-      plain.should include("Hello")
+      expect(plain).to include("Hello")
     end
 
     it 'saves Body field' do
-      plain.should include("World!")
+      expect(plain).to include("World!")
     end
   end
 
@@ -182,12 +223,12 @@ describe LetterOpener::DeliveryMethod do
 
     it 'creates attachments dir with attachment' do
       attachment = Dir["#{location}/*/attachments/#{File.basename(__FILE__)}"].first
-      File.exists?(attachment).should be_true
+      expect(File.exist?(attachment)).to be_truthy
     end
 
     it 'saves attachment name' do
       plain = File.read(Dir["#{location}/*/plain.html"].first)
-      plain.should include(File.basename(__FILE__))
+      expect(plain).to include(File.basename(__FILE__))
     end
   end
 
@@ -210,14 +251,126 @@ describe LetterOpener::DeliveryMethod do
 
     it 'creates attachments dir with attachment' do
       attachment = Dir["#{location}/*/attachments/#{File.basename(__FILE__)}"].first
-      File.exists?(attachment).should be_true
+      expect(File.exist?(attachment)).to be_truthy
     end
 
     it 'replaces inline attachment urls' do
       text = File.read(Dir["#{location}/*/rich.html"].first)
-      mail.parts[0].body.should include(url)
-      text.should_not include(url)
-      text.should include("attachments/#{File.basename(__FILE__)}")
+      expect(mail.parts[0].body).to include(url)
+      expect(text).to_not include(url)
+      expect(text).to include("attachments/#{File.basename(__FILE__)}")
+    end
+  end
+
+  context 'attachments with non-word characters in the filename' do
+    before do
+      Mail.deliver do
+        from      'foo@example.com'
+        to        'bar@example.com'
+        subject   'With attachments'
+        text_part do
+          body 'This is <plain> text'
+        end
+        attachments['non word:chars/used,01-02.txt'] = File.read(__FILE__)
+
+        url = attachments[0].url
+        html_part do
+          content_type 'text/html; charset=UTF-8'
+          body "This is an image: <img src='#{url}'>"
+        end
+      end
+    end
+
+    it 'creates attachments dir with attachment' do
+      attachment = Dir["#{location}/*/attachments/non_word_chars_used_01-02.txt"].first
+      expect(File.exist?(attachment)).to be_truthy
+    end
+
+    it 'saves attachment name' do
+      plain = File.read(Dir["#{location}/*/plain.html"].first)
+      expect(plain).to include('non_word_chars_used_01-02.txt')
+    end
+
+    it 'replaces inline attachment names' do
+      text = File.read(Dir["#{location}/*/rich.html"].first)
+      expect(text).to_not include('attachments/non word:chars/used,01-02.txt')
+      expect(text).to include('attachments/non_word_chars_used_01-02.txt')
+    end
+  end
+
+  context 'subjectless mail' do
+    before do
+      expect(Launchy).to receive(:open)
+
+      Mail.deliver do
+        from     'Foo foo@example.com'
+        reply_to 'No Reply no-reply@example.com'
+        to       'Bar bar@example.com'
+        body     'World! http://example.com'
+      end
+    end
+
+    it 'creates plain html document' do
+      expect(File.exist?(plain_file)).to be_truthy
+    end
+  end
+
+  context 'delivery params' do
+    it 'raises an exception if there is no SMTP Envelope To value' do
+      expect(Launchy).not_to receive(:open)
+
+      expect {
+        Mail.deliver do
+          from     'Foo foo@example.com'
+          reply_to 'No Reply no-reply@example.com'
+          body     'World! http://example.com'
+        end
+      }.to raise_exception(ArgumentError)
+    end
+
+    it 'does not raise an exception if there is at least one SMTP Envelope To value' do
+      expect(Launchy).to receive(:open)
+
+      expect {
+        Mail.deliver do
+          from     'Foo foo@example.com'
+          cc       'Bar bar@example.com'
+          reply_to 'No Reply no-reply@example.com'
+          body     'World! http://example.com'
+        end
+      }.not_to raise_exception
+    end
+  end
+
+  context 'light template' do
+    before do
+      expect(Launchy).to receive(:open)
+
+      LetterOpener.configure do |config|
+        config.message_template = :light
+      end
+
+      Mail.defaults do
+        delivery_method LetterOpener::DeliveryMethod, :location => File.expand_path('../../../tmp/letter_opener', __FILE__)
+      end
+
+      Mail.deliver do
+        subject  'Foo subject'
+        from     'Foo foo@example.com'
+        reply_to 'No Reply no-reply@example.com'
+        to       'Bar bar@example.com'
+        body     'World! http://example.com'
+      end
+    end
+
+    after do
+      LetterOpener.configure do |config|
+        config.message_template = :default
+      end
+    end
+
+    it 'creates plain html document' do
+      expect(File.exist?(plain_file)).to be_truthy
     end
   end
 end

data/spec/letter_opener/message_spec.rb

@@ -1,37 +1,222 @@
+# encoding: utf-8
 require 'spec_helper'
 
 describe LetterOpener::Message do
   let(:location) { File.expand_path('../../../tmp/letter_opener', __FILE__) }
 
+  def mail(options={}, &blk)
+    Mail.new(options, &blk)
+  end
+
   describe '#reply_to' do
     it 'handles one email as a string' do
-      message = described_class.new(location, mock(reply_to: 'test@example.com'))
-      message.reply_to.should eq('test@example.com')
+      mail    = mail(:reply_to => 'test@example.com')
+      message = described_class.new(mail, location: location)
+      expect(message.reply_to).to eq('test@example.com')
+    end
+
+    it 'handles one email with display names' do
+      mail    = mail(:reply_to => 'test <test@example.com>')
+      message = described_class.new(mail, location: location)
+      expect(message.reply_to).to eq('test <test@example.com>')
     end
 
     it 'handles array of emails' do
-      message = described_class.new(location, mock(reply_to: ['test1@example.com', 'test2@example.com']))
-      message.reply_to.should eq('test1@example.com, test2@example.com')
+      mail    = mail(:reply_to => ['test1@example.com', 'test2@example.com'])
+      message = described_class.new(mail, location: location)
+      expect(message.reply_to).to eq('test1@example.com, test2@example.com')
     end
+
+    it 'handles array of emails with display names' do
+      mail    = mail(:reply_to => ['test1 <test1@example.com>', 'test2 <test2@example.com>'])
+      message = described_class.new(mail, location: location)
+      expect(message.reply_to).to eq('test1 <test1@example.com>, test2 <test2@example.com>')
+    end
+
   end
 
   describe '#to' do
     it 'handles one email as a string' do
-      message = described_class.new(location, mock(to: 'test@example.com'))
-      message.to.should eq('test@example.com')
+      mail   = mail(:to => 'test@example.com')
+      message = described_class.new(mail, location: location)
+      expect(message.to).to eq('test@example.com')
+    end
+
+    it 'handles one email with display names' do
+      mail    = mail(:to => 'test <test@example.com>')
+      message = described_class.new(mail, location: location)
+      expect(message.to).to eq('test <test@example.com>')
+    end
+
+    it 'handles array of emails' do
+      mail    = mail(:to => ['test1@example.com', 'test2@example.com'])
+      message = described_class.new(mail, location: location)
+      expect(message.to).to eq('test1@example.com, test2@example.com')
+    end
+
+    it 'handles array of emails with display names' do
+      mail    = mail(:to => ['test1 <test1@example.com>', 'test2 <test2@example.com>'])
+      message = described_class.new(mail, location: location)
+      expect(message.to).to eq('test1 <test1@example.com>, test2 <test2@example.com>')
+    end
+
+  end
+
+  describe '#cc' do
+    it 'handles one cc email as a string' do
+      mail    = mail(:cc => 'test@example.com')
+      message = described_class.new(mail, location: location)
+      expect(message.cc).to eq('test@example.com')
+    end
+
+    it 'handles one cc email with display name' do
+      mail    = mail(:cc => ['test <test1@example.com>', 'test2 <test2@example.com>'])
+      message = described_class.new(mail, location: location)
+      expect(message.cc).to eq('test <test1@example.com>, test2 <test2@example.com>')
+    end
+
+    it 'handles array of cc emails' do
+      mail    = mail(:cc => ['test1@example.com', 'test2@example.com'])
+      message = described_class.new(mail, location: location)
+      expect(message.cc).to eq('test1@example.com, test2@example.com')
+    end
+
+    it 'handles array of cc emails with display names' do
+      mail    = mail(:cc => ['test <test1@example.com>', 'test2 <test2@example.com>'])
+      message = described_class.new(mail, location: location)
+      expect(message.cc).to eq('test <test1@example.com>, test2 <test2@example.com>')
+    end
+
+  end
+
+  describe '#bcc' do
+    it 'handles one bcc email as a string' do
+      mail    = mail(:bcc => 'test@example.com')
+      message = described_class.new(mail, location: location)
+      expect(message.bcc).to eq('test@example.com')
+    end
+
+    it 'handles one bcc email with display name' do
+      mail    = mail(:bcc => ['test <test1@example.com>', 'test2 <test2@example.com>'])
+      message = described_class.new(mail, location: location)
+      expect(message.bcc).to eq('test <test1@example.com>, test2 <test2@example.com>')
+    end
+
+    it 'handles array of bcc emails' do
+      mail    = mail(:bcc => ['test1@example.com', 'test2@example.com'])
+      message = described_class.new(mail, location: location)
+      expect(message.bcc).to eq('test1@example.com, test2@example.com')
+    end
+
+    it 'handles array of bcc emails with display names' do
+      mail    = mail(:bcc => ['test <test1@example.com>', 'test2 <test2@example.com>'])
+      message = described_class.new(mail, location: location)
+      expect(message.bcc).to eq('test <test1@example.com>, test2 <test2@example.com>')
+    end
+
+  end
+
+  describe '#sender' do
+    it 'handles one email as a string' do
+      mail    = mail(:sender => 'sender@example.com')
+      message = described_class.new(mail, location: location)
+      expect(message.sender).to eq('sender@example.com')
+    end
+
+    it 'handles one email as a string with display name' do
+      mail    = mail(:sender => 'test <test@example.com>')
+      message = described_class.new(mail, location: location)
+      expect(message.sender).to eq('test <test@example.com>')
     end
 
     it 'handles array of emails' do
-      message = described_class.new(location, mock(to: ['test1@example.com', 'test2@example.com']))
-      message.to.should eq('test1@example.com, test2@example.com')
+      mail    = mail(:sender => ['sender1@example.com', 'sender2@example.com'])
+      message = described_class.new(mail, location: location)
+      expect(message.sender).to eq('sender1@example.com, sender2@example.com')
+    end
+
+    it 'handles array of emails with display names' do
+      mail    = mail(:sender => ['test <test1@example.com>', 'test2 <test2@example.com>'])
+      message = described_class.new(mail, location: location)
+      expect(message.sender).to eq('test <test1@example.com>, test2 <test2@example.com>')
     end
+
   end
 
   describe '#<=>' do
     it 'sorts rich type before plain type' do
-      plain = described_class.new(location, mock(content_type: 'text/plain'))
-      rich = described_class.new(location, mock(content_type: 'text/html'))
-      [plain, rich].sort.should eq([rich, plain])
+      plain = described_class.new(double(content_type: 'text/plain'), location: location)
+      rich  = described_class.new(double(content_type: 'text/html'), location: location)
+      expect([plain, rich].sort).to eq([rich, plain])
+    end
+  end
+
+  describe '#auto_link' do
+    let(:message){ described_class.new(mail, location: location) }
+
+    it 'does not modify unlinkable text' do
+      text = 'the quick brown fox jumped over the lazy dog'
+      expect(message.auto_link(text)).to eq(text)
+    end
+
+    it 'adds links for http' do
+      raw = "Link to http://localhost:3000/example/path path"
+      linked = "Link to <a href=\"http://localhost:3000/example/path\">http://localhost:3000/example/path</a> path"
+      expect(message.auto_link(raw)).to eq(linked)
+    end
+  end
+
+  describe '#body' do
+    it 'handles UTF-8 charset body correctly, with QP CTE, for a non-multipart message' do
+      mail = mail(:sender => 'sender@example.com') do
+        content_type "text/html; charset=UTF-8"
+        content_transfer_encoding 'quoted-printable'
+        body "☃"
+      end
+      message = message = described_class.new(mail, location: location)
+      expect(message.body.encoding.name).to eq('UTF-8')
+    end
+
+    it 'handles UTF-8 charset HTML part body correctly, with QP CTE, for a multipart message' do
+      mail = mail(:sender => 'sender@example.com') do
+        html_part do
+          content_type "text/html; charset=UTF-8"
+          content_transfer_encoding 'quoted-printable'
+          body "☃"
+        end
+      end
+      message = described_class.new(mail, location: location, part: mail.html_part)
+      expect(message.body.encoding.name).to eq('UTF-8')
+    end
+
+    it 'handles UTF-8 charset text part body correctly, with QP CTE, for a multipart message' do
+      mail = mail(:sender => 'sender@example.com') do
+        text_part do
+          content_type "text/plain; charset=UTF-8"
+          content_transfer_encoding 'quoted-printable'
+          body "☃"
+        end
+      end
+      message = described_class.new(mail, location: location, part: mail.text_part)
+      expect(message.body.encoding.name).to eq('UTF-8')
+    end
+  end
+
+  describe '.rendered_messages' do
+    it 'uses configured default template if options not given' do
+      allow(LetterOpener.configuration).to receive(:location) { location }
+      messages = described_class.rendered_messages(mail)
+      expect(messages.first.template).not_to be_nil
+    end
+
+    it 'fails if necessary defaults are not provided' do
+      allow(LetterOpener.configuration).to receive(:location) { nil }
+      expect { described_class.rendered_messages(mail) }.to raise_error(ArgumentError)
+    end
+
+    it 'fails if necessary defaults are not provided' do
+      allow(LetterOpener.configuration).to receive(:message_template) { nil }
+      expect { described_class.rendered_messages(mail) }.to raise_error(ArgumentError)
     end
   end
 end

data/spec/spec_helper.rb

@@ -5,7 +5,5 @@ Bundler.require(:default)
 require "mail"
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
 end