imap-backup 1.2.2 → 1.2.3

data/spec/unit/configuration/store_spec.rb

@@ -1,19 +1,18 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'json'
+require "spec_helper"
+require "json"
 
 describe Imap::Backup::Configuration::Store do
-  let(:directory) { '/base/path' }
-  let(:file_path) { File.join(directory, '/config.json') }
+  let(:directory) { "/base/path" }
+  let(:file_path) { File.join(directory, "/config.json") }
   let(:file_exists) { true }
   let(:directory_exists) { true }
-  let(:data) { {:debug => debug, :accounts => accounts} }
+  let(:data) { {debug: debug, accounts: accounts} }
   let(:debug) { true }
   let(:accounts) { [] }
   let(:configuration) { data.to_json }
 
   before do
-    stub_const('Imap::Backup::Configuration::Store::CONFIGURATION_DIRECTORY', directory)
+    stub_const("Imap::Backup::Configuration::Store::CONFIGURATION_DIRECTORY", directory)
     allow(File).to receive(:directory?).with(directory).and_return(directory_exists)
     allow(File).to receive(:exist?).with(file_path).and_return(file_exists)
     allow(Imap::Backup::Utils).to receive(:stat).with(directory).and_return(0700)
@@ -22,9 +21,9 @@ describe Imap::Backup::Configuration::Store do
     allow(File).to receive(:read).with(file_path).and_return(configuration)
   end
 
-  describe '.exist?' do
+  describe ".exist?" do
     [true, false].each do |exists|
-      state = exists ? 'exists' : "doesn't exist"
+      state = exists ? "exists" : "doesn't exist"
       context "when the file #{state}" do
         let(:file_exists) { exists }
 
@@ -35,123 +34,123 @@ describe Imap::Backup::Configuration::Store do
     end
   end
 
-  describe '#path' do
-    it 'is the directory containing the configuration file' do
+  describe "#path" do
+    it "is the directory containing the configuration file" do
       expect(subject.path).to eq(directory)
     end
   end
 
-  describe '#modified?' do
+  describe "#modified?" do
     context "'with accounts flagged 'modified'" do
-      let(:accounts) { [{:name => 'foo', :modified => true}] }
+      let(:accounts) { [{name: "foo", modified: true}] }
 
-      it 'is true' do
+      it "is true" do
         expect(subject.modified?).to be_truthy
       end
     end
 
     context "'with accounts flagged 'delete'" do
-      let(:accounts) { [{:name => 'foo', :delete => true}] }
+      let(:accounts) { [{name: "foo", delete: true}] }
 
-      it 'is true' do
+      it "is true" do
         expect(subject.modified?).to be_truthy
       end
     end
 
     context "without accounts flagged 'modified'" do
-      let(:accounts) { [{:name => 'foo'}] }
+      let(:accounts) { [{name: "foo"}] }
 
-      it 'is false' do
+      it "is false" do
         expect(subject.modified?).to be_falsey
       end
     end
   end
 
-  describe '#debug?' do
-    context 'when the debug flag is true' do
-      it 'is true' do
+  describe "#debug?" do
+    context "when the debug flag is true" do
+      it "is true" do
         expect(subject.debug?).to be_truthy
       end
     end
 
-    context 'when the debug flag is false' do
+    context "when the debug flag is false" do
       let(:debug) { false }
 
-      it 'is false' do
+      it "is false" do
         expect(subject.debug?).to be_falsey
       end
     end
 
-    context 'when the debug flag is missing' do
-      let(:data) { {:accounts => accounts} }
+    context "when the debug flag is missing" do
+      let(:data) { {accounts: accounts} }
 
-      it 'is false' do
+      it "is false" do
         expect(subject.debug?).to be_falsey
       end
     end
 
-    context 'when the debug flag is neither true nor false' do
-      let(:debug) { 'hi' }
+    context "when the debug flag is neither true nor false" do
+      let(:debug) { "hi" }
 
-      it 'is false' do
+      it "is false" do
         expect(subject.debug?).to be_falsey
       end
     end
   end
 
-  describe '#debug=' do
+  describe "#debug=" do
     before { subject.debug = debug }
 
-    context 'when the supplied value is true' do
-      it 'sets the flag to true' do
+    context "when the supplied value is true" do
+      it "sets the flag to true" do
         expect(subject.debug?).to be_truthy
       end
     end
 
-    context 'when the supplied value is false' do
+    context "when the supplied value is false" do
       let(:debug) { false }
 
-      it 'sets the flag to false' do
+      it "sets the flag to false" do
         expect(subject.debug?).to be_falsey
       end
     end
 
-    context 'when the supplied value is neither true nor false' do
-      let(:debug) { 'ciao' }
+    context "when the supplied value is neither true nor false" do
+      let(:debug) { "ciao" }
 
-      it 'sets the flag to false' do
+      it "sets the flag to false" do
         expect(subject.debug?).to be_falsey
       end
     end
   end
 
-  describe '#save' do
+  describe "#save" do
     let(:directory_exists) { false }
