imap-backup 2.0.0 → 2.2.2

data/spec/features/support/email_server.rb

@@ -1,6 +1,6 @@
 module EmailServerHelpers
-  REQUESTED_ATTRIBUTES = ["RFC822", "FLAGS", "INTERNALDATE"]
-  DEFAULT_EMAIL = "address@example.org"
+  REQUESTED_ATTRIBUTES = %w(RFC822 FLAGS INTERNALDATE).freeze
+  DEFAULT_EMAIL = "address@example.org".freeze
 
   def send_email(folder, options)
     message = message_as_server_message(options)
@@ -11,13 +11,14 @@ module EmailServerHelpers
     from = options[:from] || DEFAULT_EMAIL
     subject = options[:subject]
     body = options[:body]
-    message = <<-EOT.gsub("\n", "\r\n")
-From: #{from}
-Subject: #{subject}
 
-#{body}
+    <<~MESSAGE.gsub("\n", "\r\n")
+      From: #{from}
+      Subject: #{subject}
 
-    EOT
+      #{body}
+
+    MESSAGE
   end
 
   def server_messages(folder)
@@ -32,18 +33,18 @@ Subject: #{subject}
 
   def server_fetch_email(folder, uid)
     examine folder
+
     fetch_data_items = imap.uid_fetch([uid.to_i], REQUESTED_ATTRIBUTES)
     return nil if fetch_data_items.nil?
+
     fetch_data_item = fetch_data_items[0]
-    attributes = fetch_data_item.attr
-    attributes["RFC822"].force_encoding("utf-8")
-    attributes
+    fetch_data_item.attr
   end
 
   def delete_emails(folder)
     imap.select(folder)
     uids = imap.uid_search(["ALL"]).sort
-    imap.store(1 .. uids.size, "+FLAGS", [:Deleted])
+    imap.store(1..uids.size, "+FLAGS", [:Deleted])
     imap.expunge
   end
 
@@ -82,6 +83,9 @@ Subject: #{subject}
   def server_delete_folder(folder)
     imap.delete folder
     imap.disconnect
+  rescue StandardError => e
+    puts e.to_s
+  ensure
     @imap = nil
   end
 

data/spec/features/support/shared/connection_context.rb

@@ -3,10 +3,10 @@ shared_context "imap-backup connection" do
   let(:default_connection) { fixture("connection") }
   let(:backup_folders) { nil }
   let(:connection_options) do
-    default_connection.merge({
+    default_connection.merge(
       local_path: local_backup_path,
       folders: backup_folders
-    })
+    )
   end
   let(:connection) { Imap::Backup::Account::Connection.new(connection_options) }
 end

data/spec/features/support/shared/message_fixtures.rb

@@ -2,7 +2,15 @@ shared_context "message-fixtures" do
   let(:uid1) { 123 }
   let(:uid2) { 345 }
   let(:uid3) { 567 }
+  let(:uid_iso8859) { 890 }
   let(:msg1) { {uid: uid1, subject: "Test 1", body: "body 1\nHi"} }
   let(:msg2) { {uid: uid2, subject: "Test 2", body: "body 2"} }
   let(:msg3) { {uid: uid3, subject: "Test 3", body: "body 3"} }
+  let(:msg_iso8859) do
+    {
+      uid: uid_iso8859,
+      subject: "iso8859 Body",
+      body: "Ma, perchè?".encode(Encoding::ISO_8859_1).force_encoding("binary")
+    }
+  end
 end

data/spec/spec_helper.rb

@@ -7,7 +7,7 @@ spec_path = File.dirname(__FILE__)
 $LOAD_PATH << File.expand_path("../lib", spec_path)
 
 support_glob = File.join(spec_path, "support", "**", "*.rb")
-Dir[support_glob].each { |f| require f }
+Dir[support_glob].sort.each { |f| require f }
 
 require "simplecov"
 SimpleCov.start do

data/spec/support/fixtures.rb

@@ -1,6 +1,6 @@
 def fixture(name)
   spec_root = File.expand_path("..", File.dirname(__FILE__))
