imap-backup 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78c6ccd7ca7a6f60ae02c24c76c121470372ffbadf268eb6f52b8f6eac633e6d
-  data.tar.gz: d5da356a60a6046301c2e66a990f24948c3dc63f6c7f757ca3da43f62772468d
+  metadata.gz: 119c39db4e00d91f68a482035050ec8c91606a120cc80f1c514f39d731a30e02
+  data.tar.gz: 451761b7d17bcc664ff6890e6c86bd33628929bfdf665a91b322bcfd92c7d7f3
 SHA512:
-  metadata.gz: 82fc5680a656d79012690e7da5038f0b8e56b1c5b14168142c222cb2c336bf44c0ec5570fbed8c50b2b2c2ea445ec17bed286d452795aa0c692d61c71d497274
-  data.tar.gz: 7eda772c5b9815dfbbe679981a0a281cecd7e3cc970c95345437d35ddc01b40f5fedb25eabef043271bdd7cfc7084bf7caad6bbd037f5926fabee0d23958252a
+  metadata.gz: 3021adbfe55940b7f0a5d306259c2ba755277105d0139e6b51c18a425cbbf49737bde1fc38c6db00f51e272b71790c2c037838fcfffac7197fd35f429636d4d6
+  data.tar.gz: 6ef608f3bc7655886b6926c746768741ca70fb3b604834fb3750dbb393ae4551c077fa30f47ee8edae24a4684853093697988e1b23f3f50c505e635496d792a8

data/.rubocop.yml

@@ -12,6 +12,8 @@ AllCops:
 RSpec/ContextWording:
   Exclude:
     - "spec/features/**/*"
+RSpec/MessageSpies:
+  Enabled: false
 RSpec/NestedGroups:
   Max: 4
 RSpec/ReturnFromStub:

data/README.md

@@ -204,8 +204,8 @@ Integration tests (feature specs) are run against a Docker image
 
 In one shell, run the Docker image:
 
-```
-docker run \
+```sh
+$ docker run \
   --env MAIL_ADDRESS=address@example.org \
   --env MAIL_PASS=pass \
   --env MAILNAME=example.org \
@@ -213,6 +213,10 @@ docker run \
   antespi/docker-imap-devel:latest
 ```
 
+```sh
+$ rake
+```
+
 To exclude Docker-based tests:
 
 ```sh

data/bin/imap-backup

@@ -53,7 +53,7 @@ if KNOWN_COMMANDS.find { |c| c[:name] == options[:command] }.nil?
 end
 
 if options[:command] == "help"
-  puts opts
+  puts parser
   exit
 end
 

data/lib/email/mboxrd/message.rb

@@ -18,7 +18,6 @@ module Email::Mboxrd
 
     def initialize(supplied_body)
       @supplied_body = supplied_body.clone
-      @supplied_body.force_encoding("binary")
     end
 
     def to_serialized

data/lib/imap/backup/account/connection.rb

@@ -57,27 +57,7 @@ module Imap::Backup
 
     def restore
       local_folders do |serializer, folder|
-        exists = folder.exist?
-        if exists
-          new_name = serializer.apply_uid_validity(folder.uid_validity)
-          old_name = serializer.folder
-          if new_name
-            Imap::Backup.logger.debug(
-              "Backup '#{old_name}' renamed and restored to '#{new_name}'"
-            )
-            new_serializer = Serializer::Mbox.new(local_path, new_name)
-            new_folder = Account::Folder.new(self, new_name)
-            new_folder.create
-            new_serializer.force_uid_validity(new_folder.uid_validity)
-            Uploader.new(new_folder, new_serializer).run
-          else
-            Uploader.new(folder, serializer).run
-          end
-        else
-          folder.create
-          serializer.force_uid_validity(folder.uid_validity)
-          Uploader.new(folder, serializer).run
-        end
+        restore_folder serializer, folder
       end
     end
 
@@ -114,6 +94,33 @@ module Imap::Backup
       end
     end
 