-    let(:file) { double('File', :write => nil) }
+    let(:file) { double("File", write: nil) }
 
     before do
       allow(FileUtils).to receive(:mkdir)
       allow(FileUtils).to receive(:chmod)
-      allow(File).to receive(:open).with(file_path, 'w') { |&b| b.call file }
-      allow(JSON).to receive(:pretty_generate).and_return('JSON output')
+      allow(File).to receive(:open).with(file_path, "w") { |&b| b.call file }
+      allow(JSON).to receive(:pretty_generate).and_return("JSON output")
     end
 
     subject { described_class.new }
 
-    it 'creates the config directory' do
+    it "creates the config directory" do
       subject.save
 
       expect(FileUtils).to have_received(:mkdir).with(directory)
     end
 
-    it 'saves the configuration' do
+    it "saves the configuration" do
       subject.save
 
-      expect(file).to have_received(:write).with('JSON output')
+      expect(file).to have_received(:write).with("JSON output")
     end
 
-    context 'when accounts are modified' do
-      let(:accounts) { [{:name => 'foo', :modified => true}] }
+    context "when accounts are modified" do
+      let(:accounts) { [{name: "foo", modified: true}] }
       
       before { subject.save }
 
@@ -163,17 +162,17 @@ describe Imap::Backup::Configuration::Store do
       end
     end
 
-    context 'when accounts are to be deleted' do
+    context "when accounts are to be deleted" do
       let(:accounts) do
         [
-          {:name => 'keep_me'},
-          {:name => 'delete_me', :delete => true},
+          {name: "keep_me"},
+          {name: "delete_me", delete: true}
         ]
       end
 
       before { subject.save }
 
-      it 'does not save them' do
+      it "does not save them" do
         expected = Marshal.load(Marshal.dump(data))
         expected[:accounts].pop
 
@@ -181,15 +180,15 @@ describe Imap::Backup::Configuration::Store do
       end
     end
 
-    context 'when file permissions are too open' do
+    context "when file permissions are too open" do
       before { subject.save }
 
-      it 'sets them to 0600' do
+      it "sets them to 0600" do
         expect(FileUtils).to have_received(:chmod).with(0600, file_path)
       end
     end
 
-    context 'if the configuration file is missing' do
+    context "if the configuration file is missing" do
       let(:file_exists) { false }
 
       it "doesn't fail" do
@@ -199,17 +198,17 @@ describe Imap::Backup::Configuration::Store do
       end
     end
 
-    context 'if the config file permissions are too lax' do
+    context "if the config file permissions are too lax" do
       let(:file_exists) { true }
 
       before do
-        allow(Imap::Backup::Utils).to receive(:check_permissions).with(file_path, 0600).and_raise('Error')
+        allow(Imap::Backup::Utils).to receive(:check_permissions).with(file_path, 0600).and_raise("Error")
       end
 
-      it 'fails' do
+      it "fails" do
         expect do
           subject.save
-        end.to raise_error(RuntimeError, 'Error')
+        end.to raise_error(RuntimeError, "Error")
       end
     end
   end

data/spec/unit/downloader_spec.rb

@@ -1,39 +1,38 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Downloader do
-  describe '#run' do
-    let(:message) { {'RFC822' => 'blah'} }
-    let(:folder) { double('Imap::Backup::Account::Folder', :fetch => message, :name => 'folder') }
-    let(:folder_uids) { ['111', '222', '333'] }
-    let(:serializer) { double('Imap::Backup::Serializer', :save => nil) }
-    let(:serializer_uids) { ['222'] }
+  describe "#run" do
+    let(:message) { {"RFC822" => "blah"} }
+    let(:folder) { double("Imap::Backup::Account::Folder", fetch: message, name: "folder") }
+    let(:folder_uids) { ["111", "222", "333"] }
+    let(:serializer) { double("Imap::Backup::Serializer", save: nil) }
+    let(:serializer_uids) { ["222"] }
 
     subject { described_class.new(folder, serializer) }
 
     before do
       allow(folder).to receive(:uids).and_return(folder_uids)
       allow(serializer).to receive(:uids).and_return(serializer_uids)
-      allow(folder).to receive(:fetch).with('333').and_return(nil)
+      allow(folder).to receive(:fetch).with("333").and_return(nil)
       subject.run
     end
 
-    context '#run' do
-      context 'fetched messages' do
-        it 'are saved' do
-          expect(serializer).to have_received(:save).with('111', message)
+    context "#run" do
+      context "fetched messages" do
+        it "are saved" do
+          expect(serializer).to have_received(:save).with("111", message)
         end
       end
 
-      context 'messages which are already present' do
-        specify 'are skipped' do
-          expect(serializer).to_not have_received(:save).with('222', anything)
+      context "messages which are already present" do
+        specify "are skipped" do
+          expect(serializer).to_not have_received(:save).with("222", anything)
         end
       end
 
-      context 'failed fetches' do
-        specify 'are skipped' do
-          expect(serializer).to_not have_received(:save).with('333', anything)
+      context "failed fetches" do
+        specify "are skipped" do
+          expect(serializer).to_not have_received(:save).with("333", anything)
         end
       end
     end