-  fixture_path = File.join(spec_root, "fixtures", name + ".yml")
+  fixture_path = File.join(spec_root, "fixtures", "#{name}.yml")
   fixture = File.read(fixture_path)
-  YAML.load(fixture)
+  YAML.safe_load(fixture, [Symbol])
 end

data/spec/support/higline_test_helpers.rb

@@ -1,6 +1,6 @@
 module HighLineTestHelpers
   def prepare_highline
-    @input = double("stdin", eof?: false, gets: "q\n")
+    @input = instance_double(IO, eof?: false, gets: "q\n")
     @output = StringIO.new
     Imap::Backup::Configuration::Setup.highline = HighLine.new(@input, @output)
     [@input, @output]

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

@@ -1,79 +1,82 @@
-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|
-
-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|
-
-msg_no_from_but_sender = %Q|Delivered-To: you@example.com
-To: FirstName LastName <you@example.com>
-Subject: Re: no subject
-Sender: FistName LastName <me@example.com>|
+msg_no_from = <<~NO_FROM
+  Delivered-To: you@example.com
+  From: example <www.example.com>
+  To: FirstName LastName <you@example.com>
+  Subject: Re: no subject
+NO_FROM
+
+msg_bad_from = <<~BAD_FROM
+  Delivered-To: you@example.com
+  from: "FirstName LastName (TEXT)" <"TEXT*" <no-reply@example.com>>
+  To: FirstName LastName <you@example.com>
+  Subject: Re: no subject
+BAD_FROM
+
+msg_no_from_but_return_path = <<~RETURN_PATH
+  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
+RETURN_PATH
+
+msg_no_from_but_sender = <<~NOT_SENDER
+  Delivered-To: you@example.com
+  To: FirstName LastName <you@example.com>
+  Subject: Re: no subject
+  Sender: FistName LastName <me@example.com>
+NOT_SENDER
 
 describe Email::Mboxrd::Message do
+  subject { described_class.new(message_body) }
+
   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)
+    instance_double(String, clone: cloned_message_body, force_encoding: nil)
   end
   let(:cloned_message_body) do
     "Foo\nBar\nFrom at the beginning of the line\n>>From quoted"
   end
   let(:msg_good) do
-    %Q|Delivered-To: you@example.com
-From: Foo <foo@example.com>
-To: FirstName LastName <you@example.com>
-Date: #{date.rfc822}
-Subject: Re: no subject|
+    <<~GOOD
+      Delivered-To: you@example.com
+      From: Foo <foo@example.com>
+      To: FirstName LastName <you@example.com>
+      Date: #{date.rfc822}
+      Subject: Re: no subject
+    GOOD
   end
 
   let(:msg_bad_date) do
-    %Q|Delivered-To: you@example.com
-From: Foo <foo@example.com>
-To: FirstName LastName <you@example.com>
-Date: Mon,5 May 2014 08:97:99 GMT
-Subject: Re: no subject|
+    <<~BAD
+      Delivered-To: you@example.com
+      From: Foo <foo@example.com>
+      To: FirstName LastName <you@example.com>
+      Date: Mon,5 May 2014 08:97:99 GMT
+      Subject: Re: no subject
+    BAD
   end
 
-  subject { described_class.new(message_body) }
-
   describe ".from_serialized" do
     let(:serialized_message) { "From foo@a.com\n#{imap_message}" }
     let(:imap_message) { "Delivered-To: me@example.com\nFrom Me\n" }
-
-    before { @result = described_class.from_serialized(serialized_message) }
+    let!(:result) { described_class.from_serialized(serialized_message) }
 
     it "returns the message" do
-      expect(@result).to be_a(described_class)
+      expect(result).to be_a(described_class)
     end
 
     it "removes one level of > before From" do
-      expect(@result.supplied_body).to eq(imap_message)
+      expect(result.supplied_body).to eq(imap_message)
     end
   end
 