+    def restore_folder(serializer, folder)
+      existing_uids = folder.uids
+      if existing_uids.any?
+        Imap::Backup.logger.debug(
+          "There's already a '#{folder.name}' folder with emails"
+        )
+        new_name = serializer.apply_uid_validity(folder.uid_validity)
+        old_name = serializer.folder
+        if new_name
+          Imap::Backup.logger.debug(
+            "Backup '#{old_name}' renamed and restored to '#{new_name}'"
+          )
+          new_serializer = Serializer::Mbox.new(local_path, new_name)
+          new_folder = Account::Folder.new(self, new_name)
+          new_folder.create
+          new_serializer.force_uid_validity(new_folder.uid_validity)
+          Uploader.new(new_folder, new_serializer).run
+        else
+          Uploader.new(folder, serializer).run
+        end
+      else
+        folder.create
+        serializer.force_uid_validity(folder.uid_validity)
+        Uploader.new(folder, serializer).run
+      end
+    end
+
     def create_account_folder
       Utils.make_folder(
         File.dirname(local_path),

data/lib/imap/backup/account/folder.rb

@@ -63,7 +63,6 @@ module Imap::Backup
       attributes = fetch_data_item.attr
       return nil if !attributes.key?("RFC822")
 
-      attributes["RFC822"].force_encoding("utf-8")
       attributes
     rescue FolderNotFound
       nil

data/lib/imap/backup/serializer/mbox_enumerator.rb

@@ -9,7 +9,7 @@ module Imap::Backup
     def each
       return enum_for(:each) if !block_given?
 
-      File.open(mbox_pathname) do |f|
+      File.open(mbox_pathname, "rb") do |f|
         lines = []
 
         loop do

data/lib/imap/backup/uploader.rb

@@ -9,10 +9,19 @@ module Imap::Backup
     end
 
     def run
-      missing_uids.each do |uid|
+      count = missing_uids.count
+      return if count.zero?
+
+      Imap::Backup.logger.debug "[#{folder.name}] #{count} to restore"
+      missing_uids.each.with_index do |uid, i|
         message = serializer.load(uid)
         next if message.nil?
 
+        log_prefix = "[#{folder.name}] uid: #{uid} (#{i + 1}/#{count}) -"
+        Imap::Backup.logger.debug(
+          "#{log_prefix} #{message.supplied_body.size} bytes"
+        )
+
         new_uid = folder.append(message)
         serializer.update_uid(uid, new_uid)
       end

data/lib/imap/backup/version.rb

@@ -2,7 +2,7 @@ module Imap; end
 
 module Imap::Backup
   MAJOR    = 2
-  MINOR    = 1
-  REVISION = 1
+  MINOR    = 2
+  REVISION = 0
   VERSION  = [MAJOR, MINOR, REVISION].compact.map(&:to_s).join(".")
 end

data/spec/features/restore_spec.rb

@@ -72,41 +72,89 @@ RSpec.describe "restore", type: :feature, docker: true do
     end
 
     context "when the uid_validity doesn't match" do
-      let(:pre) do
-        server_create_folder folder
-        email3
-      end
-      let(:new_folder) { "#{folder}.#{uid_validity}" }
-      let(:cleanup) do
-        server_delete_folder new_folder
-        super()
-      end
+      context "when the folder is empty" do
+        let(:pre) do
+          server_create_folder folder
+        end
 
-      it "sets the backup uid_validity to match the new folder" do
-        updated_imap_content = imap_parsed(new_folder)
-        expect(updated_imap_content[:uid_validity]).
-          to eq(server_uid_validity(new_folder))
-      end
+        it "sets the backup uid_validity to match the folder" do
+          updated_imap_content = imap_parsed(folder)
+          expect(updated_imap_content[:uid_validity]).
+            to eq(server_uid_validity(folder))
+        end
 
-      it "renames the backup" do
-        expect(mbox_content(new_folder)).to eq(messages_as_mbox)
+        it "uploads to the new folder" do
+          messages = server_messages(folder).map do |m|
+            server_message_to_body(m)
+          end
+          expect(messages).to eq(messages_as_server_messages)
+        end
       end
 
-      it "leaves the existing folder as is" do
-        messages = server_messages(folder).map { |m| server_message_to_body(m) }
-        expect(messages).to eq([message_as_server_message(msg3)])
-      end
+      context "when the folder has content" do
+        let(:new_folder) { "#{folder}.#{uid_validity}" }
+        let(:cleanup) do
+          server_delete_folder new_folder
+          super()
+        end
 
-      it "creates the new folder" do
-        expect(server_folders.map(&:name)).to include(new_folder)
-      end
+        let(:pre) do
+          server_create_folder folder
+          email3
+        end
 
-      it "uploads to the new folder" do
-        messages = server_messages(new_folder).map do |m|
-          server_message_to_body(m)
+        it "renames the backup" do
+          expect(mbox_content(new_folder)).to eq(messages_as_mbox)
+        end
+
+        it "leaves the existing folder as is" do
+          messages = server_messages(folder).map do |m|
+            server_message_to_body(m)
+          end
+          expect(messages).to eq([message_as_server_message(msg3)])
+        end
+
+        it "creates the new folder" do
+          expect(server_folders.map(&:name)).to include(new_folder)
+        end
+
+        it "sets the backup uid_validity to match the new folder" do
+          updated_imap_content = imap_parsed(new_folder)
+          expect(updated_imap_content[:uid_validity]).
+            to eq(server_uid_validity(new_folder))
+        end
+
+        it "uploads to the new folder" do
+          messages = server_messages(new_folder).map do |m|
+            server_message_to_body(m)
+          end
+          expect(messages).to eq(messages_as_server_messages)
         end
-        expect(messages).to eq(messages_as_server_messages)
       end
     end
   end
+
+  context "when non-Unicode encodings are used" do
+    let(:server_message) do
+      message_as_server_message(msg_iso8859)
+    end
+    let(:messages_as_mbox) do
+      message_as_mbox_entry(msg_iso8859)
+    end
+    let(:message_uids) { [uid_iso8859] }
+    let(:uid_validity) { server_uid_validity(folder) }
+
+    let(:pre) do
+      server_create_folder folder
+      uid_validity
+    end
+
+    it "maintains encodings" do
+      message =
+        server_messages(folder).
+        first["RFC822"]
+
+      expect(message).to eq(server_message)
+    end
+  end
 end

data/spec/features/support/email_server.rb

@@ -38,9 +38,7 @@ module EmailServerHelpers
     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)

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/unit/email/mboxrd/message_spec.rb