data/spec/unit/email/mboxrd/message_spec.rb

@@ -1,32 +1,47 @@
-# encoding: utf-8
+require "spec_helper"
 
-require 'spec_helper'
+msg_no_from = %Q|Delivered-To: you@example.com
+From: example <www.example.com>
+To: FirstName LastName <you@example.com>
+Subject: Re: no subject|
+
+msg_bad_from = %Q|Delivered-To: you@example.com
+from: "FirstName LastName (TEXT)" <"TEXT*" <no-reply@example.com>>
+To: FirstName LastName <you@example.com>
+Subject: Re: no subject
+Sender: FistName LastName <"TEXT*"no-reply=example.com@example.com>|
+
+msg_no_from_but_return_path = %Q|Delivered-To: you@example.com
+From: example <www.example.com>
+To: FirstName LastName <you@example.com>
+Return-Path: <me@example.com>
+Subject: Re: no subject|
 
 describe Email::Mboxrd::Message do
-  let(:from) { 'me@example.com' }
+  let(:from) { "me@example.com" }
   let(:date) { DateTime.new(2012, 12, 13, 18, 23, 45) }
   let(:message_body) do
-    double('Body', :clone => cloned_message_body, :force_encoding => nil)
+    double("Body", clone: cloned_message_body, force_encoding: nil)
   end
   let(:cloned_message_body) { "Foo\nBar\nFrom at the beginning of the line\n>>From quoted" }
 
   subject { described_class.new(message_body) }
 
-  context '#to_s' do
-    let(:mail) { double('Mail', :from =>[from], :date => date) }
+  context "#to_s" do
+    let(:mail) { double("Mail", from: [from], date: date) }
 
     before do
       allow(Mail).to receive(:new).with(cloned_message_body).and_return(mail)
     end
 
-    it 'does not modify the message' do
+    it "does not modify the message" do
       subject.to_s
 
-      expect(message_body).to_not have_received(:force_encoding).with('binary')
+      expect(message_body).to_not have_received(:force_encoding).with("binary")
     end
 
     it "adds a 'From ' line at the start" do
-      expect(subject.to_s).to start_with('From ' + from + ' ' + date.asctime + "\n")
+      expect(subject.to_s).to start_with("From " + from + " " + date.asctime + "\n")
     end
 
     it "replaces existing 'From ' with '>From '" do
@@ -37,12 +52,41 @@ describe Email::Mboxrd::Message do
       expect(subject.to_s).to include("\n>>>From quoted")
     end
 
-    context 'when date is missing' do
+    context "when date is missing" do
       let(:date) { nil }
 
-      it 'does no fail' do
+      it "does no fail" do
         expect { subject.to_s }.to_not raise_error
       end
     end
   end
+
+  context '#from' do
+    before do
+      # call original for these tests because we want to test the behaviour of
+      # class-under-test given different behaviour of the Mail parser
+      allow(Mail).to receive(:new).and_call_original
+    end
+
+    context "when original message 'from' is nil" do
+      let(:message_body) { msg_no_from }
+      it "'from' is empty string" do
+        expect(subject.to_s).to start_with("From  \n")
+      end
+    end
+
+    context "when original message 'from' is a string but not an address" do
+      let(:message_body) { msg_bad_from }
+      it "'from' is empty string" do
+        expect(subject.to_s).to start_with("From  \n")
+      end
+    end
+
+    context "when original message 'from' is nil and 'envelope from' is nil and 'return path' is available" do
+      let(:message_body) { msg_no_from_but_return_path }
+      it "'return path' is used as 'from'" do
+        expect(subject.to_s).to start_with("From " + from + " \n")
+      end
+    end
+  end
 end

data/spec/unit/email/provider_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Email::Provider do
-  describe '.for_address' do
-    context 'known providers' do
-      [['gmail.com', :gmail], ['fastmail.fm', :fastmail]].each do |domain, provider|
+  describe ".for_address" do
+    context "known providers" do
+      [["gmail.com", :gmail], ["fastmail.fm", :fastmail]].each do |domain, provider|
         it "recognizes #{provider}" do
           address = "foo@#{domain}"
           expect(described_class.for_address(address).provider).to eq(provider)
@@ -11,24 +11,24 @@ describe Email::Provider do
       end
     end
 
-    context 'with unknown providers' do
-      it 'returns a default provider' do
-        expect(described_class.for_address('foo@unknown.com').provider).to eq(:default)
+    context "with unknown providers" do
+      it "returns a default provider" do
+        expect(described_class.for_address("foo@unknown.com").provider).to eq(:default)
       end
     end
   end
 
   subject { described_class.new(:gmail) }
 
-  describe '#options' do
-    it 'returns options' do
+  describe "#options" do
+    it "returns options" do
       expect(subject.options).to eq(port: 993, ssl: true)
     end
   end
 
-  describe '#host' do
-    it 'returns host' do
-      expect(subject.host).to eq('imap.gmail.com')
+  describe "#host" do
+    it "returns host" do
+      expect(subject.host).to eq("imap.gmail.com")
     end
   end
 end