-  context "#to_serialized" do
-    let(:mail) { double("Mail", from: [from], date: date) }
+  describe "#to_serialized" do
+    let(:mail) { instance_double(Mail::Message, 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
-      subject.to_serialized
-
-      expect(message_body).to_not have_received(:force_encoding).with("binary")
+      allow(Mail).to receive(:new).with(cloned_message_body) { mail }
     end
 
     it "adds a 'From ' line at the start" do
@@ -98,7 +101,7 @@ Subject: Re: no subject|
     end
   end
 
-  context "#from" do
+  describe "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
@@ -113,7 +116,7 @@ Subject: Re: no subject|
       end
     end
 
-    context "when original message 'from' is a string but not well-formed address" do
+    context "when original message 'from' is not a well-formed address" do
       let(:message_body) { msg_bad_from }
 
       it "'from' is empty string" do
@@ -126,7 +129,7 @@ Subject: Re: no subject|
       let(:message_body) { msg_no_from_but_return_path }
 
       it "'return path' is used as 'from'" do
-        expect(subject.to_serialized).to start_with("From " + from + "\n")
+        expect(subject.to_serialized).to start_with("From #{from}\n")
       end
     end
 
@@ -134,12 +137,12 @@ Subject: Re: no subject|
       let(:message_body) { msg_no_from_but_sender }
 
       it "Sender is used as 'from'" do
-        expect(subject.to_serialized).to start_with("From " + from + "\n")
+        expect(subject.to_serialized).to start_with("From #{from}\n")
       end
     end
   end
 
-  context "#date" do
+  describe "#date" do
     let(:message_body) { msg_good }
 
     it "returns the date" do
@@ -154,4 +157,21 @@ Subject: Re: no subject|
       end
     end
   end
+
+  describe "#imap_body" do
+    let(:message_body) { "Ciao" }
+
+    it "returns the supplied body" do
+      expect(subject.imap_body).to eq(message_body)
+    end
+
+    context "when newlines are not IMAP standard" do
+      let(:message_body) { "Ciao\nHello" }
+      let(:corrected) { "Ciao\r\nHello" }
+
+      it "corrects them" do
+        expect(subject.imap_body).to eq(corrected)
+      end
+    end
+  end
 end

data/spec/unit/email/provider_spec.rb

@@ -1,8 +1,8 @@
-require "spec_helper"
-
 describe Email::Provider do
+  subject { described_class.new(:gmail) }
+
   describe ".for_address" do
-    context "known providers" do
+    context "with known providers" do
       [
         ["gmail.com", :gmail],
         ["fastmail.fm", :fastmail]
@@ -22,8 +22,6 @@ describe Email::Provider do
     end
   end
 
-  subject { described_class.new(:gmail) }
-
   describe "#options" do
     it "returns options" do
       expect(subject.options).to be_a(Hash)

data/spec/unit/imap/backup/account/connection_spec.rb

@@ -1,5 +1,3 @@
-require "spec_helper"
-
 describe Imap::Backup::Account::Connection do
   def self.backup_folder
     "backup_folder"
@@ -9,6 +7,8 @@ describe Imap::Backup::Account::Connection do
     {name: backup_folder}
   end
 
+  subject { described_class.new(options) }
+
   let(:imap) do
     instance_double(Net::IMAP, login: nil, disconnect: nil)
   end
@@ -18,7 +18,7 @@ describe Imap::Backup::Account::Connection do
       username: username,
       password: "password",
       local_path: local_path,
-      folders: backup_folders,
+      folders: backup_folders
     }
   end
   let(:local_path) { "local_path" }
@@ -33,7 +33,7 @@ describe Imap::Backup::Account::Connection do
       Imap::Backup::Serializer::Mbox,
       folder: serialized_folder,
       force_uid_validity: nil,
-      set_uid_validity: new_uid_validity,
+      apply_uid_validity: new_uid_validity,
       uids: [local_uid]
     )
   end
@@ -48,19 +48,13 @@ describe Imap::Backup::Account::Connection do
     allow(Imap::Backup::Utils).to receive(:make_folder)
   end
 
-  subject { described_class.new(options) }
-
   shared_examples "connects to IMAP" do
-    it "sets up the IMAP connection" do
-      expect(Net::IMAP).to have_received(:new)
-    end
-
     it "logs in to the imap server" do
       expect(imap).to have_received(:login)
     end
   end
 
-  context "#initialize" do
+  describe "#initialize" do
     [
       [:username, "username@gmail.com"],
       [:local_path, "local_path"],
@@ -72,22 +66,23 @@ describe Imap::Backup::Account::Connection do
     end
 
     it "creates the path" do
+      expect(Imap::Backup::Utils).to receive(:make_folder)
+
       subject.username
-      expect(Imap::Backup::Utils).to have_received(:make_folder)
     end
   end
 
   describe "#imap" do
-    before { @result = subject.imap }
+    let!(:result) { subject.imap }
 
     it "returns the IMAP connection" do
-      expect(@result).to eq(imap)
+      expect(result).to eq(imap)
     end
 
     include_examples "connects to IMAP"
   end
 
-  context "#folders" do
+  describe "#folders" do
     let(:imap_folders) do
       [instance_double(Net::IMAP::MailboxList)]
     end
@@ -97,18 +92,18 @@ describe Imap::Backup::Account::Connection do
     end
   end
 
-  context "#status" do
+  describe "#status" do
     let(:folder) do
       instance_double(Imap::Backup::Account::Folder, uids: [remote_uid])
     end
     let(:remote_uid) { "remote_uid" }
 
     before do
-      allow(Imap::Backup::Account::Folder).to receive(:new).and_return(folder)
+      allow(Imap::Backup::Account::Folder).to receive(:new) { folder }
       allow(Imap::Backup::Serializer::Mbox).to receive(:new) { serializer }
     end
 
-    it "should return the names of folders" do
+    it "returns the names of folders" do
       expect(subject.status[0][:name]).to eq(self.class.backup_folder)
     end
 
@@ -116,19 +111,21 @@ describe Imap::Backup::Account::Connection do
       expect(subject.status[0][:local]).to eq([local_uid])
     end
 
-    it "should retrieve the available uids" do
+    it "retrieves the available uids" do
       expect(subject.status[0][:remote]).to eq([remote_uid])
     end
   end
 
-  context "#run_backup" do
+  describe "#run_backup" do
     let(:folder) do
       instance_double(
         Imap::Backup::Account::Folder,
         name: "folder",
+        exist?: exists,
         uid_validity: uid_validity
       )
     end
+    let(:exists) { true }
     let(:uid_validity) { 123 }
     let(:downloader) { instance_double(Imap::Backup::Downloader, run: nil) }
 
@@ -140,15 +137,25 @@ describe Imap::Backup::Account::Connection do
     context "with supplied backup_folders" do
       before do
         allow(Imap::Backup::Account::Folder).to receive(:new).
-          with(subject, self.class.backup_folder).and_return(folder)
+          with(subject, self.class.backup_folder) { folder }
         allow(Imap::Backup::Serializer::Mbox).to receive(:new).
-          with(local_path, self.class.backup_folder).and_return(serializer)
+          with(local_path, self.class.backup_folder) { serializer }
       end
 
-      before { subject.run_backup }
-
       it "runs the downloader" do
-        expect(downloader).to have_received(:run)
+        expect(downloader).to receive(:run)
+
+        subject.run_backup
+      end
+
+      context "when a folder does not exist" do
+        let(:exists) { false }
+
+        it "does not run the downloader" do
+          expect(downloader).to_not receive(:run)
+
+          subject.run_backup
+        end
       end
     end
 
@@ -159,28 +166,28 @@ describe Imap::Backup::Account::Connection do
 
       before do
         allow(Imap::Backup::Account::Folder).to receive(:new).
-          with(subject, "foo").and_return(folder)
+          with(subject, "foo") { folder }
         allow(Imap::Backup::Serializer::Mbox).to receive(:new).
-          with(local_path, "foo").and_return(serializer)
+          with(local_path, "foo") { serializer }
       end
 
       context "when supplied backup_folders is nil" do
         let(:backup_folders) { nil }
 
-        before { subject.run_backup }
-
         it "runs the downloader for each folder" do
-          expect(downloader).to have_received(:run).exactly(:once)
+          expect(downloader).to receive(:run).exactly(:once)
+
+          subject.run_backup
         end
       end
 
       context "when supplied backup_folders is an empty list" do
         let(:backup_folders) { [] }
 
-        before { subject.run_backup }
-
         it "runs the downloader for each folder" do
-          expect(downloader).to have_received(:run).exactly(:once)
+          expect(downloader).to receive(:run).exactly(:once)
+
+          subject.run_backup
         end
       end
 
@@ -195,17 +202,17 @@ describe Imap::Backup::Account::Connection do
     end
   end
 
-  context "#restore" do
+  describe "#restore" do
     let(:folder) do
       instance_double(
         Imap::Backup::Account::Folder,
         create: nil,
-        exist?: exists,
+        uids: uids,
         name: "my_folder",
         uid_validity: uid_validity
       )
     end
-    let(:exists) { true }
+    let(:uids) { [99] }
     let(:uid_validity) { 123 }
     let(:serialized_folder) { "old name" }
     let(:uploader) do
@@ -242,73 +249,89 @@ describe Imap::Backup::Account::Connection do
         with(updated_folder, updated_serializer) { updated_uploader }
       allow(Pathname).to receive(:glob).
         and_yield(Pathname.new(File.join(local_path, "my_folder.imap")))
-      subject.restore
     end
 
     it "sets local uid validity" do
-      expect(serializer).to have_received(:set_uid_validity).with(uid_validity)
+      expect(serializer).to receive(:apply_uid_validity).with(uid_validity)
+
+      subject.restore
     end
 
-    context "when folders exist" do
+    context "when folders exist with contents" do
       context "when the local folder is renamed" do
         let(:new_uid_validity) { "new name" }
 
         it "creates the new folder" do
-          expect(updated_folder).to have_received(:create)
+          expect(updated_folder).to receive(:create)
+
+          subject.restore
         end
 
         it "sets the renamed folder's uid validity" do
           expect(updated_serializer).
-            to have_received(:force_uid_validity).with("new uid validity")
+            to receive(:force_uid_validity).with("new uid validity")
+
+          subject.restore
         end
 
         it "creates the uploader with updated folder and serializer" do
-          expect(updated_uploader).to have_received(:run)
+          expect(updated_uploader).to receive(:run)
+
+          subject.restore
         end
       end
 
       context "when the local folder is not renamed" do
         it "runs the uploader" do
-          expect(uploader).to have_received(:run)
+          expect(uploader).to receive(:run)
+
+          subject.restore
         end
       end
     end
 
-    context "when folders don't exist" do
-      let(:exists) { false }
+    context "when folders don't exist or are empty" do
+      let(:uids) { [] }
 
       it "creates the folder" do
-        expect(folder).to have_received(:create)
+        expect(folder).to receive(:create)
+
+        subject.restore
       end
 
-      it "sets local uid validity" do
+      it "forces local uid validity" do
+        expect(serializer).to receive(:force_uid_validity).with(uid_validity)
+
+        subject.restore
       end
 
       it "runs the uploader" do
-        expect(uploader).to have_received(:run)
+        expect(uploader).to receive(:run)
+
+        subject.restore
       end
     end
   end
 
-  context "#reconnect" do
-    before { subject.reconnect }
-
+  describe "#reconnect" do
     it "disconnects from the server" do
-      expect(imap).to have_received(:disconnect)
+      expect(imap).to receive(:disconnect)
+
+      subject.reconnect
     end
 
     it "causes reconnection on future access" do
-      allow(Net::IMAP).to receive(:new) { imap }
-      subject.imap
-      expect(Net::IMAP).to have_received(:new).twice
+      expect(Net::IMAP).to receive(:new)
+
+      subject.reconnect
     end
   end
 
-  context "#disconnect" do
-    before { subject.disconnect }
-
+  describe "#disconnect" do
     it "disconnects from the server" do
-      expect(imap).to have_received(:disconnect)
+      expect(imap).to receive(:disconnect)
+
+      subject.disconnect
     end
   end
 end