@@ -79,12 +79,6 @@ describe Email::Mboxrd::Message do
       allow(Mail).to receive(:new).with(cloned_message_body) { mail }
     end
 
-    it "does not modify the message" do
-      subject.to_serialized
-
-      expect(message_body).to_not have_received(:force_encoding).with("binary")
-    end
-
     it "adds a 'From ' line at the start" do
       expected = "From #{from} #{date.asctime}\n"
       expect(subject.to_serialized).to start_with(expected)

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

@@ -49,10 +49,6 @@ describe Imap::Backup::Account::Connection do
   end
 
   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
@@ -70,8 +66,9 @@ 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
 
@@ -102,7 +99,7 @@ describe Imap::Backup::Account::Connection do
     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
 
@@ -140,21 +137,24 @@ 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)
-        subject.run_backup
+          with(local_path, self.class.backup_folder) { serializer }
       end
 
       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 have_received(:run)
+          expect(downloader).to_not receive(:run)
+
+          subject.run_backup
         end
       end
     end
@@ -166,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
 
@@ -207,12 +207,12 @@ describe Imap::Backup::Account::Connection 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
@@ -249,74 +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(:apply_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
 
   describe "#reconnect" do
-    before { subject.reconnect }
-
     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
 
   describe "#disconnect" do
-    before { subject.disconnect }
-
     it "disconnects from the server" do
-      expect(imap).to have_received(:disconnect)
+      expect(imap).to receive(:disconnect)
+
+      subject.disconnect
     end
   end
 end