imap-backup 5.0.0 → 6.0.0.rc2

data/spec/unit/imap/backup/serializer_spec.rb

@@ -0,0 +1,296 @@
+module Imap::Backup
+  describe Serializer do
+    subject { described_class.new("path", "folder/sub") }
+
+    let(:directory) { instance_double(Serializer::Directory, ensure_exists: nil) }
+    let(:imap) do
+      instance_double(
+        Serializer::Imap,
+        exist?: true,
+        rename: nil,
+        uid_validity: existing_uid_validity,
+        "uid_validity=": nil
+      )
+    end
+    let(:mbox) do
+      instance_double(
+        Serializer::Mbox,
+        append: nil,
+        exist?: false,
+        length: 1,
+        pathname: "aaa",
+        rename: nil,
+        rewind: nil
+      )
+    end
+    let(:folder_path) { File.expand_path(File.join("path", "folder/sub")) }
+    let(:existing_uid_validity) { nil }
+    let(:enumerator) { instance_double(Serializer::MboxEnumerator) }
+
+    before do
+      allow(Serializer::Directory).to receive(:new) { directory }
+      allow(Serializer::Imap).to receive(:new).with(folder_path) { imap }
+      allow(Serializer::Mbox).to receive(:new) { mbox }
+      allow(Serializer::MboxEnumerator).to receive(:new) { enumerator }
+    end
+
+    describe "#apply_uid_validity" do
+      let(:imap_test) { instance_double(Serializer::Imap, exist?: imap_test_exists) }
+      let(:imap_test_exists) { false }
+      let(:test_folder_path) do
+        File.expand_path(File.join("path", "folder/sub-#{existing_uid_validity}"))
+      end
+      let(:result) { subject.apply_uid_validity("new") }
+
+      before do
+        allow(Serializer::Imap).to receive(:new).with(test_folder_path) { imap_test }
+      end
+
+      context "when there is no existing uid_validity" do
+        it "sets the metadata file's uid_validity" do
+          result
+
+          expect(imap).to have_received(:"uid_validity=").with("new")
+        end
+      end
+
+      context "when the new value is the same as the old value" do
+        let(:existing_uid_validity) { "new" }
+
+        it "does nothing" do
+          result
+
+          expect(imap).to_not have_received(:"uid_validity=")
+        end
+      end
+
+      context "when the new value is different from the old value" do
+        let(:existing_uid_validity) { "existing" }
+
+        it "renames the existing mailbox" do
+          result
+
+          expect(mbox).to have_received(:rename).with(test_folder_path)
+        end
+
+        it "renames the existing metadata file" do
+          result
+
+          expect(imap).to have_received(:rename).with(test_folder_path)
+        end
+
+        it "returns the new name for the old folder" do
+          expect(result).to eq("folder/sub-existing")
+        end
+
+        context "when the default rename is not possible" do
+          let(:imap_test_exists) { true }
+          let(:imap_test1) { instance_double(Serializer::Imap, exist?: false) }
+          let(:test_folder_path1) do
+            File.expand_path(File.join("path", "folder/sub-#{existing_uid_validity}-1"))
+          end
+
+          before do
+            allow(Serializer::Imap).to receive(:new).with(test_folder_path1) { imap_test1 }
+          end
+
+          it "renames the mailbox, appending a numeral" do
+            result
+
+            expect(mbox).to have_received(:rename).with(test_folder_path1)
+          end
+
+          it "renames the metadata file, appending a numeral" do
+            result
+
+            expect(imap).to have_received(:rename).with(test_folder_path1)
+          end
+        end
+      end
+    end
+
+    describe "#force_uid_validity" do
+      it "sets the metadata file's uid_validity" do
+        subject.force_uid_validity("new")
+
+        expect(imap).to have_received(:"uid_validity=").with("new")
+      end
+    end
+
+    describe "#append" do
+      let(:existing_uid_validity) { "42" }
+      let(:mboxrd_message) do
+        instance_double(Email::Mboxrd::Message, to_serialized: "serialized")
+      end
+      let(:uid_found) { false }
+      let(:command) { subject.append(99, "Hi") }
+
+      before do
+        allow(imap).to receive(:include?) { uid_found }
+        allow(imap).to receive(:append)
+        allow(Email::Mboxrd::Message).to receive(:new) { mboxrd_message }
+      end
+
+      it "appends the message to the mailbox" do
+        command
+
+        expect(mbox).to have_received(:append).with("serialized")
+      end
+
+      it "appends the UID to the metadata" do
+        command
+
+        expect(imap).to have_received(:append).with(99)
+      end
+
+      context "when appending to the mailbox causes an error" do
+        before do
+          allow(mbox).to receive(:append).and_throw(RuntimeError, "Boom")
+        end
+
+        it "does not fail" do
+          command
+        end
+
+        it "leaves the metadata file unchanged" do
+          command
+
+          expect(imap).to_not have_received(:append)
+        end
+      end
+
+      context "when appending to the metadata file causes an error" do
+        before do
+          allow(imap).to receive(:append).and_throw(RuntimeError, "Boom")
+        end
+
+        it "does not fail" do
+          command
+        end
+
+        it "reset the mailbox to the previous position" do
+          command
+
+          expect(mbox).to have_received(:rewind)
+        end
+      end
+
+      context "when the metadata uid_validity has not been set" do
+        let(:existing_uid_validity) { nil }
+
+        it "fails" do
+          expect { command }.to raise_error(RuntimeError, /without uid_validity/)
+        end
+      end
+
+      context "when the message has already been backed up" do
+        let(:uid_found) { true }
+
+        it "doesn't append to the mailbox file" do
+          command
+
+          expect(mbox).to_not have_received(:append)
+        end
+
+        it "doesn't append to the metadata file" do
+          command
+
+          expect(imap).to_not have_received(:append)
+        end
+      end
+    end
+
+    describe "#load" do
+      let(:uid) { 999 }
+      let(:imap_index) { 0 }
+      let(:result) { subject.load(uid) }
+
+      before do
+        allow(imap).to receive(:index).with(999) { imap_index }
+        allow(enumerator).to receive(:each) { ["message"].enum_for(:each) }
+      end
+
+      it "returns an Email::Mboxrd::Message" do
+        expect(result).to be_a(Email::Mboxrd::Message)
+      end
+
+      it "returns the message" do
+        expect(result.supplied_body).to eq("message")
+      end
+
+      context "when the message is not found" do
+        let(:imap_index) { nil }
+
+        it "returns nil" do
+          expect(result).to be nil
+        end
+      end
+
+      context "when the supplied UID is a string" do
+        let(:uid) { "999" }
+
+        it "works" do
+          expect(result).to be_a(Email::Mboxrd::Message)
+        end
+      end
+    end
+
+    describe "#load_nth" do
+      let(:imap_index) { 0 }
+      let(:result) { subject.load_nth(imap_index) }
+
+      before do
+        allow(enumerator).to receive(:each) { ["message"].enum_for(:each) }
+      end
+
+      it "returns an Email::Mboxrd::Message" do
+        expect(result).to be_a(Email::Mboxrd::Message)
+      end
+
+      it "returns the message" do
+        expect(result.supplied_body).to eq("message")
+      end
+
+      context "when the message is not found" do
+        let(:imap_index) { 1 }
+
+        it "returns nil" do
+          expect(result).to be nil
+        end
+      end
+    end
+
+    describe "#each_message" do
+      let(:good_uid) { 999 }
+
+      before do
+        allow(imap).to receive(:index) { nil }
+        allow(imap).to receive(:index).with(good_uid) { 0 }
+        allow(enumerator).to receive(:each) { ["message"].enum_for(:each) }
+      end
+
+      it "yields matching UIDs" do
+        expect { |b| subject.each_message([good_uid], &b) }.
+          to yield_successive_args([good_uid, anything])
+      end
+
+      it "yields matching messages" do
+        messages = subject.each_message([good_uid]).map { |_uid, message| message }
+        expect(messages[0].supplied_body).to eq("message")
+      end
+
+      context "with UIDs that are not present" do
+        it "skips them" do
+          expect { |b| subject.each_message([good_uid, 1234], &b) }.
+            to yield_successive_args([good_uid, anything])
+        end
+      end
+
+      context "when called without a block" do
+        it "returns an Enumerator" do
+          expect(subject.each_message([])).to be_a(Enumerator)
+        end
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/setup/account_spec.rb

@@ -11,10 +11,11 @@ describe Imap::Backup::Setup::Account do
       Imap::Backup::Account,
       username: existing_email,
       password: existing_password,
-      server: current_server,
-      connection_options: nil,
       local_path: "/backup/path",
       folders: [{name: "my_folder"}],
+      multi_fetch_size: multi_fetch_size,
+      server: current_server,
+      connection_options: connection_options,
       modified?: false
     )
   end
@@ -28,10 +29,12 @@ describe Imap::Backup::Setup::Account do
   let(:accounts) { [account, account1] }
   let(:existing_email) { "user@example.com" }
   let(:new_email) { "foo@example.com" }
-  let(:current_server) { "imap.example.com" }
   let(:existing_password) { "password" }
   let(:other_email) { "other@example.com" }
   let(:other_existing_path) { "/other/existing/path" }
+  let(:multi_fetch_size) { 1 }
+  let(:current_server) { "imap.example.com" }
+  let(:connection_options) { nil }
 
   let(:highline) { HIGHLINE }
   let(:config) { CONFIG }
@@ -99,9 +102,11 @@ describe Imap::Backup::Setup::Account do
       [
         "modify email",
         "modify password",
-        "modify server",
         "modify backup path",
         "choose backup folders",
+        "modify multi-fetch size (number of emails to fetch at a time)",
+        "modify server",
+        "modify connection options",
         "test connection",
         "delete",
         "(q) return to main menu",
@@ -136,7 +141,23 @@ describe Imap::Backup::Setup::Account do
         before { subject.run }
 
         it "indicates that a password is not set" do
-          expect(menu.header).to include("password   (unset)")
+          expect(menu.header).to match(/^password\s+\(unset\)/)
+        end
+      end
+
+      context "with multi_fetch_size" do
+        let(:multi_fetch_size) { 4 }
+
+        it "shows the size" do
+          expect(menu.header).to match(/^multi-fetch\s+4/)
+        end
+      end
+
+      context "with connection_options" do
+        let(:connection_options) { {some: "option"} }
+
+        it "shows the options" do
+          expect(menu.header).to match(/^connection options\s+'{"some":"option"}'/)
         end
       end
     end
@@ -240,23 +261,6 @@ describe Imap::Backup::Setup::Account do
       end
     end
 
-    describe "choosing 'modify server'" do
-      let(:server) { "server" }
-
-      before do
-        allow(account).to receive(:"server=")
-        allow(highline).to receive(:ask).with("server: ") { server }
-
-        subject.run
-
-        menu.choices["modify server"].call
-      end
-
-      it "updates the server" do
-        expect(account).to have_received(:"server=").with(server)
-      end
-    end
-
     describe "choosing 'modify backup path'" do
       let(:new_backup_path) { "/new/path" }
 
@@ -311,6 +315,97 @@ describe Imap::Backup::Setup::Account do
       end
     end
 
+    describe "choosing 'modify multi-fetch size'" do
+      let(:supplied) { "10" }
+
+      before do
+        allow(account).to receive(:multi_fetch_size=)
+        allow(highline).to receive(:ask).with("size: ") { supplied }
+
+        subject.run
+        menu.choices[
+          "modify multi-fetch size (number of emails to fetch at a time)"
+        ].call
+      end
+
+      it "sets the multi-fetch size" do
+        expect(account).to have_received(:multi_fetch_size=).with(10)
+      end
+
+      context "when the supplied value is not a number" do
+        let(:supplied) { "wrong!" }
+
+        it "does nothing" do
+          expect(account).to_not have_received(:multi_fetch_size=)
+        end
+      end
+
+      context "when the supplied value is not a positive number" do
+        let(:supplied) { "0" }
+
+        it "does nothing" do
+          expect(account).to_not have_received(:multi_fetch_size=)
+        end
+      end
+    end
+
+    describe "choosing 'modify server'" do
+      let(:server) { "server" }
+
+      before do
+        allow(account).to receive(:"server=")
+        allow(highline).to receive(:ask).with("server: ") { server }
+
+        subject.run
+
+        menu.choices["modify server"].call
+      end
+
+      it "updates the server" do
+        expect(account).to have_received(:"server=").with(server)
+      end
+    end
+
+    describe "choosing 'modify connection options'" do
+      context "when the JSON is well formed" do
+        let(:json) { "{}" }
+
+        before do
+          allow(highline).to receive(:ask).with("connections options (as JSON): ") { json }
+          allow(account).to receive(:"connection_options=")
+
+          subject.run
+
+          menu.choices["modify connection options"].call
+        end
+
+        it "updates the connection options" do
+          expect(account).to have_received(:"connection_options=").with(json)
+        end
+      end
+
+      context "when the JSON is malformed" do
+        before do
+          allow(highline).to receive(:ask).with("connections options (as JSON): ") { "xx" }
+          allow(account).to receive(:"connection_options=").and_raise(JSON::ParserError)
+          allow(highline).to receive(:ask).with("Press a key ")
+
+          subject.run
+
+          menu.choices["modify connection options"].call
+        end
+
+        it "does not fail" do
+          subject.run
+        end
+
+        it "reports the problem" do
+          expect(Kernel).to have_received(:puts).
+            with(/Malformed/)
+        end
+      end
+    end
+
     describe "choosing 'test connection'" do
       let(:connection_tester) do
         instance_double(
@@ -336,7 +431,7 @@ describe Imap::Backup::Setup::Account do
       let(:confirmed) { true }
 
       before do
-        allow(account).to receive(:mark_for_deletion!)
+        allow(account).to receive(:mark_for_deletion)
         allow(highline).to receive(:agree) { confirmed }
         subject.run
         catch :done do
@@ -350,7 +445,7 @@ describe Imap::Backup::Setup::Account do
 
       context "when the user confirms deletion" do
         it "flags the account to be deleted" do
-          expect(account).to have_received(:mark_for_deletion!)
+          expect(account).to have_received(:mark_for_deletion)
         end
       end
 
@@ -358,7 +453,7 @@ describe Imap::Backup::Setup::Account do
         let(:confirmed) { false }
 
         it "doesn't flag the account to be deleted" do
-          expect(account).to_not have_received(:mark_for_deletion!)
+          expect(account).to_not have_received(:mark_for_deletion)
         end
       end
     end

data/spec/unit/imap/backup/setup/helpers_spec.rb

@@ -0,0 +1,15 @@
+module Imap::Backup
+  RSpec.describe Setup::Helpers do
+    describe "#title_prefix" do
+      it "is a string" do
+        expect(subject.title_prefix).to eq("imap-backup –")
+      end
+    end
+
+    describe "#version" do
+      it "is a version string" do
+        expect(subject.version).to match(/\A\d+\.\d+\.\d+(\.\w+)?\z/)
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/thunderbird/mailbox_exporter_spec.rb

@@ -0,0 +1,116 @@
+module Imap::Backup
+  describe Thunderbird::MailboxExporter do
+    subject { described_class.new("email", serializer, "profile", **args) }
+
+    let(:args) { {} }
+    let(:serializer) do
+      instance_double(
+        Serializer,
+        folder: "folder",
+        mbox_pathname: "mbox_pathname"
+      )
+    end
+    let(:local_folder) do
+      instance_double(
+        Thunderbird::LocalFolder,
+        exists?: local_folder_exists,
+        full_path: "full_path",
+        msf_exists?: msf_exists,
+        msf_path: "msf_path",
+        path: "path",
+        set_up: set_up_result
+      )
+    end
+    let(:local_folder_exists) { false }
+    let(:msf_exists) { false }
+    let(:set_up_result) { true }
+    let(:file) { instance_double(File, write: nil) }
+    let(:enumerator) { instance_double(Serializer::MboxEnumerator) }
+
+    before do
+      allow(File).to receive(:open).with("full_path", "w").and_yield(file)
+      allow(File).to receive(:unlink)
+      allow(Thunderbird::LocalFolder).to receive(:new) { local_folder }
+      allow(Serializer::MboxEnumerator).to receive(:new) { enumerator }
+      allow(enumerator).to receive(:each) { ["message"].enum_for(:each) }
+      allow(Email::Mboxrd::Message).to receive(:clean_serialized) { "cleaned" }
+      allow(Kernel).to receive(:puts)
+    end
+
+    describe "#run" do
+      let!(:result) { subject.run }
+
+      context "when the destination folder cannot be set up" do
+        let(:set_up_result) { false }
+
+        it "doesn't copy the mailbox" do
+          expect(file).to_not have_received(:write)
+        end
+
+        it "returns false" do
+          expect(result).to be false
+        end
+      end
+
+      context "when the .msf file exists" do
+        let(:msf_exists) { true }
+
+        context "when 'force' is set" do
+          let(:args) { {force: true} }
+
+          it "deletes the file" do
+            expect(File).to have_received(:unlink).with("msf_path")
+          end
+        end
+
+        context "when 'force' isn't set" do
+          it "doesn't copy the mailbox" do
+            expect(file).to_not have_received(:write)
+          end
+
+          it "returns false" do
+            expect(result).to be false
+          end
+        end
+      end
+
+      context "when the destination mailbox exists" do
+        let(:local_folder_exists) { true }
+
+        context "when 'force' is set" do
+          let(:args) { {force: true} }
+
+          it "writes the message" do
+            expect(file).to have_received(:write)
+          end
+
+          it "returns true" do
+            expect(result).to be true
+          end
+        end
+
+        context "when 'force' isn't set" do
+          it "doesn't copy the mailbox" do
+            expect(file).to_not have_received(:write)
+          end
+
+          it "returns false" do
+            expect(result).to be false
+          end
+        end
+      end
+
+      it "adds a 'From' line" do
+        expect(file).to have_received(:write).with(/From - \w+ \w+ \d+ \d+:\d+:\d+/)
+      end
+
+      it "writes the cleaned message" do
+        expect(file).to have_received(:write).with(/cleaned/)
+      end
+
+      it "returns true" do
+        expect(result).to be true
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/uploader_spec.rb

@@ -8,7 +8,7 @@ describe Imap::Backup::Uploader do
   end
   let(:serializer) do
     instance_double(
-      Imap::Backup::Serializer::Mbox,
+      Imap::Backup::Serializer,
       uids: [1, 2],
       update_uid: nil
     )

data/spec/unit/retry_on_error_spec.rb

@@ -0,0 +1,34 @@
+class Retrier
+  class FooError < StandardError; end
+
+  include RetryOnError
+
+  def do_stuff(errors:, limit:)
+    calls = 0
+
+    retry_on_error(errors: errors, limit: limit) do
+      calls += 1
+      raise FooError if calls < 3
+
+      42
+    end
+  end
+end
+
+RSpec.describe RetryOnError do
+  describe "#retry_on_error" do
+    subject { Retrier.new }
+
+    it "retries" do
+      expect(subject.do_stuff(errors: [Retrier::FooError], limit: 3)).to eq(42)
+    end
+
+    context "when the block fails more than the limit" do
+      it "fails" do
+        expect do
+          subject.do_stuff(errors: [Retrier::FooError], limit: 1)
+        end.to raise_error(Retrier::FooError)
+      end
+    end
+  end
+end